ToB企服应用市场:ToB评测及商务社交产业平台

标题: Spring框架系列(11) - Spring AOP实现原理详解之Cglib代理实现 [打印本页]

---

作者: 雁过留声    时间: 2022-8-21 15:59
标题: Spring框架系列(11) - Spring AOP实现原理详解之Cglib代理实现

我们在前文中已经介绍了SpringAOP的切面实现和创建动态代理的过程，那么动态代理是如何工作的呢？本文主要介绍Cglib动态代理的案例和SpringAOP实现的原理。@pdai

• Spring框架系列(11) - Spring AOP实现原理详解之Cglib代理实现
  
  
  
  • 引入
    
    
    
    • 动态代理要解决什么问题？
      
      
      
      • 什么是代理？
        
      • 什么是动态代理？
        
      
      
    • 什么是Cglib? SpringAOP和Cglib是什么关系？
      
    
    
  • Cglib代理的案例
    
    
    
    • pom包依赖
      
    • 定义实体
      
    • 被代理的类
      
    • cglib代理
      
    • 使用代理
      
    • 简单测试
      
    
    
  • Cglib代理的流程
    
  • SpringAOP中Cglib代理的实现
    
  • 示例源码
    
  • 更多文章
    
  
  

引入

我们在前文中已经介绍了SpringAOP的切面实现和创建动态代理的过程，那么动态代理是如何工作的呢？本文主要介绍Cglib动态代理的案例和SpringAOP实现的原理。

要了解动态代理是如何工作的，首先需要了解

• 什么是代理模式？
  
• 什么是动态代理？
  
• 什么是Cglib？
  
• SpringAOP和Cglib是什么关系？
  

动态代理要解决什么问题？

什么是代理？

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

举个简单的例子：
我(client)如果要买(doOperation)房，可以找中介(proxy)买房，中介直接和卖方(target)买房。中介和卖方都实现买卖(doOperation)的操作。中介就是代理(proxy)。
什么是动态代理？

动态代理就是，在程序运行期，创建目标对象的代理对象，并对目标对象中的方法进行功能性增强的一种技术。

在生成代理对象的过程中，目标对象不变，代理对象中的方法是目标对象方法的增强方法。可以理解为运行期间，对象中方法的动态拦截，在拦截方法的前后执行功能操作。

什么是Cglib? SpringAOP和Cglib是什么关系？

Cglib是一个强大的、高性能的代码生成包，它广泛被许多AOP框架使用，为他们提供方法的拦截。

• 最顶层是字节码，字节码相关的知识请参考 JVM基础 - 类字节码详解
  
• ASM是操作字节码的工具
  
• cglib基于ASM字节码工具操作字节码（即动态生成代理，对方法进行增强）
  
• SpringAOP基于cglib进行封装，实现cglib方式的动态代理
  

Cglib代理的案例

这里我们写一个使用cglib的简单例子。@pdai

pom包依赖

引入cglib的依赖包

1. <?xml version="1.0" encoding="UTF-8"?>
2. <project xmlns="http://maven.apache.org/POM/4.0.0"
3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
5.     <parent>
6.         <artifactId>tech-pdai-spring-demos</artifactId>
7.         <groupId>tech.pdai</groupId>
8.         <version>1.0-SNAPSHOT</version>
9.     </parent>
10.     <modelVersion>4.0.0</modelVersion>
12.     <artifactId>007-spring-framework-demo-aop-proxy-cglib</artifactId>
14.     <properties>
15.         <maven.compiler.source>8</maven.compiler.source>
16.         <maven.compiler.target>8</maven.compiler.target>
17.     </properties>
19.     <dependencies>
20.         
21.         <dependency>
22.             <groupId>cglib</groupId>
23.             <artifactId>cglib</artifactId>
24.             <version>3.3.0</version>
25.         </dependency>
26.     </dependencies>
28. </project>

复制代码

定义实体

User

1. package tech.pdai.springframework.entity;
3. /**
4. * @author pdai
5. */
6. public class User {
8.     /**
9.      * user's name.
10.      */
11.     private String name;
13.     /**
14.      * user's age.
15.      */
16.     private int age;
18.     /**
19.      * init.
20.      *
21.      * @param name name
22.      * @param age  age
23.      */
24.     public User(String name, int age) {
25.         this.name = name;
26.         this.age = age;
27.     }
29.     public String getName() {
30.         return name;
31.     }
33.     public void setName(String name) {
34.         this.name = name;
35.     }
37.     public int getAge() {
38.         return age;
39.     }
41.     public void setAge(int age) {
42.         this.age = age;
43.     }
45.     @Override
46.     public String toString() {
47.         return "User{" +
48.                 "name='" + name + '\'' +
49.                 ", age=" + age +
50.                 '}';
51.     }
52. }

复制代码

被代理的类

即目标类, 对被代理的类中的方法进行增强

1. package tech.pdai.springframework.service;
3. import java.util.Collections;
4. import java.util.List;
6. import tech.pdai.springframework.entity.User;
8. /**
9. * @author pdai
10. */
11. public class UserServiceImpl {
13.     /**
14.      * find user list.
15.      *
16.      * @return user list
17.      */
18.     public List<User> findUserList() {
19.         return Collections.singletonList(new User("pdai", 18));
20.     }
22.     /**
23.      * add user
24.      */
25.     public void addUser() {
26.         // do something
27.     }
29. }

复制代码

cglib代理

cglib代理类，需要实现MethodInterceptor接口，并指定代理目标类target

1. package tech.pdai.springframework.proxy;
3. import java.lang.reflect.Method;
5. import net.sf.cglib.proxy.Enhancer;
6. import net.sf.cglib.proxy.MethodInterceptor;
7. import net.sf.cglib.proxy.MethodProxy;
9. /**
10. * This class is for proxy demo.
11. *
12. * @author pdai
13. */
14. public class UserLogProxy implements MethodInterceptor {
16.     /**
17.      * 业务类对象，供代理方法中进行真正的业务方法调用
18.      */
19.     private Object target;
21.     public Object getUserLogProxy(Object target) {
22.         //给业务对象赋值
23.         this.target = target;
24.         //创建加强器，用来创建动态代理类
25.         Enhancer enhancer = new Enhancer();
26.         //为加强器指定要代理的业务类（即：为下面生成的代理类指定父类）
27.         enhancer.setSuperclass(this.target.getClass());
28.         //设置回调：对于代理类上所有方法的调用，都会调用CallBack，而Callback则需要实现intercept()方法进行拦
29.         enhancer.setCallback(this);
30.         // 创建动态代理类对象并返回
31.         return enhancer.create();
32.     }
34.     // 实现回调方法
35.     @Override
36.     public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
37.         // log - before method
38.         System.out.println("[before] execute method: " + method.getName());
40.         // call method
41.         Object result = proxy.invokeSuper(obj, args);
43.         // log - after method
44.         System.out.println("[after] execute method: " + method.getName() + ", return value: " + result);
45.         return null;
46.     }
47. }

复制代码

使用代理

启动类中指定代理目标并执行。

1. package tech.pdai.springframework;
3. import tech.pdai.springframework.proxy.UserLogProxy;
4. import tech.pdai.springframework.service.UserServiceImpl;
6. /**
7. * Cglib proxy demo.
8. *
9. * @author pdai
10. */
11. public class ProxyDemo {
13.     /**
14.      * main interface.
15.      *
16.      * @param args args
17.      */
18.     public static void main(String[] args) {
19.         // proxy
20.         UserServiceImpl userService = (UserServiceImpl) new UserLogProxy().getUserLogProxy(new UserServiceImpl());
22.         // call methods
23.         userService.findUserList();
24.         userService.addUser();
25.     }
26. }

复制代码

简单测试

我们启动上述类main 函数，执行的结果如下：

1. [before] execute method: findUserList
2. [after] execute method: findUserList, return value: [User{name='pdai', age=18}]
3. [before] execute method: addUser
4. [after] execute method: addUser, return value: null

复制代码

Cglib代理的流程

我们把上述Demo的主要流程画出来，你便能很快理解

更多细节：

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

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. }

复制代码

可以结合调试，方便理解

示例源码

https://github.com/realpdai/tech-pdai-spring-demos
更多文章

首先， 从Spring框架的整体架构和组成对整体框架有个认知。

• Spring基础 - Spring和Spring框架组成
  
  
  
  • Spring是什么？它是怎么诞生的？有哪些主要的组件和核心功能呢? 本文通过这几个问题帮助你构筑Spring和Spring Framework的整体认知。
    
  
  

其次，通过案例引出Spring的核心（IoC和AOP），同时对IoC和AOP进行案例使用分析。

• Spring基础 - Spring简单例子引入Spring的核心
  
  
  
  • 上文中我们简单介绍了Spring和Spring Framework的组件，那么这些Spring Framework组件是如何配合工作的呢？本文主要承接上文，向你展示Spring Framework组件的典型应用场景和基于这个场景设计出的简单案例，并以此引出Spring的核心要点，比如IOC和AOP等；在此基础上还引入了不同的配置方式， 如XML，Java配置和注解方式的差异。
    
  
  
• Spring基础 - Spring核心之控制反转(IOC)
  
  
  
  • 在Spring基础 - Spring简单例子引入Spring的核心中向你展示了IoC的基础含义，同时以此发散了一些IoC相关知识点; 本节将在此基础上进一步解读IOC的含义以及IOC的使用方式
    
  
  
• Spring基础 - Spring核心之面向切面编程(AOP)
  
  
  
  • 在Spring基础 - Spring简单例子引入Spring的核心中向你展示了AOP的基础含义，同时以此发散了一些AOP相关知识点; 本节将在此基础上进一步解读AOP的含义以及AOP的使用方式。
    
  
  

基于Spring框架和IOC，AOP的基础，为构建上层web应用，需要进一步学习SpringMVC。

• Spring基础 - SpringMVC请求流程和案例
  
  
  
  • 前文我们介绍了Spring框架和Spring框架中最为重要的两个技术点（IOC和AOP），那我们如何更好的构建上层的应用呢（比如web 应用），这便是SpringMVC；Spring MVC是Spring在Spring Container Core和AOP等技术基础上，遵循上述Web MVC的规范推出的web开发框架，目的是为了简化Java栈的web开发。 本文主要介绍SpringMVC的请求流程和基础案例的编写和运行。
    
  
  

Spring进阶 - IoC，AOP以及SpringMVC的源码分析

• Spring进阶 - Spring IOC实现原理详解之IOC体系结构设计
  
  
  
  • 在对IoC有了初步的认知后，我们开始对IOC的实现原理进行深入理解。本文将帮助你站在设计者的角度去看IOC最顶层的结构设计
    
  
  
• Spring进阶 - Spring IOC实现原理详解之IOC初始化流程
  
  
  
  • 上文，我们看了IOC设计要点和设计结构；紧接着这篇，我们可以看下源码的实现了：Spring如何实现将资源配置（以xml配置为例）通过加载，解析，生成BeanDefination并注册到IoC容器中的
    
  
  
• Spring进阶 - Spring IOC实现原理详解之Bean实例化(生命周期,循环依赖等)
  
  
  
  • 上文，我们看了IOC设计要点和设计结构；以及Spring如何实现将资源配置（以xml配置为例）通过加载，解析，生成BeanDefination并注册到IoC容器中的；容器中存放的是Bean的定义即BeanDefinition放到beanDefinitionMap中，本质上是一个ConcurrentHashMap；并且BeanDefinition接口中包含了这个类的Class信息以及是否是单例等。那么如何从BeanDefinition中实例化Bean对象呢，这是本文主要研究的内容？
    
  
  
• Spring进阶 - Spring AOP实现原理详解之切面实现
  
  
  
  • 前文，我们分析了Spring IOC的初始化过程和Bean的生命周期等，而Spring AOP也是基于IOC的Bean加载来实现的。本文主要介绍Spring AOP原理解析的切面实现过程(将切面类的所有切面方法根据使用的注解生成对应Advice，并将Advice连同切入点匹配器和切面类等信息一并封装到Advisor，为后续交给代理增强实现做准备的过程)。
    
  
  
• Spring进阶 - Spring AOP实现原理详解之AOP代理
  
  
  
  • 上文我们介绍了Spring AOP原理解析的切面实现过程(将切面类的所有切面方法根据使用的注解生成对应Advice，并将Advice连同切入点匹配器和切面类等信息一并封装到Advisor)。本文在此基础上继续介绍，代理（cglib代理和JDK代理）的实现过程。
    
  
  
• Spring进阶 - Spring AOP实现原理详解之Cglib代理实现
  
  
  
  • 我们在前文中已经介绍了SpringAOP的切面实现和创建动态代理的过程，那么动态代理是如何工作的呢？本文主要介绍Cglib动态代理的案例和SpringAOP实现的原理。
    
  
  
• Spring进阶 - Spring AOP实现原理详解之JDK代理实现
  
  
  
  • 上文我们学习了SpringAOP Cglib动态代理的实现，本文主要是SpringAOP JDK动态代理的案例和实现部分。
    
  
  
• Spring进阶 - SpringMVC实现原理之DispatcherServlet初始化的过程
  
  
  
  • 前文我们有了IOC的源码基础以及SpringMVC的基础，我们便可以进一步深入理解SpringMVC主要实现原理，包含DispatcherServlet的初始化过程和DispatcherServlet处理请求的过程的源码解析。本文是第一篇：DispatcherServlet的初始化过程的源码解析。
    
  
  
• Spring进阶 - SpringMVC实现原理之DispatcherServlet处理请求的过程
  
  
  
  • 前文我们有了IOC的源码基础以及SpringMVC的基础，我们便可以进一步深入理解SpringMVC主要实现原理，包含DispatcherServlet的初始化过程和DispatcherServlet处理请求的过程的源码解析。本文是第二篇：DispatcherServlet处理请求的过程的源码解析。
    
  
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

---

欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/)

Powered by Discuz! X3.4