JDK动态代理与Cglib动态代理（转载）

spring容器经过动态代理再结合java反射思想能够使得方法调用更加简洁

1、动态代理概述：

    与静态代理对照（关于静态代理的介绍 能够阅读上一篇：JAVA设计模式之 代理模式【Proxy Pattern】（博主）,

    动态代理类的字节码是在程序运行时由Java反射机制动态生成。

    注意： 
      一、AspectJ是采用编译时生成AOP代理类，具备更好的性能,可是须要使用特定的编译器进行处理

      二、Spring AOP采用运行时生成AOP代理类,无需使用特定编译器进行处理,可是性能相对于AspectJ较差

2、JDK动态代理 [对有实现接口的对象作代理]

    一、JDK动态代理中 须要了解的两个重要的类或接口 [InvocationHandler 和 Proxy]

         ① InvocationHandler接口

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

参数说明： 
Object proxy：指被代理的对象 
Method method：咱们所要调用被代理对象的某个方法的Method对象
Object[] args：被代理对象某个方法调用时所须要的参数 

能够将InvocationHandler接口的子类想象成一个代理的最终操做类。

说明：每个动态代理类都必需要实现InvocationHandler这个接口，而且每一个代理类（Proxy）的实例都关联到了一个handler，当咱们经过代理对象调用一个方法的时候，这个方法的调用就会被转发为由InvocationHandler这个接口的 invoke 方法来进行调用。同时在invoke的方法里 咱们能够对被代理对象的方法调用作加强处理(如添加事务、日志、权限验证等操做)。

         ② Proxy类

 Proxy类是专门完成代理的操做类，能够经过此类为一个或多个接口动态地生成实现类，该类经常使用的调用方法以下：

 

newProxyInstance方法参数说明以下：

ClassLoader loader：类加载器，定义了由哪一个ClassLoader对象来对生成的代理对象进行加载
Class<?>[] interfaces：获得被代理类所有的接口，若是我提供了一组接口给它，那么这个代理对象就宣称实现了该接口，这样我就能调用这组接口中的方法了
InvocationHandler h：获得InvocationHandler接口的子类实例 

    二、JDK动态代理代码示例：

首先咱们定义了一个Subject类型的接口:Subject.java

public interface Subject {  
    public void visit();  
}

接着定义一个接口的实现类，这个类就是咱们示例中的被代理对象：RealSubject.java

/** 
 * 被代理类 
 * @author lvzb.software@qq.com 
 * 
 */  
public class RealSubject implements Subject {  
  
    @Override  
    public void visit() {  
         System.out.println("I am 'RealSubject',I am the execution method");  
    }  
  
}

第三步 定义一个动态代理类（必需要实现 InvocationHandler 这个接口）：DynamicProxy.java

import java.lang.reflect.InvocationHandler;  
import java.lang.reflect.Method;  
/** 
 * JDK动态代理类 
 * @author lvzb.software@qq.com 
 * 
 */  
public class DynamicProxy implements InvocationHandler {  
  
    // 咱们要代理的真实对象(委托对象)  
    private Object subject;  
      
    // 构造方法，给咱们要代理的真实对象赋初值  
    public DynamicProxy(Object obj){  
        this.subject = obj;  
    }  
      
    @Override  
    public Object invoke(Object object, Method method, Object[] args)  
            throws Throwable {  
        // 在代理真实对象操做前 咱们能够添加一些本身的操做  
        System.out.println("before proxy invoke");  
          
        // 当代理对象调用真实对象的方法时，其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用  
        method.invoke(subject, args);  
          
        // 在代理真实对象操做后 咱们也能够添加一些本身的操做  
        System.out.println("after proxy invoke");  
        return null;  
    }  
  
}

最后代理测试类：Client.java

import java.lang.reflect.InvocationHandler;  
import java.lang.reflect.Proxy;  
  
public class Client {  
  
    public static void main(String[] args) {  
        // 咱们要代理的真实对象  
        Subject realSubject = new RealSubject();  
        // 咱们要代理哪一个真实对象，就将该对象传进去，最后是经过该真实对象调用方法的  
        InvocationHandler handler = new DynamicProxy(realSubject);  
        /* 
         * 经过Proxy的newProxyInstance方法来动态建立咱们的代理对象，咱们来看看其三个参数< 
         * 参数一：咱们这里使用handler这个类的ClassLoader对象来加载咱们的代理对象 
         * 参数二：咱们这里为代理对象提供的接口是真实对象所实行的接口，表示我要代理的是该真实对象，这样我就能调用这组接口中的方法了 
         * 参数三：咱们这里将这个代理对象关联到了上方的 InvocationHandler 这个对象上 
         */  
        Subject proxyInstance = (Subject)Proxy.newProxyInstance(handler.getClass().getClassLoader(),   
                RealSubject.class.getInterfaces(),   
                handler);  
          
        System.out.println(proxyInstance.getClass().getName());  
        proxyInstance.visit();  
  
    }  
  
}

运行->控制台输出结果以下：

com.sun.proxy.$Proxy0  
before proxy invoke  
I am 'RealSubject',I am the execution method  
after proxy invoke

3、Cglib（Code Generation Library）动态代理 [对没有实现接口的普通类作代理]

     一、概述：

         Cglib是一个优秀的动态代理框架，它的底层使用ASM（JAVA字节码处理框架）在内存中动态的生成被代理类的子类。使用CGLIB即便被代理类没有实现任何接 也能够实现动态代理功能。可是不能对final修饰的类进行代理。

     二、原理：

         经过字节码技术为一个类建立子类，并在子类中采用方法拦截的技术拦截全部父类方法的调用。

         <JDK动态代理与CGLib动态代理均是实现Spring AOP的基础>

     三、使用：

          使用Cglib前须要导入如下两个jar文件：
          asm.jar – Cglib的底层实现。

        【cglib包的底层是使用字节码处理框架ASM来转换字节码并生成新的类，因此cglib包要依赖于asm包】
          cglib.jar - Cglib的核心jar包。

     四、Cglib动态代理代码示例：

首先定义一个没有实现接口的代理委托类：CglibRealSubject.java

/** 
 * 没有实现接口的代理委托类 
 * @author lvzb.software@qq.com 
 * 
 */  
public class CglibRealSubject{  
  
    public void visit() {  
        System.out.println("I am 'RealSubject',I am the execution method");  
    }  
  
}

接着定义一个Cglib动态代理类: CglibDynamicProxy.java

import java.lang.reflect.Method;  
  
import net.sf.cglib.proxy.Enhancer;  
import net.sf.cglib.proxy.MethodInterceptor;  
import net.sf.cglib.proxy.MethodProxy;  
/** 
 * 使用cglib动态代理 
 * @author lvzb.software@qq.com 
 * 
 */  
public class CglibDynamicProxy implements MethodInterceptor {  
  
    private Object target;  
      
    /** 
     * 建立代理对象 
     * @param target 被代理的对象 
     * @return 
     */  
    public Object getProxyInstance(Object target){  
        this.target = target;  
        // 声明加强类实例  
        Enhancer enhancer = new Enhancer();   
        // 设置被代理类字节码，CGLIB根据字节码生成被代理类的子类  
                enhancer.setSuperclass(this.target.getClass());    
                // 设置要代理的拦截器，回调函数，即一个方法拦截   new MethodInterceptor()  
                enhancer.setCallback(this);   
                // 建立代理对象 实例   
                return enhancer.create();    
    }  
      
    @Override  
    public Object intercept(Object obj, Method method, Object[] args,  
            MethodProxy proxy) throws Throwable {  
        // 在代理真实对象操做前 咱们能够添加一些本身的操做  
        System.out.println("前置代理,加强处理");  
          
        proxy.invokeSuper(obj, args);  
          
        // 在代理真实对象操做后 咱们也能够添加一些本身的操做  
        System.out.println("后置代理,加强处理");  
        return null;  
    }  
  
}

最后测试客户端类：CglibClient.java

public class CglibClient {  
  
    public static void main(String[] args) {  
        CglibDynamicProxy cglib = new CglibDynamicProxy();  
        CglibRealSubject realSubject = (CglibRealSubject) cglib.getProxyInstance(new CglibRealSubject());  
        realSubject.visit();  
    }  
  
}

运行->控制台输出结果以下：

前置代理,加强处理  
I am 'RealSubject',I am the execution method  
后置代理,加强处理