JDK和Cglib动态代理

Posted 2021-01-16 zhaosq

一:动态代理的引入

   Spring中的两大核心之一的 AOP是基于 动态代理实现的,简单来说就是面向切面编程.Spring AOP的实现对于接口来说就是使用的JDK的动态代理来实现的，而对于类的代理使用CGLIB来实现。

二动态代理的概念

    代理类在程序运行时创建的代理方式被成为 动态代理.也就是说，这种情况下，代理类并不是在Java代码中定义的，而是在运行时根据我们在Java代码中的“指示”动态生成的。代理模式最大的特点就是代理类和实际业务类实现同一个接口（或继承同一父类），代理对象持有一个实际对象的引用，外部调用时操作的是代理对象，而在代理对象的内部实现中又会去调用实际对象的操作，Java动态代理其实内部也是通过Java反射机制来实现的，即已知的一个对象，然后在运行时动态调用其方法，这样在调用前后作一些相应的处理。

三:JDK动态代理的原理

  JDK的动态代理，就是在程序运行的过程中，根据被代理的接口来动态生成代理类的class文件，并加载运行的过程。代理的目的是调用目标方法时可以转而执行InvocationHandler拦截器的invoke方法以及类的反射，实际上spring aop也是在这里做文章。这也是典型的代理模式 。

四:JDK动态代理的实现

  1>首先有一个实现了InvocationHandler接口的类

package com.svse.daili.jdk_cglib;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
*JDK的动态代理对象
*前提：被代理的类实现了接口才可以进行代理
*原理：利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用invokeHandler的invoke()方法来处理
*InvocationHandler其实底层为一个拦截器
*/
public class JDKProxy implements InvocationHandler
{
    private Object targetObject;//需要代理的目标对象

   public JDKProxy(Object targetObject){
   this.targetObject=targetObject;
   }

   public Object proxyObject()
  {
    // 三个参数 (被加载的类、代理的接口、代理的目标对象)
   // newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
   return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),
   targetObject.getClass().getInterfaces(), this);//返回代理对象
   }

   @Override
   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
   {
   checkPopedom();
   Object rs=null;
   rs=method.invoke(targetObject, args);
  return rs;
  }

   private void checkPopedom(){
   System.out.println("...模拟检测权限 checkPopedom()");
    }
  }

   2>定义一个接口

  package com.svse.daili.jdk_cglib;
  public interface UserManager
  {
  public void addUser(String id,String password);
  public void delUser(String id);
  }

   3>定义一个实现该接口的类

  package com.svse.daili.jdk_cglib;
  public class UserManagerImpl implements UserManager
  {

    @Override
    public void addUser(String id, String password)
    {
       System.out.println("...调用了UserManagerImpl的addUser()方法");
    }

    @Override
    public void delUser(String id)
   {
     System.out.println("...调用了UserManagerImpl的delUser()方法");

    }
  }

  4>测试类

package com.svse.daili.jdk_cglib;
/**
* 测试代理对象
* @author Administrator
*
*/
public class JDKProxyTest
{
   public static void main(String[] args)
   {
      JDKProxy jdkProxy=new JDKProxy(new UserManagerImpl());
      UserManager proxyManager=(UserManager) jdkProxy.proxyObject();//返回代理对象
      System.out.println("-----------------JDK动态代理----------------");
      proxyManager.addUser("", "");
     proxyManager.delUser("");
    }
}

  5>测试结果

6>疑问?为什么jdk动态代理必须基于接口   原因如下： 

   1)、生成的代理类继承了Proxy，由于java是单继承，所以只能实现接口，通过接口实现 
   2)、从代理模式的设计来说，充分利用了java的多态特性，也符合基于接口编码的规范 
  当然，jdk在生成代理的参数中也说明了，需要传入对应接口。

五:Cglib动态代理的原理

      利用字节码处理框架ASM开源包，主要是对指定的类生成一个子类，覆盖其中的所有方法，将代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。该类或方法不能声明为final。

六:Cglib动态代理的实现

  1>创建一个类并实现MethodInterceptor接口

package com.svse.daili.cglib;
import java.lang.reflect.Method;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
/**
* cglib动态代理 (需要引入asm.jar 和cglib.jar)
* @author Administrator
*
*/
public class CglibProxy implements MethodInterceptor
{
     private Object targetObject;

     public CglibProxy(Object obj){
     this.targetObject=obj;
    }

    public Object createProxyObject(){
      Enhancer enhancer=new Enhancer();
      enhancer.setSuperclass(targetObject.getClass());
      enhancer.setCallback(this);
      Object proxyObj=enhancer.create();
      return proxyObj;//返回代理对象
    }

   public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable
   {
    if("sayHello".equals(method.getName())){
       checkPopedom();
    }
     Object obj=null;
     obj=method.invoke(targetObject, args);
     return obj;
    }

     private void checkPopedom(){
     System.out.println("...模拟检测权限 checkPopedom()");
   }
 }

  2>创建一个代理类

package com.svse.daili.cglib;

public class StudentManager {
public void sayHello(){
     System.out.println("...调用了StudentManager类的sayHello()方法");
  }
}

3>测试类

package com.svse.daili.cglib;
public class CglixProxyTest
{

    //过程中遇到的问题：如果cglib.jar 版本为3.0以上，可能会报类找不到，原因跟asm.jar版本冲突
    public static void main(String[] args) {
        CglibProxy cglibProxy=new CglibProxy(new StudentManager());
        StudentManager studentProxy=(StudentManager) cglibProxy.createProxyObject();
        System.out.println("-----------------Cglix动态代理----------------");
        studentProxy.sayHello();
      }
  }

4>测试结果

  

 

七:jdk代理与cglib代理的区别

   （1）JDK动态代理只能对实现了接口的类生成代理，而不能针对普通类

    （2）CGLIB是针对普通类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法,因为是继承，所以CGLib不能对声明为final的方法进行代理,因为CGLib原理是动态生成被代理类的子类

      (3)JDK代理是不需要以来第三方的库，只需要JDK环境就可以进行代理,CGLib 必须依赖于CGLib的类库(asm和cglib)

      (4)JDK代理类必须实现InvocationHandler接口 ,通过Proxy.newProxyInstance产生代理对象;而CGLIB是实现MethodInterceptor接口,通过cglibProxy.createProxyObject()产生代理对象

      (5)在AOP中,如果目标对象实现了接口，默认情况下会采用JDK的动态代理实现AOP,也可以强制使用CGLIB实现AOP;如果目标对象没有实现了接口，必须采用CGLIB库进行代理，spring会自动在JDK动态代理和CGLIB之间转换

八:二者优缺点分析

   （1） 使用JDK动态代理,目标类必须实现的某个接口,如果某个类没有实现接口则不能生成代理对象。

   （2）CGLib采用了非常底层的字节码技术,其原理是通过字节码技术为一个类创建子类,并在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势织入横切逻辑。因为是覆盖其中的所有方法,所以目标类和方法不能声明为final类型。

    (3)从执行效率上看,Cglib动态代理效率较高。JDK动态代理与CGLib动态代理均是实现Spring AOP的基础。

    (4) CGLib创建的动态代理对象性能比JDK创建的动态代理对象的性能高不少，但是CGLib在创建代理对象时所花费的时间却比JDK多得多，所以对于单例的对象，因为无需频繁创建对象，用CGLib合适，反之，使用JDK方式要更为合适一些。同时，由于CGLib是采用动态创建子类的方法，对于final方法，无法进行代理