AOP中动态署理详解

动态署理概述

什么是署理

署理模式(Proxy pattern): 为另一个对象提供一个替人或占位符以控制对这个对象的访问

什么是动态署理？

   动态署理就是，在程序运行期，创建目的对象的署理对象，并对目的对象中的方法进行功能性加强的一种技能。
  在生成署理对象的过程中，目的对象稳定，署理对象中的方法是目的对象方法的加强方法。可以明白为运行期间，对象中方法的动态拦截，在拦截方法的前后执行功能操作。
署理的创建

创建署理的方法是postProcessAfterInitialization：如果bean被子类标识为署理，则利用配置的拦截器创建一个署理

1. /**
2.   * Create a proxy with the configured interceptors if the bean is
3.   * identified as one to proxy by the subclass.
4.   * @see #getAdvicesAndAdvisorsForBean
5.   */
6. @Override
7. public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
8.   if (bean != null) {
9.     Object cacheKey = getCacheKey(bean.getClass(), beanName);
10.     // 如果不是提前暴露的代理
11.     if (this.earlyProxyReferences.remove(cacheKey) != bean) {
12.       return wrapIfNecessary(bean, beanName, cacheKey);
13.     }
14.   }
15.   return bean;
16. }

复制代码

wrapIfNecessary方法主要用于判断是否须要创建署理，如果Bean可以大概获取到advisor才须要创建署理

1. /**
2.   * Wrap the given bean if necessary, i.e. if it is eligible for being proxied.
3.   * @param bean the raw bean instance
4.   * @param beanName the name of the bean
5.   * @param cacheKey the cache key for metadata access
6.   * @return a proxy wrapping the bean, or the raw bean instance as-is
7.   */
8. protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
9.    // 如果bean是通过TargetSource接口获取
10.    if (beanName != null && this.targetSourcedBeans.contains(beanName)) {
11.       return bean;
12.    }
13.    // 如果bean是切面类
14.    if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
15.       return bean;
16.    }
17.    // 如果是aop基础类？是否跳过？
18.    if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
19.       this.advisedBeans.put(cacheKey, Boolean.FALSE);
20.       return bean;
21.    }
23.   // 重点：获取所有advisor，如果没有获取到，那说明不要进行增强，也就不需要代理了。
24.   Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
25.   if (specificInterceptors != DO_NOT_PROXY) {
26.     this.advisedBeans.put(cacheKey, Boolean.TRUE);
27.     // 重点：创建代理
28.     Object proxy = createProxy(
29.         bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
30.     this.proxyTypes.put(cacheKey, proxy.getClass());
31.     return proxy;
32.   }
34.   this.advisedBeans.put(cacheKey, Boolean.FALSE);
35.   return bean;
36. }

复制代码

获取全部的Advisor

我们看下获取全部advisor的方法getAdvicesAndAdvisorsForBean

1. @Override
2. @Nullable
3. protected Object[] getAdvicesAndAdvisorsForBean(
4.     Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {
6.   List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
7.   if (advisors.isEmpty()) {
8.     return DO_NOT_PROXY;
9.   }
10.   return advisors.toArray();
11. }

复制代码

通过findEligibleAdvisors方法获取advisor， 如果获取不到返回DO_NOT_PROXY（不须要创建署理），findEligibleAdvisors方法如下

1. /**
2.   * Find all eligible Advisors for auto-proxying this class.
3.   * @param beanClass the clazz to find advisors for
4.   * @param beanName the name of the currently proxied bean
5.   * @return the empty List, not {@code null},
6.   * if there are no pointcuts or interceptors
7.   * @see #findCandidateAdvisors
8.   * @see #sortAdvisors
9.   * @see #extendAdvisors
10.   */
11. protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
12.   // 和上文一样，获取所有切面类的切面方法生成Advisor
13.   List<Advisor> candidateAdvisors = findCandidateAdvisors();
14.   // 找到这些Advisor中能够应用于beanClass的Advisor
15.   List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
16.   // 如果需要，交给子类拓展
17.   extendAdvisors(eligibleAdvisors);
18.   // 对Advisor排序
19.   if (!eligibleAdvisors.isEmpty()) {
20.     eligibleAdvisors = sortAdvisors(eligibleAdvisors);
21.   }
22.   return eligibleAdvisors;
23. }

复制代码

获取全部切面类的切面方法生成Advisor

1. /**
2.   * Find all candidate Advisors to use in auto-proxying.
3.   * @return the List of candidate Advisors
4.   */
5. protected List<Advisor> findCandidateAdvisors() {
6.   Assert.state(this.advisorRetrievalHelper != null, "No BeanFactoryAdvisorRetrievalHelper available");
7.   return this.advisorRetrievalHelper.findAdvisorBeans();
8. }

复制代码

找到这些Advisor中可以大概应用于beanClass的Advisor

1. /**
2.   * Determine the sublist of the {@code candidateAdvisors} list
3.   * that is applicable to the given class.
4.   * @param candidateAdvisors the Advisors to evaluate
5.   * @param clazz the target class
6.   * @return sublist of Advisors that can apply to an object of the given class
7.   * (may be the incoming List as-is)
8.   */
9. public static List<Advisor> findAdvisorsThatCanApply(List<Advisor> candidateAdvisors, Class<?> clazz) {
10.   if (candidateAdvisors.isEmpty()) {
11.     return candidateAdvisors;
12.   }
13.   List<Advisor> eligibleAdvisors = new ArrayList<>();
14.   for (Advisor candidate : candidateAdvisors) {
15.     // 通过Introduction实现的advice
16.     if (candidate instanceof IntroductionAdvisor && canApply(candidate, clazz)) {
17.       eligibleAdvisors.add(candidate);
18.     }
19.   }
20.   boolean hasIntroductions = !eligibleAdvisors.isEmpty();
21.   for (Advisor candidate : candidateAdvisors) {
22.     if (candidate instanceof IntroductionAdvisor) {
23.       // already processed
24.       continue;
25.     }
26.     // 是否能够应用于clazz的Advice
27.     if (canApply(candidate, clazz, hasIntroductions)) {
28.       eligibleAdvisors.add(candidate);
29.     }
30.   }
31.   return eligibleAdvisors;
32. }

复制代码

创建署理的入口方法

获取全部advisor后，如果有advisor，则阐明须要加强，即须要创建署理，创建署理的方法如下：

1. /**
2.   * Create an AOP proxy for the given bean.
3.   * @param beanClass the class of the bean
4.   * @param beanName the name of the bean
5.   * @param specificInterceptors the set of interceptors that is
6.   * specific to this bean (may be empty, but not null)
7.   * @param targetSource the TargetSource for the proxy,
8.   * already pre-configured to access the bean
9.   * @return the AOP proxy for the bean
10.   * @see #buildAdvisors
11.   */
12. protected Object createProxy(Class<?> beanClass, @Nullable String beanName,
13.     @Nullable Object[] specificInterceptors, TargetSource targetSource) {
15.   if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
16.     AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
17.   }
19.   ProxyFactory proxyFactory = new ProxyFactory();
20.   proxyFactory.copyFrom(this);
22.   if (proxyFactory.isProxyTargetClass()) {
23.     // Explicit handling of JDK proxy targets (for introduction advice scenarios)
24.     if (Proxy.isProxyClass(beanClass)) {
25.       // Must allow for introductions; can't just set interfaces to the proxy's interfaces only.
26.       for (Class<?> ifc : beanClass.getInterfaces()) {
27.         proxyFactory.addInterface(ifc);
28.       }
29.     }
30.   }
31.   else {
32.     // No proxyTargetClass flag enforced, let's apply our default checks...
33.     if (shouldProxyTargetClass(beanClass, beanName)) {
34.       proxyFactory.setProxyTargetClass(true);
35.     }
36.     else {
37.       evaluateProxyInterfaces(beanClass, proxyFactory);
38.     }
39.   }
41.   Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
42.   proxyFactory.addAdvisors(advisors);
43.   proxyFactory.setTargetSource(targetSource);
44.   customizeProxyFactory(proxyFactory);
46.   proxyFactory.setFrozen(this.freezeProxy);
47.   if (advisorsPreFiltered()) {
48.     proxyFactory.setPreFiltered(true);
49.   }
51.   // Use original ClassLoader if bean class not locally loaded in overriding class loader
52.   ClassLoader classLoader = getProxyClassLoader();
53.   if (classLoader instanceof SmartClassLoader && classLoader != beanClass.getClassLoader()) {
54.     classLoader = ((SmartClassLoader) classLoader).getOriginalClassLoader();
55.   }
56.   return proxyFactory.getProxy(classLoader);
57. }

复制代码

proxyFactory.getProxy(classLoader)

1. /**
2.   * Create a new proxy according to the settings in this factory.
3.   * <p>Can be called repeatedly. Effect will vary if we've added
4.   * or removed interfaces. Can add and remove interceptors.
5.   * <p>Uses the given class loader (if necessary for proxy creation).
6.   * @param classLoader the class loader to create the proxy with
7.   * (or {@code null} for the low-level proxy facility's default)
8.   * @return the proxy object
9.   */
10. public Object getProxy(@Nullable ClassLoader classLoader) {
11.   return createAopProxy().getProxy(classLoader);
12. }

复制代码

依据条件创建署理(jdk或cglib)

DefaultAopProxyFactory.createAopProxy

1. @Override
2. public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
3.   if (!NativeDetector.inNativeImage() &&
4.       (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config))) {
5.     Class<?> targetClass = config.getTargetClass();
6.     if (targetClass == null) {
7.       throw new AopConfigException("TargetSource cannot determine target class: " +
8.           "Either an interface or a target is required for proxy creation.");
9.     }
10.     if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
11.       return new JdkDynamicAopProxy(config);
12.     }
13.     return new ObjenesisCglibAopProxy(config);
14.   }
15.   else {
16.     return new JdkDynamicAopProxy(config);
17.   }
18. }

复制代码

小结

• config.isOptimize() 是通过optimize设置，表现配置是自定义的，默认是false；
  
• config.isProxyTargetClass()是通过<aop:config proxy-target-class="true" /> 来配置的，表现优先利用cglib署理，默认是false；
  
• hasNoUserSuppliedProxyInterfaces(config) 表现是否目的类实现了接口
  

由此可以知道：
Spring默认在目的类实现接口时是通过JDK署理实现的，只有非接口的是通过Cglib署理实现的。当设置proxy-target-class为true时在目的类不是接口大概署理类时优先利用cglib署理实现。
JDK署理

JDK动态署理是有JDK提供的工具类Proxy实现的，动态署理类是在运行时生成指定接口的署理类，每个署理实例（实现须要署理的接口）都有一个关联的调用处置处罚程序对象，此对象实现了InvocationHandler，终极的业务逻辑是在InvocationHandler实现类的invoke方法上。
JDK署理的流程如下：
   JDK署理自动生成的class是由sun.misc.ProxyGenerator来生成的。
  ProxyGenerator生成代码

我们看下sun.misc.ProxyGenerator生成代码的逻辑：

1. /**
2.     * Generate a proxy class given a name and a list of proxy interfaces.
3.     *
4.     * @param name        the class name of the proxy class
5.     * @param interfaces  proxy interfaces
6.     * @param accessFlags access flags of the proxy class
7. */
8. public static byte[] generateProxyClass(final String name,
9.                                         Class<?>[] interfaces,
10.                                         int accessFlags)
11. {
12.     ProxyGenerator gen = new ProxyGenerator(name, interfaces, accessFlags);
13.     final byte[] classFile = gen.generateClassFile();
14.     ...
15. }

复制代码

generateClassFile方法如下：

1. /**
2.     * Generate a class file for the proxy class.  This method drives the
3.     * class file generation process.
4.     */
5. private byte[] generateClassFile() {
7.     /* 第一步：将所有方法包装成ProxyMethod对象 */
8.    
9.     // 将Object类中hashCode、equals、toString方法包装成ProxyMethod对象
10.     addProxyMethod(hashCodeMethod, Object.class);
11.     addProxyMethod(equalsMethod, Object.class);
12.     addProxyMethod(toStringMethod, Object.class);
14.     // 将代理类接口方法包装成ProxyMethod对象
15.     for (Class<?> intf : interfaces) {
16.         for (Method m : intf.getMethods()) {
17.             addProxyMethod(m, intf);
18.         }
19.     }
21.     // 校验返回类型
22.     for (List<ProxyMethod> sigmethods : proxyMethods.values()) {
23.         checkReturnTypes(sigmethods);
24.     }
26.     /* 第二步：为代理类组装字段，构造函数，方法，static初始化块等 */
27.     try {
28.         // 添加构造函数，参数是InvocationHandler
29.         methods.add(generateConstructor());
31.         // 代理方法
32.         for (List<ProxyMethod> sigmethods : proxyMethods.values()) {
33.             for (ProxyMethod pm : sigmethods) {
35.                 // 字段
36.                 fields.add(new FieldInfo(pm.methodFieldName,
37.                     "Ljava/lang/reflect/Method;",
38.                         ACC_PRIVATE | ACC_STATIC));
40.                 // 上述ProxyMethod中的方法
41.                 methods.add(pm.generateMethod());
42.             }
43.         }
45.         // static初始化块
46.         methods.add(generateStaticInitializer());
48.     } catch (IOException e) {
49.         throw new InternalError("unexpected I/O Exception", e);
50.     }
52.     if (methods.size() > 65535) {
53.         throw new IllegalArgumentException("method limit exceeded");
54.     }
55.     if (fields.size() > 65535) {
56.         throw new IllegalArgumentException("field limit exceeded");
57.     }
59.     /* 第三步：写入class文件 */
61.     /*
62.         * Make sure that constant pool indexes are reserved for the
63.         * following items before starting to write the final class file.
64.         */
65.     cp.getClass(dotToSlash(className));
66.     cp.getClass(superclassName);
67.     for (Class<?> intf: interfaces) {
68.         cp.getClass(dotToSlash(intf.getName()));
69.     }
71.     /*
72.         * Disallow new constant pool additions beyond this point, since
73.         * we are about to write the final constant pool table.
74.         */
75.     cp.setReadOnly();
77.     ByteArrayOutputStream bout = new ByteArrayOutputStream();
78.     DataOutputStream dout = new DataOutputStream(bout);
80.     try {
81.         /*
82.             * Write all the items of the "ClassFile" structure.
83.             * See JVMS section 4.1.
84.             */
85.                                     // u4 magic;
86.         dout.writeInt(0xCAFEBABE);
87.                                     // u2 minor_version;
88.         dout.writeShort(CLASSFILE_MINOR_VERSION);
89.                                     // u2 major_version;
90.         dout.writeShort(CLASSFILE_MAJOR_VERSION);
92.         cp.write(dout);             // (write constant pool)
94.                                     // u2 access_flags;
95.         dout.writeShort(accessFlags);
96.                                     // u2 this_class;
97.         dout.writeShort(cp.getClass(dotToSlash(className)));
98.                                     // u2 super_class;
99.         dout.writeShort(cp.getClass(superclassName));
101.                                     // u2 interfaces_count;
102.         dout.writeShort(interfaces.length);
103.                                     // u2 interfaces[interfaces_count];
104.         for (Class<?> intf : interfaces) {
105.             dout.writeShort(cp.getClass(
106.                 dotToSlash(intf.getName())));
107.         }
109.                                     // u2 fields_count;
110.         dout.writeShort(fields.size());
111.                                     // field_info fields[fields_count];
112.         for (FieldInfo f : fields) {
113.             f.write(dout);
114.         }
116.                                     // u2 methods_count;
117.         dout.writeShort(methods.size());
118.                                     // method_info methods[methods_count];
119.         for (MethodInfo m : methods) {
120.             m.write(dout);
121.         }
123.                                         // u2 attributes_count;
124.         dout.writeShort(0); // (no ClassFile attributes for proxy classes)
126.     } catch (IOException e) {
127.         throw new InternalError("unexpected I/O Exception", e);
128.     }
130.     return bout.toByteArray();
131. }

复制代码

一共三个步骤（把大象装进冰箱分几步？）：

• 第一步：（把冰箱门打开）准备工作，将全部方法包装成ProxyMethod对象，包括Object类中hashCode、equals、toString方法，以及被署理的接口中的方法
  
• 第二步：（把大象装进去）为署理类组装字段，构造函数，方法，static初始化块等
  
• 第三步：（把冰箱门带上）写入class文件
  

从生成的Proxy代码看执行流程

从上述sun.misc.ProxyGenerator类中可以看到，这个类里面有一个配置参数sun.misc.ProxyGenerator.saveGeneratedFiles，可以通过这个参数将生成的Proxy类生存在本地，比如设置为true 执行后，生成的文件如下：

我们看下生成后的代码：

1. //
2. // Source code recreated from a .class file by IntelliJ IDEA
3. // (powered by FernFlower decompiler)
4. //
6. package com.sun.proxy;
8. import java.lang.reflect.InvocationHandler;
9. import java.lang.reflect.Method;
10. import java.lang.reflect.Proxy;
11. import java.lang.reflect.UndeclaredThrowableException;
12. import java.util.List;
13. import tech.pdai.springframework.service.IUserService;
15. // 所有类和方法都是final类型的
16. public final class $Proxy0 extends Proxy implements IUserService {
17.     private static Method m1;
18.     private static Method m3;
19.     private static Method m2;
20.     private static Method m0;
21.     private static Method m4;
23.     // 构造函数注入 InvocationHandler
24.     public $Proxy0(InvocationHandler var1) throws  {
25.         super(var1);
26.     }
28.     public final boolean equals(Object var1) throws  {
29.         try {
30.             return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
31.         } catch (RuntimeException | Error var3) {
32.             throw var3;
33.         } catch (Throwable var4) {
34.             throw new UndeclaredThrowableException(var4);
35.         }
36.     }
38.     public final List findUserList() throws  {
39.         try {
40.             return (List)super.h.invoke(this, m3, (Object[])null);
41.         } catch (RuntimeException | Error var2) {
42.             throw var2;
43.         } catch (Throwable var3) {
44.             throw new UndeclaredThrowableException(var3);
45.         }
46.     }
48.     public final String toString() throws  {
49.         try {
50.             return (String)super.h.invoke(this, m2, (Object[])null);
51.         } catch (RuntimeException | Error var2) {
52.             throw var2;
53.         } catch (Throwable var3) {
54.             throw new UndeclaredThrowableException(var3);
55.         }
56.     }
58.     public final int hashCode() throws  {
59.         try {
60.             return (Integer)super.h.invoke(this, m0, (Object[])null);
61.         } catch (RuntimeException | Error var2) {
62.             throw var2;
63.         } catch (Throwable var3) {
64.             throw new UndeclaredThrowableException(var3);
65.         }
66.     }
68.     public final void addUser() throws  {
69.         try {
70.             super.h.invoke(this, m4, (Object[])null);
71.         } catch (RuntimeException | Error var2) {
72.             throw var2;
73.         } catch (Throwable var3) {
74.             throw new UndeclaredThrowableException(var3);
75.         }
76.     }
78.     static {
79.         try {
80.             // 初始化 methods, 2个IUserService接口中的方法，3个Object中的接口
81.             m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
82.             m3 = Class.forName("tech.pdai.springframework.service.IUserService").getMethod("findUserList");
83.             m2 = Class.forName("java.lang.Object").getMethod("toString");
84.             m0 = Class.forName("java.lang.Object").getMethod("hashCode");
85.             m4 = Class.forName("tech.pdai.springframework.service.IUserService").getMethod("addUser");
86.         } catch (NoSuchMethodException var2) {
87.             throw new NoSuchMethodError(var2.getMessage());
88.         } catch (ClassNotFoundException var3) {
89.             throw new NoClassDefFoundError(var3.getMessage());
90.         }
91.     }
92. }

复制代码

上述代码是比较容易明白的，我就不绘图了。
主要流程是：

• ProxyGenerator创建Proxy的具体类$Proxy0
  
• 由static初始化块初始化接口方法：2个IUserService接口中的方法，3个Object中的接口方法
  
• 由构造函数注入InvocationHandler
  
• 执行的时间，通过ProxyGenerator创建的Proxy，调用InvocationHandler的invoke方法，执行我们自定义的invoke方法
  

SpringAOP中JDK署理的实现

SpringAOP饰演的是JDK署理的创建和调用两个脚色，我们通过这两个方向来看下SpringAOP的代码（JdkDynamicAopProxy类）
SpringAOP Jdk署理的创建

署理的创建比较简单，调用getProxy方法，然后直接调用JDK中Proxy.newProxyInstance()方法将classloader和被署理的接口方法传入即可。

1. @Override
2. public Object getProxy() {
3.     return getProxy(ClassUtils.getDefaultClassLoader());
4. }
6. @Override
7. public Object getProxy(@Nullable ClassLoader classLoader) {
8.     if (logger.isTraceEnabled()) {
9.         logger.trace("Creating JDK dynamic proxy: " + this.advised.getTargetSource());
10.     }
11.     return Proxy.newProxyInstance(classLoader, this.proxiedInterfaces, this);
12. }

复制代码

SpringAOP Jdk署理的执行

执行的方法如下：

1. /**
2.     * Implementation of {@code InvocationHandler.invoke}.
3.     * <p>Callers will see exactly the exception thrown by the target,
4.     * unless a hook method throws an exception.
5.     */
6. @Override
7. @Nullable
8. public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
9.     Object oldProxy = null;
10.     boolean setProxyContext = false;
12.     TargetSource targetSource = this.advised.targetSource;
13.     Object target = null;
15.     try {
16.         // 执行的是equal方法
17.         if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
18.             // The target does not implement the equals(Object) method itself.
19.             return equals(args[0]);
20.         }
21.         // 执行的是hashcode方法
22.         else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
23.             // The target does not implement the hashCode() method itself.
24.             return hashCode();
25.         }
26.         // 如果是包装类，则dispatch to proxy config
27.         else if (method.getDeclaringClass() == DecoratingProxy.class) {
28.             // There is only getDecoratedClass() declared -> dispatch to proxy config.
29.             return AopProxyUtils.ultimateTargetClass(this.advised);
30.         }
31.         // 用反射方式来执行切点
32.         else if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
33.                 method.getDeclaringClass().isAssignableFrom(Advised.class)) {
34.             // Service invocations on ProxyConfig with the proxy config...
35.             return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
36.         }
38.         Object retVal;
40.         if (this.advised.exposeProxy) {
41.             // Make invocation available if necessary.
42.             oldProxy = AopContext.setCurrentProxy(proxy);
43.             setProxyContext = true;
44.         }
46.         // Get as late as possible to minimize the time we "own" the target,
47.         // in case it comes from a pool.
48.         target = targetSource.getTarget();
49.         Class<?> targetClass = (target != null ? target.getClass() : null);
51.         // 获取拦截链
52.         List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
54.         // Check whether we have any advice. If we don't, we can fallback on direct
55.         // reflective invocation of the target, and avoid creating a MethodInvocation.
56.         if (chain.isEmpty()) {
57.             // We can skip creating a MethodInvocation: just invoke the target directly
58.             // Note that the final invoker must be an InvokerInterceptor so we know it does
59.             // nothing but a reflective operation on the target, and no hot swapping or fancy proxying.
60.             Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
61.             retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
62.         }
63.         else {
64.             // We need to create a method invocation...
65.             MethodInvocation invocation =
66.                     new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
67.             // Proceed to the joinpoint through the interceptor chain.
68.             retVal = invocation.proceed();
69.         }
71.         // Massage return value if necessary.
72.         Class<?> returnType = method.getReturnType();
73.         if (retVal != null && retVal == target &&
74.                 returnType != Object.class && returnType.isInstance(proxy) &&
75.                 !RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
76.             // Special case: it returned "this" and the return type of the method
77.             // is type-compatible. Note that we can't help if the target sets
78.             // a reference to itself in another returned object.
79.             retVal = proxy;
80.         }
81.         else if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) {
82.             throw new AopInvocationException(
83.                     "Null return value from advice does not match primitive return type for: " + method);
84.         }
85.         return retVal;
86.     }
87.     finally {
88.         if (target != null && !targetSource.isStatic()) {
89.             // Must have come from TargetSource.
90.             targetSource.releaseTarget(target);
91.         }
92.         if (setProxyContext) {
93.             // Restore old proxy.
94.             AopContext.setCurrentProxy(oldProxy);
95.         }
96.     }
97. }

复制代码

CGLIB署理

署理的流程

• 在上图中，我们可以通过在Enhancer中配置更多的参数来控制署理的行为，比如如果只希望加强这个类中的一个方法（而不是全部方法），那就增加callbackFilter来对目的类中方法进行过滤；Enhancer可以有更多的参数类配置其行为，不外我们在学习上述主要的流程就够了。
  
• final方法为什么不能被署理？很显然final方法没法被子类覆盖，固然不能署理了。
  
• Mockito为什么不能mock静态方法？由于mockito也是基于cglib动态署理来实现的，static方法也不能被子类覆盖，以是显然不能mock。但PowerMock可以mock静态方法，由于它直接在bytecode上工作。
  

SpringAOP中Cglib署理的实现

   SpringAOP封装了cglib，通过其进举措态署理的创建。
  我们看下CglibAopProxy的getProxy方法

1. @Override
2. public Object getProxy() {
3.   return getProxy(null);
4. }
6. @Override
7. public Object getProxy(@Nullable ClassLoader classLoader) {
8.   if (logger.isTraceEnabled()) {
9.     logger.trace("Creating CGLIB proxy: " + this.advised.getTargetSource());
10.   }
12.   try {
13.     Class<?> rootClass = this.advised.getTargetClass();
14.     Assert.state(rootClass != null, "Target class must be available for creating a CGLIB proxy");
16.     // 上面流程图中的目标类
17.     Class<?> proxySuperClass = rootClass;
18.     if (rootClass.getName().contains(ClassUtils.CGLIB_CLASS_SEPARATOR)) {
19.       proxySuperClass = rootClass.getSuperclass();
20.       Class<?>[] additionalInterfaces = rootClass.getInterfaces();
21.       for (Class<?> additionalInterface : additionalInterfaces) {
22.         this.advised.addInterface(additionalInterface);
23.       }
24.     }
26.     // Validate the class, writing log messages as necessary.
27.     validateClassIfNecessary(proxySuperClass, classLoader);
29.     // 重点看这里，就是上图的enhancer，设置各种参数来构建
30.     Enhancer enhancer = createEnhancer();
31.     if (classLoader != null) {
32.       enhancer.setClassLoader(classLoader);
33.       if (classLoader instanceof SmartClassLoader &&
34.           ((SmartClassLoader) classLoader).isClassReloadable(proxySuperClass)) {
35.         enhancer.setUseCache(false);
36.       }
37.     }
38.     enhancer.setSuperclass(proxySuperClass);
39.     enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));
40.     enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
41.     enhancer.setStrategy(new ClassLoaderAwareGeneratorStrategy(classLoader));
43.     // 设置callback回调接口，即方法的增强点
44.     Callback[] callbacks = getCallbacks(rootClass);
45.     Class<?>[] types = new Class<?>[callbacks.length];
46.     for (int x = 0; x < types.length; x++) {
47.       types[x] = callbacks[x].getClass();
48.     }
49.     // 上节说到的filter
50.     enhancer.setCallbackFilter(new ProxyCallbackFilter(
51.         this.advised.getConfigurationOnlyCopy(), this.fixedInterceptorMap, this.fixedInterceptorOffset));
52.     enhancer.setCallbackTypes(types);
54.     // 重点：创建proxy和其实例
55.     return createProxyClassAndInstance(enhancer, callbacks);
56.   }
57.   catch (CodeGenerationException | IllegalArgumentException ex) {
58.     throw new AopConfigException("Could not generate CGLIB subclass of " + this.advised.getTargetClass() +
59.         ": Common causes of this problem include using a final class or a non-visible class",
60.         ex);
61.   }
62.   catch (Throwable ex) {
63.     // TargetSource.getTarget() failed
64.     throw new AopConfigException("Unexpected AOP exception", ex);
65.   }
66. }

复制代码

获取callback的方法如下，提几个明白的要点吧，具体读者在学习的时间发起把我的例子跑一下，然后打一个断点进行明白。

• rootClass: 即目的署理类
  
• advised: 包含上文中我们获取到的advisor加强器的聚集
  
• exposeProxy: 在xml配置文件中配置的，背景就是如果在事务A中利用了署理，事务A调用了目的类的的方法a，在方法a中又调用目的类的方法b，方法a，b同时都是要被加强的方法，如果不配置exposeProxy属性，方法b的加强将会失效，如果配置exposeProxy，方法b在方法a的执行中也会被加强了
  
• DynamicAdvisedInterceptor: 拦截器将advised(包含上文中我们获取到的advisor加强器)构建配置的AOP的callback（第一个callback)
  
• targetInterceptor: xml配置的optimize属性利用的（第二个callback)
  
• 最后连同其它5个默认的Interceptor 返回作为cglib的拦截器链，之后通过CallbackFilter的accpet方法返回的索引从这个聚集中返回对应的拦截加强器执行加强操作。
  

1. private Callback[] getCallbacks(Class<?> rootClass) throws Exception {
2.   // Parameters used for optimization choices...
3.   boolean exposeProxy = this.advised.isExposeProxy();
4.   boolean isFrozen = this.advised.isFrozen();
5.   boolean isStatic = this.advised.getTargetSource().isStatic();
7.   // Choose an "aop" interceptor (used for AOP calls).
8.   Callback aopInterceptor = new DynamicAdvisedInterceptor(this.advised);
10.   // Choose a "straight to target" interceptor. (used for calls that are
11.   // unadvised but can return this). May be required to expose the proxy.
12.   Callback targetInterceptor;
13.   if (exposeProxy) {
14.     targetInterceptor = (isStatic ?
15.         new StaticUnadvisedExposedInterceptor(this.advised.getTargetSource().getTarget()) :
16.         new DynamicUnadvisedExposedInterceptor(this.advised.getTargetSource()));
17.   }
18.   else {
19.     targetInterceptor = (isStatic ?
20.         new StaticUnadvisedInterceptor(this.advised.getTargetSource().getTarget()) :
21.         new DynamicUnadvisedInterceptor(this.advised.getTargetSource()));
22.   }
24.   // Choose a "direct to target" dispatcher (used for
25.   // unadvised calls to static targets that cannot return this).
26.   Callback targetDispatcher = (isStatic ?
27.       new StaticDispatcher(this.advised.getTargetSource().getTarget()) : new SerializableNoOp());
29.   Callback[] mainCallbacks = new Callback[] {
30.       aopInterceptor,  //
31.       targetInterceptor,  // invoke target without considering advice, if optimized
32.       new SerializableNoOp(),  // no override for methods mapped to this
33.       targetDispatcher, this.advisedDispatcher,
34.       new EqualsInterceptor(this.advised),
35.       new HashCodeInterceptor(this.advised)
36.   };
38.   Callback[] callbacks;
40.   // If the target is a static one and the advice chain is frozen,
41.   // then we can make some optimizations by sending the AOP calls
42.   // direct to the target using the fixed chain for that method.
43.   if (isStatic && isFrozen) {
44.     Method[] methods = rootClass.getMethods();
45.     Callback[] fixedCallbacks = new Callback[methods.length];
46.     this.fixedInterceptorMap = CollectionUtils.newHashMap(methods.length);
48.     // TODO: small memory optimization here (can skip creation for methods with no advice)
49.     for (int x = 0; x < methods.length; x++) {
50.       Method method = methods[x];
51.       List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, rootClass);
52.       fixedCallbacks[x] = new FixedChainStaticTargetInterceptor(
53.           chain, this.advised.getTargetSource().getTarget(), this.advised.getTargetClass());
54.       this.fixedInterceptorMap.put(method, x);
55.     }
57.     // Now copy both the callbacks from mainCallbacks
58.     // and fixedCallbacks into the callbacks array.
59.     callbacks = new Callback[mainCallbacks.length + fixedCallbacks.length];
60.     System.arraycopy(mainCallbacks, 0, callbacks, 0, mainCallbacks.length);
61.     System.arraycopy(fixedCallbacks, 0, callbacks, mainCallbacks.length, fixedCallbacks.length);
62.     this.fixedInterceptorOffset = mainCallbacks.length;
63.   }
64.   else {
65.     callbacks = mainCallbacks;
66.   }
67.   return callbacks;
68. }

复制代码

可以结合调试，方便明白

AOP在嵌套方法调用时不生效

在一个实现类中，有2个方法，方法A，方法B，其中方法B上面有个注解切面，当方法B被外部调用的时间，会进入切面方法。
但当方法B是被方法A调用时，并不能从方法B的注解上，进入到切面方法，即我们经常碰到的方法嵌套时，AOP注解不生效的标题。
案例

外部调用AOP方法正常进入

通过外部，调用方法B，可以正常进入切面方法，这个场景的代码如下：

• 注解类：
  

1. @Target({ElementType.METHOD, ElementType.TYPE})
2. @Retention(RetentionPolicy.RUNTIME)
3. public @interface DemoAnno {
5. }

复制代码

• 切面类
  

1. @Aspect
2. @Order(-1)
3. @Component
4. public class DemoAspect {
6.     @Before("@annotation(da)")
7.     public void beforDoSomething(JoinPoint point, DemoAnno da) throws Exception {
8.         System.out.println("before method B, print 'hello,world' " );
9.     }
10. }

复制代码

• 接口类
  

1. public interface DemoService {
2.     void methodDemoA();
4.     void methodDemoB();
5. }

复制代码

• 服务实现类
  

1. @Service
2. public class DemoServiceImpl implements DemoService {
3.     @Override
4.     public void methodDemoA(){
5.         System.out.println("this is method A");
6.     }
8.     @Override
9.     @DemoAnno
10.     public void methodDemoB() {
11.         System.out.println("this is method B");
12.     }
13. }

复制代码

• 测试方法
  

1. @Autowired
2. DemoService demoService;
3. @Test
4. public void testMethod(){
5.     demoService.methodDemoA();
6.     demoService.methodDemoB();
7. }

复制代码

输出效果：

1. this is method A
2. before method B, print 'hello,world'
3. this is method B

复制代码

方法嵌套调用，AOP不生效

上面的代码，做下修改。在DemoServiceImpl实现类中，通过方法A去调用方法B，然后再单元测试类中，调用方法A。代码修改后如下：

• 服务实现类：
  

1. @Service
2. public class DemoServiceImpl implements DemoService {
3.     @Override
4.     public void methodDemoA(){
5.         System.out.println("this is method A");
6.         methodDemoB();
7.     }
9.     @Override
10.     @DemoAnno
11.     public void methodDemoB() {
12.         System.out.println("this is method B");
13.     }
14. }

复制代码

• 输出效果：
  

1. this is method A
2. this is method B

复制代码

原因分析

场景1中，通过外部调用方法B，是由于spring在启动时，根据切面类及注解，生成了DemoService的署理类，在调用方法B时，现实上是署理类先对目的方法进行了业务加强处置处罚（执行切面类中的业务逻辑），然后再调用方法B本身。以是场景1可以正常进入切面方法；
场景2中，通过外部调用的是方法A，虽然spring也会创建一个cglib的署理类去调用方法A，但当方法A调用方法B的时间，属于类里面的内部调用，利用的是实例对象本身去去调用方法B，非aop的cglib署理对象调用，方法B天然就不会进入到切面方法了。
解决方案

但现实上我们期望的是，方法A在调用方法B的时间，仍然可以大概进入切面方法，即须要AOP切面生效。这种环境下，在调用方法B的时间，须要利用AopContext.currentProxy()获取当前的署理对象，然后利用署理对象调用方法B。
   注：须要开启 exposeProxy=true 的配置，springboot项目中，可以在启动类上面，添加 @EnableAspectJAutoProxy(exposeProxy = true)注解。

1. @Service
2. public class DemoServiceImpl implements DemoService {
3.     @Override
4.     public void methodDemoA(){
5.         System.out.println("this is method A");
6.         DemoService service = (DemoService) AopContext.currentProxy();
7.         service.methodDemoB();
8.     }
10.     @Override
11.     @DemoAnno
12.     public void methodDemoB() {
13.         System.out.println("this is method B");
14.     }
15. }

复制代码

面试题专栏

Java面试题专栏已上线，欢迎访问。

• 如果你不知道简历怎么写，简历项目不知道怎么包装；
  
• 如果简历中有些内容你不知道该不应写上去；
  
• 如果有些综合性标题你不知道怎么答；
  

那么可以私信我，我会尽我所能帮助你。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。