AOP 代理类的创建
入口：AnnotationAwareAspectJAutoProxyCreator#postProcessAfterInitialization 和 AnnotationAwareAspectJAutoProxyCreator#getEarlyBeanReference
/**
* 代理配置：保证所有的代理创建者都有一致的属性配置
*/
public class ProxyConfig implements Serializable {
/** use serialVersionUID from Spring 1.2 for interoperability. */
private static final long serialVersionUID = -8409359707199703185L;
/**
* 是否是基于类的代理，默认是基于接口的代理
*/
private boolean proxyTargetClass = false;
/**
* 是否执行代理优化，【如果为 true，在代理创建完毕后，修改通知将没有效果】
*/
private boolean optimize = false;
/**
* 是否不允许将代理类强转为 Advised，默认可以
*/
boolean opaque = false;
/**
* 代理类是否需要暴露到 AopContext 的 currentProxy 中
*/
boolean exposeProxy = false;
/**
* 是否冻结代理配置，冻结后不可修改
*/
private boolean frozen = false;
public void setProxyTargetClass(boolean proxyTargetClass) {
this.proxyTargetClass = proxyTargetClass;
}
public boolean isProxyTargetClass() {
return proxyTargetClass;
}
public void setOptimize(boolean optimize) {
this.optimize = optimize;
}
public boolean isOptimize() {
return optimize;
}
public void setOpaque(boolean opaque) {
this.opaque = opaque;
}
public boolean isOpaque() {
return opaque;
}
public void setExposeProxy(boolean exposeProxy) {
this.exposeProxy = exposeProxy;
}
public boolean isExposeProxy() {
return exposeProxy;
}
public void setFrozen(boolean frozen) {
this.frozen = frozen;
}
public boolean isFrozen() {
return frozen;
}
/**
* 从另一个 ProxyConfig 中复制属性
*/
public void copyFrom(ProxyConfig other) {
Assert.notNull(other, "Other ProxyConfig object must not be null");
proxyTargetClass = other.proxyTargetClass;
optimize = other.optimize;
exposeProxy = other.exposeProxy;
frozen = other.frozen;
opaque = other.opaque;
}
@Override
public String toString() {
final StringBuilder sb = new StringBuilder();
sb.append("proxyTargetClass=").append(proxyTargetClass).append("; ");
sb.append("optimize=").append(optimize).append("; ");
sb.append("opaque=").append(opaque).append("; ");
sb.append("exposeProxy=").append(exposeProxy).append("; ");
sb.append("frozen=").append(frozen);
return sb.toString();
}
}
/**
* 具有代理处理器通用功能的基类
*/
@SuppressWarnings("serial")
public class ProxyProcessorSupport extends ProxyConfig implements Ordered, BeanClassLoaderAware, AopInfrastructureBean {
/**
* 它应该在其他所有处理器之后运行
*/
private int order = Ordered.LOWEST_PRECEDENCE;
@Nullable
private ClassLoader proxyClassLoader = ClassUtils.getDefaultClassLoader();
private boolean classLoaderConfigured = false;
public void setOrder(int order) {
this.order = order;
}
@Override
public int getOrder() {
return order;
}
public void setProxyClassLoader(@Nullable ClassLoader classLoader) {
proxyClassLoader = classLoader;
classLoaderConfigured = classLoader != null;
}
@Nullable
protected ClassLoader getProxyClassLoader() {
return proxyClassLoader;
}
@Override
public void setBeanClassLoader(ClassLoader classLoader) {
if (!classLoaderConfigured) {
proxyClassLoader = classLoader;
}
}
/**
* 尝试将目标类型实现的所有接口添加到 proxyFactory 中
*/
protected void evaluateProxyInterfaces(Class<?> beanClass, ProxyFactory proxyFactory) {
// 获取目标类型的所有接口
final Class<?>[] targetInterfaces = ClassUtils.getAllInterfacesForClass(beanClass, getProxyClassLoader());
boolean hasReasonableProxyInterface = false;
for (final Class<?> ifc : targetInterfaces) {
// 目标接口不是回调接口和内部语言接口 && 接口中存在方法，则需要为其创建代理
if (!isConfigurationCallbackInterface(ifc) && !isInternalLanguageInterface(ifc) &&
ifc.getMethods().length > 0) {
hasReasonableProxyInterface = true;
break;
}
}
if (hasReasonableProxyInterface) {
/**
* 此处还需要设置引入接口，以实现切面引入接口功能
*/
for (final Class<?> ifc : targetInterfaces) {
proxyFactory.addInterface(ifc);
}
}
else {
// 无需要代理的接口，则直接创建基于类的代理
proxyFactory.setProxyTargetClass(true);
}
}
/**
* 目标接口是容器回调接口
* InitializingBean
* DisposableBean
* Closeable
* AutoCloseable
* Aware
*/
protected boolean isConfigurationCallbackInterface(Class<?> ifc) {
// 可改成 Aware.class.isAssignableFrom(ifc);
return InitializingBean.class == ifc || DisposableBean.class == ifc || Closeable.class == ifc ||
AutoCloseable.class == ifc || ObjectUtils.containsElement(ifc.getInterfaces(), Aware.class);
}
/**
* 目标接口是内部语言接口
*/
protected boolean isInternalLanguageInterface(Class<?> ifc) {
return ifc.getName().equals("groovy.lang.GroovyObject") ||
ifc.getName().endsWith(".cglib.proxy.Factory") ||
ifc.getName().endsWith(".bytebuddy.MockAccess");
}
}
/**
* BeanPostProcessor 接口实现类，尝试基于目标对象创建代理类。
*/
@SuppressWarnings("serial")
public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {
/**
* 无需代理
*/
@Nullable
protected static final Object[] DO_NOT_PROXY = null;
/**
* 无需应用扩展的 interceptors
*/
protected static final Object[] PROXY_WITHOUT_ADDITIONAL_INTERCEPTORS = new Object[0];
protected final Log logger = LogFactory.getLog(getClass());
/** Default is global AdvisorAdapterRegistry. */
private AdvisorAdapterRegistry advisorAdapterRegistry = GlobalAdvisorAdapterRegistry.getInstance();
/**
* 是否需要冻结代理
*/
private boolean freezeProxy = false;
/** Default is no common interceptors. */
private String[] interceptorNames = new String[0];
private boolean applyCommonInterceptorsFirst = true;
@Nullable
private TargetSourceCreator[] customTargetSourceCreators;
@Nullable
private BeanFactory beanFactory;
private final Set<String> targetSourcedBeans = Collections.newSetFromMap(new ConcurrentHashMap<>(16));
private final Set<Object> earlyProxyReferences = Collections.newSetFromMap(new ConcurrentHashMap<>(16));
private final Map<Object, Class<?>> proxyTypes = new ConcurrentHashMap<>(16);
/**
* 已经处理的 Bean 缓存
*/
private final Map<Object, Boolean> advisedBeans = new ConcurrentHashMap<>(256);
@Override
public void setFrozen(boolean frozen) {
freezeProxy = frozen;
}
@Override
public boolean isFrozen() {
return freezeProxy;
}
public void setAdvisorAdapterRegistry(AdvisorAdapterRegistry advisorAdapterRegistry) {
this.advisorAdapterRegistry = advisorAdapterRegistry;
}
public void setCustomTargetSourceCreators(TargetSourceCreator... targetSourceCreators) {
customTargetSourceCreators = targetSourceCreators;
}
public void setInterceptorNames(String... interceptorNames) {
this.interceptorNames = interceptorNames;
}
public void setApplyCommonInterceptorsFirst(boolean applyCommonInterceptorsFirst) {
this.applyCommonInterceptorsFirst = applyCommonInterceptorsFirst;
}
@Override
public void setBeanFactory(BeanFactory beanFactory) {
this.beanFactory = beanFactory;
}
@Nullable
protected BeanFactory getBeanFactory() {
return beanFactory;
}
@Override
@Nullable
public Class<?> predictBeanType(Class<?> beanClass, String beanName) {
if (proxyTypes.isEmpty()) {
return null;
}
final Object cacheKey = getCacheKey(beanClass, beanName);
return proxyTypes.get(cacheKey);
}
@Override
@Nullable
public Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, String beanName) {
return null;
}
@Override
public Object getEarlyBeanReference(Object bean, String beanName) {
final Object cacheKey = getCacheKey(bean.getClass(), beanName);
if (!earlyProxyReferences.contains(cacheKey)) {
earlyProxyReferences.add(cacheKey);
}
return wrapIfNecessary(bean, beanName, cacheKey);
}
/**
* 实例化之前的后处理
*/
@Override
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {
final Object cacheKey = getCacheKey(beanClass, beanName);
if (!StringUtils.hasLength(beanName) || !targetSourcedBeans.contains(beanName)) {
if (advisedBeans.containsKey(cacheKey)) {
return null;
}
if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
advisedBeans.put(cacheKey, Boolean.FALSE);
return null;
}
}
// Create proxy here if we have a custom TargetSource.
final TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
if (targetSource != null) {
if (StringUtils.hasLength(beanName)) {
targetSourcedBeans.add(beanName);
}
final Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
final Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
proxyTypes.put(cacheKey, proxy.getClass());
return proxy;
}
return null;
}
@Override
public boolean postProcessAfterInstantiation(Object bean, String beanName) {
return true;
}
@Override
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
return pvs;
}
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) {
return bean;
}
/**
* 尝试为目标 bean 创建代理
*/
@Override
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
if (bean != null) {
final Object cacheKey = getCacheKey(bean.getClass(), beanName);
if (!earlyProxyReferences.contains(cacheKey)) {
return wrapIfNecessary(bean, beanName, cacheKey);
}
}
return bean;
}
protected Object getCacheKey(Class<?> beanClass, @Nullable String beanName) {
if (StringUtils.hasLength(beanName)) {
return FactoryBean.class.isAssignableFrom(beanClass) ?
BeanFactory.FACTORY_BEAN_PREFIX + beanName : beanName;
}
else {
return beanClass;
}
}
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
// 排除 targetSource Bean
if (StringUtils.hasLength(beanName) && targetSourcedBeans.contains(beanName)) {
return bean;
}
// 排除 advisedBean
if (Boolean.FALSE.equals(advisedBeans.get(cacheKey))) {
return bean;
}
/**
* 排除基础设施 Bean 和
* bean 名称以全类名开头 && 以 AutowireCapableBeanFactory.ORIGINAL_INSTANCE_SUFFIX 结尾的 Bean
*/
if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}
// 如果我们有通知，则创建代理类
final Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
if (specificInterceptors != DO_NOT_PROXY) {
advisedBeans.put(cacheKey, Boolean.TRUE);
final Object proxy = createProxy(
bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
proxyTypes.put(cacheKey, proxy.getClass());
return proxy;
}
advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}
/**
* 是否是基础设施 Bean
*/
protected boolean isInfrastructureClass(Class<?> beanClass) {
final boolean retVal = Advice.class.isAssignableFrom(beanClass) ||
Pointcut.class.isAssignableFrom(beanClass) ||
Advisor.class.isAssignableFrom(beanClass) ||
AopInfrastructureBean.class.isAssignableFrom(beanClass);
if (retVal && logger.isTraceEnabled()) {
logger.trace("Did not attempt to auto-proxy infrastructure class [" + beanClass.getName() + "]");
}
return retVal;
}
protected boolean shouldSkip(Class<?> beanClass, String beanName) {
return AutoProxyUtils.isOriginalInstance(beanName, beanClass);
}
/**
* Create a target source for bean instances.
*/
@Nullable
protected TargetSource getCustomTargetSource(Class<?> beanClass, String beanName) {
// 不能为直接创建的单例对象创建目标源
if (customTargetSourceCreators != null &&
beanFactory != null && beanFactory.containsBean(beanName)) {
for (final TargetSourceCreator tsc : customTargetSourceCreators) {
final TargetSource ts = tsc.getTargetSource(beanClass, beanName);
if (ts != null) {
// Found a matching TargetSource.
if (logger.isTraceEnabled()) {
logger.trace("TargetSourceCreator [" + tsc +
"] found custom TargetSource for bean with name '" + beanName + "'");
}
return ts;
}
}
}
// No custom TargetSource found.
return null;
}
/**
* 为指定的 bean 创建代理
*/
protected Object createProxy(Class<?> beanClass, @Nullable String beanName,
@Nullable Object[] specificInterceptors, TargetSource targetSource) {
if (beanFactory instanceof ConfigurableListableBeanFactory) {
AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) beanFactory, beanName, beanClass);
}
// 创建代理工厂
final ProxyFactory proxyFactory = new ProxyFactory();
// 复制代理属性
proxyFactory.copyFrom(this);
// 1）如果是基于接口的代理
if (!proxyFactory.isProxyTargetClass()) {
// 2）是否应该转换为类代理
if (shouldProxyTargetClass(beanClass, beanName)) {
proxyFactory.setProxyTargetClass(true);
}
else {
// 计算需要代理的接口
evaluateProxyInterfaces(beanClass, proxyFactory);
}
}
// 创建 Advisor
final Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
proxyFactory.addAdvisors(advisors);
proxyFactory.setTargetSource(targetSource);
// 自定义钩子
customizeProxyFactory(proxyFactory);
proxyFactory.setFrozen(freezeProxy);
if (advisorsPreFiltered()) {
proxyFactory.setPreFiltered(true);
}
// 基于 ProxyFactory 创建代理类
return proxyFactory.getProxy(getProxyClassLoader());
}
protected boolean shouldProxyTargetClass(Class<?> beanClass, @Nullable String beanName) {
return beanFactory instanceof ConfigurableListableBeanFactory &&
AutoProxyUtils.shouldProxyTargetClass((ConfigurableListableBeanFactory) beanFactory, beanName);
}
protected boolean advisorsPreFiltered() {
return false;
}
protected Advisor[] buildAdvisors(@Nullable String beanName, @Nullable Object[] specificInterceptors) {
// Handle prototypes correctly...
final Advisor[] commonInterceptors = resolveInterceptorNames();
final List<Object> allInterceptors = new ArrayList<>();
if (specificInterceptors != null) {
allInterceptors.addAll(Arrays.asList(specificInterceptors));
if (commonInterceptors.length > 0) {
if (applyCommonInterceptorsFirst) {
allInterceptors.addAll(0, Arrays.asList(commonInterceptors));
}
else {
allInterceptors.addAll(Arrays.asList(commonInterceptors));
}
}
}
if (logger.isTraceEnabled()) {
final int nrOfCommonInterceptors = commonInterceptors.length;
final int nrOfSpecificInterceptors = specificInterceptors != null ? specificInterceptors.length : 0;
logger.trace("Creating implicit proxy for bean '" + beanName + "' with " + nrOfCommonInterceptors +
" common interceptors and " + nrOfSpecificInterceptors + " specific interceptors");
}
final Advisor[] advisors = new Advisor[allInterceptors.size()];
for (int i = 0; i < allInterceptors.size(); i++) {
advisors[i] = advisorAdapterRegistry.wrap(allInterceptors.get(i));
}
return advisors;
}
/**
* Resolves the specified interceptor names to Advisor objects.
*/
private Advisor[] resolveInterceptorNames() {
final BeanFactory bf = beanFactory;
final ConfigurableBeanFactory cbf = bf instanceof ConfigurableBeanFactory ? (ConfigurableBeanFactory) bf : null;
final List<Advisor> advisors = new ArrayList<>();
for (final String beanName : interceptorNames) {
if (cbf == null || !cbf.isCurrentlyInCreation(beanName)) {
Assert.state(bf != null, "BeanFactory required for resolving interceptor names");
final Object next = bf.getBean(beanName);
advisors.add(advisorAdapterRegistry.wrap(next));
}
}
return advisors.toArray(new Advisor[0]);
}
/**
* Subclasses may choose to implement this: for example,
* to change the interfaces exposed.
*/
protected void customizeProxyFactory(ProxyFactory proxyFactory) {
}
/**
* 读取指定类的 Advisors
*/
@Nullable
protected abstract Object[] getAdvicesAndAdvisorsForBean(Class<?> beanClass, String beanName,
@Nullable TargetSource customTargetSource) throws BeansException;
}
/**
* 为特定的 bean 构建 AOP 代理类
*/
@SuppressWarnings("serial")
public abstract class AbstractAdvisorAutoProxyCreator extends AbstractAutoProxyCreator {
/**
* 用于从 BeanFactory 中获取标准的 Advisors
*/
@Nullable
private BeanFactoryAdvisorRetrievalHelper advisorRetrievalHelper;
@Override
public void setBeanFactory(BeanFactory beanFactory) {
super.setBeanFactory(beanFactory);
if (!(beanFactory instanceof ConfigurableListableBeanFactory)) {
throw new IllegalArgumentException(
"AdvisorAutoProxyCreator requires a ConfigurableListableBeanFactory: " + beanFactory);
}
initBeanFactory((ConfigurableListableBeanFactory) beanFactory);
}
protected void initBeanFactory(ConfigurableListableBeanFactory beanFactory) {
advisorRetrievalHelper = new BeanFactoryAdvisorRetrievalHelperAdapter(beanFactory);
}
@Override
@Nullable
protected Object[] getAdvicesAndAdvisorsForBean(
Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {
final List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
if (advisors.isEmpty()) {
return DO_NOT_PROXY;
}
return advisors.toArray();
}
/**
* 查找能自动代理此类的所有 Advisor
*/
protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
final List<Advisor> candidateAdvisors = findCandidateAdvisors();
// 查找能够应用到此类的所有 Advisor
List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
extendAdvisors(eligibleAdvisors);
if (!eligibleAdvisors.isEmpty()) {
// 排序
eligibleAdvisors = sortAdvisors(eligibleAdvisors);
}
return eligibleAdvisors;
}
protected List<Advisor> findCandidateAdvisors() {
Assert.state(advisorRetrievalHelper != null, "No BeanFactoryAdvisorRetrievalHelper available");
return advisorRetrievalHelper.findAdvisorBeans();
}
/**
* 从候选的 Advisors 列表中，查找能够应用通知到此类的所有 Advisors
*/
protected List<Advisor> findAdvisorsThatCanApply(
List<Advisor> candidateAdvisors, Class<?> beanClass, String beanName) {
ProxyCreationContext.setCurrentProxiedBeanName(beanName);
try {
return AopUtils.findAdvisorsThatCanApply(candidateAdvisors, beanClass);
}
finally {
ProxyCreationContext.setCurrentProxiedBeanName(null);
}
}
protected boolean isEligibleAdvisorBean(String beanName) {
return true;
}
protected List<Advisor> sortAdvisors(List<Advisor> advisors) {
// 根据 @Order 进行排序
AnnotationAwareOrderComparator.sort(advisors);
return advisors;
}
/**
* 允许子类定制化的扩展接口
*/
protected void extendAdvisors(List<Advisor> candidateAdvisors) {
}
@Override
protected boolean advisorsPreFiltered() {
return true;
}
private class BeanFactoryAdvisorRetrievalHelperAdapter extends BeanFactoryAdvisorRetrievalHelper {
public BeanFactoryAdvisorRetrievalHelperAdapter(ConfigurableListableBeanFactory beanFactory) {
super(beanFactory);
}
@Override
protected boolean isEligibleBean(String beanName) {
return isEligibleAdvisorBean(beanName);
}
}
}
@SuppressWarnings("serial")
public class AspectJAwareAdvisorAutoProxyCreator extends AbstractAdvisorAutoProxyCreator {
private static final Comparator<Advisor> DEFAULT_PRECEDENCE_COMPARATOR = new AspectJPrecedenceComparator();
/**
* 将通知进行排序，同一个切面的通知具有相同的顺序，
* 进入连接点时，优先级高的通知先执行，从连接点返回时，优先级低的通知先执行。
*/
@Override
@SuppressWarnings("unchecked")
protected List<Advisor> sortAdvisors(List<Advisor> advisors) {
final List<PartiallyComparableAdvisorHolder> partiallyComparableAdvisors = new ArrayList<>(advisors.size());
for (final Advisor element : advisors) {
partiallyComparableAdvisors.add(
new PartiallyComparableAdvisorHolder(element, DEFAULT_PRECEDENCE_COMPARATOR));
}
final List<PartiallyComparableAdvisorHolder> sorted = PartialOrder.sort(partiallyComparableAdvisors);
if (sorted != null) {
final List<Advisor> result = new ArrayList<>(advisors.size());
for (final PartiallyComparableAdvisorHolder pcAdvisor : sorted) {
result.add(pcAdvisor.getAdvisor());
}
return result;
}
else {
return super.sortAdvisors(advisors);
}
}
@Override
protected void extendAdvisors(List<Advisor> candidateAdvisors) {
AspectJProxyUtils.makeAdvisorChainAspectJCapableIfNecessary(candidateAdvisors);
}
@Override
protected boolean shouldSkip(Class<?> beanClass, String beanName) {
final List<Advisor> candidateAdvisors = findCandidateAdvisors();
for (final Advisor advisor : candidateAdvisors) {
if (advisor instanceof AspectJPointcutAdvisor &&
((AspectJPointcutAdvisor) advisor).getAspectName().equals(beanName)) {
return true;
}
}
return super.shouldSkip(beanClass, beanName);
}
private static class PartiallyComparableAdvisorHolder implements PartialComparable {
private final Advisor advisor;
private final Comparator<Advisor> comparator;
public PartiallyComparableAdvisorHolder(Advisor advisor, Comparator<Advisor> comparator) {
this.advisor = advisor;
this.comparator = comparator;
}
@Override
public int compareTo(Object obj) {
final Advisor otherAdvisor = ((PartiallyComparableAdvisorHolder) obj).advisor;
return comparator.compare(advisor, otherAdvisor);
}
@Override
public int fallbackCompareTo(Object obj) {
return 0;
}
public Advisor getAdvisor() {
return advisor;
}
@Override
public String toString() {
final StringBuilder sb = new StringBuilder();
final Advice advice = advisor.getAdvice();
sb.append(ClassUtils.getShortName(advice.getClass()));
sb.append(": ");
if (advisor instanceof Ordered) {
sb.append("order ").append(((Ordered) advisor).getOrder()).append(", ");
}
if (advice instanceof AbstractAspectJAdvice) {
final AbstractAspectJAdvice ajAdvice = (AbstractAspectJAdvice) advice;
sb.append(ajAdvice.getAspectName());
sb.append(", declaration order ");
sb.append(ajAdvice.getDeclarationOrder());
}
return sb.toString();
}
}
}
/**
* 用于处理容器中所有 AspectJ 注解的切面，并为目标对象创建代理类。
*/
@SuppressWarnings("serial")
public class AnnotationAwareAspectJAutoProxyCreator extends AspectJAwareAdvisorAutoProxyCreator {
@Nullable
private List<Pattern> includePatterns;
// ReflectiveAspectJAdvisorFactory
@Nullable
private AspectJAdvisorFactory aspectJAdvisorFactory;
// BeanFactoryAspectJAdvisorsBuilder
@Nullable
private BeanFactoryAspectJAdvisorsBuilder aspectJAdvisorsBuilder;
/**
* 用于匹配 @AspectJ 注解 bean 名称的正则表达式列表，默认匹配所有。
*/
public void setIncludePatterns(List<String> patterns) {
includePatterns = new ArrayList<>(patterns.size());
for (final String patternText : patterns) {
includePatterns.add(Pattern.compile(patternText));
}
}
public void setAspectJAdvisorFactory(AspectJAdvisorFactory aspectJAdvisorFactory) {
Assert.notNull(aspectJAdvisorFactory, "AspectJAdvisorFactory must not be null");
this.aspectJAdvisorFactory = aspectJAdvisorFactory;
}
@Override
protected void initBeanFactory(ConfigurableListableBeanFactory beanFactory) {
super.initBeanFactory(beanFactory);
if (aspectJAdvisorFactory == null) {
aspectJAdvisorFactory = new ReflectiveAspectJAdvisorFactory(beanFactory);
}
aspectJAdvisorsBuilder =
new BeanFactoryAspectJAdvisorsBuilderAdapter(beanFactory, aspectJAdvisorFactory);
}
/**
* 查找候选的 Advisors
*/
@Override
protected List<Advisor> findCandidateAdvisors() {
/**
* 根据父类规则查找所有的 Spring Advisors，实现 Advisor 接口的 bean
*/
final List<Advisor> advisors = super.findCandidateAdvisors();
// 构建所有 Aspect 切面的通知者
if (aspectJAdvisorsBuilder != null) {
advisors.addAll(aspectJAdvisorsBuilder.buildAspectJAdvisors());
}
return advisors;
}
@Override
protected boolean isInfrastructureClass(Class<?> beanClass) {
// 不代理切面类
return super.isInfrastructureClass(beanClass) ||
aspectJAdvisorFactory != null && aspectJAdvisorFactory.isAspect(beanClass);
}
/**
* 切面 bean 是否能够应用自动代理
*/
protected boolean isEligibleAspectBean(String beanName) {
if (includePatterns == null) {
return true;
}
else {
for (final Pattern pattern : 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 isEligibleAspectBean(beanName);
}
}
}
通过 ProxyFactory 创建代理类
/**
* 代理配置：保证所有的代理创建者都有一致的属性配置
*/
public class ProxyConfig implements Serializable {
/** use serialVersionUID from Spring 1.2 for interoperability. */
private static final long serialVersionUID = -8409359707199703185L;
/**
* 是否是基于类的代理，默认是基于接口的代理
*/
private boolean proxyTargetClass = false;
/**
* 是否执行代理优化，【如果为 true，在代理创建完毕后，修改通知将没有效果】
*/
private boolean optimize = false;
/**
* 是否不允许将代理类强转为 Advised，默认可以
*/
boolean opaque = false;
/**
* 代理类是否需要暴露到 AopContext 的 currentProxy 中
*/
boolean exposeProxy = false;
/**
* 是否冻结代理配置，冻结后不可修改
*/
private boolean frozen = false;
public void setProxyTargetClass(boolean proxyTargetClass) {
this.proxyTargetClass = proxyTargetClass;
}
public boolean isProxyTargetClass() {
return proxyTargetClass;
}
public void setOptimize(boolean optimize) {
this.optimize = optimize;
}
public boolean isOptimize() {
return optimize;
}
public void setOpaque(boolean opaque) {
this.opaque = opaque;
}
public boolean isOpaque() {
return opaque;
}
public void setExposeProxy(boolean exposeProxy) {
this.exposeProxy = exposeProxy;
}
public boolean isExposeProxy() {
return exposeProxy;
}
public void setFrozen(boolean frozen) {
this.frozen = frozen;
}
public boolean isFrozen() {
return frozen;
}
/**
* 从另一个 ProxyConfig 中复制属性
*/
public void copyFrom(ProxyConfig other) {
Assert.notNull(other, "Other ProxyConfig object must not be null");
proxyTargetClass = other.proxyTargetClass;
optimize = other.optimize;
exposeProxy = other.exposeProxy;
frozen = other.frozen;
opaque = other.opaque;
}
@Override
public String toString() {
final StringBuilder sb = new StringBuilder();
sb.append("proxyTargetClass=").append(proxyTargetClass).append("; ");
sb.append("optimize=").append(optimize).append("; ");
sb.append("opaque=").append(opaque).append("; ");
sb.append("exposeProxy=").append(exposeProxy).append("; ");
sb.append("frozen=").append(frozen);
return sb.toString();
}
}
/**
* AOP 配置管理器的基类
*/
public class AdvisedSupport extends ProxyConfig implements Advised {
/** use serialVersionUID from Spring 2.0 for interoperability. */
private static final long serialVersionUID = 2651364800145442165L;
public static final TargetSource EMPTY_TARGET_SOURCE = EmptyTargetSource.INSTANCE;
/** AOP 通知的目标对象 */
TargetSource targetSource = EMPTY_TARGET_SOURCE;
/** 是否已经为特定目标类型筛选过 Advisor */
private boolean preFiltered = false;
/**
* 通知者链工厂
*/
AdvisorChainFactory advisorChainFactory = new DefaultAdvisorChainFactory();
/** 目标方法和通知者链缓存 */
private transient Map<MethodCacheKey, List<Object>> methodCache;
/**
* 代理类实现的接口列表
*/
private List<Class<?>> interfaces = new ArrayList<>();
/**
* 通知者列表
*/
private List<Advisor> advisors = new ArrayList<>();
/**
* 通知者数组
*/
private Advisor[] advisorArray = new Advisor[0];
public AdvisedSupport() {
this.methodCache = new ConcurrentHashMap<>(32);
}
public AdvisedSupport(Class<?>... interfaces) {
this();
setInterfaces(interfaces);
}
public void setTarget(Object target) {
setTargetSource(new SingletonTargetSource(target));
}
@Override
public void setTargetSource(@Nullable TargetSource targetSource) {
this.targetSource = (targetSource != null ? targetSource : EMPTY_TARGET_SOURCE);
}
@Override
public TargetSource getTargetSource() {
return this.targetSource;
}
public void setTargetClass(@Nullable Class<?> targetClass) {
this.targetSource = EmptyTargetSource.forClass(targetClass);
}
@Override
@Nullable
public Class<?> getTargetClass() {
return this.targetSource.getTargetClass();
}
@Override
public void setPreFiltered(boolean preFiltered) {
this.preFiltered = preFiltered;
}
@Override
public boolean isPreFiltered() {
return this.preFiltered;
}
public void setAdvisorChainFactory(AdvisorChainFactory advisorChainFactory) {
Assert.notNull(advisorChainFactory, "AdvisorChainFactory must not be null");
this.advisorChainFactory = advisorChainFactory;
}
public AdvisorChainFactory getAdvisorChainFactory() {
return this.advisorChainFactory;
}
public void setInterfaces(Class<?>... interfaces) {
Assert.notNull(interfaces, "Interfaces must not be null");
this.interfaces.clear();
for (Class<?> ifc : interfaces) {
addInterface(ifc);
}
}
/**
* 增加一个新的代理接口
*/
public void addInterface(Class<?> intf) {
Assert.notNull(intf, "Interface must not be null");
if (!intf.isInterface()) {
throw new IllegalArgumentException("[" + intf.getName() + "] is not an interface");
}
if (!this.interfaces.contains(intf)) {
this.interfaces.add(intf);
adviceChanged();
}
}
/**
* 移除一个代理接口
*/
public boolean removeInterface(Class<?> intf) {
return this.interfaces.remove(intf);
}
@Override
public Class<?>[] getProxiedInterfaces() {
return ClassUtils.toClassArray(this.interfaces);
}
@Override
public boolean isInterfaceProxied(Class<?> intf) {
for (Class<?> proxyIntf : this.interfaces) {
if (intf.isAssignableFrom(proxyIntf)) {
return true;
}
}
return false;
}
@Override
public final Advisor[] getAdvisors() {
return this.advisorArray;
}
@Override
public void addAdvisor(Advisor advisor) {
int pos = this.advisors.size();
addAdvisor(pos, advisor);
}
@Override
public void addAdvisor(int pos, Advisor advisor) throws AopConfigException {
if (advisor instanceof IntroductionAdvisor) {
validateIntroductionAdvisor((IntroductionAdvisor) advisor);
}
addAdvisorInternal(pos, advisor);
}
@Override
public boolean removeAdvisor(Advisor advisor) {
int index = indexOf(advisor);
if (index == -1) {
return false;
}
else {
removeAdvisor(index);
return true;
}
}
@Override
public void removeAdvisor(int index) throws AopConfigException {
if (isFrozen()) {
throw new AopConfigException("Cannot remove Advisor: Configuration is frozen.");
}
if (index < 0 || index > this.advisors.size() - 1) {
throw new AopConfigException("Advisor index " + index + " is out of bounds: " +
"This configuration only has " + this.advisors.size() + " advisors.");
}
Advisor advisor = this.advisors.get(index);
if (advisor instanceof IntroductionAdvisor) {
IntroductionAdvisor ia = (IntroductionAdvisor) advisor;
// We need to remove introduction interfaces.
for (int j = 0; j < ia.getInterfaces().length; j++) {
removeInterface(ia.getInterfaces()[j]);
}
}
this.advisors.remove(index);
updateAdvisorArray();
adviceChanged();
}
@Override
public int indexOf(Advisor advisor) {
Assert.notNull(advisor, "Advisor must not be null");
return this.advisors.indexOf(advisor);
}
@Override
public boolean replaceAdvisor(Advisor a, Advisor b) throws AopConfigException {
Assert.notNull(a, "Advisor a must not be null");
Assert.notNull(b, "Advisor b must not be null");
int index = indexOf(a);
if (index == -1) {
return false;
}
removeAdvisor(index);
addAdvisor(index, b);
return true;
}
public void addAdvisors(Advisor... advisors) {
addAdvisors(Arrays.asList(advisors));
}
public void addAdvisors(Collection<Advisor> advisors) {
if (isFrozen()) {
throw new AopConfigException("Cannot add advisor: Configuration is frozen.");
}
if (!CollectionUtils.isEmpty(advisors)) {
for (Advisor advisor : advisors) {
if (advisor instanceof IntroductionAdvisor) {
validateIntroductionAdvisor((IntroductionAdvisor) advisor);
}
Assert.notNull(advisor, "Advisor must not be null");
this.advisors.add(advisor);
}
updateAdvisorArray();
adviceChanged();
}
}
private void validateIntroductionAdvisor(IntroductionAdvisor advisor) {
advisor.validateInterfaces();
// If the advisor passed validation, we can make the change.
Class<?>[] ifcs = advisor.getInterfaces();
for (Class<?> ifc : ifcs) {
addInterface(ifc);
}
}
private void addAdvisorInternal(int pos, Advisor advisor) throws AopConfigException {
Assert.notNull(advisor, "Advisor must not be null");
if (isFrozen()) {
throw new AopConfigException("Cannot add advisor: Configuration is frozen.");
}
if (pos > this.advisors.size()) {
throw new IllegalArgumentException(
"Illegal position " + pos + " in advisor list with size " + this.advisors.size());
}
this.advisors.add(pos, advisor);
updateAdvisorArray();
adviceChanged();
}
protected final void updateAdvisorArray() {
this.advisorArray = this.advisors.toArray(new Advisor[0]);
}
protected final List<Advisor> getAdvisorsInternal() {
return this.advisors;
}
@Override
public void addAdvice(Advice advice) throws AopConfigException {
int pos = this.advisors.size();
addAdvice(pos, advice);
}
@Override
public void addAdvice(int pos, Advice advice) throws AopConfigException {
Assert.notNull(advice, "Advice must not be null");
if (advice instanceof IntroductionInfo) {
// We don't need an IntroductionAdvisor for this kind of introduction:
// It's fully self-describing.
addAdvisor(pos, new DefaultIntroductionAdvisor(advice, (IntroductionInfo) advice));
}
else if (advice instanceof DynamicIntroductionAdvice) {
// We need an IntroductionAdvisor for this kind of introduction.
throw new AopConfigException("DynamicIntroductionAdvice may only be added as part of IntroductionAdvisor");
}
else {
addAdvisor(pos, new DefaultPointcutAdvisor(advice));
}
}
@Override
public boolean removeAdvice(Advice advice) throws AopConfigException {
int index = indexOf(advice);
if (index == -1) {
return false;
}
else {
removeAdvisor(index);
return true;
}
}
@Override
public int indexOf(Advice advice) {
Assert.notNull(advice, "Advice must not be null");
for (int i = 0; i < this.advisors.size(); i++) {
Advisor advisor = this.advisors.get(i);
if (advisor.getAdvice() == advice) {
return i;
}
}
return -1;
}
public boolean adviceIncluded(@Nullable Advice advice) {
if (advice != null) {
for (Advisor advisor : this.advisors) {
if (advisor.getAdvice() == advice) {
return true;
}
}
}
return false;
}
/**
* 计算给定通知类型的通知者个数
*/
public int countAdvicesOfType(@Nullable Class<?> adviceClass) {
int count = 0;
if (adviceClass != null) {
for (Advisor advisor : this.advisors) {
if (adviceClass.isInstance(advisor.getAdvice())) {
count++;
}
}
}
return count;
}
/**
* 获取指定方法的 MethodInterceptor 列表
*/
public List<Object> getInterceptorsAndDynamicInterceptionAdvice(Method method, @Nullable Class<?> targetClass) {
MethodCacheKey cacheKey = new MethodCacheKey(method);
List<Object> cached = this.methodCache.get(cacheKey);
if (cached == null) {
cached = this.advisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice(
this, method, targetClass);
this.methodCache.put(cacheKey, cached);
}
return cached;
}
protected void adviceChanged() {
this.methodCache.clear();
}
protected void copyConfigurationFrom(AdvisedSupport other) {
copyConfigurationFrom(other, other.targetSource, new ArrayList<>(other.advisors));
}
/**
* Copy the AOP configuration from the given AdvisedSupport object,
* but allow substitution of a fresh TargetSource and a given interceptor chain.
*/
protected void copyConfigurationFrom(AdvisedSupport other, TargetSource targetSource, List<Advisor> advisors) {
copyFrom(other);
this.targetSource = targetSource;
this.advisorChainFactory = other.advisorChainFactory;
this.interfaces = new ArrayList<>(other.interfaces);
for (Advisor advisor : advisors) {
if (advisor instanceof IntroductionAdvisor) {
validateIntroductionAdvisor((IntroductionAdvisor) advisor);
}
Assert.notNull(advisor, "Advisor must not be null");
this.advisors.add(advisor);
}
updateAdvisorArray();
adviceChanged();
}
AdvisedSupport getConfigurationOnlyCopy() {
AdvisedSupport copy = new AdvisedSupport();
copy.copyFrom(this);
copy.targetSource = EmptyTargetSource.forClass(getTargetClass(), getTargetSource().isStatic());
copy.advisorChainFactory = this.advisorChainFactory;
copy.interfaces = this.interfaces;
copy.advisors = this.advisors;
copy.updateAdvisorArray();
return copy;
}
@Override
public String toProxyConfigString() {
return toString();
}
/**
* For debugging/diagnostic use.
*/
@Override
public String toString() {
StringBuilder sb = new StringBuilder(getClass().getName());
sb.append(": ").append(this.interfaces.size()).append(" interfaces ");
sb.append(ClassUtils.classNamesToString(this.interfaces)).append("; ");
sb.append(this.advisors.size()).append(" advisors ");
sb.append(this.advisors).append("; ");
sb.append("targetSource [").append(this.targetSource).append("]; ");
sb.append(super.toString());
return sb.toString();
}
private static final class MethodCacheKey implements Comparable<MethodCacheKey> {
private final Method method;
private final int hashCode;
public MethodCacheKey(Method method) {
this.method = method;
this.hashCode = method.hashCode();
}
@Override
public boolean equals(Object other) {
return (this == other || (other instanceof MethodCacheKey &&
this.method == ((MethodCacheKey) other).method));
}
@Override
public int hashCode() {
return this.hashCode;
}
@Override
public String toString() {
return this.method.toString();
}
@Override
public int compareTo(MethodCacheKey other) {
int result = this.method.getName().compareTo(other.method.getName());
if (result == 0) {
result = this.method.toString().compareTo(other.method.toString());
}
return result;
}
}
}
代理创建
通过 AopProxyFactory#createAopProxy 创建 AopProxy，再通过 AopProxy#getProxy 创建代理类。
/**
* 基于 AdvisedSupport 创建 AopProxy 的工厂
*/
public interface AopProxyFactory {
/**
* 基于指定的 AOP 配置创建 AopProxy
*/
AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException;
}
@SuppressWarnings("serial")
public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {
@Override
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
final Class<?> targetClass = config.getTargetClass();
if (targetClass == null) {
throw new AopConfigException("TargetSource cannot determine target class: " +
"Either an interface or a target is required for proxy creation.");
}
// 目标类型是接口 || 代理类
if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
return new JdkDynamicAopProxy(config);
}
return new ObjenesisCglibAopProxy(config);
}
else {
return new JdkDynamicAopProxy(config);
}
}
/**
* 没有用户定义的代理接口
*/
private boolean hasNoUserSuppliedProxyInterfaces(AdvisedSupport config) {
final Class<?>[] ifcs = config.getProxiedInterfaces();
return ifcs.length == 0 || ifcs.length == 1 && SpringProxy.class.isAssignableFrom(ifcs[0]);
}
}
/**
* 已配置AOP代理的委托接口，用于创建实际的代理对象
*/
public interface AopProxy {
/**
* 创建一个新的代理对象
*/
Object getProxy();
/**
* 基于指定的类加载器创建一个新的代理对象
*/
Object getProxy(@Nullable ClassLoader classLoader);
}
/**
* 基于 JDK 动态代理实现的 AopProxy
*/
final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {
private static final long serialVersionUID = 5531744639992436476L;
private static final Log logger = LogFactory.getLog(JdkDynamicAopProxy.class);
/** 代理配置 */
private final AdvisedSupport advised;
/**
* equals 方法定义在代理接口中？
*/
private boolean equalsDefined;
/**
* hashCode 定义在代理接口中？
*/
private boolean hashCodeDefined;
public JdkDynamicAopProxy(AdvisedSupport config) throws AopConfigException {
Assert.notNull(config, "AdvisedSupport must not be null");
if (config.getAdvisors().length == 0 && config.getTargetSource() == AdvisedSupport.EMPTY_TARGET_SOURCE) {
throw new AopConfigException("No advisors and no TargetSource specified");
}
advised = config;
}
@Override
public Object getProxy() {
return getProxy(ClassUtils.getDefaultClassLoader());
}
@Override
public Object getProxy(@Nullable ClassLoader classLoader) {
if (logger.isTraceEnabled()) {
logger.trace("Creating JDK dynamic proxy: " + advised.getTargetSource());
}
// 读取所有代理接口
final Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(advised, true);
// 查找 equals 和 hashCode 方法
findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
// 创建代理类
return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
}
/**
* 查找 equals 和 hashCode 方法
*/
private void findDefinedEqualsAndHashCodeMethods(Class<?>[] proxiedInterfaces) {
for (final Class<?> proxiedInterface : proxiedInterfaces) {
final Method[] methods = proxiedInterface.getDeclaredMethods();
for (final Method method : methods) {
// 如果是 equals 方法
if (AopUtils.isEqualsMethod(method)) {
equalsDefined = true;
}
// 如果是 hashCode 方法
if (AopUtils.isHashCodeMethod(method)) {
hashCodeDefined = true;
}
if (equalsDefined && hashCodeDefined) {
return;
}
}
}
}
/**
* 执行核心调用
*/
@Override
@Nullable
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
MethodInvocation invocation;
Object oldProxy = null;
boolean setProxyContext = false;
final TargetSource targetSource = advised.targetSource;
Object target = null;
try {
// 1）目标方法是 equals
if (!equalsDefined && AopUtils.isEqualsMethod(method)) {
// The target does not implement the equals(Object) method itself.
return equals(args[0]);
}
// 2）目标方法是 hashCode
else if (!hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
// The target does not implement the hashCode() method itself.
return hashCode();
}
else if (method.getDeclaringClass() == DecoratingProxy.class) {
// There is only getDecoratedClass() declared -> dispatch to proxy config.
return AopProxyUtils.ultimateTargetClass(advised);
}
else if (!advised.opaque && method.getDeclaringClass().isInterface() &&
method.getDeclaringClass().isAssignableFrom(Advised.class)) {
// Service invocations on ProxyConfig with the proxy config...
return AopUtils.invokeJoinpointUsingReflection(advised, method, args);
}
Object retVal;
// 将代理类写入 AopContext 中
if (advised.exposeProxy) {
oldProxy = AopContext.setCurrentProxy(proxy);
setProxyContext = true;
}
// 尽量减少目标对象的持有时间，它可能来自于对象池
target = targetSource.getTarget();
final Class<?> targetClass = target != null ? target.getClass() : null;
// 获取方法的拦截链
final List<Object> chain = advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
// 1）没有拦截链，则直接触发目标方法调用
if (chain.isEmpty()) {
// 将可变参数封装到数组中
final Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
// 反射调用目标方法
retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
}
else {
// 创建 ReflectiveMethodInvocation
invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
// 执行拦截链和目标方法
retVal = invocation.proceed();
}
final Class<?> returnType = method.getReturnType();
// 1）某种兼容
if (retVal != null && retVal == target &&
returnType != Object.class && returnType.isInstance(proxy) &&
!RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
retVal = proxy;
}
// 2）方法的返回类型声明为原生类型 && 但是返回了 null
else if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) {
throw new AopInvocationException(
"Null return value from advice does not match primitive return type for: " + method);
}
return retVal;
}
finally {
if (target != null && !targetSource.isStatic()) {
// Must have come from TargetSource.
targetSource.releaseTarget(target);
}
if (setProxyContext) {
// Restore old proxy.
AopContext.setCurrentProxy(oldProxy);
}
}
}
@Override
public boolean equals(@Nullable Object other) {
if (other == this) {
return true;
}
if (other == null) {
return false;
}
JdkDynamicAopProxy otherProxy;
if (other instanceof JdkDynamicAopProxy) {
otherProxy = (JdkDynamicAopProxy) other;
}
else if (Proxy.isProxyClass(other.getClass())) {
final InvocationHandler ih = Proxy.getInvocationHandler(other);
if (!(ih instanceof JdkDynamicAopProxy)) {
return false;
}
otherProxy = (JdkDynamicAopProxy) ih;
}
else {
// Not a valid comparison...
return false;
}
// If we get here, otherProxy is the other AopProxy.
return AopProxyUtils.equalsInProxy(advised, otherProxy.advised);
}
@Override
public int hashCode() {
return JdkDynamicAopProxy.class.hashCode() * 13 + advised.getTargetSource().hashCode();
}
}