欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

Java设计模式之动态代理

程序员文章站 2024-03-01 19:46:52
动态代理的意义在于生成一个占位(又称代理对象),来代理真实对象,从而控制真实对象的访问。 我们首先来谈谈什么是代理模式。假设客户带着需求去找公司,显然不会直接和软件工程师...

动态代理的意义在于生成一个占位(又称代理对象),来代理真实对象,从而控制真实对象的访问。

我们首先来谈谈什么是代理模式。假设客户带着需求去找公司,显然不会直接和软件工程师谈,而是和商务谈,此时客户会认为商务就代表公司,客户是通过商务去访问软件工程师的。我们就可以认为商务(代理对象)代理了软件工程师(真实对象),因此,代理的作用就是,在真实对象访问之前或者之后加入对应的逻辑,或者根据其他规则控制是否使用真实对象。

商务和软件工程师是代理和被代理的关系,客户是通过商务去访问软件工程师的。此时客户就是程序中的调用者,商务就是代理对象,软件工程师就是真实对象。我们需要在调用者调用对象之前产生一个代理对象,而这个代理对象需要和真实对象建立代理关系,所以代理必须分为两个步骤:

  • 代理对象和真实对象建立代理关系
  • 实现代理对象的代理逻辑方法

在java中有多种动态代理技术,比如jdk、cglib、javassist、asm,其中最常用的动态代理技术有两种:一种是jdk动态代理,这是jdk自带的功能;另一种是cglib,这是第三方提供的一个技术。目前,spring常用jdk和cglib,而mybatis还使用了javassist。(cglib的底层原理是asm)

本文只讨论两种最常用的动态代理技术:jdk和cglib。在jdk动态代理中必须使用接口,而cglib不需要,所以使用cglib会更简单一点。下面依次讨论这两种技术。

一.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
调用真实对象后

个人小结:cglib动态代理相对简单一些,通过字节码技术为需要代理的类生成一个子类,它不需要提供接口,只需写一个代理逻辑类并实现methodinterceptor接口,其中getproxy方法用于生成代理对象,然后重写intercept方法即可。

总结

以上就是这篇文章的全部内容了,希望本文的内容对大家的学习或者工作具有一定的参考学习价值,谢谢大家对的支持。如果你想了解更多相关内容请查看下面相关链接