Spring 源码之 AOP 实现原理
@EnableAspectJAutoProxy
@EnableAspectJAutoProxy；外围从这个动手,AOP 整个性能要启作用, 就是靠这个, 退出它才有 AOP
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
// 导入 AspectJAutoProxyRegistrar
@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {
/**
* Indicate whether subclass-based (CGLIB) proxies are to be created as opposed
* to standard Java interface-based proxies. The default is {@code false}.
*/
// proxyTargetClass 属性，默认 false，采纳 JDK 动静代理织入加强 (实现接口的形式)；如果设为 true，则采纳 CGLIB 动静代理织入加强
boolean proxyTargetClass() default false;
/**
* Indicate that the proxy should be exposed by the AOP framework as a {@code ThreadLocal}
* for retrieval via the {@link org.springframework.aop.framework.AopContext} class.
* Off by default, i.e. no guarantees that {@code AopContext} access will work.
* @since 4.3.1
*/
// 通过 aop 框架裸露该代理对象，aopContext 可能拜访
boolean exposeProxy() default false;}AspectJAutoProxyRegistrar
/**
* Registers an {@link org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator
* AnnotationAwareAspectJAutoProxyCreator} against the current {@link BeanDefinitionRegistry}
* as appropriate based on a given @{@link EnableAspectJAutoProxy} annotation.
*
* @author Chris Beams
* @author Juergen Hoeller
* @since 3.1
* @see EnableAspectJAutoProxy
*/
// 实现 ImportBeanDefinitionRegistrar 接口
class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {
/**
* Register, escalate, and configure the AspectJ auto proxy creator based on the value
* of the @{@link EnableAspectJAutoProxy#proxyTargetClass()} attribute on the importing
* {@code @Configuration} class.
*/
@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
// 注册 AnnotationAwareAspectJAutoProxyCreator 组件
AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);
AnnotationAttributes enableAspectJAutoProxy =
AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);
if (enableAspectJAutoProxy != null) {if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) {AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
}
if (enableAspectJAutoProxy.getBoolean("exposeProxy")) {AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
}
}
}
}registerAspectJAnnotationAutoProxyCreatorIfNecessary
@Nullable
public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry) {return registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry, null);
}
@Nullable
public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry, @Nullable Object source) {return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
}
@Nullable
private static BeanDefinition registerOrEscalateApcAsRequired(Class<?> cls, BeanDefinitionRegistry registry, @Nullable Object source) {Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
// 如果容器中 bean 曾经有了
if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
if (!cls.getName().equals(apcDefinition.getBeanClassName())) {int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
int requiredPriority = findPriorityForClass(cls);
if (currentPriority < requiredPriority) {apcDefinition.setBeanClassName(cls.getName());
}
}
return null;
}
RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
beanDefinition.setSource(source);
beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
return beanDefinition;
}IOC 容器中注入了一个 internalAutoProxyCreator=AnnotationAwareAspectJAutoProxyCreator 的 bean， 到此能够得出结论，@EnableAspectJAutoProxy 给容器中注册一个 AnnotationAwareAspectJAutoProxyCreator。
三、AnnotationAwareAspectJAutoProxyCreator 创立过程
AnnotationAwareAspectJAutoProxyCreator
重点钻研 AnnotationAwareAspectJAutoProxyCreator 组件 (ASPECT 主动代理创立器)
AnnotationAwareAspectJAutoProxyCreator 类关系图如下, 继承关系:
AnnotationAwareAspectJAutoProxyCreator：
\* AnnotationAwareAspectJAutoProxyCreator
\* ->AspectJAwareAdvisorAutoProxyCreator
\* ->AbstractAdvisorAutoProxyCreator
\* ->AbstractAutoProxyCreator
\* implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware
\* 关注后置处理器（在 bean 初始化实现前后做事件）、主动拆卸 BeanFactory
SmartInstantiationAwareBeanPostProcessor: bean 的后置处理器（在 bean 初始化实现前后做事件）
BeanFactoryAware 能把 beanFacotry bean 工厂传进来
创立和注册 AnnotationAwareAspectJAutoProxyCreator
1）、传入配置类，创立 ioc 容器
2）、注册配置类，调用 refresh（）刷新容器；3）、registerBeanPostProcessors(beanFactory); 注册 bean 的后置处理器来不便拦挡 bean 的创立；1）、先获取 ioc 容器曾经定义了的须要创建对象的所有 BeanPostProcessor
2）、给容器中加别的 BeanPostProcessor
3）、优先注册实现了 PriorityOrdered 接口的 BeanPostProcessor；4）、再给容器中注册实现了 Ordered 接口的 BeanPostProcessor；5）、注册没实现优先级接口的 BeanPostProcessor；6）、注册 BeanPostProcessor，实际上就是创立 BeanPostProcessor 对象，保留在容器中；创立 internalAutoProxyCreator 的 BeanPostProcessor【AnnotationAwareAspectJAutoProxyCreator】1）、创立 Bean 的实例
2）、populateBean；给 bean 的各种属性赋值
3）、initializeBean：初始化 bean；1）、invokeAwareMethods()：解决 Aware 接口的办法回调
2）、applyBeanPostProcessorsBeforeInitialization()：利用后置处理器的 postProcessBeforeInitialization（）3）、invokeInitMethods()；执行自定义的初始化办法
4）、applyBeanPostProcessorsAfterInitialization()；执行后置处理器的 postProcessAfterInitialization（）；4）、BeanPostProcessor(AnnotationAwareAspectJAutoProxyCreator) 创立胜利；--》aspectJAdvisorsBuilder
7）、把 BeanPostProcessor 注册到 BeanFactory 中；beanFactory.addBeanPostProcessor(postProcessor); registerBeanPostProcessors:
/**
* Instantiate and register all BeanPostProcessor beans,
* respecting explicit order if given.
* <p>Must be called before any instantiation of application beans.
*/
protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}PostProcessorRegistrationDelegate.registerBeanPostProcessors:
public static void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
// Register BeanPostProcessorChecker that logs an info message when
// a bean is created during BeanPostProcessor instantiation, i.e. when
// a bean is not eligible for getting processed by all BeanPostProcessors.
int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
// Separate between BeanPostProcessors that implement PriorityOrdered,
// Ordered, and the rest.
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
List<String> orderedPostProcessorNames = new ArrayList<>();
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
for (String ppName : postProcessorNames) {if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
priorityOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {internalPostProcessors.add(pp);
}
}
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {orderedPostProcessorNames.add(ppName);
}
else {nonOrderedPostProcessorNames.add(ppName);
}
}
// First, register the BeanPostProcessors that implement PriorityOrdered.
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
// Next, register the BeanPostProcessors that implement Ordered.
List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
for (String ppName : orderedPostProcessorNames) {BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
orderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {internalPostProcessors.add(pp);
}
}
sortPostProcessors(orderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, orderedPostProcessors);
// Now, register all regular BeanPostProcessors.
List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
for (String ppName : nonOrderedPostProcessorNames) {BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
nonOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {internalPostProcessors.add(pp);
}
}
registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
// Finally, re-register all internal BeanPostProcessors.
sortPostProcessors(internalPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, internalPostProcessors);
// Re-register post-processor for detecting inner beans as ApplicationListeners,
// moving it to the end of the processor chain (for picking up proxies etc).
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}AnnotationAwareAspectJAutoProxyCreator 的执行机会
之前剖析到 AnnotationAwareAspectJAutoProxyCreator 是一个后置处理器，能够猜想它在其余 bean 的初始化前后进行了非凡解决。
4）、finishBeanFactoryInitialization(beanFactory); 实现 BeanFactory 初始化工作；创立剩下的单实例 bean
1）、遍历获取容器中所有的 Bean，顺次创建对象 getBean(beanName);
getBean->doGetBean()->getSingleton()->
2）、创立 bean【AnnotationAwareAspectJAutoProxyCreator 在所有 bean 创立之前会有一个拦挡，InstantiationAwareBeanPostProcessor，会调用 postProcessBeforeInstantiation()】1）、先从缓存中获取以后 bean，如果能获取到，阐明 bean 是之前被创立过的，间接应用，否则再创立；只有创立好的 Bean 都会被缓存起来
2）、createBean（）; 创立 bean；AnnotationAwareAspectJAutoProxyCreator 会在任何 bean 创立之前先尝试返回 bean 的实例【BeanPostProcessor 是在 Bean 对象创立实现初始化前后调用的】【InstantiationAwareBeanPostProcessor 是在创立 Bean 实例之前先尝试用后置处理器返回对象的】1）、resolveBeforeInstantiation(beanName, mbdToUse); 解析 BeforeInstantiation
心愿后置处理器在此能返回一个代理对象；如果能返回代理对象就应用，如果不能就持续
1）、后置处理器先尝试返回对象；bean = applyBeanPostProcessorsBeforeInstantiation（）：拿到所有后置处理器，如果是 InstantiationAwareBeanPostProcessor;
就执行 postProcessBeforeInstantiation
if (bean != null) {bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
2）、doCreateBean(beanName, mbdToUse, args); 真正的去创立一个 bean 实例；和 3.6 流程一样；3）、*AnnotationAwareAspectJAutoProxyCreator 会在任何 bean 创立之前先尝试返回 bean 的实例
【BeanPostProcessor 是在 Bean 对象创立实现初始化前后调用的】【InstantiationAwareBeanPostProcessor 是在创立 Bean 实例之前先尝试用后置处理器返回对象的】*
AbstractAutowireCapableBeanFactory#createBean
try {
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {return bean;}
}
catch (Throwable ex) {throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
"BeanPostProcessor before instantiation of bean failed", ex);
} @Nullable
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
Object bean = null;
if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
// Make sure bean class is actually resolved at this point.
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {Class<?> targetType = determineTargetType(beanName, mbd);
if (targetType != null) {bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
if (bean != null) {bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
}
}
mbd.beforeInstantiationResolved = (bean != null);
}
return bean;
} @Nullable
protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {for (BeanPostProcessor bp : getBeanPostProcessors()) {if (bp instanceof InstantiationAwareBeanPostProcessor) {InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
if (result != null) {return result;}
}
}
return null;
}AbstractAutoProxyCreator#postProcessBeforeInstantiation
@Override
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {Object cacheKey = getCacheKey(beanClass, beanName);
if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {if (this.advisedBeans.containsKey(cacheKey)) {return null;}
if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {this.advisedBeans.put(cacheKey, Boolean.FALSE);
return null;
}
}
// Create proxy here if we have a custom TargetSource.
// Suppresses unnecessary default instantiation of the target bean:
// The TargetSource will handle target instances in a custom fashion.
TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
if (targetSource != null) {if (StringUtils.hasLength(beanName)) {this.targetSourcedBeans.add(beanName);
}
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
this.proxyTypes.put(cacheKey, proxy.getClass());
return proxy;
}
return null;
}创立 AOP 代理
AbstractAutoProxyCreator#postProcessBeforeInstantiation 办法外部会进行一系列的判断，判断以后 bean 是否在 advisedBeans 中（保留了所有须要加强 bean）、判断以后 bean 是否是根底类型的 Advice、Pointcut、Advisor、AopInfrastructureBean、判断是否是切面（是否实现了注解 @Aspect）、判断是否须要跳过等。
在判断的过程中会拿到加强 bean 的相干的告诉办法，并通过这些切面进行逻辑判断。
执行完 postProcessBeforeInstantiation 办法进行告诉办法的判断后，执行 postProcessAfterInitialization 办法。
AbstractAutoProxyCreator#postProcessAfterInitialization
/**
* Create a proxy with the configured interceptors if the bean is
* identified as one to proxy by the subclass.
* @see #getAdvicesAndAdvisorsForBean
*/
@Override
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {if (bean != null) {Object cacheKey = getCacheKey(bean.getClass(), beanName);
if (this.earlyProxyReferences.remove(cacheKey) != bean) {return wrapIfNecessary(bean, beanName, cacheKey);
}
}
return bean;
}在对对象包装的过程中创立了一个代理对象。
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {return bean;}
if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {return bean;}
if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}
// Create proxy if we have advice.
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
if (specificInterceptors != DO_NOT_PROXY) {this.advisedBeans.put(cacheKey, Boolean.TRUE);
Object proxy = createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
this.proxyTypes.put(cacheKey, proxy.getClass());
return proxy;
}
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}创立代理对象的过程，发现在创立之前首先会依据切入点表达式对增强器进行一一匹配，最终拿到所有的增强器
/**
* Create an AOP proxy for the given bean.
* @param beanClass the class of the bean
* @param beanName the name of the bean
* @param specificInterceptors the set of interceptors that is
* specific to this bean (may be empty, but not null)
* @param targetSource the TargetSource for the proxy,
* already pre-configured to access the bean
* @return the AOP proxy for the bean
* @see #buildAdvisors
*/
protected Object createProxy(Class<?> beanClass, @Nullable String beanName,
@Nullable Object[] specificInterceptors, TargetSource targetSource) {if (this.beanFactory instanceof ConfigurableListableBeanFactory) {AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
}
ProxyFactory proxyFactory = new ProxyFactory();
proxyFactory.copyFrom(this);
if (!proxyFactory.isProxyTargetClass()) {if (shouldProxyTargetClass(beanClass, beanName)) {proxyFactory.setProxyTargetClass(true);
}
else {evaluateProxyInterfaces(beanClass, proxyFactory);
}
}
Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
proxyFactory.addAdvisors(advisors);
proxyFactory.setTargetSource(targetSource);
customizeProxyFactory(proxyFactory);
proxyFactory.setFrozen(this.freezeProxy);
if (advisorsPreFiltered()) {proxyFactory.setPreFiltered(true);
}
return proxyFactory.getProxy(getProxyClassLoader());
} /**
* Create a new proxy according to the settings in this factory.
* <p>Can be called repeatedly. Effect will vary if we've added
* or removed interfaces. Can add and remove interceptors.
* <p>Uses the given class loader (if necessary for proxy creation).
* @param classLoader the class loader to create the proxy with
* (or {@code null} for the low-level proxy facility's default)
* @return the proxy object
*/
public Object getProxy(@Nullable ClassLoader classLoader) {return createAopProxy().getProxy(classLoader);
}创立代理对象过程中，会先创立一个代理工厂，获取到所有的增强器（告诉办法），将这些增强器和指标类注入代理工厂，再用代理工厂创建对象。
代理工厂会抉择 JdkDynamicAopProxy 或者 CglibAopProxy，次要通过是否接口和是否配置 cglib 代理来抉择。
获取拦截器链
剖析指标办法被拦挡并执行的过程。
指标办法执行；容器中保留了组件的代理对象（cglib 加强后的对象），这个对象外面保留了详细信息（比方增强器，指标对象，xxx）；1）、CglibAopProxy.intercept(); 拦挡指标办法的执行
2）、依据 ProxyFactory 对象获取将要执行的指标办法拦截器链；List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
1）、List<Object> interceptorList 保留所有拦截器 5
一个默认的 ExposeInvocationInterceptor 和 4 个增强器；2）、遍历所有的增强器，将其转为 Interceptor；registry.getInterceptors(advisor);
3）、将增强器转为 List<MethodInterceptor>；如果是 MethodInterceptor，间接退出到汇合中
如果不是，应用 AdvisorAdapter 将增强器转为 MethodInterceptor；转换实现返回 MethodInterceptor 数组；3）、如果没有拦截器链，间接执行指标办法; 拦截器链（每一个告诉办法又被包装为办法拦截器，利用 MethodInterceptor 机制）4）、如果有拦截器链，把须要执行的指标对象，指标办法，拦截器链等信息传入创立一个 CglibMethodInvocation 对象，并调用 Object retVal = mi.proceed();5）、拦截器链的触发过程; 1)、如果没有拦截器执行执行指标办法，或者拦截器的索引和拦截器数组 - 1 大小一样（指定到了最初一个拦截器）执行指标办法；2)、链式获取每一个拦截器，拦截器执行 invoke 办法，每一个拦截器期待下一个拦截器执行实现返回当前再来执行；拦截器链的机制，保障告诉办法与指标办法的执行程序；CglibAopProxy:
/**
* General purpose AOP callback. Used when the target is dynamic or when the
* proxy is not frozen.
*/
private static class DynamicAdvisedInterceptor implements MethodInterceptor, Serializable {
private final AdvisedSupport advised;
public DynamicAdvisedInterceptor(AdvisedSupport advised) {this.advised = advised;}
@Override
@Nullable
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
Object oldProxy = null;
boolean setProxyContext = false;
Object target = null;
TargetSource targetSource = this.advised.getTargetSource();
try {if (this.advised.exposeProxy) {
// Make invocation available if necessary.
oldProxy = AopContext.setCurrentProxy(proxy);
setProxyContext = true;
}
// Get as late as possible to minimize the time we "own" the target, in case it comes from a pool...
target = targetSource.getTarget();
Class<?> targetClass = (target != null ? target.getClass() : null);
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
Object retVal;
// Check whether we only have one InvokerInterceptor: that is,
// no real advice, but just reflective invocation of the target.
if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {
// We can skip creating a MethodInvocation: just invoke the target directly.
// Note that the final invoker must be an InvokerInterceptor, so we know
// it does nothing but a reflective operation on the target, and no hot
// swapping or fancy proxying.
Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
retVal = methodProxy.invoke(target, argsToUse);
}
else {
// We need to create a method invocation...
// 办法调用
retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();}
retVal = processReturnType(proxy, target, method, retVal);
return retVal;
}
finally {if (target != null && !targetSource.isStatic()) {targetSource.releaseTarget(target);
}
if (setProxyContext) {
// Restore old proxy.
AopContext.setCurrentProxy(oldProxy);
}
}
}
@Override
public boolean equals(Object other) {
return (this == other ||
(other instanceof DynamicAdvisedInterceptor &&
this.advised.equals(((DynamicAdvisedInterceptor) other).advised)));
}
/**
* CGLIB uses this to drive proxy creation.
*/
@Override
public int hashCode() {return this.advised.hashCode();
}
}public class DefaultAdvisorChainFactory implements AdvisorChainFactory, Serializable {
@Override
public List<Object> getInterceptorsAndDynamicInterceptionAdvice(Advised config, Method method, @Nullable Class<?> targetClass) {
// This is somewhat tricky... We have to process introductions first,
// but we need to preserve order in the ultimate list.
AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance();
Advisor[] advisors = config.getAdvisors();
List<Object> interceptorList = new ArrayList<>(advisors.length);
Class<?> actualClass = (targetClass != null ? targetClass : method.getDeclaringClass());
Boolean hasIntroductions = null;
for (Advisor advisor : advisors) {if (advisor instanceof PointcutAdvisor) {
// Add it conditionally.
PointcutAdvisor pointcutAdvisor = (PointcutAdvisor) advisor;
if (config.isPreFiltered() || pointcutAdvisor.getPointcut().getClassFilter().matches(actualClass)) {MethodMatcher mm = pointcutAdvisor.getPointcut().getMethodMatcher();
boolean match;
if (mm instanceof IntroductionAwareMethodMatcher) {if (hasIntroductions == null) {hasIntroductions = hasMatchingIntroductions(advisors, actualClass);
}
match = ((IntroductionAwareMethodMatcher) mm).matches(method, actualClass, hasIntroductions);
}
else {match = mm.matches(method, actualClass);
}
if (match) {MethodInterceptor[] interceptors = registry.getInterceptors(advisor);
if (mm.isRuntime()) {// Creating a new object instance in the getInterceptors() method
// isn't a problem as we normally cache created chains.
for (MethodInterceptor interceptor : interceptors) {interceptorList.add(new InterceptorAndDynamicMethodMatcher(interceptor, mm));
}
}
else {interceptorList.addAll(Arrays.asList(interceptors));
}
}
}
}
else if (advisor instanceof IntroductionAdvisor) {IntroductionAdvisor ia = (IntroductionAdvisor) advisor;
if (config.isPreFiltered() || ia.getClassFilter().matches(actualClass)) {Interceptor[] interceptors = registry.getInterceptors(advisor);
interceptorList.addAll(Arrays.asList(interceptors));
}
}
else {Interceptor[] interceptors = registry.getInterceptors(advisor);
interceptorList.addAll(Arrays.asList(interceptors));
}
}
return interceptorList;
}
} @Override
public MethodInterceptor[] getInterceptors(Advisor advisor) throws UnknownAdviceTypeException {List<MethodInterceptor> interceptors = new ArrayList<>(3);
Advice advice = advisor.getAdvice();
if (advice instanceof MethodInterceptor) {interceptors.add((MethodInterceptor) advice);
}
for (AdvisorAdapter adapter : this.adapters) {if (adapter.supportsAdvice(advice)) {interceptors.add(adapter.getInterceptor(advisor));
}
}
if (interceptors.isEmpty()) {throw new UnknownAdviceTypeException(advisor.getAdvice());
}
return interceptors.toArray(new MethodInterceptor[0]);
}通过 registry.getInterceptors(advisor) 办法获取所有的增强器，并将增强器转为 List<MethodInterceptor>，最终返回。
// 将拦截器链和指标对象等传入 methodInvocation，并调用 proceed() 办法。该办法执行也是拦截器的触发过程，也是指标办法的次要执行过程。@Override
@Nullable
public Object proceed() throws Throwable {
// We start with an index of -1 and increment early.
if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {return invokeJoinpoint();
}
Object interceptorOrInterceptionAdvice =
this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
// Evaluate dynamic method matcher here: static part will already have
// been evaluated and found to match.
InterceptorAndDynamicMethodMatcher dm =
(InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
Class<?> targetClass = (this.targetClass != null ? this.targetClass : this.method.getDeclaringClass());
if (dm.methodMatcher.matches(this.method, targetClass, this.arguments)) {return dm.interceptor.invoke(this);
}
else {
// Dynamic matching failed.
// Skip this interceptor and invoke the next in the chain.
return proceed();}
}
else {
// It's an interceptor, so we just invoke it: The pointcut will have
// been evaluated statically before this object was constructed.
return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
}
}
小结
1）、@EnableAspectJAutoProxy 开启 AOP 性能
2）、@EnableAspectJAutoProxy 会给容器中注册一个组件 AnnotationAwareAspectJAutoProxyCreator
3）、AnnotationAwareAspectJAutoProxyCreator 是一个后置处理器；4）、容器的创立流程：1）、registerBeanPostProcessors（）注册后置处理器；创立 AnnotationAwareAspectJAutoProxyCreator 对象
2）、finishBeanFactoryInitialization（）初始化剩下的单实例 bean
1）、创立业务逻辑组件和切面组件
2）、AnnotationAwareAspectJAutoProxyCreator 拦挡组件的创立过程
3）、组件创立完之后，判断组件是否须要加强
是：切面的告诉办法，包装成增强器（Advisor）; 给业务逻辑组件创立一个代理对象（cglib）；5）、执行指标办法：1）、代理对象执行指标办法
2）、CglibAopProxy.intercept()；1）、失去指标办法的拦截器链（增强器包装成拦截器 MethodInterceptor）2）、利用拦截器的链式机制，顺次进入每一个拦截器进行执行；3）、成果：失常执行：前置告诉 -》指标办法 -》后置告诉 -》返回告诉
出现异常：前置告诉 -》指标办法 -》后置告诉 -》异样告诉