Open Source Repository

Home /spring/spring-aop-3.0.5 | Repository Home



org/springframework/aop/aspectj/annotation/AnnotationAwareAspectJAutoProxyCreator.java
/*
 * Copyright 2002-2009 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.springframework.aop.aspectj.annotation;

import java.util.ArrayList;
import java.util.List;
import java.util.regex.Pattern;

import org.springframework.aop.Advisor;
import org.springframework.aop.aspectj.autoproxy.AspectJAwareAdvisorAutoProxyCreator;
import org.springframework.beans.factory.ListableBeanFactory;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.util.Assert;

/**
 {@link AspectJAwareAdvisorAutoProxyCreator} subclass that processes all AspectJ
 * annotation aspects in the current application context, as well as Spring Advisors.
 *
 <p>Any AspectJ annotated classes will automatically be recognized, and their
 * advice applied if Spring AOP's proxy-based model is capable of applying it.
 * This covers method execution joinpoints.
 *
 <p>If the &lt;aop:include&gt; element is used, only @AspectJ beans with names matched by
 * an include pattern will be considered as defining aspects to use for Spring auto-proxying.
 *
 <p>Processing of Spring Advisors follows the rules established in
 {@link org.springframework.aop.framework.autoproxy.AbstractAdvisorAutoProxyCreator}.
 *
 @author Rod Johnson
 @author Juergen Hoeller
 @since 2.0
 @see org.springframework.aop.aspectj.annotation.AspectJAdvisorFactory
 */
public class AnnotationAwareAspectJAutoProxyCreator extends AspectJAwareAdvisorAutoProxyCreator {

  private List<Pattern> includePatterns;

  private AspectJAdvisorFactory aspectJAdvisorFactory = new ReflectiveAspectJAdvisorFactory();

  private BeanFactoryAspectJAdvisorsBuilder aspectJAdvisorsBuilder;


  /**
   * Set a list of regex patterns, matching eligible @AspectJ bean names.
   <p>Default is to consider all @AspectJ beans as eligible.
   */
  public void setIncludePatterns(List<String> patterns) {
    this.includePatterns = new ArrayList<Pattern>(patterns.size());
    for (String patternText : patterns) {
      this.includePatterns.add(Pattern.compile(patternText));
    }
  }

  public void setAspectJAdvisorFactory(AspectJAdvisorFactory aspectJAdvisorFactory) {
    Assert.notNull(this.aspectJAdvisorFactory, "AspectJAdvisorFactory must not be null");
    this.aspectJAdvisorFactory = aspectJAdvisorFactory;
  }

  @Override
  protected void initBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    super.initBeanFactory(beanFactory);
    this.aspectJAdvisorsBuilder =
        new BeanFactoryAspectJAdvisorsBuilderAdapter(beanFactory, this.aspectJAdvisorFactory);
  }


  @Override
  protected List<Advisor> findCandidateAdvisors() {
    // Add all the Spring advisors found according to superclass rules.
    List<Advisor> advisors = super.findCandidateAdvisors();
    // Build Advisors for all AspectJ aspects in the bean factory.
    advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
    return advisors;
  }

  @Override
  protected boolean isInfrastructureClass(Class beanClass) {
    // Previously we setProxyTargetClass(true) in the constructor, but that has too
    // broad an impact. Instead we now override isInfrastructureClass to avoid proxying
    // aspects. I'm not entirely happy with that as there is no good reason not
    // to advise aspects, except that it causes advice invocation to go through a
    // proxy, and if the aspect implements e.g the Ordered interface it will be
    // proxied by that interface and fail at runtime as the advice method is not
    // defined on the interface. We could potentially relax the restriction about
    // not advising aspects in the future.
    return (super.isInfrastructureClass(beanClass|| this.aspectJAdvisorFactory.isAspect(beanClass));
  }

  /**
   * Check whether the given aspect bean is eligible for auto-proxying.
   <p>If no &lt;aop:include&gt; elements were used then "includePatterns" will be
   <code>null</code> and all beans are included. If "includePatterns" is non-null,
   * then one of the patterns must match.
   */
  protected boolean isEligibleAspectBean(String beanName) {
    if (this.includePatterns == null) {
      return true;
    }
    else {
      for (Pattern pattern : this.includePatterns) {
        if (pattern.matcher(beanName).matches()) {
          return true;
        }
      }
      return false;
    }
  }


  /**
   * Subclass of BeanFactoryAspectJAdvisorsBuilderAdapter that delegates to
   * surrounding AnnotationAwareAspectJAutoProxyCreator facilities.
   */
  private class BeanFactoryAspectJAdvisorsBuilderAdapter extends BeanFactoryAspectJAdvisorsBuilder {

    public BeanFactoryAspectJAdvisorsBuilderAdapter(
        ListableBeanFactory beanFactory, AspectJAdvisorFactory advisorFactory) {
      super(beanFactory, advisorFactory);
    }

    @Override
    protected boolean isEligibleBean(String beanName) {
      return AnnotationAwareAspectJAutoProxyCreator.this.isEligibleAspectBean(beanName);
    }
  }

}