Можно ли повлиять на жизненные фазы Spring бина?

Можно ли повлиять на жизненные фазы Spring бина?

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

Да, абсолютно можно. Spring предоставляет множество способов влиять на жизненный цикл бина, начиная от инициализации и заканчивая уничтожением. Это один из ключевых механизмов Spring Framework для гибкого управления приложением.

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

Основные этапы:

1. Instantiation — создание экземпляра класса
2. Dependency Injection — внедрение зависимостей
3. Post-Construction Initialization — инициализация
4. Working — жизнь объекта в контейнере
5. Destruction — уничтожение бина

Способы влияния на жизненный цикл

1. Аннотации @PostConstruct и @PreDestroy

Самый простой способ:

@Component
public class UserService {
    private DatabaseConnection dbConnection;
    
    // Выполняется сразу после создания и внедрения зависимостей
    @PostConstruct
    public void init() {
        System.out.println("UserService инициализирован");
        dbConnection = new DatabaseConnection();
        dbConnection.connect();
    }
    
    // Выполняется перед удалением бина из контейнера
    @PreDestroy
    public void cleanup() {
        System.out.println("UserService уничтожается");
        dbConnection.close();
    }
    
    public void saveUser(User user) {
        dbConnection.execute("INSERT INTO users ...");
    }
}

2. Интерфейсы InitializingBean и DisposableBean

Более явный подход:

@Component
public class EmailService implements InitializingBean, DisposableBean {
    private EmailClient emailClient;
    
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("EmailService инициализирован");
        emailClient = new EmailClient();
        emailClient.authenticate();
    }
    
    @Override
    public void destroy() throws Exception {
        System.out.println("EmailService уничтожается");
        emailClient.shutdown();
    }
    
    public void sendEmail(String to, String message) {
        emailClient.send(to, message);
    }
}

3. Методы инициализации и уничтожения в @Bean

В Java Config:

@Configuration
public class AppConfig {
    
    @Bean(initMethod = "initialize", destroyMethod = "shutdown")
    public PaymentService paymentService() {
        return new PaymentService();
    }
}

public class PaymentService {
    public void initialize() {
        System.out.println("PaymentService инициализирован");
        // Настройка платёжного шлюза
    }
    
    public void shutdown() {
        System.out.println("PaymentService выключается");
        // Закрытие соединений
    }
}

4. BeanPostProcessor

Для применения к ВСЕМ бинам или группе:

@Component
public class CustomBeanPostProcessor implements BeanPostProcessor {
    
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) 
            throws BeansException {
        System.out.println("До инициализации: " + beanName);
        // Здесь можно изменить бин ДО @PostConstruct
        return bean;
    }
    
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) 
            throws BeansException {
        System.out.println("После инициализации: " + beanName);
        // Здесь можно обработать бин ПОСЛЕ @PostConstruct
        return bean;
    }
}

5. ApplicationContextAware и BeanNameAware

Получение доступа к контексту:

@Component
public class ContextAwareService implements ApplicationContextAware, BeanNameAware {
    private ApplicationContext applicationContext;
    private String beanName;
    
    @Override
    public void setApplicationContext(ApplicationContext context) throws BeansException {
        this.applicationContext = context;
        System.out.println("Получен ApplicationContext");
    }
    
    @Override
    public void setBeanName(String name) {
        this.beanName = name;
        System.out.println("Имя бина: " + name);
    }
    
    public void dynamicallyLoadBeans() {
        // Можно достать другие бины из контекста
        UserService userService = applicationContext.getBean(UserService.class);
    }
}

Полный пример жизненного цикла

@Component
public class LifecycleService 
        implements InitializingBean, DisposableBean, 
                   BeanNameAware, ApplicationContextAware {
    
    private ApplicationContext context;
    private String name;
    
    public LifecycleService() {
        System.out.println("1️⃣ Конструктор вызван");
    }
    
    @Override
    public void setBeanName(String beanName) {
        this.name = beanName;
        System.out.println("2️⃣ setBeanName: " + beanName);
    }
    
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) {
        this.context = applicationContext;
        System.out.println("3️⃣ setApplicationContext вызван");
    }
    
    @PostConstruct
    public void postConstruct() {
        System.out.println("4️⃣ @PostConstruct вызван");
    }
    
    @Override
    public void afterPropertiesSet() {
        System.out.println("5️⃣ afterPropertiesSet вызван");
    }
    
    @PreDestroy
    public void preDestroy() {
        System.out.println("6️⃣ @PreDestroy вызван");
    }
    
    @Override
    public void destroy() {
        System.out.println("7️⃣ destroy вызван");
    }
}

// Вывод:
// 1️⃣ Конструктор вызван
// 2️⃣ setBeanName: lifecycleService
// 3️⃣ setApplicationContext вызван
// 4️⃣ @PostConstruct вызван
// 5️⃣ afterPropertiesSet вызван
// ... бин работает ...
// 6️⃣ @PreDestroy вызван
// 7️⃣ destroy вызван

InitializingBean vs @PostConstruct

Практический пример: работа с БД

@Component
public class DatabaseInitializer {
    private final DataSource dataSource;
    private Connection connection;
    
    public DatabaseInitializer(DataSource dataSource) {
        this.dataSource = dataSource;
    }
    
    @PostConstruct
    public void initializeDatabase() throws SQLException {
        connection = dataSource.getConnection();
        // Создаём схему если её нет
        try (Statement stmt = connection.createStatement()) {
            stmt.execute("CREATE SCHEMA IF NOT EXISTS app");
        }
        System.out.println("Database инициализирована");
    }
    
    @PreDestroy
    public void closeDatabase() throws SQLException {
        if (connection != null && !connection.isClosed()) {
            connection.close();
            System.out.println("Database соединение закрыто");
        }
    }
}

Заключение

Spring предоставляет мощный и гибкий механизм управления жизненным циклом бинов. Основные инструменты:

• @PostConstruct / @PreDestroy — используй для 90% случаев
• InitializingBean / DisposableBean — для сложных сценариев
• BeanPostProcessor — для глобальной обработки
• Aware интерфейсы — для доступа к контексту Spring

Это позволяет управлять инициализацией ресурсов, кэшированием, соединениями с БД и корректным завершением работы приложения.