Как конфигурируются бины

# Как конфигурируются бины в Spring?

Что такое бин

Бин — это объект, которым управляет Spring контейнер. Вместо того чтобы писать new UserService(), мы даём Spring инструкции как создавать и конфигурировать объекты.

3 основных способа конфигурации бинов

1. Аннотации (самый популярный способ)

// @Component — базовая аннотация для любого бина
@Component
public class EmailService {
    public void send(String message) {
        System.out.println("Отправлено: " + message);
    }
}

// @Service — специализация для бизнес-логики
@Service
public class UserService {
    private EmailService emailService; // Spring внедрит сам
    
    @Autowired // внедрение зависимости
    public UserService(EmailService emailService) {
        this.emailService = emailService;
    }
    
    public void registerUser(String email) {
        emailService.send("Добро пожаловать!");
    }
}

// @Repository — для доступа к данным
@Repository
public class UserRepository {
    // Логика работы с БД
}

// @Controller или @RestController — для веб-запросов
@RestController
@RequestMapping("/api/users")
public class UserController {
    @Autowired
    private UserService userService;
    
    @PostMapping
    public void createUser(@RequestBody User user) {
        userService.registerUser(user.getEmail());
    }
}

2. Java конфигурация (@Configuration)

Когда нужна более гибкая конфигурация или интеграция сторонних библиотек:

@Configuration
public class AppConfig {
    
    // Простой бин
    @Bean
    public EmailService emailService() {
        return new EmailService();
    }
    
    // Бин с зависимостью
    @Bean
    public UserService userService(EmailService emailService) {
        return new UserService(emailService);
    }
    
    // Бин с условием
    @Bean
    @ConditionalOnProperty(name = "app.cache.enabled", havingValue = "true")
    public CacheManager cacheManager() {
        return new RedisCacheManager();
    }
    
    // Бин с жизненным циклом
    @Bean(initMethod = "init", destroyMethod = "shutdown")
    public DatabaseConnection dbConnection() {
        return new DatabaseConnection();
    }
}

3. XML конфигурация (устаревший способ)

В старых проектах может встречаться:

<!-- applicationContext.xml -->
<beans>
    <bean id="emailService" class="com.example.EmailService"/>
    
    <bean id="userService" class="com.example.UserService">
        <constructor-arg ref="emailService"/>
    </bean>
</beans>

Внедрение зависимостей (Dependency Injection)

Через конструктор (рекомендуется)

@Service
public class OrderService {
    private final UserRepository userRepository;
    private final PaymentService paymentService;
    
    // Все зависимости явные, нельзя создать без них
    public OrderService(UserRepository userRepository, PaymentService paymentService) {
        this.userRepository = userRepository;
        this.paymentService = paymentService;
    }
}

Через setter

@Service
public class OrderService {
    private UserRepository userRepository;
    
    @Autowired
    public void setUserRepository(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
}

Через поле (@Autowired)

@Service
public class OrderService {
    @Autowired
    private UserRepository userRepository; // не рекомендуется
}

Scope бинов

Как долго живет объект бина:

// Singleton (по умолчанию) — один объект на все приложение
@Bean
@Scope("singleton")
public UserService userService() {
    return new UserService();
}

// Prototype — новый объект при каждом запросе
@Bean
@Scope("prototype")
public RequestContext requestContext() {
    return new RequestContext();
}

// Request scope — новый объект на каждый HTTP запрос
@Bean
@Scope("request")
public HttpSession httpSession() {
    return new HttpSession();
}

Квалификаторы (когда несколько реализаций одного интерфейса)

public interface PaymentService {
    void pay(double amount);
}

@Service
public class StripePayment implements PaymentService { ... }

@Service
public class PayPalPayment implements PaymentService { ... }

// Использование
@Service
public class OrderService {
    private final PaymentService paymentService;
    
    // Указываем какую реализацию внедрить
    public OrderService(@Qualifier("stripePayment") PaymentService paymentService) {
        this.paymentService = paymentService;
    }
}

Профили (разные конфигурации для окружения)

// Для development
@Configuration
@Profile("dev")
public class DevConfig {
    @Bean
    public DataSource dataSource() {
        return new EmbeddedDatabaseBuilder().addScript("schema.sql").build();
    }
}

// Для production
@Configuration
@Profile("prod")
public class ProdConfig {
    @Bean
    public DataSource dataSource() {
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl(System.getenv("DB_URL"));
        return new HikariDataSource(config);
    }
}

Жизненный цикл бина

@Component
public class MyService implements InitializingBean, DisposableBean {
    
    // 1. Конструктор
    public MyService() { }
    
    // 2. Установка зависимостей (@Autowired)
    @Autowired
    private Dependency dependency;
    
    // 3. Инициализация
    @PostConstruct
    public void init() {
        System.out.println("Инициализация");
        // Открыть соединение с БД, загрузить кэш и т.д.
    }
    
    // 4. Использование
    public void doWork() { }
    
    // 5. Удаление
    @PreDestroy
    public void cleanup() {
        System.out.println("Очистка ресурсов");
        // Закрыть соединения
    }
}

Практические советы

1. Используй конструкторное внедрение — видны все зависимости, легче тестировать
2. Избегай @Autowired на полях — усложняет тестирование и зависимости неявные
3. @Configuration вместо XML — современнее, проще отлаживать
4. Не забывай про @ComponentScan — Spring должна знать где искать компоненты
5. Используй профили — разные конфигурации для разных окружений

Примерная иерархия

UserController (@RestController)
    ↓ внедрение
UserService (@Service)
    ↓ внедрение
UserRepository (@Repository)
    ↓ внедрение
Datasource (@Bean)

Все эти компоненты создаёт и управляет Spring контейнер на старте приложения.