org.springframework.aop.framework.adapter

## Class AdvisorAdapterRegistrationManager

- java.lang.Object
- - org.springframework.aop.framework.adapter.AdvisorAdapterRegistrationManager

- All Implemented Interfaces:
    BeanPostProcessor

      public class AdvisorAdapterRegistrationManager
      extends Object
      implements BeanPostProcessor

  BeanPostProcessor that registers `AdvisorAdapter` beans in the BeanFactory with an `AdvisorAdapterRegistry` (by default the `GlobalAdvisorAdapterRegistry`).

  The only requirement for it to work is that it needs to be defined in application context along with "non-native" Spring AdvisorAdapters that need to be "recognized" by Spring's AOP framework.

  Since:
    27.02.2004
  Author:
    Dmitriy Kopylenko, Juergen Hoeller
  See Also:
    `setAdvisorAdapterRegistry(org.springframework.aop.framework.adapter.AdvisorAdapterRegistry)`, `AdvisorAdapter`

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `AdvisorAdapterRegistrationManager()`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `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).
    `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).
    `void` | `setAdvisorAdapterRegistry(AdvisorAdapterRegistry advisorAdapterRegistry)` Specify the AdvisorAdapterRegistry to register AdvisorAdapter beans with.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### AdvisorAdapterRegistrationManager

          public AdvisorAdapterRegistrationManager()

  - ### Method Detail

    - #### setAdvisorAdapterRegistry

          public void setAdvisorAdapterRegistry(AdvisorAdapterRegistry advisorAdapterRegistry)

      Specify the AdvisorAdapterRegistry to register AdvisorAdapter beans with. Default is the global AdvisorAdapterRegistry.
      See Also:
        `GlobalAdvisorAdapterRegistry`

    - #### postProcessBeforeInitialization

          public Object postProcessBeforeInitialization(Object bean,
                                               String beanName)
                                                 throws BeansException

      Description copied from interface: `BeanPostProcessor`
      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.
      Specified by:
        `postProcessBeforeInitialization` in interface `BeanPostProcessor`
      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

          public Object postProcessAfterInitialization(Object bean,
                                              String beanName)
                                                throws BeansException

      Description copied from interface: `BeanPostProcessor`
      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.

      Specified by:
        `postProcessAfterInitialization` in interface `BeanPostProcessor`
      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`