## Uses of Interface
org.springframework.beans.factory.config.BeanPostProcessor

- Packages that use BeanPostProcessor
  Package | Description
  --- | ---
  org.springframework.aop.aspectj.annotation | Classes enabling AspectJ 5 @Annotated classes to be used in Spring AOP.
  org.springframework.aop.aspectj.autoproxy | Base classes enabling auto-proxying based on AspectJ.
  org.springframework.aop.framework | Package containing Spring's basic AOP infrastructure, compliant with the AOP Alliance interfaces.
  org.springframework.aop.framework.adapter | SPI package allowing Spring AOP framework to handle arbitrary advice types.
  org.springframework.aop.framework.autoproxy | Bean post-processors for use in ApplicationContexts to simplify AOP usage by automatically creating AOP proxies without the need to use a ProxyFactoryBean.
  org.springframework.beans.factory.annotation | Support package for annotation-driven bean configuration.
  org.springframework.beans.factory.config | SPI interfaces and configuration-related convenience classes for bean factories.
  org.springframework.beans.factory.support | Classes supporting the `org.springframework.beans.factory` package.
  org.springframework.context.annotation | Annotation support for the Application Context, including JSR-250 "common" annotations, component-scanning, and Java-based metadata for creating Spring-managed objects.
  org.springframework.context.weaving | Load-time weaving support for a Spring application context, building on Spring's `LoadTimeWeaver` abstraction.
  org.springframework.dao.annotation | Annotation support for DAOs.
  org.springframework.jms.annotation | Annotations and support classes for declarative JMS listener endpoints.
  org.springframework.orm.jpa.support | Classes supporting the `org.springframework.orm.jpa` package.
  org.springframework.scheduling.annotation | Annotation support for asynchronous method execution.
  org.springframework.scripting.support | Support classes for Spring's scripting package.
  org.springframework.validation.beanvalidation | Support classes for integrating a JSR-303 Bean Validation provider (such as Hibernate Validator) into a Spring ApplicationContext and in particular with Spring's data binding and validation APIs.
  org.springframework.web.context.support | Classes supporting the `org.springframework.web.context` package, such as WebApplicationContext implementations and various utility classes.
  org.springframework.web.servlet.handler | Provides standard HandlerMapping implementations, including abstract base classes for custom implementations.

- - ### Uses of BeanPostProcessor in org.springframework.aop.aspectj.annotation

    Classes in org.springframework.aop.aspectj.annotation that implement BeanPostProcessor
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AnnotationAwareAspectJAutoProxyCreator` `AspectJAwareAdvisorAutoProxyCreator` subclass that processes all AspectJ annotation aspects in the current application context, as well as Spring Advisors.

  - ### Uses of BeanPostProcessor in org.springframework.aop.aspectj.autoproxy

    Classes in org.springframework.aop.aspectj.autoproxy that implement BeanPostProcessor
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AspectJAwareAdvisorAutoProxyCreator` `AbstractAdvisorAutoProxyCreator` subclass that exposes AspectJ's invocation context and understands AspectJ's rules for advice precedence when multiple pieces of advice come from the same aspect.

  - ### Uses of BeanPostProcessor in org.springframework.aop.framework

    Classes in org.springframework.aop.framework that implement BeanPostProcessor
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AbstractAdvisingBeanPostProcessor` Base class for `BeanPostProcessor` implementations that apply a Spring AOP `Advisor` to specific beans.

  - ### Uses of BeanPostProcessor in org.springframework.aop.framework.adapter

    Classes in org.springframework.aop.framework.adapter that implement BeanPostProcessor
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AdvisorAdapterRegistrationManager` BeanPostProcessor that registers `AdvisorAdapter` beans in the BeanFactory with an `AdvisorAdapterRegistry` (by default the `GlobalAdvisorAdapterRegistry`).

  - ### Uses of BeanPostProcessor in org.springframework.aop.framework.autoproxy

    Classes in org.springframework.aop.framework.autoproxy that implement BeanPostProcessor
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AbstractAdvisorAutoProxyCreator` Generic auto proxy creator that builds AOP proxies for specific beans based on detected Advisors for each bean.
    `class` | `AbstractAutoProxyCreator` `BeanPostProcessor` implementation that wraps each eligible bean with an AOP proxy, delegating to specified interceptors before invoking the bean itself.
    `class` | `AbstractBeanFactoryAwareAdvisingPostProcessor` Extension of `AbstractAutoProxyCreator` which implements `BeanFactoryAware`, adds exposure of the original target class for each proxied bean (`AutoProxyUtils.ORIGINAL_TARGET_CLASS_ATTRIBUTE`), and participates in an externally enforced target-class mode for any given bean (`AutoProxyUtils.PRESERVE_TARGET_CLASS_ATTRIBUTE`).
    `class` | `BeanNameAutoProxyCreator` Auto proxy creator that identifies beans to proxy via a list of names.
    `class` | `DefaultAdvisorAutoProxyCreator` `BeanPostProcessor` implementation that creates AOP proxies based on all candidate `Advisor`s in the current `BeanFactory`.
    `class` | `InfrastructureAdvisorAutoProxyCreator` Auto-proxy creator that considers infrastructure Advisor beans only, ignoring any application-defined Advisors.

  - ### Uses of BeanPostProcessor in org.springframework.beans.factory.annotation

    Classes in org.springframework.beans.factory.annotation that implement BeanPostProcessor
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AutowiredAnnotationBeanPostProcessor` `BeanPostProcessor` implementation that autowires annotated fields, setter methods, and arbitrary config methods.
    `class` | `InitDestroyAnnotationBeanPostProcessor` `BeanPostProcessor` implementation that invokes annotated init and destroy methods.
    `class` | `RequiredAnnotationBeanPostProcessor` Deprecated. as of 5.1, in favor of using constructor injection for required settings (or a custom `InitializingBean` implementation)

  - ### Uses of BeanPostProcessor in org.springframework.beans.factory.config

    Subinterfaces of BeanPostProcessor in org.springframework.beans.factory.config
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `DestructionAwareBeanPostProcessor` Subinterface of `BeanPostProcessor` that adds a before-destruction callback.
    `interface` | `InstantiationAwareBeanPostProcessor` Subinterface of `BeanPostProcessor` that adds a before-instantiation callback, and a callback after instantiation but before explicit properties are set or autowiring occurs.
    `interface` | `SmartInstantiationAwareBeanPostProcessor` Extension of the `InstantiationAwareBeanPostProcessor` interface, adding a callback for predicting the eventual type of a processed bean.

    Classes in org.springframework.beans.factory.config that implement BeanPostProcessor
    Modifier and Type | Class and Description
    --- | ---
    `class` | `InstantiationAwareBeanPostProcessorAdapter` Deprecated. as of 5.3 in favor of implementing `InstantiationAwareBeanPostProcessor` or `SmartInstantiationAwareBeanPostProcessor` directly.

    Methods in org.springframework.beans.factory.config with parameters of type BeanPostProcessor
    Modifier and Type | Method and Description
    --- | ---
    `void` | ConfigurableBeanFactory.`addBeanPostProcessor(BeanPostProcessor beanPostProcessor)` Add a new BeanPostProcessor that will get applied to beans created by this factory.

  - ### Uses of BeanPostProcessor in org.springframework.beans.factory.support

    Subinterfaces of BeanPostProcessor in org.springframework.beans.factory.support
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `MergedBeanDefinitionPostProcessor` Post-processor callback interface for merged bean definitions at runtime.

    Methods in org.springframework.beans.factory.support that return types with arguments of type BeanPostProcessor
    Modifier and Type | Method and Description
    --- | ---
    `List<BeanPostProcessor>` | AbstractBeanFactory.`getBeanPostProcessors()` Return the list of BeanPostProcessors that will get applied to beans created with this factory.

    Methods in org.springframework.beans.factory.support with parameters of type BeanPostProcessor
    Modifier and Type | Method and Description
    --- | ---
    `void` | AbstractBeanFactory.`addBeanPostProcessor(BeanPostProcessor beanPostProcessor)`

    Method parameters in org.springframework.beans.factory.support with type arguments of type BeanPostProcessor
    Modifier and Type | Method and Description
    --- | ---
    `void` | AbstractBeanFactory.`addBeanPostProcessors(Collection<? extends BeanPostProcessor> beanPostProcessors)` Add new BeanPostProcessors that will get applied to beans created by this factory.

  - ### Uses of BeanPostProcessor in org.springframework.context.annotation

    Classes in org.springframework.context.annotation that implement BeanPostProcessor
    Modifier and Type | Class and Description
    --- | ---
    `class` | `CommonAnnotationBeanPostProcessor` `BeanPostProcessor` implementation that supports common Java annotations out of the box, in particular the JSR-250 annotations in the `javax.annotation` package.

  - ### Uses of BeanPostProcessor in org.springframework.context.weaving

    Classes in org.springframework.context.weaving that implement BeanPostProcessor
    Modifier and Type | Class and Description
    --- | ---
    `class` | `LoadTimeWeaverAwareProcessor` `BeanPostProcessor` implementation that passes the context's default `LoadTimeWeaver` to beans that implement the `LoadTimeWeaverAware` interface.

  - ### Uses of BeanPostProcessor in org.springframework.dao.annotation

    Classes in org.springframework.dao.annotation that implement BeanPostProcessor
    Modifier and Type | Class and Description
    --- | ---
    `class` | `PersistenceExceptionTranslationPostProcessor` Bean post-processor that automatically applies persistence exception translation to any bean marked with Spring's @`Repository` annotation, adding a corresponding `PersistenceExceptionTranslationAdvisor` to the exposed proxy (either an existing AOP proxy or a newly generated proxy that implements all of the target's interfaces).

  - ### Uses of BeanPostProcessor in org.springframework.jms.annotation

    Classes in org.springframework.jms.annotation that implement BeanPostProcessor
    Modifier and Type | Class and Description
    --- | ---
    `class` | `JmsListenerAnnotationBeanPostProcessor` Bean post-processor that registers methods annotated with `JmsListener` to be invoked by a JMS message listener container created under the cover by a `JmsListenerContainerFactory` according to the attributes of the annotation.

  - ### Uses of BeanPostProcessor in org.springframework.orm.jpa.support

    Classes in org.springframework.orm.jpa.support that implement BeanPostProcessor
    Modifier and Type | Class and Description
    --- | ---
    `class` | `PersistenceAnnotationBeanPostProcessor` BeanPostProcessor that processes `PersistenceUnit` and `PersistenceContext` annotations, for injection of the corresponding JPA resources `EntityManagerFactory` and `EntityManager`.

  - ### Uses of BeanPostProcessor in org.springframework.scheduling.annotation

    Classes in org.springframework.scheduling.annotation that implement BeanPostProcessor
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AsyncAnnotationBeanPostProcessor` Bean post-processor that automatically applies asynchronous invocation behavior to any bean that carries the `Async` annotation at class or method-level by adding a corresponding `AsyncAnnotationAdvisor` to the exposed proxy (either an existing AOP proxy or a newly generated proxy that implements all the target's interfaces).
    `class` | `ScheduledAnnotationBeanPostProcessor` Bean post-processor that registers methods annotated with `@Scheduled` to be invoked by a `TaskScheduler` according to the "fixedRate", "fixedDelay", or "cron" expression provided via the annotation.

  - ### Uses of BeanPostProcessor in org.springframework.scripting.support

    Classes in org.springframework.scripting.support that implement BeanPostProcessor
    Modifier and Type | Class and Description
    --- | ---
    `class` | `ScriptFactoryPostProcessor` `BeanPostProcessor` that handles `ScriptFactory` definitions, replacing each factory with the actual scripted Java object generated by it.

  - ### Uses of BeanPostProcessor in org.springframework.validation.beanvalidation

    Classes in org.springframework.validation.beanvalidation that implement BeanPostProcessor
    Modifier and Type | Class and Description
    --- | ---
    `class` | `BeanValidationPostProcessor` Simple `BeanPostProcessor` that checks JSR-303 constraint annotations in Spring-managed beans, throwing an initialization exception in case of constraint violations right before calling the bean's init method (if any).
    `class` | `MethodValidationPostProcessor` A convenient `BeanPostProcessor` implementation that delegates to a JSR-303 provider for performing method-level validation on annotated methods.

  - ### Uses of BeanPostProcessor in org.springframework.web.context.support

    Classes in org.springframework.web.context.support that implement BeanPostProcessor
    Modifier and Type | Class and Description
    --- | ---
    `class` | `ServletContextAwareProcessor` `BeanPostProcessor` implementation that passes the ServletContext to beans that implement the `ServletContextAware` interface.

  - ### Uses of BeanPostProcessor in org.springframework.web.servlet.handler

    Classes in org.springframework.web.servlet.handler that implement BeanPostProcessor
    Modifier and Type | Class and Description
    --- | ---
    `class` | `SimpleServletPostProcessor` `BeanPostProcessor` that applies initialization and destruction callbacks to beans that implement the `Servlet` interface.