Java设中动态代理的原理是什么

这期内容当中小编将会给大家带来有关Java设中动态代理的原理是什么，文章内容丰富且以专业的角度为大家分析和叙述，阅读完这篇文章希望大家可以有所收获。

创新互联公司是一家以网站建设、网页设计、品牌设计、软件运维、成都网站营销、小程序App开发等移动开发为一体互联网公司。已累计为集装箱等众行业中小客户提供优质的互联网建站和软件开发服务。

一.JDK动态代理

JDK动态代理是java.lang.reflect.*包提供的方式。它必须借助一个接口才能产生代理对象，所以先定义接口HelloWorld：

public interface HelloWorld {
  void sayHelloWorld();
}

然后提供实现类HelloWorldImpl来实现接口：

public class HelloWorldImpl implements HelloWorld {
  @Override
  public void sayHelloWorld(){
    System.out.println("Hello World");
  }
}

这是最简答的Java接口和实现类的关系，此时可以开始动态代理了。按照我们之前的分析，先要建立代理对象和真实对象的关系，然后实现代理逻辑，所以一共分为两个步骤。在JDK动态代理中，代理逻辑类必须去实现java.lang.reflect.InvocationHandler接口，它定义了一个invoke方法，并提供接口数组用于下挂代理对象。我们自己定义一个JDK动态代理的类：

public class MyJdkProxyExample implements InvocationHandler{
  /**
   * @description 真实对象
   **/
  private Object target = null;
  /**
   * @author haozz
   * @date 2018-05-21 10:54
   * @param target 真实对象
   * @return 代理对象
   * @throws
   * @description 建立代理对象和真实对象的代理关系，并返回代理对象
   **/
  public Object getProxy(Object target) {
    this.target = target;
    return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
  }
  /**
   * @author haozz
   * @date 2018-05-21 11:09
   * @param proxy 代理对象
   * @param method 当前调度方法
   * @param args 当前方法参数
   * @return 代理结果
   * @throws Throwable 异常
   * @description 代理方法逻辑
   **/
  @Override
  public Object invoke(Object proxy, Method method,Object [] args) throws Throwable{
    System.out.println("进入代理逻辑方法");
    System.out.println("在调度真实对象之前的服务");
    Object obj = method.invoke(target,args);//相当于调用sayHelloWorld方法
    System.out.println("在调度真实对象之后的服务");
    return obj;
  }
}

第一步，通过getProxy()方法建立代理对象和真实对象的关系，并返回代理对象。首先用类的属性target保存了真实对象，然后通过Proxy.newProxyInstance()方法建立并生成代理对象，该方法中包含3个参数：

第1个是类加载器，这里采用了target本身的类加载器；
第2个是把生成的动态代理对象下挂在哪些接口下，这个写法就是放在target实现的接口下。HelloWorldImpl对象的接口显然就是HelloWorld，代理对象可以这样声明：HelloWorld proxy = xxxx;；
第3个是定义实现方法逻辑的代理类，this表示当前对象，它必须实现InvocationHandler接口的invoke方法，它就是代理逻辑方法的现实方法。

第二步，通过invoke方法实现代理逻辑方法。invoke方法的3个参数：

proxy，代理对象，就是getProxy方法生成的对象；
method，当前调度的方法；
args，当前调度方法的参数。

当我们使用了代理对象调度方法后，它就会进入到invoke方法里面。

Object obj = method.invoke(target,args);

这行代码相当于调度真实对象的方法，只是通过反射实现。类比前面的例子，proxy相当于商务，target相当于软件工程师，getProxy方法就是建立商务和软件工程师之间的代理关系，invoke方法就是商务逻辑。

测试JDK动态代理：

  @Test
  public void testJdkProxy(){
    MyJdkProxyExample jdkProxy = new MyJdkProxyExample();
    //绑定关系，因为挂在接口HelloWorld下，所以声明代理对象HelloWorld proxy
    HelloWorld proxy = (HelloWorld) jdkProxy.getProxy(new HelloWorldImpl());
    //此时HelloWorld对象已经是一个代理对象，它会进入代理的逻辑方法invoke里
    proxy.sayHelloWorld();
  }

首先通过getProxy方法绑定了代理关系，然后在代理对象调度sayHelloWorld方法时进入了代理的逻辑，测试结果如下：

进入代理逻辑方法
在调度真实对象之前的服务
Hello World
在调度真实对象之后的服务

此时，在调度打印Hello World之前和之后都可以加入相关的逻辑，甚至可以不调度Hello World的打印。

个人小结：JDK动态代理要求真实对象和代理对象之间是实现类和接口的关系，创建一个代理逻辑类实现InvocationHandler接口，其中getProxy方法用于生成代理对象，然后重写invoke方法。

二.CGLIB动态代理

JDK动态代理必须提供接口才能使用，在一些不能提供接口的环境中，只能采用其他第三方技术，比如CGLIB动态代理，这里提供CGLIB动态代理的相关jar包，供学习和测试使用。它的优势在于不需要提供接口，只要一个非抽象类就能实现动态代理。

CGLIB原理：动态生成一个要代理类的子类，子类重写要代理的类的所有不是final的方法。在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势织入横切逻辑。它比使用java反射的JDK动态代理要快。CGLIB底层：使用字节码处理框架ASM，来转换字节码并生成新的类。不鼓励直接使用ASM，因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉。CGLIB缺点：对于final方法，无法进行代理。CGLIB广泛地被许多AOP的框架使用，例如Spring AOP和dynaop。Hibernate使用CGLIB来代理单端single-ended(多对一和一对一)关联。

我们以下面这个类为例：

public class ReflectServiceImpl {
  public void sayHello(String name){
    System.out.println("Hello "+name);
  }
}

它不存在实现任何接口，所以不能使用JDK动态代理，这里采用CGLIB动态代理技术：

public class MyCglibProxyExample implements MethodInterceptor{
  /**
   * @author haozz
   * @date 2018-05-21 15:11
   * @param cls Class类
   * @return Class类的CGLIB对象
   * @throws
   * @description 生成CGLIB代理对象
   **/
  public Object getProxy(Class cls){
    //CGLIB增强类对象
    Enhancer enhancer = new Enhancer();
    //设置增强类型
    enhancer.setSuperclass(cls);
    //定义代理逻辑对象为当前对象，要求当前对象实现MethodInterceptor方法
    enhancer.setCallback(this);
    //生成并返回代理对象
    return enhancer.create();
  }
  /**
   * @author haozz
   * @date 2018-05-21 15:17
   * @param proxy 代理对象
   * @param method 目标方法
   * @param args 目标方法参数
   * @param methodProxy 方法代理
   * @return 代理逻辑返回
   * @throws Throwable 异常
   * @description 代理逻辑方法
   **/
  @Override
  public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy)throws Throwable{
    System.out.println("调用真实对象前");
    //CGLIB反射调用真实对象方法
    Object result = methodProxy.invokeSuper(proxy,args);
    System.out.println("调用真实对象后");
    return result;
  }
}

这里用了CGLIB的加强者Enhancer（net.sf.sglib.proxy.Enhancer），通过设置超类的方法（setSuperclass），然后通过setCallback方法设置哪个类为它的代理类。其中，参数this表示当前对象，那就要求用this这个对象实现接口MethodInterceptor（net.sf.sglib.proxy.MethodInterceptor）的方法intercept，然后返回代理对象。那么此时当前类的intercept方法就是其代理逻辑方法，其参数内容见代码注解，我们在反射真实对象方法前后进行了打印，CGLIB是通过如下代码完成的：

Object result = methodProxy.invokeSuper(proxy,args);

测试一下CGLIB动态代理：

  @Test
  public void testCglibProxy(){
    MyCglibProxyExample cglibProxy = new MyCglibProxyExample();
    ReflectServiceImpl obj = (ReflectServiceImpl) cglibProxy.getProxy(ReflectServiceImpl.class);
    obj.sayHello("haozz");
  }

得到结果：

调用真实对象前
Hello haozz
调用真实对象后

上述就是小编为大家分享的Java设中动态代理的原理是什么了，如果刚好有类似的疑惑，不妨参照上述分析进行理解。如果想知道更多相关知识，欢迎关注创新互联行业资讯频道。

文章题目：Java设中动态代理的原理是什么
URL分享：http://cdiso.cn/article/pogcgc.html

Java设中动态代理的原理是什么

其他资讯