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

更通俗的说，代理解决的问题当两个类需要通信时，引入第三方代理类，将两个类的关系解耦，让我们只了解代理类即可，而且代理的出现还可以让我们完成与另一个类之间的关系的统一管理，但是切记，代理类和委托类要实现相同的接口，因为代理真正调用的还是委托类的方法

动态代理的优势就是实现无侵入式的代码扩展。

Java的两种动态代理方式 

jdk方式，委托类必须实现接口(目标类基于统一的接口)，代理类只能对接口进行代理。使用java的反射机制，以及Proxy和InvocationHandler来实现，代理类与委托类实现了相同的接口。
　　cglib，code generate library，代理类可对类进行代理，使用第三方cglib库来实现，其内部使用asm框架生成代理类的字节码，其字节码文件更加复杂，不能代理final方法，因为代理类是委托类的子类。
　　cglib生成的代理类的运行性能比jdk更加优秀，但是生成对象的时间更长，在单例模式中可以使用cglib，在频繁创建对象的模式中建议使用jdk。随着jdk版本的提高，jdk的性能会更高，要根据实际情况决定

 

// jdk方式
// 被代理接口
public interface Xx() {
    public Integer say(String message);
}

// 委托类
public class XxImpl implements Xx {
    public String say(String name) {
        return "hello " + name;
    }
}

// 拦截器
public class XxInvocationHandler implements InvocationHandler {
    // 委托类
    private Object xxProxyed;

    // 初始化委托类
    public void XxInvocationHandler(Object xxProxyed) {
        this.xxProxyed = xxProxyed;
    }

    // proxy，代理类实例，认为是预留接口
    // 代理类执行代理方法时，回调此方法，并将自己this作为实参传给proxy
    public Object invoke(Object proxy, Method method, Object[] params) 
        throws Throwable {
        // 此处可通过method.getName()判断是否为要拦截的方法
        ...

        // 核心方法之前的内容
        ...

        // 以反射的形式，调用委托类的方法
        Object result = method.invoke(xxProxyed, params);

        // 核心方法之后的内容
        ...

        // 一定要返回结果
        return result;
    }
}

// 代理类生成容器
public class ProxyContainer {
    public static Object createProxy(Object proxyed, InvocationHandler invo) {
        return Proxy.newProxyInstance(proxyed.getClass().getClassLoader(), 
            proxyed.getClass().getInterfaces(), invo);
    }
}


// cglib方式，需要第三方jar库
// 委托类
public class Yy {
    public String say(String name) {
        return "hello " + name;
    }
}

// 拦截器
public class YyIntercepter implements MethodInterceptor {  
    // 前三个参数同jdk方式
    // methodProxy，委托类中的每一个被代理方法都对应一个MethodProxy对象
    public Object intercept(Object proxy, Method method, Object[] params, MethodProxy methodProxy) 
        throws Throwable {
        // 此处可通过method.getName()判断是否为要拦截的方法
        ...

        // 核心方法之前的内容
        ...

        // MethodProxy为cgli生成的对象，性能更高也体现在此
        Object result = methodProxy.invokeSuper(proxy, params);

        // 核心方法之后的内容
        ...

        // 一定要返回结果
        return result;
    }
}

// 代理类生成容器
public class ProxyContainer {
    public static Object createProxy(Class proxyed) {
        // cglib自带的字节码增强器
        Enhancer enhancer = new Enhancer();
        // 将委托类设置成父类
        enhancer.setSuperclass(proxyed);
        // 设置拦截器
        enhancer.setCallback(new YyIntercepter());

        return enhancer.create();
    }
}

 

 

静态代理：

具体用户管理实现类

  1. public class UserManagerImpl implements UserManager {  
  2.   
  3.     @Override  
  4.     public void addUser(String userId, String userName) {  
  5.         System.out.println("UserManagerImpl.addUser");  
  6.     }  
  7.   
  8.     @Override  
  9.     public void delUser(String userId) {  
  10.         System.out.println("UserManagerImpl.delUser");  
  11.     }  
  12.   
  13.     @Override  
  14.     public String findUser(String userId) {  
  15.         System.out.println("UserManagerImpl.findUser");  
  16.         return "张三";  
  17.     }  
  18.   
  19.     @Override  
  20.     public void modifyUser(String userId, String userName) {  
  21.         System.out.println("UserManagerImpl.modifyUser");  
  22.   
  23.     }  
  24. }  

 

代理类--代理用户管理实现类

  1. public class UserManagerImplProxy implements UserManager {  
  2.   
  3.     // 目标对象  
  4.     private UserManager userManager;  
  5.     // 通过构造方法传入目标对象  
  6.     public UserManagerImplProxy(UserManager userManager){  
  7.         this.userManager=userManager;  
  8.     }  
  9.     @Override  
  10.     public void addUser(String userId, String userName) {  
  11.         try{  
  12.                 //添加打印日志的功能  
  13.                 //开始添加用户  
  14.                 System.out.println("start-->addUser()");  
  15.                 userManager.addUser(userId, userName);  
  16.                 //添加用户成功  
  17.                 System.out.println("success-->addUser()");  
  18.             }catch(Exception e){  
  19.                 //添加用户失败  
  20.                 System.out.println("error-->addUser()");  
  21.             }  
  22.     }  
  23.   
  24.     @Override  
  25.     public void delUser(String userId) {  
  26.         userManager.delUser(userId);  
  27.     }  
  28.   
  29.     @Override  
  30.     public String findUser(String userId) {  
  31.         userManager.findUser(userId);  
  32.         return "张三";  
  33.     }  
  34.   
  35.     @Override  
  36.     public void modifyUser(String userId, String userName) {  
  37.         userManager.modifyUser(userId,userName);  
  38.     }  
  39.   
  40. }  

 

客户端调用

  1. public class Client {  
  2.   
  3.     public static void main(String[] args){  
  4.         //UserManager userManager=new UserManagerImpl();  
  5.         UserManager userManager=new UserManagerImplProxy(new UserManagerImpl());  
  6.         userManager.addUser("1111", "张三");  
  7.     }  
  8. }  

 

静态代理类优缺点

优点：

 

代理使客户端不需要知道实现类是什么，怎么做的，而客户端只需知道代理即可（解耦合），对于如上的客户端代码，newUserManagerImpl()可以应用工厂将它隐藏，如上只是举个例子而已。

 

 

缺点：

 

1）代理类和委托类实现了相同的接口，代理类通过委托类实现了相同的方法。这样就出现了大量的代码重复。如果接口增加一个方法，除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。

 

2）代理对象只服务于一种类型的对象，如果要服务多类型的对象。势必要为每一种对象都进行代理，静态代理在程序规模稍大时就无法胜任了。如上的代码是只为UserManager类的访问提供了代理，但是如果还要为其他类如Department类提供代理的话，就需要我们再次添加代理Department的代理类。

 

 

 

举例说明：代理可以对实现类进行统一的管理，如在调用具体实现类之前，需要打印日志等信息，这样我们只需要添加一个代理类，在代理类中添加打印日志的功能，然后调用实现类，这样就避免了修改具体实现类。满足我们所说的开闭原则。但是如果想让每个实现类都添加打印日志的功能的话，就需要添加多个代理类，以及代理类中各个方法都需要添加打印日志功能（如上的代理方法中删除，修改，以及查询都需要添加上打印日志的功能）

 

即静态代理类只能为特定的接口(Service)服务。如想要为多个接口服务则需要建立很多个代理类。

 


 

引入动态代理：

根据如上的介绍，你会发现每个代理类只能为一个接口服务，这样程序开发中必然会产生许多的代理类

所以我们就会想办法可以通过一个代理类完成全部的代理功能，那么我们就需要用动态代理

 

 

在上面的示例中，一个代理只能代理一种类型，而且是在编译器就已经确定被代理的对象。而动态代理是在运行时，通过反射机制实现动态代理，并且能够代理各种类型的对象

 

 

 

在Java中要想实现动态代理机制，需要java.lang.reflect.InvocationHandler接口和 java.lang.reflect.Proxy 类的支持

 

java.lang.reflect.InvocationHandler接口的定义如下：

 

[java] view plain copy print?
  1. //Object proxy:被代理的对象  
  2. //Method method:要调用的方法  
  3. //Object[] args:方法调用时所需要参数  
  4. public interface InvocationHandler {  
  5.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;  
  6. }  

 


 

java.lang.reflect.Proxy类的定义如下：

 

[java] view plain copy print?
  1. //CLassLoader loader:类的加载器  
  2. //Class<?> interfaces:得到全部的接口  
  3. //InvocationHandler h:得到InvocationHandler接口的子类的实例  
  4. public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException  


动态代理：

具体实现类

 

[java] view plain copy print?
  1. public class UserManagerImpl implements UserManager {  
  2.   
  3.     @Override  
  4.     public void addUser(String userId, String userName) {  
  5.         System.out.println("UserManagerImpl.addUser");  
  6.     }  
  7.   
  8.     @Override  
  9.     public void delUser(String userId) {  
  10.         System.out.println("UserManagerImpl.delUser");  
  11.     }  
  12.   
  13.     @Override  
  14.     public String findUser(String userId) {  
  15.         System.out.println("UserManagerImpl.findUser");  
  16.         return "张三";  
  17.     }  
  18.   
  19.     @Override  
  20.     public void modifyUser(String userId, String userName) {  
  21.         System.out.println("UserManagerImpl.modifyUser");  
  22.   
  23.     }  
  24.   
  25. }  


动态创建代理对象的类

 

 

 

[java] view plain copy print?
  1. //动态代理类只能代理接口（不支持抽象类），代理类都需要实现InvocationHandler类，实现invoke方法。该invoke方法就是调用被代理接口的所有方法时需要调用的，该invoke方法返回的值是被代理接口的一个实现类  
  2.      
  3. public class LogHandler implements InvocationHandler {  
  4.   
  5.     // 目标对象  
  6.     private Object targetObject;  
  7.     //绑定关系，也就是关联到哪个接口（与具体的实现类绑定）的哪些方法将被调用时，执行invoke方法。              
  8.     public Object newProxyInstance(Object targetObject){  
  9.         this.targetObject=targetObject;  
  10.         //该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例    
  11.         //第一个参数指定产生代理对象的类加载器，需要将其指定为和目标对象同一个类加载器  
  12.         //第二个参数要实现和目标对象一样的接口，所以只需要拿到目标对象的实现接口  
  13.         //第三个参数表明这些被拦截的方法在被拦截时需要执行哪个InvocationHandler的invoke方法  
  14.         //根据传入的目标返回一个代理对象  
  15.         return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),  
  16.                 targetObject.getClass().getInterfaces(),this);  
  17.     }  
  18.     @Override  
  19.     //关联的这个实现类的方法被调用时将被执行  
  20.     /*InvocationHandler接口的方法，proxy表示代理，method表示原对象被调用的方法，args表示方法的参数*/  
  21.     public Object invoke(Object proxy, Method method, Object[] args)  
  22.             throws Throwable {  
  23.         System.out.println("start-->>");  
  24.         for(int i=0;i<args.length;i++){  
  25.             System.out.println(args[i]);  
  26.         }  
  27.         Object ret=null;  
  28.         try{  
  29.             /*原对象方法调用前处理日志信息*/  
  30.             System.out.println("satrt-->>");  
  31.               
  32.             //调用目标方法  
  33.             ret=method.invoke(targetObject, args);  
  34.             /*原对象方法调用后处理日志信息*/  
  35.             System.out.println("success-->>");  
  36.         }catch(Exception e){  
  37.             e.printStackTrace();  
  38.             System.out.println("error-->>");  
  39.             throw e;  
  40.         }  
  41.         return ret;  
  42.     }  
  43.   
  44. }  

 

被代理对象targetObject通过参数传递进来，我们通过targetObject.getClass().getClassLoader()获取ClassLoader对象，然后通过targetObject.getClass().getInterfaces()获取它实现的所有接口，然后将targetObject包装到实现了InvocationHandler接口的LogHandler对象中。通过newProxyInstance函数我们就获得了一个动态代理对象。

 

 

 

客户端代码

 

[java] view plain copy print?
  1. public class Client {  
  2.   
  3.     public static void main(String[] args){  
  4.         LogHandler logHandler=new LogHandler();  
  5.         UserManager userManager=(UserManager)logHandler.newProxyInstance(new UserManagerImpl());  
  6.         //UserManager userManager=new UserManagerImpl();  
  7.         userManager.addUser("1111", "张三");  
  8.     }  
  9. }  


可以看到，我们可以通过LogHandler代理不同类型的对象，如果我们把对外的接口都通过动态代理来实现，那么所有的函数调用最终都会经过invoke函数的转发，因此我们就可以在这里做一些自己想做的操作，比如日志系统、事务、拦截器、权限控制等。这也就是AOP(面向切面编程)的基本原理。

 

 

 

插曲：

 


 

AOP（AspectOrientedProgramming）：将日志记录，性能统计，安全控制，事务处理，异常处理等代码从业务逻辑代码中划分出来，通过对这些行为的分离，我们希望可以将它们独立到非指导业务逻辑的方法中，进而改变这些行为的时候不影响业务逻辑的代码---解耦。

 

 

 

针对如上的示例解释：

 

 

 

我们来看上面的UserManagerImplProxy类，它的两个方法System.out.println("start-->addUser()")和System.out.println("success-->addUser()")，这是做核心动作之前和之后的两个截取段，正是这两个截取段，却是我们AOP的基础，在OOP里，System.out.println("start-->addUser()")、核心动作、System.out.println("success-->addUser()")这个三个动作在多个类里始终在一起，但他们所要完成的逻辑却是不同的，如System.out.println("start-->addUser()")里做的可能是权限的判断，在所有类中它都是做权限判断，而在每个类里核心动作却各不相同，System.out.println("success-->addUser()")可能做的是日志，在所有类里它都做日志。正是因为在所有的类里，核心代码之前的操作和核心代码之后的操作都做的是同样的逻辑，因此我们需要将它们提取出来，单独分析，设计和编码，这就是我们的AOP思想。一句话说，AOP只是在对OOP的基础上进行进一步抽象，使我们的类的职责更加单一。

 


 

动态代理优点：

 

 

 

动态代理与静态代理相比较，最大的好处是接口中声明的所有方法都被转移到调用处理器一个集中的方法中处理（InvocationHandler.invoke）。这样，在接口方法数量比较多的时候，我们可以进行灵活处理，而不需要像静态代理那样每一个方法进行中转。而且动态代理的应用使我们的类职责更加单一，复用性更强

 

 

 

总结：

 

其实所谓代理，就是一个人或者一个机构代表另一个人或者另一个机构采取行动。在一些情况下，一个客户不想或者不能够直接引用一个对象，而代理对象可以在客户端和目标对象之前起到中介的作用。

 

代理对象就是把被代理对象包装一层，在其内部做一些额外的工作，比如用户需要上facebook,而普通网络无法直接访问，网络代理帮助用户先FQ，然后再访问facebook。这就是代理的作用了。

 

纵观静态代理与动态代理，它们都能实现相同的功能，而我们看从静态代理到动态代理的这个过程，我们会发现其实动态代理只是对类做了进一步抽象和封装，使其复用性和易用性得到进一步提升而这不仅仅符合了面向对象的设计理念，其中还有AOP的身影，这也提供给我们对类抽象的一种参考。关于动态代理与AOP的关系，个人觉得AOP是一种思想，而动态代理是一种AOP思想的实现！