Что принимает контейнер для создания бина Spring

Что принимает контейнер для создания бина Spring

Spring контейнер (ApplicationContext) получает информацию о бинах несколькими способами. Рассмотрю все основные подходы.

1. Аннотации (@Configuration, @Bean, @Component)

Это современный и рекомендуемый подход:

// Вариант 1: @Component + автоматическое сканирование
@Component
public class UserService {
    private UserRepository repository;
    
    public UserService(UserRepository repository) {
        this.repository = repository;
    }
}

// Контейнер сканирует класспат, находит @Component
// и автоматически создает бин
ApplicationContext context = new AnnotationConfigApplicationContext(
    "com.example.service"  // Путь для сканирования
);

UserService userService = context.getBean(UserService.class);

Основные аннотации компонентов:

// @Component — общий контейнер для любого бина
@Component
public class GenericService { }

// @Service — для service слоя (semantic, более понятно)
@Service
public class UserService { }

// @Repository — для data access layer
@Repository
public class UserRepository { }

// @Controller/@RestController — для web layer
@RestController
@RequestMapping("/api/users")
public class UserController { }

// @Configuration — класс с @Bean методами
@Configuration
public class AppConfig {
    @Bean
    public UserService userService(UserRepository repository) {
        return new UserService(repository);
    }
}

2. @Bean методы в @Configuration классе

Это явное определение бинов:

@Configuration
public class DataSourceConfig {
    
    // Spring вызовет этот метод и зарегистрирует результат как бин
    @Bean
    public DataSource dataSource() {
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl("jdbc:postgresql://localhost/mydb");
        config.setUsername("user");
        config.setPassword("pass");
        return new HikariDataSource(config);
    }
    
    // Зависимости передаются как параметры метода
    @Bean
    public UserRepository userRepository(DataSource dataSource) {
        return new JdbcUserRepository(dataSource);
    }
    
    @Bean
    public UserService userService(UserRepository repository) {
        return new UserService(repository);
    }
}

// Использование
ApplicationContext context = new AnnotationConfigApplicationContext(
    DataSourceConfig.class
);
UserService userService = context.getBean(UserService.class);

3. XML конфигурация (старый способ, но все еще используется)

<!-- application-context.xml -->
<beans xmlns="http://www.springframework.org/schema/beans">
    
    <!-- Явное определение бина -->
    <bean id="userRepository" 
          class="com.example.repository.UserRepository">
        <constructor-arg ref="dataSource" />
    </bean>
    
    <bean id="userService" 
          class="com.example.service.UserService">
        <constructor-arg ref="userRepository" />
    </bean>
    
    <!-- Свойства бина -->
    <bean id="appConfig" class="com.example.AppConfig">
        <property name="maxConnections" value="10" />
        <property name="timeout" value="5000" />
    </bean>
    
</beans>

// Загрузка из XML
ApplicationContext context = new ClassPathXmlApplicationContext(
    "application-context.xml"
);
UserService userService = context.getBean("userService", UserService.class);

4. Что именно принимает контейнер

Контейнер Spring получает:

A. BeanDefinition (Метаданные о бине)

// Spring создает BeanDefinition на основе аннотаций
BeanDefinition definition = new RootBeanDefinition(UserService.class);
definition.setScope("singleton"); // или "prototype"

// Или автоматически из класса
RootBeanDefinition definition = new RootBeanDefinition();
definition.setBeanClass(UserService.class);
definition.setScope(BeanDefinition.SCOPE_SINGLETON);

// BeanDefinition содержит:
// - Класс бина
// - Способ создания (constructor, factory method)
// - Зависимости (что нужно передать)
// - Scope (singleton, prototype, request, session)
// - Жизненный цикл callbacks

B. BeanFactory (фактический создатель)

// BeanFactory — это основной интерфейс
public interface BeanFactory {
    Object getBean(String name) throws BeansException;
    <T> T getBean(String name, Class<T> requiredType) throws BeansException;
    <T> T getBean(Class<T> requiredType) throws BeansException;
}

// ApplicationContext расширяет BeanFactory и добавляет функций
public interface ApplicationContext extends BeanFactory {
    // ... дополнительные методы
}

5. Процесс создания бина (Bean Lifecycle)

public class UserService {
    
    // 1. Конструктор вызывается Spring
    public UserService(UserRepository repository) {
        this.repository = repository; // Dependency Injection
    }
    
    // 2. Setter injection (альтернатива constructor injection)
    @Autowired
    public void setRepository(UserRepository repository) {
        this.repository = repository;
    }
    
    // 3. Init callback — вызывается после создания бина
    @PostConstruct
    public void init() {
        System.out.println("Бин инициализирован");
        // Здесь можно выполнить инициализацию
    }
    
    // 4. Destroy callback — вызывается при закрытии контекста
    @PreDestroy
    public void cleanup() {
        System.out.println("Бин уничтожается");
        // Здесь можно выполнить очистку ресурсов
    }
}

6. Параметры создания бина (@Bean параметры)

@Configuration
public class AdvancedConfig {
    
    // Параметр 1: Другой бин (Spring его инжектирует)
    @Bean
    public UserService userService(UserRepository repository) {
        return new UserService(repository);
    }
    
    // Параметр 2: Конфигурационные свойства
    @Bean
    public DatabaseConfig dbConfig(
        @Value("${db.url}") String url,
        @Value("${db.username}") String username
    ) {
        return new DatabaseConfig(url, username);
    }
    
    // Параметр 3: Environment
    @Bean
    public AppConfig appConfig(Environment env) {
        return new AppConfig(env.getProperty("app.name"));
    }
    
    // Параметр 4: List других бинов
    @Bean
    public CompositeService compositeService(
        List<Service> allServices  // Spring подставит все реализации Service
    ) {
        return new CompositeService(allServices);
    }
}

7. Практический пример: полный цикл

// 1. Определяем компоненты
@Component
public class UserRepository {
    public User findById(Long id) { /* ... */ }
}

@Service
public class UserService {
    private UserRepository repository;
    
    public UserService(UserRepository repository) {
        this.repository = repository; // Dependency Injection
    }
    
    @PostConstruct
    public void init() {
        System.out.println("UserService инициализирован");
    }
}

// 2. Конфигурируем контейнер
@Configuration
@ComponentScan(basePackages = "com.example")
public class AppConfig {
    // Явные бины если нужны
}

// 3. Используем контейнер
public class Application {
    public static void main(String[] args) {
        // Spring сканирует пакеты, находит компоненты, создает бины
        ApplicationContext context = 
            new AnnotationConfigApplicationContext(AppConfig.class);
        
        // Получаем бин
        UserService userService = context.getBean(UserService.class);
        User user = userService.getUserById(1L);
    }
}

8. Что контейнер принимает: итоговый список

1. Класс бина — где его искать
2. Аннотации (@Component, @Service, @Bean и т.д.)
3. BeanDefinition — метаданные о бине
4. Зависимости — какие бины нужно инжектировать
5. Scope — singleton, prototype, request, session
6. Жизненный цикл callbacks (@PostConstruct, @PreDestroy)
7. Конфигурационные свойства (@Value, Environment)
8. Условия (@Conditional для условного создания)

Важный момент: Lazy Initialization

// По умолчанию @Bean создается EAGERLY (сразу)
@Bean
public HeavyService heavyService() {
    return new HeavyService(); // Создается при старте приложения
}

// Можем сделать LAZY (лениво, только при первом обращении)
@Bean
@Lazy
public HeavyService lazyHeavyService() {
    return new HeavyService(); // Создается только при первом getBean()
}

Вывод: Spring контейнер — это очень гибкая система, которая может получить информацию о бинах из аннотаций, XML, Java кода или programmatic API. Это позволяет разработчикам выбрать удобный способ конфигурации для своего проекта.