AOP的底层实现

男娘i 2022-07-11 11:23 232阅读 0赞

AOP是目前Spring框架中的核心之一，在应用中具有非常重要的作用，也是Spring其他组件的基础。它是一种面向切面编程的思想。关于AOP的基础知识，相信多数童鞋都已经了如指掌，我们就略过这部分，来讲解下AOP的核心功能的底层实现机制：如何用动态代理来实现切面拦截。

AOP的拦截功能是由java中的动态代理来实现的。说白了，就是在目标类的基础上增加切面逻辑，生成增强的目标类（该切面逻辑或者在目标类函数执行之前，或者目标类函数执行之后，或者在目标类函数抛出异常时候执行。不同的切入时机对应不同的Interceptor的种类，如BeforeAdviseInterceptor，AfterAdviseInterceptor以及ThrowsAdviseInterceptor等）。

那么动态代理是如何实现将切面逻辑（advise）织入到目标类方法中去的呢？下面我们就来详细介绍并实现AOP中用到的两种动态代理。

AOP的源码中用到了两种动态代理来实现拦截切入功能：jdk动态代理和cglib动态代理。两种方法同时存在，各有优劣。jdk动态代理是由java内部的反射机制来实现的，cglib动态代理底层则是借助asm来实现的。总的来说，反射机制在生成类的过程中比较高效，而asm在生成类之后的相关执行过程中比较高效（可以通过将asm生成的类进行缓存，这样解决asm生成类过程低效问题）。还有一点必须注意：jdk动态代理的应用前提，必须是目标类基于统一的接口。如果没有上述前提，jdk动态代理不能应用。由此可以看出，jdk动态代理有一定的局限性，cglib这种第三方类库实现的动态代理应用更加广泛，且在效率上更有优势。

一、jdk动态代理实现AOP拦截（代码中的关键地方都添加了注释）

1、为目标类（target）定义统一的接口类Service，这个是jdk动态代理必须的前提。

**\[java\]**  [view plain][]   [copy][view plain]

1.  **package** jdkproxy;  
2.    
3.  /\*\* 
4.   \* 该类是所有被代理类的接口类，jdk实现的代理要求被代理类基于统一的接口 
5.   \*  
6.   \* @author typ 
7.   \*  
8.   \*/  
9.  **public** **interface** Service \{  
10.     /\*\* 
11.      \* add方法 
12.      \*/  
13.     **public** **void** add();  
14.   
15.     /\*\* 
16.      \* update方法 
17.      \*/  
18.     **public** **void** update();  
19. \}

2、目标类AService，我们的实验目标就是在AService中add和update方法的前后实现拦截，加入自定义切面逻辑advise

**\[java\]**  [view plain][]   [copy][view plain]

1.  **package** jdkproxy;  
2.    
3.  /\*\* 
4.   \* 被代理类，即目标类target 
5.   \*  
6.   \* @author typ 
7.   \*  
8.   \*/  
9.  **public** **class** AService **implements** Service \{  
10.     /\* 
11.      \* (non-Javadoc) 
12.      \*  
13.      \* @see jdkproxy.Service\#add() 
14.      \*/  
15.     **public** **void** add() \{  
16.         System.out.println("AService add>>>>>>>>>>>>>>>>>>");  
17.     \}  
18.   
19.     /\* 
20.      \* (non-Javadoc) 
21.      \*  
22.      \* @see jdkproxy.Service\#update() 
23.      \*/  
24.     **public** **void** update() \{  
25.         System.out.println("AService update>>>>>>>>>>>>>>>");  
26.     \}  
27. \}

3、实现动态代理类MyInvocationHandler，实现InvocationHandler接口，并且实现接口中的invoke方法。仔细看invoke方法，就是在该方法中加入切面逻辑的。目标类方法的执行是由mehod.invoke(target,args)这条语句完成。

**\[java\]**  [view plain][]   [copy][view plain]

1.  **package** jdkproxy;  
2.    
3.  **import** java.lang.reflect.InvocationHandler;  
4.  **import** java.lang.reflect.Method;  
5.    
6.  /\*\* 
7.   \* @author typ 
8.   \* 
9.   \*/  
10. **public** **class** MyInvocationHandler **implements** InvocationHandler \{  
11.     **private** Object target;  
12.   
13.     MyInvocationHandler() \{  
14.         **super**();  
15.     \}  
16.   
17.     MyInvocationHandler(Object target) \{  
18.         **super**();  
19.         **this**.target = target;  
20.     \}  
21.   
22.     **public** Object invoke(Object proxy, Method method, Object\[\] args)  
23.             **throws** Throwable \{  
24.         // 程序执行前加入逻辑，MethodBeforeAdviceInterceptor  
25.         System.out.println("before-----------------------------");  
26.         // 程序执行  
27.         Object result = method.invoke(target, args);  
28.         // 程序执行后加入逻辑，MethodAfterAdviceInterceptor  
29.         System.out.println("after------------------------------");  
30.         **return** result;  
31.     \}  
32.   
33. \}

4、测试类，其中增强的目标对象是由Proxy.newProxyInstance(aService.getClass().getClassLoader(), aService.getClass().getInterfaces(), handler);来生成的。

**\[java\]**  [view plain][]   [copy][view plain]

1.  **package** jdkproxy;  
2.    
3.  **import** java.lang.reflect.Proxy;  
4.    
5.  /\*\* 
6.   \* @author typ 
7.   \* 
8.   \*/  
9.  **public** **class** Test \{  
10.     **public** **static** **void** main(String\[\] args) \{  
11.         Service aService = **new** AService();  
12.         MyInvocationHandler handler = **new** MyInvocationHandler(aService);  
13.         // Proxy为InvocationHandler实现类动态创建一个符合某一接口的代理实例  
14.         Service aServiceProxy = (Service) Proxy.newProxyInstance(aService  
15.                 .getClass().getClassLoader(), aService.getClass()  
16.                 .getInterfaces(), handler);  
17.         // 由动态生成的代理对象来aServiceProxy 代理执行程序，其中aServiceProxy 符合Service接口  
18.         aServiceProxy.add();  
19.         System.out.println();  
20.         aServiceProxy.update();  
21.         // 以下是对B的代理  
22.         // Service bService = new BService();  
23.         // MyInvocationHandler handler = new MyInvocationHandler(bService);  
24.         // Service bServiceProxy = (Service) Proxy.newProxyInstance(bService  
25.         // .getClass().getClassLoader(), bService.getClass()  
26.         // .getInterfaces(), handler);  
27.         // bServiceProxy.add();  
28.         // System.out.println();  
29.         // bServiceProxy.update();  
30.     \}  
31. \}

自此，jdk动态代理来实现AOP拦截机制的代码已经实现，下面我们看一下拦截的结果，程序输出结果如下：

before-----------------------------

AService add>>>>>>>>>>>>>>>>>>

after------------------------------

before-----------------------------

AService update>>>>>>>>>>>>>>>

after------------------------------  
可以看到，在目标类AService的add和update方法前后已经加入了自定义的切面逻辑，AOP拦截机制生效了。

二、cglib动态代理实现AOP拦截（ 代码中的关键地方都添加了注释）

1、目标类，cglib不需要定义目标类的统一接口

**\[java\]**  [view plain][]   [copy][view plain]

1.  **package** cglibproxy;  
2.    
3.  /\*\* 
4.   \* 被代理类，即目标对象target 
5.   \*  
6.   \* @author typ 
7.   \*  
8.   \*/  
9.  **public** **class** Base \{  
10.     /\*\* 
11.      \* 一个模拟的add方法 
12.      \*/  
13.     **public** **void** add() \{  
14.         System.out.println("add ------------");  
15.     \}  
16. \}

2、实现动态代理类CglibProxy，需要实现MethodInterceptor接口，实现intercept方法。该代理中在add方法前后加入了自定义的切面逻辑，目标类add方法执行语句为proxy.invokeSuper(object, args);

**\[java\]**  [view plain][]   [copy][view plain]

1.  **package** cglibproxy;  
2.    
3.  **import** java.lang.reflect.Method;  
4.  **import** net.sf.cglib.proxy.MethodInterceptor;  
5.  **import** net.sf.cglib.proxy.MethodProxy;  
6.    
7.  /\*\* 
8.   \* 此为代理类，用于在pointcut处添加advise 
9.   \*  
10.  \* @author typ 
11.  \*  
12.  \*/  
13. **public** **class** CglibProxy **implements** MethodInterceptor \{  
14.   
15.     **public** Object intercept(Object object, Method method, Object\[\] args,  
16.             MethodProxy proxy) **throws** Throwable \{  
17.         // 添加切面逻辑（advise），此处是在目标类代码执行之前，即为MethodBeforeAdviceInterceptor。  
18.         System.out.println("before-------------");  
19.         // 执行目标类add方法  
20.         proxy.invokeSuper(object, args);  
21.         // 添加切面逻辑（advise），此处是在目标类代码执行之后，即为MethodAfterAdviceInterceptor。  
22.         System.out.println("after--------------");  
23.         **return** **null**;  
24.     \}  
25.   
26. \}

3、获取增强的目标类的工厂Factory，其中增强的方法类对象是有Enhancer来实现的，代码如下所示：

**\[java\]**  [view plain][]   [copy][view plain]

1.  **package** cglibproxy;  
2.    
3.  **import** net.sf.cglib.proxy.Enhancer;  
4.    
5.  /\*\* 
6.   \* 工厂类，生成增强过的目标类（已加入切入逻辑） 
7.   \*  
8.   \* @author typ 
9.   \*  
10.  \*/  
11. **public** **class** Factory \{  
12.     /\*\* 
13.      \* 获得增强之后的目标类，即添加了切入逻辑advice之后的目标类 
14.      \*  
15.      \* @param proxy 
16.      \* @return 
17.      \*/  
18.     **public** **static** Base getInstance(CglibProxy proxy) \{  
19.         Enhancer enhancer = **new** Enhancer();  
20.         enhancer.setSuperclass(Base.**class**);  
21.         //回调方法的参数为代理类对象CglibProxy，最后增强目标类调用的是代理类对象CglibProxy中的intercept方法  
22.         enhancer.setCallback(proxy);  
23.         // 此刻，base不是单纯的目标类，而是增强过的目标类  
24.         Base base = (Base) enhancer.create();  
25.         **return** base;  
26.     \}  
27. \}

4、测试类

**\[java\]**  [view plain][]   [copy][view plain]

1.  **package** cglibproxy;  
2.    
3.  /\*\* 
4.   \* @author typ 
5.   \* 
6.   \*/  
7.  **public** **class** Test \{  
8.      **public** **static** **void** main(String\[\] args) \{  
9.          CglibProxy proxy = **new** CglibProxy();  
10.         // base为生成的增强过的目标类  
11.         Base base = Factory.getInstance(proxy);  
12.         base.add();  
13.     \}  
14. \}

自此，cglib动态代理实现的AOP拦截机制已经基本实现，下面我们来看一下拦截的效果如何，程序执行结果如下：

before-------------

add ------------

after--------------

可以看到，在目标类Base的add方法前后已经加入了自定义的切面逻辑，AOP拦截机制生效了。

此外，需要说明一下的是，cglib动态代理用到了第三方类库，需要在项目中引入两个jar包：cglib.jar和asm.jar。稍后会在csdn资源中上传这两个jar包。免积分的啊。

jar包和相关代码请见 [http://download.csdn.net/detail/dreamrealised/6427885][http_download.csdn.net_detail_dreamrealised_6427885]

总之，AOP的核心机制和基本功能已经能够通过动态代理来实现了，至于AOP中，如何从配置文档中得到目标类target、advisor的bean，如何判断拦截器类型等问题，就借助于Spring中另一个核心IOC来解决了，后续会有IOC的核心实现机制讲解。

#  #

[view plain]: http://blog.csdn.net/dreamrealised/article/details/12885739#
[http_download.csdn.net_detail_dreamrealised_6427885]: http://download.csdn.net/detail/dreamrealised/6427885