Java静态代理&动态代理&Cglib代理详解

一、静态代理

根据被代理的类的时机的不同，如果在编译阶段就能确定下来的被代理的类是哪一个，那么，就可以使用静态代理的方式。

申明一个接口：

 /**
  * @author jiaqing.xu@hand-china.com
  * @version 1.0
  * @name
  * @description
  * @date 2018/7/23
  */
 public interface Person {
     void sayHello(String content, int age);
 }

实现类，即需要被代理的类：

 /**
  * @author jiaqing.xu@hand-china.com
  * @version 1.0
  * @name
  * @description 需要被代理的类 实现接口
  * @date 2018/7/23
  */
 public class Student implements Person {
     @Override
     public void sayHello(String content, int age) {
         System.out.println("student say hello " + content + " "+ age);
     }
 }

实现类：

 /**
  * @author jiaqing.xu@hand-china.com
  * @version 1.0
  * @name
  * @description
  * @date 2018/7/23
  */
 public class StaticProxyTest implements Person{
     //接口对象
     private Person o;

     public StaticProxyTest(Person o){
         this.o = o;
     }

     public static void main(String[] args) {
         // TODO Auto-generated method stub
         //s为被代理的对象，某些情况下 我们不希望修改已有的代码，我们采用代理来间接访问
         //在代理类中引入被代理的对象
         Student s = new Student();
         //创建代理类对象 s是接口的实例
         StaticProxyTest proxy = new StaticProxyTest(s);
         //调用代理类对象的方法
         proxy.sayHello("welcome to java", 20);
     }

     @Override
     public void sayHello(String content, int age) {
         // TODO Auto-generated method stub
         System.out.println("ProxyTest sayHello begin");
         //在代理类的方法中 间接访问被代理对象的方法
         o.sayHello(content, age);
         System.out.println("ProxyTest sayHello end");
     }
 }

二、动态代理

如果不能在代码的编译阶段就去确定需要代理的类是哪一个的话，就可以使用类的动态代理机制，在代码运行期间去动态加载类的信息。

Java动态代理和Cglib方式的代理的重要区别：

Java动态代理只能对接口进行代理，如果要代理的类是一个普通的类，没有接口则需要使用Cglib来实现。
Java动态代理是利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。
Cglib动态代理是利用asm开源包，对代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。

创建接口：

 /**
  * @author jiaqing.xu@hand-china.com
  * @version 1.0
  * @name
  * @description
  * @date 2018/7/23
  */
 public interface IStudent {
     void action();
 }

 /**
  * @author jiaqing.xu@hand-china.com
  * @version 1.0
  * @name
  * @description
  * @date 2018/7/23
  */
 public class StudentImpl implements IStudent{
     @Override
     public void action() {
         System.out.println("Student action");
     }
 }

基于jdk的动态代理 该动态代理一定要实现InvocationHandler

 /**
  * @author jiaqing.xu@hand-china.com
  * @version 1.0
  * @name
  * @description 基于jdk的动态代理 该动态代理一定要实现InvocationHandler
  * @date 2018/7/23
  */
 public class JavaProxy implements InvocationHandler {
     private Object target;

     /**
      * 绑定委托对象并返回一个代理类
      *
      * @param target
      * @return
      */
     public Object bind(Object target) {
         this.target = target;
         return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this); // 要绑定接口
     }

     @Override
     public Object invoke(Object proxy, Method method, Object[] args)
             throws Throwable {
         Object result;
         //在这里可以做拦截前的操作
         System.out.println("【java代理】调用实际方法前");
         // 执行方法
         result = method.invoke(target, args);
         //在这里可以做拦截后的操作
         System.out.println("【java代理】调用实际方法后");
         return result;
     }
 }

 /**
  * @author jiaqing.xu@hand-china.com
  * @version 1.0
  * @name
  * @description
  * @date 2018/7/23
  */
 public class TestProxy {
     public static void main(String[] args) {
         //创建代理对象
         JavaProxy proxy = new JavaProxy();
         //绑定接口对象
         IStudent student = (IStudent) proxy.bind(new StudentImpl());
         //调用接口方法
         student.action();
     }
 }

三、基于cglib的动态代理

可以对任何的普通类进行代理

 /**
  * @author jiaqing.xu@hand-china.com
  * @version 1.0
  * @name
  * @description 一个普通类
  * @date 2018/7/23
  */
 public class StudentImpl {
     public void action() {
         System.out.println("[Student]实际方法。。。");
     }
 }

代理类要去实现MethosInterceptor接口：

 /**
  * @author jiaqing.xu@hand-china.com
  * @version 1.0
  * @name
  * @description
  * @date 2018/7/23
  */
 public class CgLibProxy implements MethodInterceptor {
     private Object target;

     /**
      * 创建代理对象
      *
      * @param target
      * @return
      */
     public Object getInstance(Object target) {
         this.target = target;
         Enhancer enhancer = new Enhancer();
         enhancer.setSuperclass(this.target.getClass());
         // 回调方法
         enhancer.setCallback(this);
         // 创建代理对象
         return enhancer.create();
     }

     // 回调方法 拦截方法 在调用具体的业务逻辑前和后 进行其他的相关处理
     @Override
     public Object intercept(Object obj, Method method, Object[] args,
                             MethodProxy proxy) throws Throwable {
         System.out.println("[cglib代理]调用实际方法前");
         proxy.invokeSuper(obj, args);
         System.out.println("[cglib代理]调用实际方法后");
         return null;
     }
 }

 /**
  * @author jiaqing.xu@hand-china.com
  * @version 1.0
  * @name
  * @description
  * @date 2018/7/23
  */
 public class TestProxy {
     public static void main(String[] args) {
         CgLibProxy cglib = new CgLibProxy();
         StudentImpl student = (StudentImpl) cglib.getInstance(new StudentImpl());
         student.action();
     }
 }