AOP实现原理

　　Spring 为解耦而生，其中AOP（面向切面编程）是很浓重的一笔。

　　本文来探讨一下AOP实现的原理。

一. 概述

　　代理模式是常用的java设计模式，他的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。 
　　按照代理的创建时期，代理类可以分为两种。

• 静态代理：由程序员创建或特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。
• 动态代理：在程序运行时，运用反射机制动态创建而成。

　　另外还有Cglib动态代理，它是针对类实现的代理。

二. 静态代理

1.  Count.java 

 1 /** 
 2 * 定义一个账户接口 
 3 */  
 4 public interface Count {  
 5     // 查看账户方法  
 6     public void queryCount();  
 7   
 8     // 修改账户方法  
 9     public void updateCount();    
10 }

2.  CountImpl.java

 1 import net.battier.dao.Count;  
 2 /** 
 3  * 委托类(包含业务逻辑) 
 4  */  
 5 public class CountImpl implements Count {  
 6   
 7     @Override  
 8     public void queryCount() {  
 9         System.out.println("查看账户方法...");  
10   
11     }  
12 
13     @Override  
14     public void updateCount() {  
15         System.out.println("修改账户方法...");  
16     }  
17 }  

3.  CountProxy.java  

 1 import net.battier.dao.Count;  
 2 /** 
 3  * 这是一个代理类（增强CountImpl实现类） 
 4  */  
 5 public class CountProxy implements Count {  
 6     private CountImpl countImpl;  
 7     /** 
 8      * 覆盖默认构造器 
 9      *  
10      * @param countImpl 
11      */  
12     public CountProxy(CountImpl countImpl) {  
13         this.countImpl = countImpl;  
14     }  
15   
16     @Override  
17     public void queryCount() {  
18         System.out.println("事务处理之前");  
19         // 调用委托类的方法;  
20         countImpl.queryCount();  
21         System.out.println("事务处理之后");  
22     }  
23   
24     @Override  
25     public void updateCount() {  
26         System.out.println("事务处理之前");  
27         // 调用委托类的方法;  
28         countImpl.updateCount();  
29         System.out.println("事务处理之后");  
30     }  
31 } 

4.  TestCount.java

 1 import net.battier.dao.impl.CountImpl;  
 2 import net.battier.dao.impl.CountProxy;    
 3 /** 
 4  *测试Count类 
 5  */  
 6 public class TestCount {  
 7     public static void main(String[] args) {  
 8         CountImpl countImpl = new CountImpl();  
 9         CountProxy countProxy = new CountProxy(countImpl);  
10         countProxy.updateCount();  
11         countProxy.queryCount();  
12     }  
13 }  

　　观察代码可以发现每一个代理类只能为一个接口服务，这样一来程序开发中必然会产生过多的代理，而且，所有的代理操作除了调用的方法不一样之外，其他的操作都一样，则此时肯定是重复代码。解决这一问题最好的做法是可以通过一个代理类完成全部的代理功能，那么此时就必须使用动态代理完成。 

三. 动态代理

　　与静态代理类对照的是动态代理类，动态代理类的字节码在程序运行时由Java反射机制动态生成，无需程序员手工编写它的源代码。动态代理类不仅简化了编程工作，而且提高了软件系统的可扩展性，因为Java 反射机制可以生成任意类型的动态代理类。java.lang.reflect 包中的Proxy类和InvocationHandler 接口提供了生成动态代理类的能力。 

JDK动态代理中包含一个接口和一个类： 

1).InvocationHandler接口

1 public interface InvocationHandler {
2     public Object invoke(Object proxy, Method method, Object[] args)
3         throws Throwable;
4 }

参数说明： 
Object proxy：指被代理的对象。 
Method method：要调用的方法 
Object[] args：方法调用时所需要的参数

可以将InvocationHandler接口的子类想象成一个代理的最终操作类，替换掉ProxySubject。

2).Proxy类： 

Proxy类是专门完成代理的操作类，可以通过此类为一个或多个接口动态地生成实现类，此类提供了如下的操作方法：

1 public static Object newProxyInstance(ClassLoader loader,
2                                           Class<?>[] interfaces,
3                                           InvocationHandler h)
4         throws IllegalArgumentException
5     {
6         /**************
7         *具体内容略去**
8         **************/
9     }

参数说明： 
ClassLoader loader：类加载器 
Class<?>[] interfaces：得到全部的接口 
InvocationHandler h：得到InvocationHandler接口的子类实例

Ps:类加载器 
在Proxy类中的newProxyInstance（）方法中需要一个ClassLoader类的实例，ClassLoader实际上对应的是类加载器，在Java中主要有一下三种类加载器：

• Booststrap ClassLoader：此加载器采用C++编写，一般开发中是看不到的；
• Extendsion ClassLoader：用来进行扩展类的加载，一般对应的是jre\lib\ext目录中的类;
• AppClassLoader：(默认)加载classpath指定的类，是最常使用的是一种加载器。

动态代理示例：

1.  BookFacade.java

1 public interface BookFacade {  
2     public void addBook();  
3 }  

2.  BookFacadeImpl.java 

1 import net.battier.dao.BookFacade;  
2   
3 public class BookFacadeImpl implements BookFacade {  
4   
5     @Override  
6     public void addBook() {  
7         System.out.println("增加图书方法。。。");  
8     }  
9 }

3.  BookFacadeProxy.java 

 1 import java.lang.reflect.InvocationHandler;  
 2 import java.lang.reflect.Method;  
 3 import java.lang.reflect.Proxy;  
 4 /** 
 5  * JDK动态代理代理类 
 6  */  
 7 public class BookFacadeProxy implements InvocationHandler {  
 8     private Object target;  
 9     /** 
10      * 绑定委托对象并返回一个代理类 
11      * @param target 
12      * @return 
13      */  
14     public Object bind(Object target) {  
15         this.target = target;  
16         //取得代理对象  
17         return Proxy.newProxyInstance(target.getClass().getClassLoader(),  
18                 target.getClass().getInterfaces(), this);   //要绑定接口(这是一个缺陷，cglib弥补了这一缺陷)  
19     }  
20   
21     @Override  
22     /** 
23      * 调用方法 
24      */  
25     public Object invoke(Object proxy, Method method, Object[] args)  
26             throws Throwable {  
27         Object result=null;  
28         System.out.println("事物开始");  
29         //执行方法  
30         result=method.invoke(target, args);  
31         System.out.println("事物结束");  
32         return result;  
33     }  
34 }

4.  TestProxy.java

 1 import net.battier.dao.BookFacade;  
 2 import net.battier.dao.impl.BookFacadeImpl;  
 3 import net.battier.proxy.BookFacadeProxy;  
 4   
 5 public class TestProxy {  
 6     public static void main(String[] args) {  
 7         BookFacadeProxy proxy = new BookFacadeProxy();  
 8         BookFacade bookProxy = (BookFacade) proxy.bind(new BookFacadeImpl());  
 9         bookProxy.addBook();  
10     }    
11 }

　　但是，JDK的动态代理依靠接口实现，如果有些类并没有实现接口，则不能使用JDK代理，这就要使用cglib动态代理了。 

四. Cglib动态代理

　　JDK的动态代理机制只能代理实现了接口的类，而不能实现接口的类就不能实现JDK的动态代理，cglib是针对类来实现代理的，他的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强，但因为采用的是继承，所以不能对final修饰的类进行代理。 

示例如下：

1.  BookFacadeCglib.java 

1 public interface BookFacade {  
2     public void addBook();  
3 } 

2.  BookCadeImpl1.java 

1 /** 
2  * 这个是没有实现接口的实现类 
3  */  
4 public class BookFacadeImpl1 {  
5     public void addBook() {  
6         System.out.println("增加图书的普通方法...");  
7     }  
8 }

3.  BookFacadeProxy.java

 1 import net.sf.cglib.proxy.Enhancer;  
 2 import net.sf.cglib.proxy.MethodInterceptor;  
 3 import net.sf.cglib.proxy.MethodProxy;    
 4 /** 
 5  * 使用cglib动态代理  
 6  */  
 7 public class BookFacadeCglib implements MethodInterceptor {  
 8     private Object target;  
 9   
10     /** 
11      * 创建代理对象 
12      *  
13      * @param target 
14      * @return 
15      */  
16     public Object getInstance(Object target) {  
17         this.target = target;  
18         Enhancer enhancer = new Enhancer();  
19         enhancer.setSuperclass(this.target.getClass());  
20         // 回调方法  
21         enhancer.setCallback(this);  
22         // 创建代理对象  
23         return enhancer.create();  
24     }  
25   
26     @Override  
27     // 回调方法  
28     public Object intercept(Object obj, Method method, Object[] args,  
29             MethodProxy proxy) throws Throwable {  
30         System.out.println("事物开始");  
31         proxy.invokeSuper(obj, args);  
32         System.out.println("事物结束");  
33         return null;  
34     }  
35 }

4.  TestCglib.java

 1 import net.battier.dao.impl.BookFacadeImpl1;  
 2 import net.battier.proxy.BookFacadeCglib;  
 3   
 4 public class TestCglib {  
 5       
 6     public static void main(String[] args) {  
 7         BookFacadeCglib cglib=new BookFacadeCglib();  
 8         BookFacadeImpl1 bookCglib=(BookFacadeImpl1)cglib.getInstance(new BookFacadeImpl1());  
 9         bookCglib.addBook();  
10     }  
11 }

参考：http://www.cnblogs.com/jqyp/archive/2010/08/20/1805041.html#3460821