В чем разница между BeanFactoryPostProcessor и BeanPostProcessor в Spring?

# BeanFactoryPostProcessor vs BeanPostProcessor в Spring

Это два фундаментальных интерфейса в Spring для расширения и модификации жизненного цикла bean-ов. Хотя они звучат похоже, они работают на разных этапах и имеют разные предназначения.

Временная шкала жизненного цикла Bean

Для понимания разницы важно знать порядок этапов:

1. Читается BeanDefinition (метаинформация)
2. ▼ BeanFactoryPostProcessor обрабатывает BeanDefinition-ы
3. Создается инстанс Bean (constructor)
4. Устанавливаются свойства (setter injection)
5. ▼ BeanPostProcessor.postProcessBeforeInitialization()
6. Вызывается @PostConstruct / init-method
7. Bean готов к использованию
8. ▼ BeanPostProcessor.postProcessAfterInitialization()
9. Bean находится в контексте (может быть использован)

BeanFactoryPostProcessor

Работает с определением bean-а (BeanDefinition), до создания его инстанса.

Определение

public interface BeanFactoryPostProcessor {
    void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) 
        throws BeansException;
}

Когда вызывается

• После создания BeanFactory, но ДО создания инстансов bean-ов
• Обрабатывает BeanDefinition-ы
• Вызывается один раз для каждого BeanDefinition

Примеры использования

// 1. Модификация BeanDefinition-ов
@Component
public class CustomBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        // Получить BeanDefinition
        BeanDefinition beanDef = beanFactory.getBeanDefinition("myBean");
        
        // Модифицировать метаинформацию
        beanDef.setScope(BeanDefinition.SCOPE_PROTOTYPE); // изменить scope
        beanDef.setAttribute("customAttribute", "value"); // добавить атрибут
        
        // Зарегистрировать новый BeanDefinition
        GenericBeanDefinition newBeanDef = new GenericBeanDefinition();
        newBeanDef.setBeanClass(SomeClass.class);
        beanFactory.registerBeanDefinition("dynamicBean", newBeanDef);
    }
}

// 2. PropertyPlaceholderConfigurer - подстановка ${} плейсхолдеров
public class PropertyPlaceholderConfigurer extends PropertyResourceConfigurer 
    implements BeanFactoryPostProcessor {
    // Заменяет ${property.name} на значения из properties файла
}

// 3. Условная регистрация bean-ов
@Component
public class ConditionalBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        String activeProfile = System.getProperty("spring.profiles.active");
        
        if ("production".equals(activeProfile)) {
            // Зарегистрировать production-specific bean
            GenericBeanDefinition beanDef = new GenericBeanDefinition();
            beanDef.setBeanClass(ProductionDataSource.class);
            beanFactory.registerBeanDefinition("dataSource", beanDef);
        }
    }
}

// 4. Изменение класса bean-а
@Component
public class BeanClassChangerProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        BeanDefinition beanDef = beanFactory.getBeanDefinition("myService");
        // Изменить класс bean-а динамически
        beanDef.setBeanClassName(EnhancedMyService.class.getName());
    }
}

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

Если несколько BeanFactoryPostProcessor-ов, порядок контролируется Ordered интерфейсом:

@Component
public class FirstProcessor implements BeanFactoryPostProcessor, Ordered {
    @Override
    public int getOrder() {
        return 1; // Выполнится первым
    }
    
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        // Выполнится раньше
    }
}

@Component
public class SecondProcessor implements BeanFactoryPostProcessor, Ordered {
    @Override
    public int getOrder() {
        return 2; // Выполнится вторым
    }
    
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        // Выполнится позже
    }
}

BeanPostProcessor

Работает с инстансом bean-а, после его создания.

Определение

public interface BeanPostProcessor {
    Object postProcessBeforeInitialization(Object bean, String beanName) 
        throws BeansException;
    
    Object postProcessAfterInitialization(Object bean, String beanName) 
        throws BeansException;
}

Когда вызывается

• После создания инстанса bean-а
• До вызова init-method / @PostConstruct (before)
• После вызова init-method / @PostConstruct (after)
• Вызывается для каждого bean-а в контексте

Примеры использования

// 1. Логирование создания bean-ов
@Component
public class LoggingBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) 
            throws BeansException {
        System.out.println("Before init: " + beanName);
        return bean;
    }
    
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) 
            throws BeansException {
        System.out.println("After init: " + beanName);
        return bean;
    }
}

// 2. Валидация bean-а
@Component
public class ValidationBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) 
            throws BeansException {
        // Проверить что все необходимые свойства установлены
        if (bean instanceof ConfigurableComponent) {
            ConfigurableComponent component = (ConfigurableComponent) bean;
            if (component.getConfig() == null) {
                throw new BeanInitializationException(
                    "Config must be set for " + beanName);
            }
        }
        return bean;
    }
}

// 3. Создание прокси (как @Transactional работает)
@Component
public class ProxyCreatingBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) 
            throws BeansException {
        // Если bean имеет @Transactional аннотацию
        if (bean.getClass().isAnnotationPresent(Transactional.class)) {
            // Создать динамический прокси
            return Proxy.newProxyInstance(
                bean.getClass().getClassLoader(),
                bean.getClass().getInterfaces(),
                (proxy, method, args) -> {
                    // Оборотить вызов в транзакцию
                    return wrapInTransaction(() -> method.invoke(bean, args));
                }
            );
        }
        return bean;
    }
}

// 4. AutowiredAnnotationBeanPostProcessor (встроенный в Spring)
// Это BeanPostProcessor, который обрабатывает @Autowired аннотации
// и инжектирует зависимости

// 5. CommonAnnotationBeanPostProcessor
// Обрабатывает @PostConstruct, @PreDestroy, @Resource и т.д.

// 6. Инициализация очереди для асинхронной обработки
@Component
public class QueueInitializer implements BeanPostProcessor {
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) 
            throws BeansException {
        if (bean instanceof AsyncProcessor) {
            AsyncProcessor processor = (AsyncProcessor) bean;
            // Инициализировать очередь
            processor.initializeQueue(new LinkedBlockingQueue<>());
        }
        return bean;
    }
}

Ключевые отличия (таблица)

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

// Иллюстрация работы обоих интерфейсов

@Component
public class MyService {
    private String config;
    
    @PostConstruct
    public void init() {
        System.out.println("5. init() вызван");
    }
}

@Component
public class DemoBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        System.out.println("2. BeanFactoryPostProcessor работает");
        BeanDefinition bd = beanFactory.getBeanDefinition("myService");
        System.out.println("   Модифицируем BeanDefinition");
    }
}

@Component
public class DemoBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) 
            throws BeansException {
        if ("myService".equals(beanName)) {
            System.out.println("4. BeanPostProcessor.postProcessBeforeInitialization()");
        }
        return bean;
    }
    
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) 
            throws BeansException {
        if ("myService".equals(beanName)) {
            System.out.println("7. BeanPostProcessor.postProcessAfterInitialization()");
        }
        return bean;
    }
}

// Вывод при запуске Spring:
// 1. Читается BeanDefinition
// 2. BeanFactoryPostProcessor работает
// 3. Создается инстанс MyService
// 4. BeanPostProcessor.postProcessBeforeInitialization()
// 5. init() вызван
// 6. (тут вызвалась бы @PostConstruct если была)
// 7. BeanPostProcessor.postProcessAfterInitialization()
// 8. Bean готов к использованию

Когда использовать?

BeanFactoryPostProcessor

• Когда нужно модифицировать определение bean-а (до его создания)
• Динамическая регистрация bean-ов
• Подстановка properties и переменных окружения
• Условная регистрация bean-ов на основе конфигурации

BeanPostProcessor

• Когда нужно модифицировать инстанс bean-а (после создания)
• Создание прокси для cross-cutting concerns (транзакции, безопасность)
• Валидация состояния bean-а
• Инжекция zusätzных зависимостей
• Регистрация listener-ов или обработчиков

Понимание этих интерфейсов критично для глубокого понимания Spring Framework и создания advanced приложений.