org.springframework.aop.framework

## Class AbstractAdvisingBeanPostProcessor

- java.lang.Object
- - org.springframework.aop.framework.ProxyConfig
  - - org.springframework.aop.framework.AbstractAdvisingBeanPostProcessor

- All Implemented Interfaces:
    Serializable, Aware, BeanClassLoaderAware, BeanPostProcessor, Ordered
  Direct Known Subclasses:
    AsyncAnnotationBeanPostProcessor, MethodValidationPostProcessor, PersistenceExceptionTranslationPostProcessor

      public abstract class AbstractAdvisingBeanPostProcessor
      extends ProxyConfig
      implements BeanPostProcessor, BeanClassLoaderAware, Ordered

  Base class for `BeanPostProcessor` implementations that apply a Spring AOP `Advisor` to specific beans.
  Since:
    3.2
  Author:
    Juergen Hoeller
  See Also:
    Serialized Form

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected Advisor` | `advisor`
    `protected boolean` | `beforeExistingAdvisors`

    - ### Fields inherited from interface org.springframework.core.Ordered

      `HIGHEST_PRECEDENCE, LOWEST_PRECEDENCE`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `AbstractAdvisingBeanPostProcessor()`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `int` | `getOrder()` Return the order value of this object, with a higher value meaning greater in terms of sorting.
    `protected boolean` | `isEligible(Object bean, String beanName)` Check whether the given bean is eligible for advising with this post-processor's `Advisor`.
    `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` | `setBeanClassLoader(ClassLoader beanClassLoader)` Callback that supplies the bean `class loader` to a bean instance.
    `void` | `setBeforeExistingAdvisors(boolean beforeExistingAdvisors)` Set whether this post-processor's advisor is supposed to apply before existing advisors when encountering a pre-advised object.
    `void` | `setOrder(int order)`

    - ### Methods inherited from class org.springframework.aop.framework.ProxyConfig

      `copyFrom, isExposeProxy, isFrozen, isOpaque, isOptimize, isProxyTargetClass, setExposeProxy, setFrozen, setOpaque, setOptimize, setProxyTargetClass, toString`

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

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

- - ### Field Detail

    - #### advisor

          protected Advisor advisor

    - #### beforeExistingAdvisors

          protected boolean beforeExistingAdvisors

  - ### Constructor Detail

    - #### AbstractAdvisingBeanPostProcessor

          public AbstractAdvisingBeanPostProcessor()

  - ### Method Detail

    - #### setBeforeExistingAdvisors

          public void setBeforeExistingAdvisors(boolean beforeExistingAdvisors)

      Set whether this post-processor's advisor is supposed to apply before existing advisors when encountering a pre-advised object.

      Default is "false", applying the advisor after existing advisors, i.e. as close as possible to the target method. Switch this to "true" in order for this post-processor's advisor to wrap existing advisors as well.

      Note: Check the concrete post-processor's javadoc whether it possibly changes this flag by default, depending on the nature of its advisor.

    - #### setBeanClassLoader

          public void setBeanClassLoader(ClassLoader beanClassLoader)

      Description copied from interface: `BeanClassLoaderAware`
      Callback that supplies the bean `class loader` to a bean instance.

      Invoked after the population of normal bean properties but before an initialization callback such as `InitializingBean's` `InitializingBean.afterPropertiesSet()` method or a custom init-method.

      Specified by:
        `setBeanClassLoader` in interface `BeanClassLoaderAware`
      Parameters:
        `beanClassLoader` - the owning class loader; may be `null` in which case a default `ClassLoader` must be used, for example the `ClassLoader` obtained via `ClassUtils.getDefaultClassLoader()`

    - #### setOrder

          public void setOrder(int order)

    - #### getOrder

          public int getOrder()

      Description copied from interface: `Ordered`
      Return the order value of this object, with a higher value meaning greater in terms of sorting.

      Normally starting with 0, with `Integer.MAX_VALUE` indicating the greatest value. Same order values will result in arbitrary positions for the affected objects.

      Higher values can be interpreted as lower priority. As a consequence, the object with the lowest value has highest priority (somewhat analogous to Servlet "load-on-startup" values).

      Specified by:
        `getOrder` in interface `Ordered`
      Returns:
        the order value

    - #### postProcessBeforeInitialization

          public Object postProcessBeforeInitialization(Object bean,
                                                        String beanName)

      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
      See Also:
        `InitializingBean.afterPropertiesSet()`

    - #### postProcessAfterInitialization

          public Object postProcessAfterInitialization(Object bean,
                                                       String beanName)

      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
      See Also:
        `InitializingBean.afterPropertiesSet()`, `FactoryBean`

    - #### isEligible

          protected boolean isEligible(Object bean,
                                       String beanName)

      Check whether the given bean is eligible for advising with this post-processor's `Advisor`.

      Implements caching of `canApply` results per bean target class. Can be overridden e.g. to specifically exclude certain beans by name.

      Parameters:
        `bean` - the bean instance
        `beanName` - the name of the bean
      See Also:
        `AopUtils.getTargetClass(Object)`, `AopUtils.canApply(Advisor, Class)`