Как использовать бины?

# Использование Spring бинов (Beans)

Что такое Spring бин

Bin — это объект, который управляется контейнером Spring. Spring создаёт, конфигурирует и управляет жизненным циклом бинов. Это основной компонент Spring Framework.

Способы определения бинов

1. Аннотация @Component

Самый базовый способ — пометить класс аннотацией @Component:

@Component
public class UserService {
    public void createUser(String name) {
        System.out.println("Creating user: " + name);
    }
}

// Использование
@Component
public class UserController {
    @Autowired
    private UserService userService;
    
    public void registerUser(String name) {
        userService.createUser(name);
    }
}

2. Специализированные аннотации

Spring предоставляет более специализированные аннотации:

@Service — для бизнес-логики:

@Service
public class OrderService {
    public Order createOrder(OrderRequest request) {
        // Бизнес-логика
        return new Order();
    }
}

@Repository — для доступа к БД:

@Repository
public class UserRepository {
    public User findById(Long id) {
        // Работа с БД
        return new User();
    }
}

@Controller — для REST эндпоинтов:

@RestController
@RequestMapping("/api/users")
public class UserController {
    @GetMapping("/{id}")
    public User getUser(@PathVariable Long id) {
        return new User();
    }
}

3. @Bean в конфигурационных классах

Для создания бинов более сложных объектов используют методы в конфигурационных классах:

@Configuration
public class AppConfig {
    
    @Bean
    public DataSource dataSource() {
        return new HikariDataSource();
    }
    
    @Bean
    public JdbcTemplate jdbcTemplate(DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }
    
    @Bean
    public UserService userService(JdbcTemplate jdbc) {
        return new UserService(jdbc);
    }
}

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

<beans>
    <bean id="userService" class="com.example.UserService"/>
    <bean id="orderService" class="com.example.OrderService">
        <constructor-arg ref="userService"/>
    </bean>
</beans>

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

1. Через конструктор (рекомендуемый способ)

@Service
public class OrderService {
    private final UserService userService;
    private final PaymentService paymentService;
    
    // Конструктор с зависимостями
    public OrderService(UserService userService, PaymentService paymentService) {
        this.userService = userService;
        this.paymentService = paymentService;
    }
    
    public void placeOrder(Long userId, double amount) {
        userService.validateUser(userId);
        paymentService.processPayment(amount);
    }
}

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

• Зависимости явные
• Легче тестировать
• Обязательные поля
• Неизменяемость (final)

2. Через поле (field injection)

@Service
public class OrderService {
    @Autowired
    private UserService userService;
    
    @Autowired
    private PaymentService paymentService;
}

Недостатки:

• Скрытые зависимости
• Сложнее тестировать (нужен Spring для тестов)
• Может привести к NullPointerException

3. Через setter

@Service
public class OrderService {
    private UserService userService;
    private PaymentService paymentService;
    
    @Autowired
    public void setUserService(UserService service) {
        this.userService = service;
    }
    
    @Autowired
    public void setPaymentService(PaymentService service) {
        this.paymentService = service;
    }
}

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

@Service
public class MyService implements InitializingBean, DisposableBean {
    
    // 1. Конструктор
    public MyService() {
        System.out.println("1. Constructor called");
    }
    
    // 2. Установка зависимостей
    @Autowired
    private SomeDependency dependency;
    
    // 3. Инициализация после конструктора
    @PostConstruct
    public void init() {
        System.out.println("3. PostConstruct: Bean initialized");
        // Подключение к БД, загрузка конфига
    }
    
    // 4. afterPropertiesSet (опционально)
    @Override
    public void afterPropertiesSet() {
        System.out.println("4. afterPropertiesSet");
    }
    
    // 5. Уничтожение
    @PreDestroy
    public void destroy() {
        System.out.println("5. PreDestroy: Bean destroyed");
        // Закрытие соединений, очистка ресурсов
    }
}

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

1. Singleton (по умолчанию)

@Component
@Scope("singleton")
public class AppConfig {
    // Один экземпляр на всё приложение
}

2. Prototype

@Component
@Scope("prototype")
public class RequestProcessor {
    // Новый экземпляр каждый раз
}

3. Request, Session, Application (только для web)

@Component
@Scope("request")
public class RequestData {
    // Новый экземпляр для каждого HTTP запроса
}

Разрешение неоднозначности с @Qualifier

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

@Component("creditCard")
public class CreditCardPaymentService implements PaymentService {
    @Override
    public void pay(double amount) {
        System.out.println("Pay with credit card: " + amount);
    }
}

@Component("paypal")
public class PayPalPaymentService implements PaymentService {
    @Override
    public void pay(double amount) {
        System.out.println("Pay with PayPal: " + amount);
    }
}

@Service
public class OrderService {
    @Autowired
    @Qualifier("creditCard")
    private PaymentService paymentService;
}

@Primary для выбора по умолчанию

@Component
@Primary
public class CreditCardPaymentService implements PaymentService {
    // Этот бин будет использоваться по умолчанию
}

@Service
public class OrderService {
    @Autowired
    private PaymentService paymentService;  // Используется CreditCard
}

Ленивая инициализация (@Lazy)

@Component
@Lazy
public class HeavyService {
    public HeavyService() {
        System.out.println("HeavyService initialized");
        // Инициализируется только при первом использовании
    }
}

Условное создание бинов (@ConditionalOnProperty)

@Configuration
public class PaymentConfig {
    
    @Bean
    @ConditionalOnProperty(name = "payment.method", havingValue = "stripe")
    public PaymentService stripePaymentService() {
        return new StripePaymentService();
    }
    
    @Bean
    @ConditionalOnProperty(name = "payment.method", havingValue = "paypal")
    public PaymentService paypalPaymentService() {
        return new PayPalPaymentService();
    }
}

Практический пример

// Repository層
@Repository
public class UserRepository {
    private final JdbcTemplate jdbc;
    
    public UserRepository(JdbcTemplate jdbc) {
        this.jdbc = jdbc;
    }
    
    public User findById(Long id) {
        return jdbc.queryForObject(
            "SELECT * FROM users WHERE id = ?",
            new UserRowMapper(),
            id
        );
    }
}

// Service層
@Service
public class UserService {
    private final UserRepository userRepository;
    private final EmailService emailService;
    
    public UserService(UserRepository userRepository, EmailService emailService) {
        this.userRepository = userRepository;
        this.emailService = emailService;
    }
    
    public User getUser(Long id) {
        User user = userRepository.findById(id);
        if (user != null) {
            emailService.sendWelcomeEmail(user.getEmail());
        }
        return user;
    }
}

// Controller層
@RestController
@RequestMapping("/api/users")
public class UserController {
    private final UserService userService;
    
    public UserController(UserService userService) {
        this.userService = userService;
    }
    
    @GetMapping("/{id}")
    public ResponseEntity<User> getUser(@PathVariable Long id) {
        return ResponseEntity.ok(userService.getUser(id));
    }
}

// Configuration
@Configuration
public class AppConfig {
    @Bean
    public JdbcTemplate jdbcTemplate(DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }
}

Лучшие практики

1. Используй constructor injection — явные зависимости
2. Делай бины final и immutable — безопаснее
3. Не используй field injection — сложнее тестировать
4. Используй @Qualifier для разрешения конфликтов — явность
5. Определяй @PostConstruct и @PreDestroy — управление ресурсами
6. Избегай циклических зависимостей — может привести к ошибкам
7. Используй правильные аннотации — @Service, @Repository, @Controller

Понимание работы Spring бинов — ключ к разработке scalable Java приложений.