BeanPostProcessor — How Spring Modifies Beans Before Use

Direct Answer

A BeanPostProcessor is a Spring extension point with two hooks — postProcessBeforeInitialization and postProcessAfterInitialization — that the container calls on every bean during creation, right around the @PostConstruct / afterPropertiesSet boundary. The Before hook runs on the raw bean before init callbacks; the After hook runs after init callbacks and is the hook that powers AOP proxying — this is where @Transactional, @Async, @Cacheable, and custom aspects are applied. Spring Boot's auto-configuration uses dozens of built-in BeanPostProcessors (AutowiredAnnotationBeanPostProcessor wires @Autowired, CommonAnnotationBeanPostProcessor wires @PostConstruct/@Resource, AnnotationAwareAspectJAutoProxyCreator creates AOP proxies). Order matters: register via @Order or implement Ordered; BPPs are instantiated very early, so they cannot depend on other @Beans that haven't been created yet.

Code Example

The most practical way to understand BeanPostProcessor is to build one. The example creates a custom @Timed annotation that automatically logs how long each method takes — similar to Micrometer or Spring AOP, but implemented from scratch to show the mechanism.

The processor scans every bean for methods annotated with @Timed. When it finds one, it wraps the original bean in a CGLIB proxy that intercepts method calls and measures execution time. This is the same pattern Spring uses internally for @Transactional and @Cacheable.

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Timed {}

@Component
public class TimingPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessAfterInitialization(Object bean, String name) {
        boolean hasTimed = Arrays.stream(bean.getClass().getMethods())
            .anyMatch(m -> m.isAnnotationPresent(Timed.class));
        if (!hasTimed) return bean;

        return Enhancer.create(bean.getClass(), (MethodInterceptor) (obj, method, args, proxy) -> {
            if (!method.isAnnotationPresent(Timed.class))
                return proxy.invokeSuper(obj, args);
            long start = System.nanoTime();
            Object result = proxy.invokeSuper(obj, args);
            log.info("{}.{} took {}ms", name, method.getName(),
                (System.nanoTime() - start) / 1_000_000);
            return result;
        });
    }
}

The key insight is the return value. The postProcessAfterInitialization method returns either the original bean (no processing needed) or a new object (the proxy). Spring replaces the bean in the container with whatever this method returns. This is why @Transactional works — the bean registered in the container is a proxy, not the original class.

Practical performance note

• Proxy creation happens once at startup for singleton beans — no per-call cost
• CGLIB proxies add roughly 1-2 microseconds per method call — negligible for most applications
• For post-processors that wrap thousands of beans, the startup time impact can be measurable; profile before optimizing

Common Mistakes & Pitfalls

Confusing BeanPostProcessor (modifies beans) with BeanFactoryPostProcessor (modifies bean definitions); thinking it's only called on beans you annotate