spring5 源码深度解析----- AOP代理的生成

1 protected static final Object[] DO_NOT_PROXY = null;
2 
3 protectedObject wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
4     if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
5         returnbean;
6 }
7     if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
8         returnbean;
9 }
10     if (isInfrastructureClass(bean.getClass()) ||shouldSkip(bean.getClass(), beanName)) {
11         this.advisedBeans.put(cacheKey, Boolean.FALSE);
12         returnbean;
13 }
14 
15     //Create proxy if we have advice.
16    Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
17     if (specificInterceptors !=DO_NOT_PROXY) {
18         this.advisedBeans.put(cacheKey, Boolean.TRUE);
19        Object proxy =createProxy(
20                 bean.getClass(), beanName, specificInterceptors, newSingletonTargetSource(bean));
21         this.proxyTypes.put(cacheKey, proxy.getClass());
22         returnproxy;
23 }
24 
25     this.advisedBeans.put(cacheKey, Boolean.FALSE);
26     returnbean;
27 }

protected Object createProxy(Class<?>beanClass, @Nullable String beanName,
        @Nullable Object[] specificInterceptors, TargetSource targetSource) {
    if (this.beanFactory instanceofConfigurableListableBeanFactory) {
        AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
    }
    ProxyFactory proxyFactory = newProxyFactory();
    //获取当前类中相关属性
    proxyFactory.copyFrom(this);
    if (!proxyFactory.isProxyTargetClass()) {
        //决定对于给定的bean是否应该使用targetClass而不是他的接口代理，
        //检査 proxyTargetClass 设置以及 preserveTargetClass 属性
        if(shouldProxyTargetClass(beanClass, beanName)) {
            proxyFactory.setProxyTargetClass(true);
        }
        else{
            evaluateProxyInterfaces(beanClass, proxyFactory);
        }
    }
    Advisor[] advisors =buildAdvisors(beanName, specificInterceptors);
    //加入增强器
proxyFactory.addAdvisors(advisors);
    //设置要代理的目标类
proxyFactory.setTargetSource(targetSource);
    //定制代理
customizeProxyFactory(proxyFactory);
    //用来控制代理工厂被配置之后，是否还允许修改通知。
    //缺省值是false (即在代理被配置之后，不允许修改代理的配置)。
    proxyFactory.setFrozen(this.freezeProxy);
    if(advisorsPreFiltered()) {
        proxyFactory.setPreFiltered(true);
    }
    //真正创建代理的方法
    returnproxyFactory.getProxy(getProxyClassLoader());
}
@Override
public voidsetTargetSource(@Nullable TargetSource targetSource) {
    this.targetSource = (targetSource != null ?targetSource : EMPTY_TARGET_SOURCE);
}
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 instanceofIntroductionAdvisor) {
                validateIntroductionAdvisor((IntroductionAdvisor) advisor);
            }
            Assert.notNull(advisor, "Advisor must not be null");
            this.advisors.add(advisor);
        }
        updateAdvisorArray();
        adviceChanged();
    }
}

publicObject getProxy(@Nullable ClassLoader classLoader) {
    returncreateAopProxy().getProxy(classLoader);
}

protected final synchronizedAopProxy createAopProxy() {
    if (!this.active) {
        activate();
    }
    //创建代理
    return getAopProxyFactory().createAopProxy(this);
}
public AopProxy createAopProxy(AdvisedSupport config) throwsAopConfigException {
    if (config.isOptimize() || config.isProxyTargetClass() ||hasNoUserSuppliedProxyInterfaces(config)) {
        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.");
        }
        //手动设置创建Cglib代理类后，如果目标bean是一个接口，也要创建jdk代理类
        if (targetClass.isInterface() ||Proxy.isProxyClass(targetClass)) {
            return newJdkDynamicAopProxy(config);
        }
        //创建Cglib代理
        return newObjenesisCglibAopProxy(config);
    }
    else{
        //默认创建jdk代理
        return newJdkDynamicAopProxy(config);
    }
}

1 final class JdkDynamicAopProxy implementsAopProxy, InvocationHandler, Serializable {
2 
3     private finalAdvisedSupport advised;
4 
5     public JdkDynamicAopProxy(AdvisedSupport config) throwsAopConfigException {
6         Assert.notNull(config, "AdvisedSupport must not be null");
7         if (config.getAdvisors().length == 0 && config.getTargetSource() ==AdvisedSupport.EMPTY_TARGET_SOURCE) {
8             throw new AopConfigException("No advisors and no TargetSource specified");
9 }
10         this.advised =config;
11 }
12 
13 
14 @Override
15     publicObject getProxy() {
16         returngetProxy(ClassUtils.getDefaultClassLoader());
17 }
18 
19 @Override
20     publicObject getProxy(@Nullable ClassLoader classLoader) {
21         if(logger.isTraceEnabled()) {
22             logger.trace("Creating JDK dynamic proxy: " + this.advised.getTargetSource());
23 }
24         Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
25 findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
26      return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
27 }
28 
29 @Override
30 @Nullable
31     public Object invoke(Object proxy, Method method, Object[] args) throwsThrowable {
32         Object oldProxy = null;
33         boolean setProxyContext = false;
34 
35         TargetSource targetSource = this.advised.targetSource;
36         Object target = null;
37 
38         try{
39             if (!this.equalsDefined &&AopUtils.isEqualsMethod(method)) {
40                 //The target does not implement the equals(Object) method itself.
41                 return equals(args[0]);
42 }
43             else if (!this.hashCodeDefined &&AopUtils.isHashCodeMethod(method)) {
44                 //The target does not implement the hashCode() method itself.
45                 returnhashCode();
46 }
47             else if (method.getDeclaringClass() == DecoratingProxy.class) {
48                 //There is only getDecoratedClass() declared -> dispatch to proxy config.
49                 return AopProxyUtils.ultimateTargetClass(this.advised);
50 }
51             else if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
52                     method.getDeclaringClass().isAssignableFrom(Advised.class)) {
53                 //Service invocations on ProxyConfig with the proxy config...
54                 return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
55 }
56 
57 Object retVal;
58 
59             if (this.advised.exposeProxy) {
60                 //Make invocation available if necessary.
61                 oldProxy =AopContext.setCurrentProxy(proxy);
62                 setProxyContext = true;
63 }
64 
65             //Get as late as possible to minimize the time we "own" the target,
66             //in case it comes from a pool.
67             target =targetSource.getTarget();
68             Class<?> targetClass = (target != null ? target.getClass() : null);
69 
70             //Get the interception chain for this method.
71             List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
72 
73             //Check whether we have any advice. If we don't, we can fallback on direct
74             //reflective invocation of the target, and avoid creating a MethodInvocation.
75             if(chain.isEmpty()) {
76                 //We can skip creating a MethodInvocation: just invoke the target directly
77                 //Note that the final invoker must be an InvokerInterceptor so we know it does
78                 //nothing but a reflective operation on the target, and no hot swapping or fancy proxying.
79                 Object[] argsToUse =AopProxyUtils.adaptArgumentsIfNecessary(method, args);
80                 retVal =AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
81 }
82             else{
83                 //We need to create a method invocation...
84                 MethodInvocation invocation =
85                         newReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
86                 //Proceed to the joinpoint through the interceptor chain.
87                 retVal =invocation.proceed();
88 }
89 
90             //Massage return value if necessary.
91             Class<?> returnType =method.getReturnType();
92             if (retVal != null && retVal == target &&
93                     returnType != Object.class && returnType.isInstance(proxy) &&
94                     !RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
95                 //Special case: it returned "this" and the return type of the method
96                 //is type-compatible. Note that we can't help if the target sets
97                 //a reference to itself in another returned object.
98                 retVal =proxy;
99 }
100             else if (retVal == null && returnType != Void.TYPE &&returnType.isPrimitive()) {
101                 throw newAopInvocationException(
102                         "Null return value from advice does not match primitive return type for: " +method);
103 }
104             returnretVal;
105 }
106         finally{
107             if (target != null && !targetSource.isStatic()) {
108                 //Must have come from TargetSource.
109 targetSource.releaseTarget(target);
110 }
111             if(setProxyContext) {
112                 //Restore old proxy.
113 AopContext.setCurrentProxy(oldProxy);
114 }
115 }
116 }
117 
118 }

1 @Override
2 @Nullable
3 public Object invoke(Object proxy, Method method, Object[] args) throwsThrowable {
4 MethodInvocation invocation;
5     Object oldProxy = null;
6     boolean setProxyContext = false;
7 
8     TargetSource targetSource = this.advised.targetSource;
9     Object target = null;
10 
11     try{
12         if (!this.equalsDefined &&AopUtils.isEqualsMethod(method)) {
13             return equals(args[0]);
14 }
15         else if (!this.hashCodeDefined &&AopUtils.isHashCodeMethod(method)) {
16             returnhashCode();
17 }
18         else if (method.getDeclaringClass() == DecoratingProxy.class) {
19             return AopProxyUtils.ultimateTargetClass(this.advised);
20 }
21         else if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
22                 method.getDeclaringClass().isAssignableFrom(Advised.class)) {
23             return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
24 }
25 
26 Object retVal;
27         if (this.advised.exposeProxy) {
28             //Make invocation available if necessary.
29             oldProxy =AopContext.setCurrentProxy(proxy);
30             setProxyContext = true;
31 }
32 
33         target =targetSource.getTarget();
34         Class<?> targetClass = (target != null ? target.getClass() : null);
35 
36         //获取当前方法的拦截器链
37        List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
38 
39         if(chain.isEmpty()) {
40             //如果没有发现任何拦截器那么直接调用切点方法
41             Object[] argsToUse =AopProxyUtils.adaptArgumentsIfNecessary(method, args);
42             retVal =AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
43 }
44         else{
45             //We need to create a method invocation...
46             //将拦截器封装在ReflectiveMethodInvocation，
47             //以便于使用其proceed进行链接表用拦截器
48          invocation = newReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
49             //Proceed to the joinpoint through the interceptor chain.
50             //执行拦截器链
51           retVal =invocation.proceed();
52 }
53 
54         Class<?> returnType =method.getReturnType();
55         //返回结果
56         if (retVal != null && retVal == target &&
57                 returnType != Object.class && returnType.isInstance(proxy) &&
58                 !RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
59             retVal =proxy;
60 }
61         else if (retVal == null && returnType != Void.TYPE &&returnType.isPrimitive()) {
62             throw newAopInvocationException(
63                     "Null return value from advice does not match primitive return type for: " +method);
64 }
65         returnretVal;
66 }
67     finally{
68         if (target != null && !targetSource.isStatic()) {
69             //Must have come from TargetSource.
70 targetSource.releaseTarget(target);
71 }
72         if(setProxyContext) {
73             //Restore old proxy.
74 AopContext.setCurrentProxy(oldProxy);
75 }
76 }
77 }

1 @Override
2 public List<Object>getInterceptorsAndDynamicInterceptionAdvice(
3         Advised config, Method method, @Nullable Class<?>targetClass) {
4 
5     //This is somewhat tricky... We have to process introductions first,
6     //but we need to preserve order in the ultimate list.
7     AdvisorAdapterRegistry registry =GlobalAdvisorAdapterRegistry.getInstance();
8     Advisor[] advisors =config.getAdvisors();
9     List<Object> interceptorList = new ArrayList<>(advisors.length);
10     Class<?> actualClass = (targetClass != null ?targetClass : method.getDeclaringClass());
11     Boolean hasIntroductions = null;
12 
13     //获取bean中的所有增强器
14     for(Advisor advisor : advisors) {
15         if (advisor instanceofPointcutAdvisor) {
16             //Add it conditionally.
17             PointcutAdvisor pointcutAdvisor =(PointcutAdvisor) advisor;
18             if (config.isPreFiltered() ||pointcutAdvisor.getPointcut().getClassFilter().matches(actualClass)) {
19                 MethodMatcher mm =pointcutAdvisor.getPointcut().getMethodMatcher();
20                 booleanmatch;
21                 if (mm instanceofIntroductionAwareMethodMatcher) {
22                     if (hasIntroductions == null) {
23                         hasIntroductions =hasMatchingIntroductions(advisors, actualClass);
24 }
25                     match =((IntroductionAwareMethodMatcher) mm).matches(method, actualClass, hasIntroductions);
26 }
27                 else{
28                   //根据增强器中的Pointcut判断增强器是否能匹配当前类中的method
29                     //我们要知道目标Bean中并不是所有的方法都需要增强，也有一些普通方法
30                     match =mm.matches(method, actualClass);
31 }
32                 if(match) {
33                   //如果能匹配，就将advisor封装成MethodInterceptor加入到interceptorList中
34                     MethodInterceptor[] interceptors =registry.getInterceptors(advisor);
35                     if(mm.isRuntime()) {
36                         //Creating a new object instance in the getInterceptors() method
37                         //isn't a problem as we normally cache created chains.
38                         for(MethodInterceptor interceptor : interceptors) {
39                            interceptorList.add(newInterceptorAndDynamicMethodMatcher(interceptor, mm));
40 }
41 }
42                     else{
43 interceptorList.addAll(Arrays.asList(interceptors));
44 }
45 }
46 }
47 }
48         else if (advisor instanceofIntroductionAdvisor) {
49             IntroductionAdvisor ia =(IntroductionAdvisor) advisor;
50             if (config.isPreFiltered() ||ia.getClassFilter().matches(actualClass)) {
51                 Interceptor[] interceptors =registry.getInterceptors(advisor);
52 interceptorList.addAll(Arrays.asList(interceptors));
53 }
54 }
55         else{
56             Interceptor[] interceptors =registry.getInterceptors(advisor);
57 interceptorList.addAll(Arrays.asList(interceptors));
58 }
59 }
60 
61     returninterceptorList;
62 }

@Override
public MethodInterceptor[] getInterceptors(Advisor advisor) throwsUnknownAdviceTypeException {
    List<MethodInterceptor> interceptors = new ArrayList<>(3);
    Advice advice =advisor.getAdvice();
    if (advice instanceofMethodInterceptor) {
        interceptors.add((MethodInterceptor) advice);
    }
    //这里遍历三个适配器，将对应的advisor转化成Interceptor
    //这三个适配器分别是MethodBeforeAdviceAdapter，AfterReturningAdviceAdapter，ThrowsAdviceAdapter
    for (AdvisorAdapter adapter : this.adapters) {
        if(adapter.supportsAdvice(advice)) {
            interceptors.add(adapter.getInterceptor(advisor));
        }
    }
    if(interceptors.isEmpty()) {
        throw newUnknownAdviceTypeException(advisor.getAdvice());
    }
    return interceptors.toArray(new MethodInterceptor[0]);
}
private final List<AdvisorAdapter> adapters = new ArrayList<>(3);
/**
 * Create a new DefaultAdvisorAdapterRegistry, registering well-known adapters.
 */
publicDefaultAdvisorAdapterRegistry() {
    registerAdvisorAdapter(newMethodBeforeAdviceAdapter());
    registerAdvisorAdapter(newAfterReturningAdviceAdapter());
    registerAdvisorAdapter(newThrowsAdviceAdapter());
}
@Override
public voidregisterAdvisorAdapter(AdvisorAdapter adapter) {
    this.adapters.add(adapter);
}

class MethodBeforeAdviceAdapter implementsAdvisorAdapter, Serializable {
    @Override
    public booleansupportsAdvice(Advice advice) {
        //判断是否是MethodBeforeAdvice类型的advice
        return (advice instanceofMethodBeforeAdvice);
    }
    @Override
    publicMethodInterceptor getInterceptor(Advisor advisor) {
        MethodBeforeAdvice advice =(MethodBeforeAdvice) advisor.getAdvice();
        //将advice封装成MethodBeforeAdviceInterceptor
        return newMethodBeforeAdviceInterceptor(advice);
    }
}
//MethodBeforeAdviceInterceptor实现了MethodInterceptor接口，实现了invoke方法，并将advice作为属性
public class MethodBeforeAdviceInterceptor implementsMethodInterceptor, BeforeAdvice, Serializable {
    private finalMethodBeforeAdvice advice;
    publicMethodBeforeAdviceInterceptor(MethodBeforeAdvice advice) {
        Assert.notNull(advice, "Advice must not be null");
        this.advice =advice;
    }
    @Override
    public Object invoke(MethodInvocation mi) throwsThrowable {
        this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis());
        returnmi.proceed();
    }
}

class AfterReturningAdviceAdapter implementsAdvisorAdapter, Serializable {
    @Override
    public booleansupportsAdvice(Advice advice) {
        return (advice instanceofAfterReturningAdvice);
    }
    @Override
    publicMethodInterceptor getInterceptor(Advisor advisor) {
        AfterReturningAdvice advice =(AfterReturningAdvice) advisor.getAdvice();
        return newAfterReturningAdviceInterceptor(advice);
    }
}
public class AfterReturningAdviceInterceptor implementsMethodInterceptor, AfterAdvice, Serializable {
    private finalAfterReturningAdvice advice;
    publicAfterReturningAdviceInterceptor(AfterReturningAdvice advice) {
        Assert.notNull(advice, "Advice must not be null");
        this.advice =advice;
    }
    @Override
    public Object invoke(MethodInvocation mi) throwsThrowable {
        Object retVal =mi.proceed();
        this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis());
        returnretVal;
    }
}

protectedReflectiveMethodInvocation(
        Object proxy, @Nullable Object target, Method method, @Nullable Object[] arguments,
        @Nullable Class<?> targetClass, List<Object>interceptorsAndDynamicMethodMatchers) {
    this.proxy =proxy;
    this.target =target;
    this.targetClass =targetClass;
    this.method =BridgeMethodResolver.findBridgedMethod(method);
    this.arguments =AopProxyUtils.adaptArgumentsIfNecessary(method, arguments);
    this.interceptorsAndDynamicMethodMatchers =interceptorsAndDynamicMethodMatchers;
}
private int currentInterceptorIndex = -1;

public Object proceed() throwsThrowable {
    //首先，判断是不是所有的interceptor（也可以想像成advisor）都被执行完了。
    //判断的方法是看currentInterceptorIndex这个变量的值，增加到Interceptor总个数这个数值没有，
    //如果到了，就执行被代理方法(invokeJoinpoint())；如果没到，就继续执行Interceptor。
    if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
        returninvokeJoinpoint();
    }
    //如果Interceptor没有被全部执行完，就取出要执行的Interceptor，并执行。
    //currentInterceptorIndex先自增
    Object interceptorOrInterceptionAdvice =this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
    //如果Interceptor是PointCut类型
    if (interceptorOrInterceptionAdvice instanceofInterceptorAndDynamicMethodMatcher) {
        InterceptorAndDynamicMethodMatcher dm =(InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
        //如果当前方法符合Interceptor的PointCut限制，就执行Interceptor
        if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
        　　 //这里将this当变量传进去，这是非常重要的一点
            return dm.interceptor.invoke(this);
        }
        //如果不符合，就跳过当前Interceptor，执行下一个Interceptor
        else{
            returnproceed();
        }
    }
    //如果Interceptor不是PointCut类型，就直接执行Interceptor里面的增强。
    else{
        return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
    }
}