org.springframework.aop.framework.autoproxy.AbstractAdvisorAutoProxyCreator Maven / Gradle / Ivy
/*
* Copyright 2002-2007 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.framework.autoproxy;
import java.util.Collections;
import java.util.List;
import org.springframework.aop.TargetSource;
import org.springframework.aop.support.AopUtils;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.core.OrderComparator;
/**
* Abstract BeanPostProcessor implementation that creates AOP proxies.
* This class is completely generic; it contains no special code to handle
* any particular aspects, such as pooling aspects.
*
* Subclasses must implement the abstract findCandidateAdvisors()
* method to return a list of Advisors applying to any object. Subclasses can
* also override the inherited shouldSkip method to exclude certain
* objects from auto-proxying, but they must be careful to invoke the base
* shouldSkip method, which tries to avoid circular reference
* problems and infinite loops.
*
*
Advisors or advices requiring ordering should implement the Ordered interface.
* This class sorts advisors by Ordered order value. Advisors that don't implement
* the Ordered interface will be considered to be unordered, and will appear
* at the end of the advisor chain in undefined order.
*
* @author Rod Johnson
* @author Juergen Hoeller
* @see #findCandidateAdvisors
* @see org.springframework.aop.support.AopUtils
*/
public abstract class AbstractAdvisorAutoProxyCreator extends AbstractAutoProxyCreator {
private BeanFactoryAdvisorRetrievalHelper advisorRetrievalHelper;
public void setBeanFactory(BeanFactory beanFactory) {
super.setBeanFactory(beanFactory);
if (!(beanFactory instanceof ConfigurableListableBeanFactory)) {
throw new IllegalStateException("Cannot use AdvisorAutoProxyCreator without a ConfigurableListableBeanFactory");
}
initBeanFactory((ConfigurableListableBeanFactory) beanFactory);
}
protected void initBeanFactory(ConfigurableListableBeanFactory beanFactory) {
this.advisorRetrievalHelper = new BeanFactoryAdvisorRetrievalHelperAdapter(beanFactory);
}
protected Object[] getAdvicesAndAdvisorsForBean(Class beanClass, String name, TargetSource targetSource) {
List advisors = findEligibleAdvisors(beanClass);
if (advisors.isEmpty()) {
return DO_NOT_PROXY;
}
return advisors.toArray();
}
/**
* Find all eligible advices for auto-proxying this class.
* @param clazz the clazz to find advisors for
* @return the empty list, not null,
* if there are no pointcuts or interceptors
* @see #findCandidateAdvisors
* @see #sortAdvisors
* @see #extendAdvisors
*/
protected List findEligibleAdvisors(Class clazz) {
List eligibleAdvisors = AopUtils.findAdvisorsThatCanApply(findCandidateAdvisors(), clazz);
if (!eligibleAdvisors.isEmpty()) {
eligibleAdvisors = sortAdvisors(eligibleAdvisors);
}
extendAdvisors(eligibleAdvisors);
return eligibleAdvisors;
}
/**
* Find all candidate advisors to use in auto-proxying.
* @return list of candidate Advisors
*/
protected List findCandidateAdvisors() {
return this.advisorRetrievalHelper.findAdvisorBeans();
}
/**
* Return whether the Advisor bean with the given name is eligible
* for proxying in the first place.
* @param beanName the name of the Advisor bean
* @return whether the bean is eligible
*/
protected boolean isEligibleAdvisorBean(String beanName) {
return true;
}
/**
* Sort advisors based on ordering. Subclasses may choose to override this
* method to customize the sorting strategy.
* @param advisors the source List of Advisors
* @return the sorted List of Advisors
* @see org.springframework.core.Ordered
* @see org.springframework.core.OrderComparator
*/
protected List sortAdvisors(List advisors) {
Collections.sort(advisors, new OrderComparator());
return advisors;
}
/**
* Extension hook that subclasses can choose to register additional Advisors,
* given the sorted Advisors obtained to date. The default implementation
* is empty.
*
Typically used to add Advisors that expose contextual information
* required by some of the later advisors.
* @param candidateAdvisors Advisors that have already been identified as
* applying to a given bean
*/
protected void extendAdvisors(List candidateAdvisors) {
}
/**
* Subclass of BeanFactoryAdvisorRetrievalHelper that delegates to
* surrounding AbstractAdvisorAutoProxyCreator facilities.
*/
private class BeanFactoryAdvisorRetrievalHelperAdapter extends BeanFactoryAdvisorRetrievalHelper {
public BeanFactoryAdvisorRetrievalHelperAdapter(ConfigurableListableBeanFactory beanFactory) {
super(beanFactory);
}
protected boolean isEligibleBean(String beanName) {
return AbstractAdvisorAutoProxyCreator.this.isEligibleAdvisorBean(beanName);
}
}
}