Что вызывает @RestController

@RestController: Аннотация и её Механизм

Этот вопрос проверяет понимание Spring Framework и того, как работают аннотации. Это важно для современной разработки на Java.

Краткий Ответ

@RestController — это метаннотация (composition аннотация), которая комбинирует:

• @Controller — помечает класс как Spring компонент для обработки веб-запросов
• @ResponseBody — сериализует результат в JSON/XML вместо возврата представления

Подробное Объяснение

Сначала давайте поймём, что вызывает аннотацию

// @RestController в Spring Framework выглядит так:

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Controller
@ResponseBody
public @interface RestController {
    @AliasFor(annotation = Controller.class)
    String value() default "";
}

// Это означает:
// 1. @Controller — это Spring компонент для веб-запросов
// 2. @ResponseBody — все возвращаемые значения сериализуются в JSON

Как Это Работает в Spring

Шаг 1: Spring находит класс с @RestController

@RestController
@RequestMapping("/api/users")
public class UserController {
    
    @GetMapping
    public User getUser(@RequestParam String id) {
        return new User(id, "John");
    }
}

// Spring делает:
// 1. Сканирует classpath при загрузке приложения
// 2. Находит класс помеченный @RestController
// 3. Создает экземпляр (bean) этого класса
// 4. Регистрирует в DispatcherServlet

Шаг 2: DispatcherServlet обрабатывает запрос

HTTP Request
    ↓
DispatcherServlet (главный сервлет Spring)
    ↓
HandlerMapping (находит подходящий контроллер)
    ↓
UserController.getUser() (вызывает метод)
    ↓
User объект (результат)
    ↓
HttpMessageConverter (@ResponseBody сериализует в JSON)
    ↓
JSON Response

Шаг 3: Сериализация результата

@RestController
public class UserController {
    
    @GetMapping("/user")
    public User getUser() {
        return new User("1", "John", "john@example.com");
    }
}

// Что происходит:
// 1. Метод возвращает User объект
// 2. Spring видит @ResponseBody (из @RestController)
// 3. Spring использует HttpMessageConverter для сериализации
// 4. Jackson (по умолчанию) конвертирует User → JSON
// 5. Отправляет в HTTP ответе

// Результат:
// {
//   "id": "1",
//   "name": "John",
//   "email": "john@example.com"
// }

Разница: @Controller vs @RestController

// ❌ @Controller — возвращает представление (HTML)
@Controller
@RequestMapping("/pages")
public class PageController {
    
    @GetMapping("/home")
    public String getHomePage(Model model) {
        model.addAttribute("title", "Home");
        return "home"; // Возвращаем имя шаблона!
    }
}

// Spring обработает:
// 1. Вызовет метод getHomePage()
// 2. Получит строку "home"
// 3. Найдет шаблон /templates/home.html (Thymeleaf)
// 4. Отрендерит HTML
// 5. Отправит HTML в браузер

// ✅ @RestController — возвращает данные (JSON)
@RestController
@RequestMapping("/api/users")
public class UserController {
    
    @GetMapping("/user")
    public User getUser() {
        return new User("1", "John");
    }
}

// Spring обработает:
// 1. Вызовет метод getUser()
// 2. Получит User объект
// 3. Сериализует в JSON (благодаря @ResponseBody)
// 4. Отправит JSON в ответе

Техника: Как Spring Регистрирует Контроллер

// 1. Spring сканирует classpath (при загрузке BeanFactory)
public class AnnotationConfigApplicationContext {
    public AnnotationConfigApplicationContext(Class<?>... configClasses) {
        this();
        register(configClasses);
        refresh(); // Здесь сканируется @RestController
    }
}

// 2. ClassPathBeanDefinitionScanner находит @RestController
@Component // @RestController наследует эту аннотацию
public class UserController { }

// 3. Spring создает BeanDefinition
GenericBeanDefinition beanDef = new GenericBeanDefinition();
beanDef.setBeanClass(UserController.class);
beanDef.setScope(BeanDefinition.SCOPE_SINGLETON);

// 4. Spring создает экземпляр (через reflection)
UserController controller = (UserController) beanDef.getBeanClass()
    .getConstructor().newInstance();

// 5. Spring регистрирует в RequestMappingHandlerMapping
requestMappingHandlerMapping.registerMapping(
    "/api/users",
    controller,
    method
);

Процесс Обработки Запроса

// HTTP GET /api/users?id=1

public class DispatcherServlet extends HttpServlet {
    protected void doGet(HttpServletRequest request, HttpServletResponse response) {
        
        // 1. Найти HandlerMapping для пути "/api/users"
        HandlerExecutionChain chain = getHandler(request);
        // chain.handler = UserController.getUser методом
        // chain.interceptors = [LoggingInterceptor, ...]
        
        // 2. Выполнить interceptor preHandle
        for (HandlerInterceptor interceptor : chain.getInterceptors()) {
            interceptor.preHandle(request, response, chain.getHandler());
        }
        
        // 3. Вызвать метод контроллера
        User user = chain.getHandler().handle(request);
        // В нашем случае: UserController.getUser()
        
        // 4. Обработать возвращаемое значение (@ResponseBody)
        HttpMessageConverter<User> converter = getConverter(User.class);
        converter.write(user, MediaType.APPLICATION_JSON, response.getBody());
        // Jackson сериализует User → JSON
        
        // 5. Выполнить interceptor postHandle
        for (HandlerInterceptor interceptor : chain.getInterceptors()) {
            interceptor.postHandle(request, response, chain.getHandler());
        }
        
        // 6. Отправить ответ
        response.flushBuffer();
    }
}

Пример с HttpMessageConverter

@RestController
public class DataController {
    
    @GetMapping("/user")
    public User getUser() {
        return new User("1", "John");
    }
    // Spring использует MappingJackson2HttpMessageConverter
    // Результат: {"id":"1","name":"John"}
    
    @GetMapping("/users")
    public List<User> getUsers() {
        return Arrays.asList(
            new User("1", "John"),
            new User("2", "Jane")
        );
    }
    // Spring автоматически обрабатывает List
    // Результат: [{"id":"1","name":"John"}, {"id":"2","name":"Jane"}]
    
    @GetMapping("/text")
    public String getText() {
        return "Hello World";
    }
    // Spring использует StringHttpMessageConverter
    // Результат: Hello World (текст/плэйн)
    
    @GetMapping("/bytes")
    public byte[] getBytes() {
        return "Binary data".getBytes();
    }
    // Spring использует ByteArrayHttpMessageConverter
    // Результат: бинарные данные
}

Где @RestController Регистрируется

// 1. В Spring Boot это происходит автоматически
@SpringBootApplication // Включает @ComponentScan
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
        // Spring сканирует все @RestController
    }
}

// 2. В обычном Spring нужно настроить
@Configuration
@ComponentScan(basePackages = "com.example")
public class WebConfig {
    // Явно сканируем пакет
}

// 3. Spring находит все классы с @RestController
Set<Class<?>> classes = scanner.findAnnotated(
    RestController.class, 
    "com.example"
);

// 4. Для каждого создает bean
for (Class<?> cls : classes) {
    BeanDefinition def = new BeanDefinition(cls);
    beanFactory.registerBeanDefinition(cls.getSimpleName(), def);
}

Полный Пример: Что Вызывает @RestController

@RestController
@RequestMapping("/api/products")
public class ProductController {
    
    private ProductService service;
    
    @Autowired // Spring инжектит зависимость
    public ProductController(ProductService service) {
        this.service = service;
    }
    
    @GetMapping("/{id}")
    public Product getProduct(@PathVariable Long id) {
        return service.findById(id);
    }
    
    @PostMapping
    public Product createProduct(@RequestBody Product product) {
        return service.save(product);
    }
    
    @PutMapping("/{id}")
    public Product updateProduct(@PathVariable Long id, @RequestBody Product product) {
        product.setId(id);
        return service.update(product);
    }
}

// Что вызывает @RestController:

// 1. ComponentScan находит класс
// 2. BeanFactory создает экземпляр
ProductController controller = new ProductController(productService);

// 3. RequestMappingHandlerMapping регистрирует маршруты
// GET /api/products/{id} → getProduct()
// POST /api/products → createProduct()
// PUT /api/products/{id} → updateProduct()

// 4. При HTTP запросе DispatcherServlet:
//    - Находит метод по маршруту
//    - Вызывает метод
//    - @ResponseBody сериализует результат в JSON
//    - Отправляет HTTP ответ

Заключение

@RestController вызывает (запускает) следующие механизмы Spring:

1. Component Scanning — Spring находит класс при загрузке
2. Bean Creation — Spring создает экземпляр класса
3. Dependency Injection — Spring инжектит зависимости
4. Request Mapping — Spring регистрирует URL маршруты
5. Request Handling — DispatcherServlet вызывает методы
6. Response Serialization — HttpMessageConverter конвертирует результат в JSON

В сущности, @RestController — это просто аннотация, которая говорит Spring:

• "Этот класс — веб-контроллер"
• "Все методы возвращают данные (JSON), не представления"

Всю остальную магию делает Spring Framework благодаря reflection и аннотациям.