Class AbstractAdvisingBeanPostProcessor

All Implemented Interfaces:
Serializable, AopInfrastructureBean, Aware, BeanClassLoaderAware, BeanPostProcessor, InstantiationAwareBeanPostProcessor, SmartInstantiationAwareBeanPostProcessor, Ordered
Direct Known Subclasses:

public abstract class AbstractAdvisingBeanPostProcessor extends ProxyProcessorSupport implements SmartInstantiationAwareBeanPostProcessor
Base class for BeanPostProcessor implementations that apply a Spring AOP Advisor to specific beans.
Juergen Hoeller
See Also:
  • Field Details

    • advisor

      @Nullable protected Advisor advisor
    • beforeExistingAdvisors

      protected boolean beforeExistingAdvisors
  • Constructor Details

    • AbstractAdvisingBeanPostProcessor

      public AbstractAdvisingBeanPostProcessor()
  • Method Details

    • 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.

    • determineBeanType

      public Class<?> determineBeanType(Class<?> beanClass, String beanName)
      Description copied from interface: SmartInstantiationAwareBeanPostProcessor
      Determine the type of the bean to be eventually returned from this processor's InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation(java.lang.Class<?>, java.lang.String) callback.

      The default implementation returns the given bean class as-is. Specific implementations should fully evaluate their processing steps in order to create/initialize a potential proxy class upfront.

      Specified by:
      determineBeanType in interface SmartInstantiationAwareBeanPostProcessor
      beanClass - the raw class of the bean
      beanName - the name of the bean
      the type of the bean (never null)
    • 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.

      The default implementation returns the given bean as-is.

      Specified by:
      postProcessAfterInitialization in interface BeanPostProcessor
      bean - the new bean instance
      beanName - the name of the bean
      the bean instance to use, either the original or a wrapped one; if null, no subsequent BeanPostProcessors will be invoked
      See Also:
    • isEligible

      protected boolean isEligible(Object bean, String beanName)
      Check whether the given bean is eligible for advising with this post-processor's Advisor.

      Delegates to isEligible(Class) for target class checking. Can be overridden e.g. to specifically exclude certain beans by name.

      Note: Only called for regular bean instances but not for existing proxy instances which implement Advised and allow for adding the local Advisor to the existing proxy's Advisor chain. For the latter, isEligible(Class) is being called directly, with the actual target class behind the existing proxy (as determined by AopUtils.getTargetClass(Object)).

      bean - the bean instance
      beanName - the name of the bean
      See Also:
    • isEligible

      protected boolean isEligible(Class<?> targetClass)
      Check whether the given class is eligible for advising with this post-processor's Advisor.

      Implements caching of canApply results per bean target class.

      targetClass - the class to check against
      See Also:
    • prepareProxyFactory

      protected ProxyFactory prepareProxyFactory(Object bean, String beanName)
      Prepare a ProxyFactory for the given bean.

      Subclasses may customize the handling of the target instance and in particular the exposure of the target class. The default introspection of interfaces for non-target-class proxies and the configured advisor will be applied afterwards; customizeProxyFactory(org.springframework.aop.framework.ProxyFactory) allows for late customizations of those parts right before proxy creation.

      bean - the bean instance to create a proxy for
      beanName - the corresponding bean name
      the ProxyFactory, initialized with this processor's ProxyConfig settings and the specified bean
      See Also:
    • customizeProxyFactory

      protected void customizeProxyFactory(ProxyFactory proxyFactory)
      Subclasses may choose to implement this: for example, to change the interfaces exposed.

      The default implementation is empty.

      proxyFactory - the ProxyFactory that is already configured with target, advisor and interfaces and will be used to create the proxy immediately after this method returns
      See Also: