Является ли контроллер бином?

# Является ли контроллер бином?

Да, контроллер является Spring бином (bean). Это фундаментальное понимание Spring фреймворка. Контроллеры регистрируются как beans в контексте приложения и управляются Spring контейнером, как и любые другие компоненты.

Что такое Bean в Spring

Spring Bean — это объект, управляемый Spring контейнером:

• Создается Spring (не новый оператор)
• Инициализируется с помощью конструкторов/фабрик
• Конфигурируется через dependency injection
• Управляется жизненным циклом (init → use → destroy)
• Может быть singleton, prototype, request-scoped и т.д.

Контроллер как Bean

Регистрация контроллера

// ✅ @Controller или @RestController — это метаанннотации @Component
@RestController
@RequestMapping("/api/users")
public class UserController {  // ЭТО BEAN!
    
    @Autowired  // Внедрение зависимостей
    private UserService userService;
    
    @GetMapping("/{id}")
    public UserDTO getUser(@PathVariable Long id) {
        return userService.findById(id);
    }
}

Spring делает следующее:

1. Classpath Scanning
   ├─ Находит класс UserController
   └─ Видит аннотацию @RestController

2. Bean Registration
   ├─ Регистрирует UserController как bean
   └─ ID бина = "userController" (camelCase от имени класса)

3. Instantiation
   ├─ Создает экземпляр: new UserController()
   └─ Теперь это управляемый объект

4. Dependency Injection
   ├─ Видит @Autowired private UserService
   ├─ Находит UserService bean
   └─ Внедряет его в контроллер

5. Registration in Container
   ├─ userController bean готов к использованию
   ├─ Когда приходит HTTP запрос на /api/users/1
   └─ Spring вызывает метод на этом бине

Аннотации контроллеров — это метаанnotations @Component

Иерархия аннотаций

// @RestController является производной @Component
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Controller  // это тоже @Component
@ResponseBody  // для REST-like responses
public @interface RestController {
    @AliasFor(annotation = Controller.class)
    String value() default "";
}

// @Controller тоже @Component
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component  // ЗДЕСЬ! Это просто @Component
public @interface Controller {
    String value() default "";
}

Вывод:

@RestController = @Component + @ResponseBody
@Controller = @Component

Это означает, что контроллер регистрируется как bean точно так же, как любой класс с @Component.

Доказательство: Spring контейнер управляет контроллером

Пример 1: Внедрение зависимостей

@RestController
@RequestMapping("/api/products")
public class ProductController {
    
    // ✅ Spring внедряет эти зависимости как beans
    @Autowired
    private ProductService productService;
    
    @Autowired
    private Logger logger;
    
    @Autowired
    private ObjectMapper mapper;
    
    @GetMapping()
    public List<ProductDTO> getAll() {
        logger.info("Getting all products");  // logger внедрен
        return productService.findAll();      // сервис внедрен
    }
}

// Это работает ТОЛЬКО потому что контроллер — это bean
// Spring может внедрять зависимости в beans

Пример 2: Жизненный цикл бина

@RestController
@RequestMapping("/api/data")
public class DataController implements InitializingBean, DisposableBean {
    
    private DataCache cache;
    
    // Вызывается Spring при создании бина
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("Controller bean created");
        cache = new DataCache();
        cache.preloadData();
    }
    
    // Вызывается Spring при уничтожении бина
    @Override
    public void destroy() throws Exception {
        System.out.println("Controller bean destroyed");
        cache.shutdown();
    }
}

// Это жизненный цикл BEAN!
// Spring управляет контроллером как бином

Пример 3: @PostConstruct и @PreDestroy

@RestController
@RequestMapping("/api/orders")
public class OrderController {
    
    @Autowired
    private OrderService orderService;
    
    // Вызывается Spring после внедрения зависимостей
    @PostConstruct
    public void init() {
        System.out.println("OrderController bean initialized");
        orderService.validateConnection();
    }
    
    // Вызывается Spring перед уничтожением бина
    @PreDestroy
    public void cleanup() {
        System.out.println("OrderController bean is shutting down");
        orderService.closeConnections();
    }
    
    @PostMapping
    public OrderDTO createOrder(@RequestBody CreateOrderRequest request) {
        return orderService.create(request);
    }
}

Область видимости (Scope) контроллера

По умолчанию: Singleton

// ✅ По умолчанию контроллер — SINGLETON
@RestController
public class UserController {
    // Создается ОДН раз при запуске приложения
    // Переиспользуется для всех запросов
}

// Эквивалентно:
@RestController
@Scope("singleton")
public class UserController {
}

Как это работает:

Приложение стартует:
├─ Spring создает UserController bean (новый экземпляр)
├─ Регистрирует его в контейнере
└─ Готов к использованию

Приходит первый запрос:
├─ HTTP GET /api/users/1
├─ Spring берет то ЖЕ самое экземпляр контроллера
└─ Вызывает метод getUser(1)

Приходит второй запрос:
├─ HTTP GET /api/users/2
├─ Spring берет ТО ЖЕ самое экземпляр контроллера
└─ Вызывает метод getUser(2)

Все запросы ПЕРЕИСПОЛЬЗУЮТ ОДИН бин!

Можно менять scope

// Request-scoped контроллер (создается для каждого запроса)
@RestController
@Scope("request")
public class SessionController {
    // Каждый запрос получает новый экземпляр
    // Полезно для thread-local данных
}

// Prototype (новый экземпляр каждый раз)
@RestController
@Scope("prototype")
public class PrototypeController {
    // Каждый раз при запросе создается новый экземпляр
    // Редко используется для контроллеров
}

Где контроллер находится в контейнере

Получение контроллера из контейнера

public class Application {
    public static void main(String[] args) {
        ApplicationContext context = SpringApplication.run(Application.class, args);
        
        // ✅ Контроллер есть в контейнере как bean
        UserController controller = context.getBean("userController", UserController.class);
        System.out.println(controller);  // UserController bean instance
        
        // Можно получить по типу
        UserController controller2 = context.getBean(UserController.class);
        System.out.println(controller == controller2);  // true (singleton)
    }
}

Разница: Spring Bean vs простой объект

Простой объект (без Spring)

public class SimpleController {
    public SimpleController() {
        System.out.println("Created with new operator");
    }
}

public class Main {
    public static void main(String[] args) {
        // Создание БЕЗ Spring
        SimpleController controller = new SimpleController();
        // Spring не управляет этим объектом
    }
}

Проблемы:

• ❌ Dependency injection не работает
• ❌ Нет жизненного цикла
• ❌ Нет @PostConstruct/@PreDestroy
• ❌ Нет scope управления

Spring Bean (с аннотациями)

@RestController
public class SpringManagedController {
    
    @Autowired  // ✅ Работает
    private UserService userService;
    
    @PostConstruct  // ✅ Вызывается Spring
    public void init() { }
    
    @PreDestroy  // ✅ Вызывается Spring
    public void cleanup() { }
}

public class Main {
    public static void main(String[] args) {
        ApplicationContext context = SpringApplication.run(Main.class);
        // Spring управляет жизненным циклом контроллера
    }
}

Преимущества:

• ✅ Automatic dependency injection
• ✅ Lifecycle callbacks
• ✅ Scope management
• ✅ AOP и другие Spring features

Как Spring обрабатывает HTTP запросы через бин-контроллер

1. HTTP запрос приходит
   GET /api/users/1
   
2. DispatcherServlet перехватывает
   (центральный сервлет Spring)
   
3. Spring ищет подходящий бин
   @RequestMapping("/api/users")
   UserController bean
   
4. Spring вызывает метод на бине
   userController.getUser(1L)
   
5. Бин выполняет бизнес-логику
   UserDTO dto = userService.findById(1L)
   
6. Spring сериализует результат
   DTO → JSON
   
7. HTTP response отправляется
   {"id": 1, "name": "John"}

Проверка: как узнать, что контроллер — это bean

Способ 1: ApplicationContext

@SpringBootTest
public class ControllerBeanTest {
    
    @Autowired
    private ApplicationContext context;
    
    @Test
    public void testControllerIsBean() {
        // ✅ Контроллер есть в контейнере
        assertTrue(context.containsBean("userController"));
        
        // ✅ Можно получить его как bean
        UserController bean = context.getBean(UserController.class);
        assertNotNull(bean);
    }
}

Способ 2: @Autowired инъекция

@SpringBootTest
public class ControllerAutowireTest {
    
    // ✅ Если бы контроллер НЕ был бином,
    // эта инъекция бы не работала
    @Autowired
    private UserController userController;
    
    @Test
    public void testControllerInjection() {
        assertNotNull(userController);  // Внедрен как bean
    }
}

Best Practices для контроллеров-бинов

1. Singleton контроллер — thread-safe

// ✅ Контроллер singleton → используй thread-safe поля
@RestController
public class OrderController {
    @Autowired
    private OrderService service;  // ✅ Thread-safe (внедрено один раз)
    
    private List<Order> cache = new CopyOnWriteArrayList<>();  // ✅ Thread-safe
    
    // ❌ НЕ используй изменяемые поля!
    // private int counter = 0;  // ОПАСНО! Race condition
}

2. Используй constructor injection для бинов

// ✅ Лучше: constructor injection явно показывает зависимости
@RestController
public class ProductController {
    private final ProductService service;
    private final Logger logger;
    
    public ProductController(ProductService service, Logger logger) {
        this.service = service;
        this.logger = logger;
    }
}

// ❌ Если нужно: field injection для optional зависимостей
@RestController
public class LegacyController {
    @Autowired(required = false)
    private OptionalService optionalService;
}

3. Минимальная логика в контроллере

// ✅ Контроллер — тонкая оболочка
@RestController
public class UserController {
    @Autowired
    private UserService service;
    
    @GetMapping("/{id}")
    public UserDTO getUser(@PathVariable Long id) {
        return service.findById(id);  // Вся логика в сервисе
    }
}

// ❌ Не клади бизнес-логику в контроллер
@RestController
public class BadController {
    @GetMapping("/{id}")
    public UserDTO getUser(@PathVariable Long id) {
        // ❌ ПЛОХО: бизнес-логика в контроллере
        if (id < 1) throw new Exception();
        // много других проверок
        // валидация
        // вычисления
    }
}

Заключение

Да, контроллер является Spring бином:

1. Регистрируется как bean через @Controller/@RestController
2. Управляется Spring контейнером (создание, инициализация, уничтожение)
3. Может получать dependency injection через @Autowired
4. По умолчанию singleton scope (переиспользуется для всех запросов)
5. Поддерживает lifecycle callbacks (@PostConstruct/@PreDestroy)
6. Может быть извлечен из контейнера через ApplicationContext.getBean()

Это означает, что контроллер подчиняется всем правилам и преимуществам Spring бинов.