JDK代理和CGLIB代理的区别

一．概念

        代理是什么呢？举个例子，一个公司是卖摄像头的，但公司不直接跟用户打交道，而是通过代理商跟用户打交道。如果：公司接口中有一个卖产品的方法，那么公司需要实现这个方法，而代理商也必须实现这个方法。如果公司卖多少钱，代理商也卖多少钱，那么代理商就赚不了钱。所以代理商在调用公司的卖方法后，加上自己的利润然后再把产品卖给客户。而客户部直接跟公司打交道，或者客户根本不知道公司的存在，然而客户最终却买到了产品。

专业点说：代理模式是常用的java设计模式，代理模式给某一个对象提供代理，并由代理对象控制原对象（目标对象，被代理对象）的引用。简单点说，就是通过一个工厂生成一个类的代理对象，当客户端使用的时候不直接使用目标对象，而是直接使用代理对象。

二．jdk的静态代理

       首先看一下静态代理： 
        /**
          * 定义一个账户接口
          */ 
         public interface Count { 
            // 查看账户方法 
           public void queryCount(); 
           // 修改账户方法 
           public void updateCount(); 
         }

        /**
          * 目标对象(包含业务逻辑)
          */ 
 public class CountImpl implements Count { 
     @Override 
     public void queryCount() { 
         System.out.println("查看账户方法..."); 
     } 
     @Override 
     public void updateCount() { 
         System.out.println("修改账户方法..."); 
     } 
 }

为目标对象创建代理对象：CountProxy.java代理对象持有目标对象的引用。

 /**
  * 这是一个代理类（增强CountImpl实现类）
  */ 
 public class CountProxy implements Count { 
     private CountImpl countImpl; 
     /**
      * 覆盖默认构造器
      */ 
     public CountProxy(CountImpl countImpl) { 
         this.countImpl = countImpl; 
     } 
     @Override 
     public void queryCount() { 
         System.out.println("事务处理之前"); 
         // 调用委托类的方法; 
         countImpl.queryCount(); 
         System.out.println("事务处理之后"); 
     } 
     @Override 
     public void updateCount() { 
         System.out.println("事务处理之前"); 
         // 调用委托类的方法; 
         countImpl.updateCount(); 
         System.out.println("事务处理之后"); 
     } 
 } 
TestCount.java

 /**
   * 测试Count类
   */ 
 public class TestCount { 
     public static void main(String[] args) { 
         CountProxy countProxy = new CountProxy(new CountImpl()); 
         countProxy.updateCount(); 
         countProxy.queryCount(); 
     } 
 }

        用法：

               1、目标对象和代理对象都要实现相同的接口。

               2、代理对象持有目标对象的引用。

        缺点

               1、需要建大量的代理类。

               2、违背了重复代码只写一次的原则。

一．jdk动态代理

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

       Jdk的动态要求目标对象必须实现接口，因为它创建代理对象的时候是根据接口创建的。如果不实现接口，jdk无法给目标对象创建代理对象。被代理对象可以可以实现多个接口，创建代理时指定创建某个接口的代理对象就可以调用该接口定义的方法了。是Spring AOP代理的默认方式。

动态代理示例:     

1、定义一个接口

public interface BookFacade { 
    public void addBook(); 
}

2、接口实现类

 public class BookFacadeImpl implements BookFacade { 
    @Override 
    public void addBook() { 
        System.out.println("增加图书方法。。。"); 
     } 
 }

3、提供一个生成代理对象的的类

 /**
   * JDK动态代理代理类
   */ 
  public class BookFacadeProxy implements InvocationHandler { 
      private Object target; 
      /**
       * 绑定委托对象并返回一个代理类
       */ 
      public Object newInstance(Object target) { 
          this.target = target; 
          //取得代理对象 
          return Proxy.newProxyInstance(target.getClass().getClassLoader(), 
                  target.getClass().getInterfaces(), this);   //要绑定接口(这是一个缺陷，cglib弥补了这一缺陷) 
      } 
      @Override 
      public Object invoke(Object proxy, Method method, Object[] args) 
              throws Throwable { 
          Object result=null; 
          System.out.println("事物开始"); 
          //执行方法 
          result=method.invoke(target, args); 
          System.out.println("事物结束"); 
          return result; 
      } 
  }

4、TestProxy.java

 public class TestProxy { 
    public static void main(String[] args) { 
         BookFacadeProxy proxy = new BookFacadeProxy(); 
         BookFacade bookProxy = (BookFacade) proxy.newInstance(new BookFacadeImpl()); 
         bookProxy.addBook(); 
     } 
 }

 

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

动态代理了。

二．cglib 动态代理

        jdk给目标类提供动态要求目标类必须实现接口，当一个目标类不实现接口时，jdk是无法为其提供动态代理的。cglib 却能给这样的类提供动态代理。Spring在给某个类提供动态代理时会自动在jdk动态代理和cglib动态代理中动态的选择。

使用cglib为目标类提供动态代理：需要导入cglib.jar和asm.jar

如果出现asm中的类无法找到的异常，在java工程中是真的缺少asm.jar，而在web工程中很可能是asm.jar和spring提供的org.springframework.asm-3.0.4.RELEASE.jar包冲突。

       cglib是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法。
因为是继承，所以该类或方法最好不要声明成final

示例：

1、定义一个接口

public interface BookFacade {
     public void addBook();
}

2、接口实现类

public class BookFacadeImpl implements BookFacade {
      @Override
      public void addBook() {
            System.out.println("增加图书方法。。。");
      }
}

3、创建一个代理工厂，用于生成目标类的代理对象

/**
  * 使用cglib动态代理
  * 
  * @author student
  * 
  */ 
 public class BookFacadeCglib 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("事物开始"); 
         proxy.invokeSuper(obj, args); 
         System.out.println("事物结束"); 
         return null;  
   }  
 } 

4、TestCglib.java

 public class TestCglib { 
     public static void main(String[] args) { 
         BookFacadeCglib cglib=new BookFacadeCglib(); 
         BookFacadeImpl1 bookCglib=(BookFacadeImpl1)cglib.getInstance(new BookFacadeImpl1()); 
         bookCglib.addBook(); 
     } 
  }

总结：CGLib所创建的动态代理对象的性能比JDK的高大概10倍，但CGLib在创建代理对象的时间比JDK大概多8倍，所以对于singleton的代理对象或者具有实例池的代理，因为无需重复的创建代理对象，所以比较适合CGLib动态代理技术，反之选择JDK代理。值得一提的是由于CGLib采用动态创建子类的方式生成代理对象，所以不能对目标类中final的方法进行代理。