Package org.springframework.beans.factory.config

# Interface BeanPostProcessor

All Known Subinterfaces:
  `DestructionAwareBeanPostProcessor`, `InstantiationAwareBeanPostProcessor`, `MergedBeanDefinitionPostProcessor`, `SmartInstantiationAwareBeanPostProcessor`

All Known Implementing Classes:
  `AutowiredAnnotationBeanPostProcessor`, `InitDestroyAnnotationBeanPostProcessor`

public interface BeanPostProcessor
Factory hook that allows for custom modification of new bean instances — for example, checking for marker interfaces or wrapping beans with proxies.

Typically, post-processors that populate beans via marker interfaces or the like will implement `postProcessBeforeInitialization(java.lang.Object, java.lang.String)`, while post-processors that wrap beans with proxies will normally implement `postProcessAfterInitialization(java.lang.Object, java.lang.String)`.

### Registration

An `ApplicationContext` can autodetect `BeanPostProcessor` beans in its bean definitions and apply those post-processors to any beans subsequently created. A plain `BeanFactory` allows for programmatic registration of post-processors, applying them to all beans created through the bean factory.

### Ordering

`BeanPostProcessor` beans that are autodetected in an `ApplicationContext` will be ordered according to `PriorityOrdered` and `Ordered` semantics. In contrast, `BeanPostProcessor` beans that are registered programmatically with a `BeanFactory` will be applied in the order of registration; any ordering semantics expressed through implementing the `PriorityOrdered` or `Ordered` interface will be ignored for programmatically registered post-processors. Furthermore, the `@Order` annotation is not taken into account for `BeanPostProcessor` beans.

Since:
  10.10.2003
Author:
  Juergen Hoeller, Sam Brannen
See Also:
  - `InstantiationAwareBeanPostProcessor`
  - `DestructionAwareBeanPostProcessor`
  - `ConfigurableBeanFactory.addBeanPostProcessor(org.springframework.beans.factory.config.BeanPostProcessor)`
  - `BeanFactoryPostProcessor`

## Method Summary

Modifier and Type
Method
Description
`default Object`
`postProcessAfterInitialization(Object bean, String beanName)`
Apply this `BeanPostProcessor` to the given new bean instance after any bean initialization callbacks (like InitializingBean's `afterPropertiesSet` or a custom init-method).
`default Object`
`postProcessBeforeInitialization(Object bean, String beanName)`
Apply this `BeanPostProcessor` to the given new bean instance before any bean initialization callbacks (like InitializingBean's `afterPropertiesSet` or a custom init-method).

## Method Details

### postProcessBeforeInitialization

@Nullable default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException
Apply this `BeanPostProcessor` to the given new bean instance before any bean initialization callbacks (like InitializingBean's `afterPropertiesSet` or a custom init-method). The bean will already be populated with property values. The returned bean instance may be a wrapper around the original.

The default implementation returns the given `bean` as-is.

Parameters:
  `bean` - the new bean instance
  `beanName` - the name of the bean
Returns:
  the bean instance to use, either the original or a wrapped one; if `null`, no subsequent BeanPostProcessors will be invoked
Throws:
  `BeansException` - in case of errors
See Also:
  - `InitializingBean.afterPropertiesSet()`

### postProcessAfterInitialization

@Nullable default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException
Apply this `BeanPostProcessor` to the given new bean instance after any bean initialization callbacks (like InitializingBean's `afterPropertiesSet` or a custom init-method). The bean will already be populated with property values. The returned bean instance may be a wrapper around the original.

In case of a FactoryBean, this callback will be invoked for both the FactoryBean instance and the objects created by the FactoryBean (as of Spring 2.0). The post-processor can decide whether to apply to either the FactoryBean or created objects or both through corresponding `bean instanceof FactoryBean` checks.

This callback will also be invoked after a short-circuiting triggered by a `InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation(java.lang.Class<?>, java.lang.String)` method, in contrast to all other `BeanPostProcessor` callbacks.

The default implementation returns the given `bean` as-is.

Parameters:
  `bean` - the new bean instance
  `beanName` - the name of the bean
Returns:
  the bean instance to use, either the original or a wrapped one; if `null`, no subsequent BeanPostProcessors will be invoked
Throws:
  `BeansException` - in case of errors
See Also:
  - `InitializingBean.afterPropertiesSet()`
  - `FactoryBean`