Spring Extension Point (Part 1): Understanding PostProcessor Mechanisms

1. Overview

Spring provides several crucial extension points called post‑processors that allow developers to hook into the container's bean handling. The most important one is ConfigurationClassPostProcessor, which parses configuration classes and annotations. Other frameworks such as MyBatis integrate with Spring via post‑processors like MapperScannerConfigurer to register mapper interfaces.

Core Post‑Processors

Spring defines three fundamental post‑processor interfaces, all of which other post‑processors extend:

BeanDefinitionRegistryPostProcessor : can dynamically register additional BeanDefinition objects, even from outside the classpath.

BeanFactoryPostProcessor : runs after all BeanDefinition s are loaded but before any bean is instantiated, allowing modification of bean properties such as scope or lazyInit.

BeanPostProcessor : invoked after a bean is instantiated; it provides postProcessBeforeInitialization (called after property population, before init()) and postProcessAfterInitialization (called after init()).

The execution sequence is:

BeanDefinitionRegistryPostProcessor → BeanFactoryPostProcessor → BeanPostProcessor

2.1 BeanDefinitionRegistryPostProcessor

Definition:

public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor {
    void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;
}

It registers additional bean definitions after the standard loading phase. Example implementation registers a Boo bean definition:

@Component
public class MyBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        BeanDefinition beanDefinition = new RootBeanDefinition();
        beanDefinition.setBeanClassName("com.shepherd.common.bean.Boo");
        registry.registerBeanDefinition("boo", beanDefinition);
    }
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        // no logic here for this demo
    }
}

Running a test context prints the newly registered bean name, confirming successful registration.

2.2 BeanFactoryPostProcessor

Definition:

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

It operates after all BeanDefinition s are loaded. In the example, the processor modifies the description of the previously registered boo bean:

@Component
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("BeanFactoryPostProcessor execute...");
        BeanDefinition beanDefinition = beanFactory.getBeanDefinition("boo");
        if (Objects.nonNull(beanDefinition)) {
            beanDefinition.setDescription("芽儿哟，可以的");
        }
    }
}

The test prints the modified description, demonstrating the post‑processor’s effect.

2.3 BeanPostProcessor

Definition:

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

It runs after bean instantiation, surrounding the bean’s initialization phase. The example logs messages before and after the init() method of Boo:

@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("beanPostProcessor before() executed..." + beanName);
        return bean;
    }
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("beanPostProcessor after() executed..." + beanName);
        return bean;
    }
}

Running the context produces the following output, confirming the exact invocation points:

boo实例化构造方法执行了...
beanPostProcessor before()执行了....boo
boo执行初始化init()方法了...
beanPostProcessor after()执行了....boo

Advanced Post‑Processors

InstantiationAwareBeanPostProcessor extends BeanPostProcessor and adds three methods that allow extensions during the bean instantiation phase and property injection phase: postProcessBeforeInstantiation: called before the bean is instantiated. postProcessAfterInstantiation: called after the bean is instantiated. postProcessPropertyValues: called during property injection, enabling support for annotations like @Autowired and @Resource. postProcessBeforeInitialization and postProcessAfterInitialization retain their original meanings.

SmartInstantiationAwareBeanPostProcessor further adds three trigger points: predictBeanType: predicts the bean’s type before instantiation. determineCandidateConstructors: selects candidate constructors after postProcessBeforeInstantiation. getEarlyBeanReference: provides an early reference after instantiation to resolve circular dependencies.

3. Summary

Understanding Spring’s post‑processor extension points is essential for mastering automatic configuration and bean lifecycle manipulation. The three core interfaces— BeanDefinitionRegistryPostProcessor, BeanFactoryPostProcessor, and BeanPostProcessor —cover registration, property adjustment, and initialization phases respectively. Advanced interfaces like InstantiationAwareBeanPostProcessor and SmartInstantiationAwareBeanPostProcessor further broaden the extension capabilities, enabling developers to intervene even before bean instantiation and during constructor selection, which is valuable for building middleware and custom framework features.