设计模式——代理模式

---

平时我们使用的框架中非常频繁地使用了动态代理。可以说如果一个框架不使用动态代理的话，这个框架不太可能做成一个通用的框架。因此动态代理的知识是我们必须要掌握的知识。

本博客是网络转载的，原文请点击

---

代理模式简介

proxy代理模式是一种结构型设计模式，主要解决的问题是：在直接访问对象时带来的问题。（某些对象只想提供部分方法让外部对象访问）

代理模式是一种常用的结构型设计模式，其目的就是为其他对象提供一个代理以控制对某个对象的访问。代理类负责为委托类预处理消息（beforeadvice），过滤消息并转发消息，以及进行消息被委托类执行后的后续处理（afteradvice）

为了保持行为的一致性，代理类和委托类通常会实现相同的接口，所以在访问者看来两者没有丝毫的区别。通过代理类这中间一层，能有效控制对委托类对象的直接访问，也可以很好地隐藏和保护委托类对象，同时也为实施不同控制策略预留了空间，从而在设计上获得了更大的灵活性。

更通俗的说，代理解决的问题当两个类需要通信时，引入第三方代理类，将两个类的关系解耦，让我们只了解代理类即可，而且代理的出现还可以让我们完成与另一个类之间的关系的统一管理，但是切记，代理类和委托类要实现相同的接口，因为代理真正调用的还是委托类的方法。

使用场景

• 方法增强（添加注解实现一些额外的功能）
• aop等

代理模式分类

按照代理的创建时期，代理类可以分为两种：

• 静态代理：由程序员创建代理类或特定工具自动生成源代码再对其编译。在程序运行前代理类的.class文件就已经存在了。（代理类在程序编译前就已经存在）
• 动态代理：代理类在程序运行时运用反射机制动态创建而成。（代理类运行时动态生成）

下面分别用静态代理与动态代理演示一个示例：添加打印日志的功能，即每个方法调用之前和调用之后写入日志。

静态代理

具体用户管理实现类——usermanager接口相当于subject角色，usermanagerimpl相当于realsubject角色

public class usermanagerimpl implements usermanager {
 
    @override
    public void adduser(string userid, string username) {
        system.out.println("usermanagerimpl.adduser");
    }
 
    @override
    public void deluser(string userid) {
        system.out.println("usermanagerimpl.deluser");
    }
 
    @override
    public string finduser(string userid) {
        system.out.println("usermanagerimpl.finduser");
        return "张三";
    }
 
    @override
    public void modifyuser(string userid, string username) {
        system.out.println("usermanagerimpl.modifyuser");
 
    }
}

代理用户管理实现类——usermanagerimplproxy相当于proxy角色

public class usermanagerimplproxy implements usermanager {
 
    // 目标对象
    private usermanager usermanager;
    // 通过构造方法传入目标对象
    public usermanagerimplproxy(usermanager usermanager){
        this.usermanager=usermanager;
    }
    @override
    public void adduser(string userid, string username) {
        try{
                //添加打印日志的功能
                //开始添加用户
                system.out.println("start-->adduser()");
                usermanager.adduser(userid, username);
                //添加用户成功
                system.out.println("success-->adduser()");
            }catch(exception e){
                //添加用户失败
                system.out.println("error-->adduser()");
            }
    }
 
    @override
    public void deluser(string userid) {
        usermanager.deluser(userid);
    }
 
    @override
    public string finduser(string userid) {
        usermanager.finduser(userid);
        return "张三";
    }
 
    @override
    public void modifyuser(string userid, string username) {
        usermanager.modifyuser(userid,username);
    }
 
}

客户端调用

public class client {
 
    public static void main(string[] args){
        //usermanager usermanager=new usermanagerimpl();
        usermanager usermanager=new usermanagerimplproxy(new usermanagerimpl());
        usermanager.adduser("1111", "张三");
    }
}

静态代理类优缺点

优点：

代理使客户端不需要知道实现类是什么，怎么做的，而客户端只需知道代理即可（解耦合），对于如上的客户端代码，newusermanagerimpl()可以应用工厂将它隐藏，如上只是举个例子而已。

缺点：

• 代理类和委托类实现了相同的接口，代理类通过委托类实现了相同的方法。这样就出现了大量的代码重复。如果接口增加一个方法，除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。
• 代理对象只服务于一种类型的对象，如果要服务多类型的对象。势必要为每一种对象都进行代理，静态代理在程序规模稍大时就无法胜任了。如上的代码是只为usermanager类的访问提供了代理，但是如果还要为其他类如department类提供代理的话，就需要我们再次添加代理department的代理类。

举例说明：代理可以对实现类进行统一的管理，如在调用具体实现类之前，需要打印日志等信息，这样我们只需要添加一个代理类，在代理类中添加打印日志的功能，然后调用实现类，这样就避免了修改具体实现类。满足我们所说的开闭原则。但是如果想让每个实现类都添加打印日志的功能的话，就需要添加多个代理类，以及代理类中各个方法都需要添加打印日志功能（如上的代理方法中删除，修改，以及查询都需要添加上打印日志的功能）

即静态代理类只能为特定的接口(service)服务。如想要为多个接口服务则需要建立很多个代理类。

动态代理

根据如上的介绍，你会发现在静态代理中每个代理类只能为一个接口服务，这样程序开发中必然会产生许多的代理类。所以我们就会想办法可以通过一个代理类完成全部的代理功能，那么我们就需要用动态代理。（一个代理类服务于多个委托对象）

在上面的示例中，一个代理只能代理一种类型，而且是在编译期就已经确定被代理的对象。而动态代理是在运行时，通过反射机制实现动态代理，并且能够代理各种类型的对象。

在java中要想实现动态代理机制，需要java.lang.reflect.invocationhandler接口和 java.lang.reflect.proxy 类的支持。

java.lang.reflect.invocationhandler接口的定义如下：

//object proxy:被代理的对象
//method method:要调用的方法
//object[] args:方法调用时所需要参数
public interface invocationhandler {
    public object invoke(object proxy, method method, object[] args) throws throwable;
}

java.lang.reflect.proxy类的定义如下：

//classloader loader:类的加载器
//class<?> interfaces:得到全部的接口
//invocationhandler h:得到invocationhandler接口的子类的实例
public static object newproxyinstance(classloader loader, class<?>[] interfaces, invocationhandler h) throws illegalargumentexception

具体实现——相当于subject角色

public class usermanagerimpl implements usermanager {
 
    @override
    public void adduser(string userid, string username) {
        system.out.println("usermanagerimpl.adduser");
    }
 
    @override
    public void deluser(string userid) {
        system.out.println("usermanagerimpl.deluser");
    }
 
    @override
    public string finduser(string userid) {
        system.out.println("usermanagerimpl.finduser");
        return "张三";
    }
 
    @override
    public void modifyuser(string userid, string username) {
        system.out.println("usermanagerimpl.modifyuser");
 
    }
 
}

动态创建代理对象的类——相当于proxy角色

public class loghandler implements invocationhandler {
 
    // 目标对象
    private object targetobject;
    //绑定关系，也就是关联到哪个接口（与具体的实现类绑定）的哪些方法将被调用时，执行invoke方法。            
    public object newproxyinstance(object targetobject){
        this.targetobject=targetobject;
        //该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例  
        //第一个参数指定产生代理对象的类加载器，需要将其指定为和目标对象同一个类加载器
        //第二个参数要实现和目标对象一样的接口，所以只需要拿到目标对象的实现接口
        //第三个参数表明这些被拦截的方法在被拦截时需要执行哪个invocationhandler的invoke方法
        //根据传入的目标返回一个代理对象
        return proxy.newproxyinstance(targetobject.getclass().getclassloader(),
                targetobject.getclass().getinterfaces(),this);
    }
    @override
    //关联的这个实现类的方法被调用时将被执行
    /*invocationhandler接口的方法，proxy表示代理，method表示原对象被调用的方法，args表示方法的参数*/
    public object invoke(object proxy, method method, object[] args)
            throws throwable {
        system.out.println("start-->>");
        for(int i=0;i<args.length;i++){
            system.out.println(args[i]);
        }
        object ret=null;
        try{
            /*原对象方法调用前处理日志信息*/
            system.out.println("satrt-->>");
            
            //调用目标方法
            ret=method.invoke(targetobject, args);
            /*原对象方法调用后处理日志信息*/
            system.out.println("success-->>");
        }catch(exception e){
            e.printstacktrace();
            system.out.println("error-->>");
            throw e;
        }
        return ret;
    }
 
}

被代理对象targetobject通过参数传递进来，我们通过targetobject.getclass().getclassloader()获取classloader对象，然后通过targetobject.getclass().getinterfaces()获取它实现的所有接口，然后将targetobject包装到实现了invocationhandler接口的loghandler对象中。通过newproxyinstance函数我们就获得了一个动态代理对象。

客户端代码

public class client {
 
    public static void main(string[] args){
        loghandler loghandler=new loghandler();
        usermanager usermanager=(usermanager)loghandler.newproxyinstance(new usermanagerimpl());
        //usermanager usermanager=new usermanagerimpl();
        usermanager.adduser("1111", "张三");
    }
}

可以看到，我们可以通过loghandler代理不同类型的对象，如果我们把对外的接口都通过动态代理来实现，那么所有的函数调用最终都会经过invoke函数的转发，因此我们就可以在这里做一些自己想做的操作，比如日志系统、事务、拦截器、权限控制等。这也就是aop(面向切面编程)的基本原理。

aop（aspect oriented programming）：将日志记录，性能统计，安全控制，事务处理，异常处理等代码从业务逻辑代码中划分出来，通过对这些行为的分离，我们希望可以将它们独立到非指导业务逻辑的方法中，进而改变这些行为的时候不影响业务逻辑的代码——解耦。

针对如上的示例解释：

我们来看上面的usermanagerimplproxy类，它的两个方法system.out.println("start-->adduser()")和system.out.println("success-->adduser()")，这是做核心动作之前和之后的两个截取段，正是这两个截取段，却是我们aop的基础，在oop里，system.out.println("start-->adduser()")、核心动作、system.out.println("success-->adduser()")这个三个动作在多个类里始终在一起，但他们所要完成的逻辑却是不同的，如system.out.println("start-->adduser()")里做的可能是权限的判断，在所有类中它都是做权限判断，而在每个类里核心动作却各不相同，system.out.println("success-->adduser()")可能做的是日志，在所有类里它都做日志。正是因为在所有的类里，核心代码之前的操作和核心代码之后的操作都做的是同样的逻辑，因此我们需要将它们提取出来，单独分析，设计和编码，这就是我们的aop思想。一句话说，aop只是在对oop的基础上进行进一步抽象，使我们的类的职责更加单一。

动态代理优点：

动态代理与静态代理相比较，最大的好处是接口中声明的所有方法都被转移到调用处理器一个集中的方法中处理（invocationhandler.invoke）。这样，在接口方法数量比较多的时候，我们可以进行灵活处理，而不需要像静态代理那样每一个方法进行中转。而且动态代理的应用使我们的类职责更加单一，复用性更强

jdk动态代理类的一些说明

下面是一个动态代理类的反编译代码：

package com.sun.proxy;
import com.mikan.proxy.helloworld;
import java.lang.reflect.invocationhandler;
import java.lang.reflect.method;
import java.lang.reflect.proxy;
import java.lang.reflect.undeclaredthrowableexception;
public final class $proxy0 extends proxy implements helloworld{
  privatestatic method m1;
  privatestatic method m3;
  privatestatic method m0;
  privatestatic method m2;
  public $proxy0(invocationhandler paraminvocationhandler) {
    super(paraminvocationhandler);
  }
  public final boolean equals(object paramobject){
    try {
      return ((boolean)this.h.invoke(this, m1, new object[] { paramobject })).booleanvalue();
    }
    catch (error|runtimeexception localerror) {
      throw localerror;
    }
    catch (throwable localthrowable) {
      thrownew undeclaredthrowableexception(localthrowable);
    }
  }
  public final void sayhello(string paramstring){
    try {
      this.h.invoke(this, m3, new object[] { paramstring });
      return;
    }
    catch (error|runtimeexception localerror) {
      throw localerror;
    }
    catch (throwable localthrowable) {
      thrownew undeclaredthrowableexception(localthrowable);
    }
  }
  public final int hashcode(){
    try {
      return ((integer)this.h.invoke(this, m0, null)).intvalue();
    }
    catch (error|runtimeexception localerror) {
      throw localerror;
    }
    catch (throwable localthrowable) {
      thrownew undeclaredthrowableexception(localthrowable);
    }
  }
  public final string tostring(){
    try {
      return (string)this.h.invoke(this, m2, null);
    }
    catch (error|runtimeexception localerror) {
      throw localerror;
    }
    catch (throwable localthrowable) {
      thrownew undeclaredthrowableexception(localthrowable);
    }
  }
  static {
    try {
      m1 = class.forname("java.lang.object").getmethod("equals", new class[] { class.forname("java.lang.object") });
      m3 = class.forname("com.mikan.proxy.helloworld").getmethod("sayhello", new class[] { class.forname("java.lang.string") });
      m0 = class.forname("java.lang.object").getmethod("hashcode", new class[0]);
      m2 = class.forname("java.lang.object").getmethod("tostring", new class[0]);
      return;
    }
    catch (nosuchmethodexception localnosuchmethodexception) {
      thrownew nosuchmethoderror(localnosuchmethodexception.getmessage());
    }
    catch (classnotfoundexception localclassnotfoundexception) {
      thrownew noclassdeffounderror(localclassnotfoundexception.getmessage());
    }
  }
}

可以看到，动态生成的代理类有如下特性：

• 继承了proxy类，实现了代理的接口，由于java不能多继承，这里已经继承了proxy类了，不能再继承其他的类，所以jdk的动态代理不支持对类的代理，只支持接口的代理。

• 提供了一个使用invocationhandler作为参数的构造方法。

• 生成静态代码块来初始化接口中方法的method对象，以及object类的equals、hashcode、tostring方法。

• 重写了object类的equals、hashcode、tostring，它们都只是简单的调用了invocationhandler的invoke方法，即可以对其进行特殊的操作，也就是说jdk的动态代理还可以代理上述三个方法。

• 代理类实现代理接口的sayhello方法中，只是简单的调用了invocationhandler的invoke方法，我们可以在invoke方法中进行一些特殊操作，甚至不调用实现的方法，直接返回。

  ​

  至此jdk动态代理的实现原理就分析的差不多了。同时我们可以想像一下spring aop提供的各种拦截该如何实现，就已经很明了了，如下所示：

public object invoke(object proxy, method method, object[] args) throws throwable {
        // beforeadvice
        object retval = null;
        try {
            // aroundadvice
            retval = method.invoke(target, args);
            // aroundadvice
            // afterreturningadvice
        }
        catch (throwable e) {
            // afterthrowingadvice
        }
        finally {
            // afteradvice
        }
        return retval;
    }

上面是对于spring aop使用jdk动态代理实现的基本框架代码，当然具体的实现肯定比这个复杂得多，但是基本原理不外乎如是。所以理解基本原理对于理解其他的代码也是很有好处的。

动态代理实现的几种方式

• jdk动态代理（对接口进行代理）
• cglib动态代理（可以对类进行代理）

代理模式和其他模式的对比

如果你还学过其他的设计模式，你肯定会发现代理模式和适配器模式、装饰器模式很像。下面来讲下这几种模式的区别。

1. 装饰模式和代理模式的区别
装饰器模式关注于在一个对象上动态的添加方法，然而代理模式关注于控制对对象的访问。换句话 说，用代理模式，代理类（proxy class）可以对它的客户隐藏一个对象的具体信息。因此，当使用代理模式的时候，我们常常在一个代理类中创建一个对象的实例。并且，当我们使用装饰器模式的时候，我们通常的做法是将原始对象作为一个参数传给装饰者的构造器。

2. 外观模式和代理模式的区别
代理与外观的主要区别在于，代理对象代表一个单一对象而外观对象代表一个子系统，代理的客户对象无法直接访问对象，由代理提供单独的目标对象的访问，而通常外观对象提供对子系统各元件功能的简化的共同层次的调用接口。代理是一种原来对象的代表，其他需要与这个对象打交道的操作都是和这个代表交涉的。

3. 适配器模式和代理模式的区别
适配器模式改变所考虑的对象的接口，代理模式不能改变所代理对象的接口。

适配器模式偏重的是适配，即实现要适配的接口功能。装饰模式偏重的是对已有对象的功能扩展。而代理模式则偏重的是访问逻辑的控制，因此通常这个代理的构建过程是不直接由client控制的。

简单总结

代理模式最大的有点就是可以有效控制对委托类对象的直接访问，也可以很好地隐藏和保护委托类对象，同时也为实施不同控制策略预留了空间，从而在设计上获得了更大的灵活性。

缺点就是需要设计代理类，一定程度上增加了系统设计的复杂性。

代理模式可以分为静态代理和动态代理。静态代理的通用型较差，一般在开发实践中使用动态代理比较多。

动态代理的实现方式有jdk动态代理和cglib动态代理。jdk动态代理的缺陷是只能代理接口（因为java只能单继承，jdk动态代理生成的代理类已经继承了proxy类，所以不能再继承其他类）

代理模式和适配器模式、装饰器比较像。适配器模式更加注重于接口的适配转换、装饰器模式更加注重于对象功能的增强扩展，而代理模式更加注重于对象的访问控制。

以上。

参考

• https://blog.csdn.net/hejingyuan6/article/details/36203505
• https://blog.csdn.net/u013256816/article/details/51009592