Как работает BeanPostProcessor в Spring?

BeanPostProcessor в Spring

BeanPostProcessor — это интерфейс Spring Framework, позволяющий модифицировать bean-ы на этапе инициализации (создание и настройка объектов). Это мощный механизм для apply логики к всем bean-ам или специфичным bean-ам во время их жизненного цикла.

Что такое BeanPostProcessor?

BeanPostProcessor — это callback интерфейс с двумя методами:

public interface BeanPostProcessor {
    // Вызывается ДО инициализации bean-а (после setProperty)
    @Nullable
    default Object postProcessBeforeInitialization(Object bean, String beanName)
            throws BeansException {
        return bean;
    }

    // Вызывается ПОСЛЕ инициализации bean-а (@PostConstruct, init-method)
    @Nullable
    default Object postProcessAfterInitialization(Object bean, String beanName)
            throws BeansException {
        return bean;
    }
}

Жизненный цикл Bean-а с BeanPostProcessor

1. Создание экземпляра bean-а (new)
2. Установка зависимостей (Dependency Injection)
3. ✓ postProcessBeforeInitialization() <- BeanPostProcessor
4. @PostConstruct или init-method
5. ✓ postProcessAfterInitialization() <- BeanPostProcessor
6. Bean готов к использованию
7. При завершении контекста: @PreDestroy или destroy-method

Пример 1: Простой BeanPostProcessor

import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;

@Component
public class LoggingBeanPostProcessor implements BeanPostProcessor {
    
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName)
            throws BeansException {
        System.out.println("Before init: " + beanName + " (" + bean.getClass().getSimpleName() + ")");
        return bean;
    }
    
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName)
            throws BeansException {
        System.out.println("After init: " + beanName + " (" + bean.getClass().getSimpleName() + ")");
        return bean;
    }
}

// Класс для тестирования
@Component
public class MyService {
    @PostConstruct
    public void init() {
        System.out.println("MyService initialization");
    }
}

// Вывод:
// Before init: myService (MyService)
// MyService initialization
// After init: myService (MyService)

Пример 2: Прокси и AOP

Spring использует BeanPostProcessor для создания прокси-объектов (AOP, @Transactional):

@Component
public class ProxyCreatingBeanPostProcessor implements BeanPostProcessor {
    
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        // Если bean помечен @Transactional, создаём прокси
        if (bean.getClass().isAnnotationPresent(Transactional.class)) {
            return createProxy(bean); // Прокси оборачивает оригинальный bean
        }
        return bean;
    }
    
    private Object createProxy(Object bean) {
        // Используем Java Dynamic Proxy или CGLIB для создания прокси
        InvocationHandler handler = (proxy, method, args) -> {
            System.out.println("[PROXY] Перехватили вызов: " + method.getName());
            return method.invoke(bean, args);
        };
        return Proxy.newProxyInstance(
            bean.getClass().getClassLoader(),
            bean.getClass().getInterfaces(),
            handler
        );
    }
}

Это основной механизм, через который Spring реализует @Transactional, @Async, @Cacheable.

Пример 3: Модификация bean-а

import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;

@Configuration
public class PropertyInjecterPostProcessor implements BeanPostProcessor, Ordered {
    
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        // Инъектируем переменные окружения в bean-ы
        Field[] fields = bean.getClass().getDeclaredFields();
        for (Field field : fields) {
            if (field.isAnnotationPresent(MyCustomProperty.class)) {
                MyCustomProperty annotation = field.getAnnotation(MyCustomProperty.class);
                String value = System.getenv(annotation.value());
                
                field.setAccessible(true);
                try {
                    field.set(bean, value);
                } catch (IllegalAccessException e) {
                    throw new RuntimeException(e);
                }
            }
        }
        return bean;
    }
    
    @Override
    public int getOrder() {
        return Ordered.HIGHEST_PRECEDENCE; // Выполнить в первую очередь
    }
}

// Custom аннотация
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyCustomProperty {
    String value();
}

// Использование
@Service
public class ConfigurableService {
    @MyCustomProperty("APP_NAME")
    private String appName; // Инъектируется из переменной окружения
}

Пример 4: Валидация Bean-ов

@Component
public class BeanValidationPostProcessor implements BeanPostProcessor {
    
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        // Валидируем все bean-ы с @Validated
        if (bean.getClass().isAnnotationPresent(Validated.class)) {
            validateBean(bean);
        }
        return bean;
    }
    
    private void validateBean(Object bean) {
        Field[] fields = bean.getClass().getDeclaredFields();
        for (Field field : fields) {
            if (field.isAnnotationPresent(NotNull.class)) {
                field.setAccessible(true);
                try {
                    Object value = field.get(bean);
                    if (value == null) {
                        throw new IllegalStateException(
                            "Field " + field.getName() + " in " + bean.getClass().getSimpleName() + " is null"
                        );
                    }
                } catch (IllegalAccessException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}

Spring-ы BeanPostProcessor (встроенные)

Spring использует множество встроенных BeanPostProcessor-ов:

1. AutowiredAnnotationBeanPostProcessor — обрабатывает @Autowired
2. CommonAnnotationBeanPostProcessor — обрабатывает @PostConstruct, @PreDestroy, @Resource
3. PersistenceExceptionTranslationPostProcessor — переводит JDBC исключения в Spring DataAccessException
4. AsyncAnnotationBeanPostProcessor — обрабатывает @Async
5. CacheAnnotationBeanPostProcessor — обрабатывает @Cacheable, @CacheEvict
6. MethodValidationPostProcessor — валидирует аргументы методов (@Validated)
7. ProxyCreatorSupport — создаёт AOP прокси

Порядок выполнения (Ordering)

Множество BeanPostProcessor-ов выполняются в определённом порядке:

@Component
@Order(1) // Выполнится первым
public class FirstProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        System.out.println("First: " + beanName);
        return bean;
    }
}

@Component
@Order(2) // Выполнится вторым
public class SecondProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        System.out.println("Second: " + beanName);
        return bean;
    }
}

Возвращаемое значение BeanPostProcessor

Важно: BeanPostProcessor может вернуть другой объект!

@Component
public class WrappingBeanPostProcessor implements BeanPostProcessor {
    
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        // Можно обернуть или заменить bean
        if (bean instanceof DataSource) {
            // Оборачиваем DataSource в ConnectionPool
            return new ConnectionPoolWrapper((DataSource) bean);
        }
        return bean; // Или вернуть оригинальный bean
    }
}

Практические случаи использования

1. Логирование инициализации — отслеживание создания bean-ов
2. Создание прокси — AOP, @Transactional, @Async
3. Инъекция зависимостей — настройка пользовательских аннотаций
4. Валидация — проверка bean-ов перед использованием
5. Модификация свойств — автоматическая инъекция конфигурации
6. Мониторинг — метрики производительности

BeanPostProcessor — это один из самых мощных расширений Spring, позволяющий customизировать поведение всех bean-ов в контексте приложения.