Java for Beginner
@Java_for_beginner_dev
672 subscribers
540 photos
155 videos
12 files
827 links
Канал от новичков для новичков!
Изучайте Java вместе с нами!
Здесь мы обмениваемся опытом и постоянно изучаем что-то новое!

Наш YouTube канал - https://www.youtube.com/@Java_Beginner-Dev

Наш канал на RUTube - https://rutube.ru/channel/37896292/
Download Telegram
About
Blog
Apps
Platform
Join
Java for Beginner
672 subscribers
Java for Beginner
Подробный разбор решения задачи Task011124_2

1. Контекст задачи:

Эта задача исследует использование аннотаций @Import и @Value в Spring для конфигурации и управления зависимостями между бинами. Задача демонстрирует, как Spring позволяет импортировать конфигурационные классы и использовать параметры из внешних конфигураций (или задавать их значения по умолчанию) через аннотацию @Value.

2. Ключевые элементы кода:

Аннотация @Import:
Аннотация @Import(ServiceConfig0111.class) в классе MainConfig0111 используется для импорта конфигурации из другого класса, ServiceConfig0111. Это позволяет разделять конфигурацию приложения на несколько файлов и управлять зависимостями между ними.

Аннотация @Value:
Аннотация @Value("${message:Hello, Spring}") в методе service0111() устанавливает значение для параметра message. Здесь используется шаблон с подстановкой значения по умолчанию: если в настройках Spring нет переменной message, будет использовано значение "Hello, Spring".

Метод registerUser():
В классе Client0111 метод printMessage() вызывает метод getMessage() объекта Service0111, который возвращает сообщение, переданное в конструктор этого объекта.

3. Сценарий работы программы:

Программа создает контекст Spring с помощью AnnotationConfigApplicationContext, который сканирует конфигурационный класс MainConfig0111. Этот класс импортирует конфигурацию из ServiceConfig0111, где находится бин Service0111.
В методе service0111() используется аннотация @Value, чтобы задать значение для параметра message. Поскольку переменная message не была определена в контексте (например, в файле свойств), используется значение по умолчанию "Hello, Spring".
Контекст создает бин Client0111, который получает бин Service0111 через конструкторную инъекцию.
Вызывается метод printMessage(), который выводит значение message из бина Service0111.

4. Ключевые моменты и выводы:

Аннотация @Import: Позволяет разделять конфигурацию Spring на несколько классов. Это улучшает модульность приложения и помогает управлять конфигурацией большого количества бинов.

Аннотация @Value: Позволяет извлекать значения из внешних конфигураций, а также устанавливать значения по умолчанию, если переменные не заданы. В этом примере используется значение по умолчанию "Hello, Spring", так как переменная message не была передана.

Конфигурация бинов через Java-классы: Вся конфигурация бинов задается через Java-классы (аннотации @Configuration и @Bean), что является альтернативой использованию XML-файлов для конфигурации Spring.

#Solution_TasksSpring
140 views
Java for Beginner
Всем доброго субботне-рабочего утра!😉

Так как на сегодня постов не предвидится, предлагаю всем перейти в наш чат (https://t.me/Java_Beginner_chat) и просто поболтать).

Я вот нашел где генерить неплохие картинки)

А как Вы проводите "выходной"?😂
138 views
Java for Beginner
Всем уютного воскресного утра!🖐

Сегодня официальный выходной поэтому можно немного полениться😜

Но изучение Java нельзя останавливать! Ни в коем случае🤪😂

Поэтому как и всегда в 16:00 мы встречаемся в Яндекс.Телемост и посмотрим лайф-кодинг @MrAbhorrent!💪

Ждем всех!🫵
132 views
Java for Beginner
Встреча создана, залетаем!

https://telemost.yandex.ru/j/17362795415876
155 views
Java for Beginner
Давайте выберем что полайф-кодим на следующие выходные?
Anonymous Poll
17%
Псевдо-жизнь, с применением Swing и математики.
75%
Небольшое веб-приложение с контроллерами и Spring
0%
Мой вариант в комментариях!
8%
Что я делаю в этом канале!?
24 voters135 views
Java for Beginner
Spring MVC

Spring MVC — это мощный модуль Spring Framework, предназначенный для построения веб-приложений. MVC расшифровывается как "Model-View-Controller" и описывает шаблон проектирования, который разделяет приложения на три основные части: модель, представление и контроллер. Это разделение способствует удобству поддержки и расширяемости кода.

1. Основные особенности Spring MVC

Модульность: Spring MVC обеспечивает структурированное разделение логики приложения на уровни, что облегчает поддержку и масштабирование.
Обработка HTTP-запросов: Модуль поддерживает маппинг запросов на методы контроллеров, что делает его идеальным для создания REST API и динамических сайтов.
Поддержка различных форматов данных: Spring MVC поддерживает JSON и XML для обмена данными, что упрощает интеграцию с внешними системами.
Валидация и обработка ошибок: С помощью Spring MVC можно удобно обрабатывать ошибки и выполнять валидацию входных данных.

2. Ключевые компоненты Spring MVC

Spring MVC включает в себя следующие важные компоненты:
DispatcherServlet — главный компонент, принимающий все запросы от клиента и перенаправляющий их в нужные контроллеры.
Контроллеры — обрабатывают запросы и возвращают данные, которые отображаются в представлениях.
View (представление) — отображает данные пользователю.
Model — представляет данные приложения и позволяет контроллерам и представлениям обмениваться информацией.

3. Пример создания простого контроллера в Spring MVC

Конфигурация DispatcherServlet
Для начала создадим конфигурацию DispatcherServlet — центрального компонента Spring MVC, отвечающего за обработку запросов и отправку их на соответствующие контроллеры.

Конфигурация Spring MVC в web.xml (если используется XML-конфигурация):
<servlet>
    <servlet-name>dispatcher</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
    <servlet-name>dispatcher</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>
Этот код создает DispatcherServlet, который будет принимать все запросы, направленные к приложению.


Создание контроллера

Контроллер — это компонент, который получает запросы и управляет взаимодействием между моделью и представлением.
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class HomeController {

    @GetMapping("/home")
    public String home(Model model) {
        model.addAttribute("message", "Добро пожаловать в Spring MVC!");
        return "home";
    }
}
Здесь метод home() маппится на URL /home. Он добавляет сообщение в объект Model, который будет отображен в представлении home.


Создание представления

Создадим JSP-страницу home.jsp для отображения сообщения, переданного из контроллера.
<html>
<body>
    <h1>${message}</h1>
</body>
</html>


#Java #Training #Spring #SpringMVC
134 views
Java for Beginner
4. Основные аннотации в Spring MVC

@Controller — используется для указания, что данный класс является контроллером.
@RequestMapping — задает маппинг URL на метод контроллера.
@GetMapping, @PostMapping и другие аннотации — задают метод HTTP-запроса (GET, POST и т.д.).
@ModelAttribute — связывает данные с моделью, доступной в представлении.

5. Валидация в Spring MVC

Spring MVC поддерживает валидацию данных с помощью аннотаций из пакета javax.validation. Для включения валидации необходимо использовать аннотацию @Valid перед объектом в методе контроллера.

Пример валидации:
import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.Size;

public class User {

    @NotEmpty(message = "Имя не может быть пустым")
    private String name;

    @Size(min = 6, message = "Пароль должен быть не менее 6 символов")
    private String password;
    
    // Геттеры и сеттеры
}


В контроллере можно использовать аннотацию @Valid для автоматической валидации:
import org.springframework.validation.BindingResult;
import javax.validation.Valid;

@PostMapping("/register")
public String register(@Valid User user, BindingResult result) {
    if (result.hasErrors()) {
        return "register";
    }
    return "success";
}


#Java #Training #Spring #SpringMVC
118 views
Java for Beginner
Что выведет код?

import java.util.HashSet;
import java.util.Objects;
import java.util.Set;

public class Task041124_1 {
    public static void main(String[] args) {
        Set<Item> set = new HashSet<>();
        Item item1 = new Item("Book", 123);
        Item item2 = new Item("Book", 123);
        Item item3 = new Item("Pen", 456);

        set.add(item1);
        set.add(item2);
        set.add(item3);

        System.out.println("Set size: " + set.size());
        System.out.println(set.contains(new Item("Book", 123)));
    }
}

class Item {
    private String name;
    private int id;

    public Item(String name, int id) {
        this.name = name;
        this.id = id;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Item item = (Item) o;
        return id == item.id && Objects.equals(name, item.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, id);
    }
}


#Tasks
123 views
Java for Beginner
Варианты ответа:
Anonymous Quiz
38%
Set size: 3, true
8%
Set size: 2, false
54%
Set size: 2, true
0%
Set size: 3, false
13 voters112 views
Java for Beginner
Да не херня какая-то... Печатать надо на часах, че там...🤪😂😂

https://t.me/Java_for_beginner_dev

#Mems
117 views
Java for Beginner
Архитектура MVC в Spring

Архитектура MVC (Model-View-Controller) — это архитектурный шаблон, широко используемый при построении веб-приложений, особенно в Spring. В рамках Spring MVC данный паттерн позволяет управлять структурой приложения, отделяя логику представления от логики контроллера и модели. Это упрощает поддержку, масштабирование и расширение кода.

1. Компоненты архитектуры MVC

Архитектура MVC разделяет приложение на три части:
Model (Модель) — содержит данные и логику, отвечающие за их получение и обработку.
View (Представление) — отвечает за визуализацию данных, предоставляемых контроллером, пользователю.
Controller (Контроллер) — обрабатывает запросы, вызывает нужные модели и передает данные для отображения в представление.

Каждый из этих компонентов выполняет свою уникальную роль, обеспечивая четкое разделение обязанностей.

2. Роль компонентов MVC в Spring

Модель в Spring представляет собой POJO-классы, которые хранят и обрабатывают данные, передаваемые между представлением и контроллером.
Представление отвечает за рендеринг данных. В Spring MVC поддерживаются различные виды представлений, включая JSP, Thymeleaf, и другие.
Контроллер — главный компонент в Spring MVC, который связывает запросы клиента с определенными действиями.

3. Обработка запросов в Spring MVC

Запрос поступает на DispatcherServlet — когда клиент отправляет запрос, он сначала попадает на DispatcherServlet. Он анализирует запрос и перенаправляет его на нужный контроллер.
Выбор контроллера — DispatcherServlet определяет контроллер, соответствующий URL, и направляет запрос к этому контроллеру.
Обработка контроллером — контроллер обрабатывает запрос, обращается к модели (если необходимо) и добавляет данные в объект Model.
Выбор и рендеринг представления — контроллер возвращает имя представления, и ViewResolver рендерит его, отображая данные для клиента.

4. Пример архитектуры MVC с обработкой данных пользователя

Модель
public class User {
    private String name;
    private String email;
    // Геттеры и сеттеры
}


Контроллер
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class UserController {

    @GetMapping("/user")
    public String getUser(Model model) {
        User user = new User();
        user.setName("John");
        user.setEmail("john@example.com");
        model.addAttribute("user", user);
        return "userView";
    }
}


Представление
userView.jsp:
<html>
<body>
    <h2>Профиль пользователя</h2>
    <p>Имя: ${user.name}</p>
    <p>Email: ${user.email}</p>
</body>
</html>


5. ViewResolver и его роль

ViewResolver в Spring отвечает за нахождение и рендеринг представлений. Он используется для сопоставления имен представлений, возвращаемых контроллером, с реальными файлами. Например, для JSP-страниц можно использовать InternalResourceViewResolver.

Пример конфигурации ViewResolver:
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.view.InternalResourceViewResolver;

@Configuration
public class WebConfig {

    @Bean
    public InternalResourceViewResolver viewResolver() {
        InternalResourceViewResolver resolver = new InternalResourceViewResolver();
        resolver.setPrefix("/WEB-INF/views/");
        resolver.setSuffix(".jsp");
        return resolver;
    }
}


6. Преимущества архитектуры MVC

Архитектура MVC обеспечивает следующие преимущества:
Четкое разделение обязанностей: каждый компонент (модель, представление и контроллер) выполняет свою отдельную задачу.
Поддерживаемость: изменения в логике представления или контроллера не влияют на модель.
Повышенная тестируемость: благодаря изолированности логики легче проводить модульное тестирование.

#Java #Training #Spring #SpringMVC
109 views
Java for Beginner
Что выведет код при обращении к URL "/greet/John"?

Задача по Spring. Spring MVC. Сложность легкая.

Подробный разбор через 30 минут!🫡

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

@SpringBootApplication
public class Main041124_2 {
    public static void main(String[] args) {
        SpringApplication.run(Main041124_2.class, args);
    }
}

@Controller
class GreetingController0411 {

    @GetMapping("/greet/{name}")
    @ResponseBody
    public String greetUser(@PathVariable String name, @RequestParam(defaultValue = "Guest") String title) {
        return "Hello, " + title + " " + name + "!";
    }
}


#TasksSpring
122 views
Java for Beginner
Варианты ответа:
Anonymous Quiz
79%
Hello, Guest John!
14%
Hello, Mr. John!
0%
Hello, null John!
7%
Ошибка времени выполнения
14 voters119 views
Java for Beginner
Подробный разбор решения задачи Task041124_2

1. Контекст задачи:

Задача исследует работу Spring MVC, в частности, как используются аннотации @PathVariable и @RequestParam для обработки параметров запроса. Она демонстрирует, как Spring MVC контроллер может принимать параметры из URL и как использовать значение по умолчанию с аннотацией @RequestParam.

2. Ключевые элементы кода:

@SpringBootApplication:
Аннотация @SpringBootApplication объединяет в себе @Configuration, @EnableAutoConfiguration, и @ComponentScan. Она указывает, что Main041124_2 — это основной класс, который запускает Spring Boot приложение.

@Controller и @GetMapping:
@Controller указывает, что класс GreetingController0411 является контроллером Spring MVC.
@GetMapping("/greet/{name}") связывает HTTP GET-запросы по URL "/greet/{name}" с методом greetUser(). Параметр name из URL связывается с параметром метода name через аннотацию @PathVariable.

@PathVariable и @RequestParam:
@PathVariable связывает значение из части пути запроса {name} с аргументом метода name. В этом случае, если мы обращаемся по URL "/greet/John", name получит значение "John".
@RequestParam(defaultValue = "Guest") связывает параметр title из строки запроса (например, "/greet/John?title=Mr") с аргументом метода title. Если параметр title отсутствует, будет использоваться значение по умолчанию "Guest".

@ResponseBody:
Аннотация @ResponseBody указывает Spring возвращать результат метода greetUser() как HTTP-ответ в виде строки, а не искать шаблон или представление. Это упрощает вывод ответа прямо в консоль, если задача настроена на веб-запрос.

3. Сценарий работы программы:

Программа запускается через SpringApplication.run(Main041124_2.class, args);, и Spring Boot настраивает встроенный сервер (например, Tomcat).
Spring Boot создает бин GreetingController0411 и связывает его метод greetUser() с URL "/greet/{name}".
Когда к приложению поступает GET-запрос на "/greet/John", Spring:
Считывает значение "John" из пути и передает его параметру name через @PathVariable.
Проверяет наличие параметра title в строке запроса. Так как параметр не передан, используется значение по умолчанию "Guest".
Метод greetUser() формирует и возвращает строку:

"Hello, Guest John!"


Аннотация @ResponseBody указывает Spring отдать этот текст как ответ на запрос.

4. Ключевые моменты и выводы:

@PathVariable и @RequestParam: Эта задача демонстрирует разницу между @PathVariable (для значений, извлекаемых из пути запроса) и @RequestParam (для значений из строки запроса). Если @RequestParam отсутствует, используется значение по умолчанию (если оно задано).
Значение по умолчанию: defaultValue аннотации @RequestParam позволяет избежать null, если параметр отсутствует в запросе. Это упрощает обработку запросов, где параметр не является обязательным.
Упрощенный вывод с @ResponseBody: Аннотация @ResponseBody используется для возврата текстового ответа прямо из метода контроллера без необходимости в шаблонах, что особенно полезно для простых API.

#Solution_TasksSpring
116 views
Java for Beginner
Всем доброго утра!

Прошу проголосовать тех, кто по какой-то причине пропустил😉

https://t.me/Java_for_beginner_dev/958
Telegram
Java for Beginner
Давайте выберем что полайф-кодим на следующие выходные?
Псевдо-жизнь, с применением Swing и математики. / Небольшое веб-приложение с контроллерами и Spring / Мой вариант в комментариях! / Что я делаю в этом канале!?
128 viewsedited  
Java for Beginner
Аннотация @Controller

Аннотация @Controller — один из ключевых компонентов в Spring MVC, которая помогает создать контроллеры для обработки HTTP-запросов. Контроллеры играют центральную роль в паттерне MVC (Model-View-Controller), связывая запросы клиента с необходимой логикой обработки и представлением. Аннотация @Controller указывает Spring, что данный класс будет использоваться как контроллер в веб-приложении.

1. Зачем нужна аннотация @Controller?

Аннотация @Controller служит для регистрации класса как компонента, обрабатывающего запросы. В отличие от других бинов, контроллеры работают с запросами пользователя, обрабатывая входные данные, выполняя бизнес-логику и возвращая представления. Аннотация также позволяет использовать другие аннотации, такие как @GetMapping и @PostMapping, для указания маппингов на методы контроллера.

2. Пример использования @Controller

Создадим базовый контроллер с аннотацией @Controller, который возвращает страницу приветствия.

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class HomeController {

    @GetMapping("/welcome")
    public String welcomePage(Model model) {
        model.addAttribute("message", "Добро пожаловать в Spring MVC!");
        return "welcome";
    }
}


В этом примере контроллер HomeController содержит метод welcomePage, который маппится на URL /welcome. Метод добавляет сообщение в модель, чтобы его отобразить на JSP-странице welcome.jsp.

welcome.jsp:
<!DOCTYPE html>
<html>
<body>
    <h1>${message}</h1>
</body>
</html>


3. Как работает @Controller в Spring MVC

Когда приложение получает запрос, он обрабатывается специальным объектом DispatcherServlet, который перенаправляет запрос на соответствующий контроллер. Если класс помечен как @Controller, Spring понимает, что это класс для обработки запросов, и анализирует его методы на наличие маппингов. Каждый метод, возвращающий строку с именем представления, после выполнения логики переходит к отображению страницы с этим именем.

4. Как отличить @Controller от других компонентных аннотаций

В Spring существует несколько аннотаций для управления бинами, таких как @Service, @Repository, @Component. Однако @Controller обладает уникальными возможностями, необходимыми для работы с веб-приложениями. В отличие от других бинов, контроллеры тесно связаны с веб-слоем, обрабатывая запросы и возвращая представления, в то время как @Service и @Repository отвечают за бизнес-логику и работу с данными.

5. Связь @Controller с представлениями

Контроллер в Spring может возвращать как HTML-страницу, так и данные в формате JSON. Если нужно вернуть HTML-страницу, достаточно указать имя представления. Spring автоматически передаст управление в папку представлений.

Пример возврата JSON:
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class JsonController {

    @GetMapping("/json")
    @ResponseBody
    public Map<String, String> getJson() {
        Map<String, String> response = new HashMap<>();
        response.put("message", "Привет, это JSON!");
        return response;
    }
}
Аннотация @ResponseBody позволяет вернуть JSON в качестве ответа. Теперь при обращении к /json клиент получит JSON вместо HTML.


#Java #Training #Spring #Controller
132 views
Java for Beginner
Что выведет код?

import java.util.*;

public class Task051124_1 {
    public static void main(String[] args) {
        Queue<Integer> queue = new LinkedList<>(Arrays.asList(10, 20, 30, 40, 50));
        
        queue.add(60);
        queue.offer(70);
        
        queue.poll();
        queue.remove();
        
        System.out.println("Head of queue: " + queue.peek());
        System.out.println("Queue size: " + queue.size());
    }
}


#Tasks
126 views
Java for Beginner
Варианты ответа:
Anonymous Quiz
0%
Head of queue: 30, Queue size: 4
50%
Head of queue: 20, Queue size: 5
0%
Head of queue: 40, Queue size: 3
50%
Head of queue: 30, Queue size: 5
8 voters125 views
Java for Beginner
Какое самое страшное?😱🤪😂

https://t.me/Java_for_beginner_dev

#Mems
120 views
Java for Beginner
Аннотация @RequestMapping и ее применение в Spring MVC

Аннотация @RequestMapping — это один из ключевых инструментов в Spring MVC, позволяющий маппить запросы на определенные методы контроллера. Она поддерживает гибкое указание URL-адресов, HTTP-методов, а также дополнительных параметров, таких как заголовки и параметры запроса.

1. Обзор аннотации @RequestMapping

Аннотация @RequestMapping позволяет связать запрос HTTP (GET, POST, PUT и другие) с конкретным методом контроллера. С ее помощью можно:
Маппить URL-запрос на метод контроллера.
Определять HTTP-метод, который будет обрабатывать запрос.
Устанавливать ограничения на заголовки или параметры запроса.
Настраивать регулярные выражения для динамических сегментов пути.

Пример:
@RequestMapping(value = "/example", method = RequestMethod.GET)
public String example() {
    return "example";
}


2. Использование @RequestMapping для маппинга по URL

Основное использование @RequestMapping — это связывание URL с методом контроллера. Пример маппинга на корневой URL:
@Controller
@RequestMapping("/home")
public class HomeController {

    @RequestMapping("/index")
    public String index() {
        return "homePage";
    }
}
В этом случае, запрос /home/index перенаправляется на метод index, возвращающий представление homePage.


3. Спецификация HTTP-методов

С помощью @RequestMapping можно указать, какой HTTP-метод будет обрабатывать запрос.
@RequestMapping(value = "/submit", method = RequestMethod.POST)
public String handlePost() {
    return "postPage";
}
Здесь handlePost() будет вызываться только при POST-запросе к /submit. Если отправить GET-запрос к этому же URL, сервер вернет ошибку, так как метод не поддерживает GET.


4. Маппинг с параметрами запроса

С @RequestMapping также можно настраивать параметры и заголовки. Например, так:
@RequestMapping(value = "/search", params = "query")
public String search(@RequestParam String query) {
    return "searchResult";
}
В этом случае метод search() будет обрабатывать запрос /search только если у него есть параметр query.


5. Использование регулярных выражений

Можно задавать динамические части URL с помощью регулярных выражений:
@RequestMapping("/user/{userId:[0-9]+}")
public String getUser(@PathVariable int userId) {
    return "userProfile";
}
Здесь userId должен быть числом. Этот метод будет вызван только для URL, соответствующих шаблону /user/123, но не /user/john.


6. Использование @RequestMapping на уровне класса

Если @RequestMapping применяется к классу контроллера, то все методы будут обрабатываться с префиксом, указанным в аннотации класса. Это удобно для организации кода, например:
@Controller
@RequestMapping("/users")
public class UserController {

    @RequestMapping("/list")
    public String listUsers() {
        return "userList";
    }
    
    @RequestMapping("/profile")
    public String userProfile() {
        return "userProfile";
    }
}
В данном примере запросы /users/list и /users/profile будут направлены к методам listUsers() и userProfile() соответственно.


#Java #Training #Spring #RequestMapping
121 views
Java for Beginner
Что выведет код при обращении к URL "/home/welcome"?

Задача по Spring. @Controller,@RequestMapping . Сложность легкая.

Подробный разбор через 30 минут!🫡

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@SpringBootApplication
public class Main051124_2 {
    public static void main(String[] args) {
        SpringApplication.run(Main051124_2.class, args);
    }
}

@Controller
@RequestMapping("/home")
class HomeController0511 {

    @RequestMapping("/welcome")
    @ResponseBody
    public String welcome() {
        return "Welcome to the home page!";
    }

    @RequestMapping("/hello")
    @ResponseBody
    public String hello() {
        return "Hello from home!";
    }
}


#TasksSpring
111 views