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
`protected Advisor` `advisor`

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

`HIGHEST_PRECEDENCE, LOWEST_PRECEDENCE`

### Constructor Summary

Constructors
Constructor and Description
`AbstractAdvisingBeanPostProcessor()`

### Method Summary

Methods
`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` `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

### Constructor Detail

#### AbstractAdvisingBeanPostProcessor

    public AbstractAdvisingBeanPostProcessor()

### Method Detail

#### 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)`