23天读懂23种设计模式：代理模式（结构型）

点击上方 蓝字 关注我们

结构型模式讨论的是类和对象的结构，它采用继承机制来组合接口或实现（类结构型模式），或者通过组合一些对象实现新的功能（对象结构型模式）。

代理模式的目的：为其他对象提供一种代理以控制对该对象的访问，即用一个类去代表另一个类的功能。

winter

代理模式也是结构型的设计模式之一，本文是设计模式系列（共24节）的第7篇文章。

设计模式都从六大原则出发进行总结：《第一节：设计模式的六大原则》

结构型设计模式共7种：

• 代理模式（Proxy Pattern）：为其他对象提供一种代理以控制对该对象的访问。

• 装饰模式（Decorator Pattern）：动态的给一个对象添加一些额外的职责。就增加功能来说，装饰模式比生成子类更灵活。
  

• 适配器模式（Adapter Pattern）：将一个类的接口变换成客户端所期待的接口，从而使原本因接口不匹配而无法在一起工作的两个类能够在一起工作。
  

• 组合模式（Composite Pattern）：也叫合成模式，将对象组合成属性结构一表示“部分-整体”的层次结构，使得用户对单个对象和组成对象的使用具有一致性。

• 桥梁模式（Bridge Pattern）：也叫桥接模式，将抽象和实现解耦，是的两者可以独立的变化。

• 外观模式（Facade Pattern）：也叫门面模式，要求一个子系统的外部与其内部的通信必须通过一个统一的对象进行，外观模式提供一个高层次的接口，使得子系统更易于使用。

• 亨元模式（Flyweight Pattern）：是池技术的重要实现方式，使用共享对象可有效的支持大量的细粒度的对象

代理模式是什么？

代理模式分两种：

• 静态代理：构造不同的实体类，显式传参给代理类进行方法调用。

• 动态代理：入参是对象和注解名，重新构造被代理对象。

静态代理实现

静态代理的特点：代理类接受一个Subject接口的对象，任何实现该接口的对象，都可以通代理类进行代理，增加了通用性。

1、定义被代理类：UserDao 和 WomanDao，两者都实现了 Subject 公共接口。

public interface Subject {
    void visit();
}
class UserDao implements Subject {
    private String name = "name-1";
    @Override
    public void visit() {
        System.out.println("my name is "+name);
    }
}
class WomanDao implements Subject {
    private String name = "name-2";
    @Override
    public void visit() {
        System.out.println("my name is "+name);
    }
}

2、定义代理类：ProxyHuman

/**
 * 

 *     代理类
 * 
 */
public class ProxyHuman {
    private Subject subject;
    public ProxyHuman(Subject subject) {
        this.subject = subject;
    }
    public void visit() {
        subject.visit();
    }
    public void setSubject(Subject subject) {
        this.subject = subject;
    }
}

3、代理Demo：

public class StaticsProxyTest {
    public static void main(String[] args){
        //代理类
        ProxyHuman proxyHuman = new ProxyHuman(new UserDao());
        proxyHuman.visit();
        //代理类
        proxyHuman.setSubject(new WomanDao());
        proxyHuman.visit();
    }
}

代码分析：

缺点：

1）每一个代理类都必须实现一遍委托类（也就是realsubject）的接口，如果接口增加方法，则代理类也必须跟着修改；

2）代理类每一个接口对象对应一个委托对象，如果委托对象非常多，则静态代理类就非常臃肿，难以胜任。

动态代理实现：JDK实现

JDK的动态代理是基于反射实现。

JDK通过反射生成的代理类实现了原来那个类的所有接口，并对接口的方法进行了代理。（此处我是有些云里雾里了..继续看下去吧）

JDK实现动态代理需要两个组件：

1、首先是定义公共业务接口：

/**
 * 
公共接口
 */
public interface IUserDao {
    void find();
}
/**
 * 被代理类或者叫代理目标类
 */
public class UserDao implements IUserDao{
    @Override
    public void find() {
        System.out.println("查找用户");
    }
}
public class WomanDao implements IUserDao {
  @Override
  public void find() {
    System.out.println("查找女性用户");
  }
}

2、组件一：编写一个代理拦截器类，并实现InvocationHandler接口。我们在使用JDK的动态代理时，需要，去实现这个接口，然后重写invoke方法，这个方法其实就是我们提供的代理方法。

/**
 * 

 *     JDK 动态代理拦截器类
 * 
 */
public class JDKDynamicProxy implements InvocationHandler{
    //被代理类的实例
    private IUserDao iud;
    //构造方法
    public JDKDynamicProxy(IUserDao iud){
        this.iud=iud;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result=null;
        System.out.println("开始JDK动态代理");
        method.invoke(iud, args);
        System.out.println("结束JDK动态代理");
        return result;
    }
}

3、组件二：使用Proxy这个类，通过静态方法Proxy.newProxyInstance()方法，返回一个代理对象。

public class Test2 {
    public static void main(String[] args) {
        //被代理类
        UserDao ud=new UserDao();
        WomanDao wd=new WomanDao();
        //代理器（通过构造器设置 被代理类）
        JDKDynamicProxy dp=new JDKDynamicProxy(ud);
        JDKDynamicProxy dp2=new JDKDynamicProxy(wd);
      
        //在创建代理对象前，可以通过下面语句，将生成的代理类的.class保存在本地。
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
        //生成代理对象1
        IUserDao iud=(IUserDao)Proxy.newProxyInstance(ud.getClass().getClassLoader(), ud.getClass().getInterfaces(), dp);
        iud.find();
        //切换代理对象2，生成
        iud=(IUserDao)Proxy.newProxyInstance(wd.getClass().getClassLoader(), wd.getClass().getInterfaces(), dp2);
        iud.find();
    }
}

代码分析：

其实，这个代理对象在底层是会被JVM编译为一个新的类对象（ $Proxy0），它是由Proxy这个类通过newProxyInstance方法动态生成的。

JDK动态生成代理类

我们demo里面有提示：将动态生成的代理类的.class文件保存在本地。

System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");

我们打开本地保存的这个class文件，可以看到源码，走读一下代码：

1、$Proxy0 继承了 Proxy 类，并且实现了公共接口 IUserDao；

2、find() 方法最终触发我们的 JDKDynamicProxy 的 invoke() 方法；

public final class $Proxy0 extends Proxy implements IUserDao {
    private static Method m1;
    private static Method m3;
    private static Method m2;
    private static Method m0;


    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }
    
    //... 省略了其他无关方法
    
    //$Proxy0继承了Proxy，且将InvocationHandler h在构造时传给了Proxy。
    //因此，super.h.invoke(this, m3, (Object[])null)其实就是调用的invoker handler的invoke方法。
    //也正是像InvocationHandler定义中所说的，
    // 【当proxy instance的方法被调用时，方法调用将会委派为invocation handler的invoke方法】。 
    public final void find() throws  {
        try {
        //h指向的是 Proxy 父类的  InvocationHandler h对象，
        // 而这个对象就是我们初始化时传入的 JDKDynamicProxy 类
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }


    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            //静态代码块，初始化时反射将IUserDao的find方法赋值
            m3 = Class.forName("design_module.ProxyPattern.dynamicProxy2.IUserDao").getMethod("find");
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

代码分析：

因此，当通过代理对象调用这些方法时，底层将通过反射，调用我们实现的invoke方法（即：IUserDao的find()方法调用，会触发我们 JDKDynamicProxy 的 invoke() 方法。）

优点：依赖JDK，更稳定可靠，跟着JDK升级，代码简单。

缺点：要求被代理类必须要有实现的接口，否则无法使用JDK动态代理（从newProxyInstance方法的第二个参数可得知，必须传入被代理类的实现接口），而这个解决方法便是使用CGLib动态代理。

Spring默认使用JDK的动态代理实现AOP，类如果实现了接口，Spring就会使用这种方式实现动态代理。熟悉Java语言的应该会对JDK动态代理有所了解。

动态代理实现：CGlib实现

JDK 动态代理只能为接口中的方法完成代理，而委托类自己的方法或者父类中的方法都不可能被代理。

CGLIB 应运而生，它是一个高性能的，底层基于 ASM 框架的一个代码生成框架，它完美的解决了 JDK 版本的动态代理只能为接口方法代理的单一性不足问题。Cglib动态代理采用的是创建目标类的子类的方式。

    下面我们看下Cglib的动态代理例子：

1、编写CGlib 动态代理类拦截规则类：实现CGLIB动态代理必须实现MethodInterceptor(方法拦截器)接口。

这个接口只有一个intercept()方法，这个方法有4个参数： 

1）obj表示增强的对象，即实现这个接口类的一个对象； 

2）method表示要被拦截的方法； 

3）args表示要被拦截方法的参数；

4）proxy表示要触发父类的方法对象；

public interface MethodInterceptor extends Callback
{
    public Object intercept(Object obj, java.lang.reflect.Method method, Object[] args,
                               MethodProxy proxy) throws Throwable;
}

我们自定义的动态代理拦截器类 CGlibMyMethodInterceptor：

/**
 * 

 *     CGlib 动态代理拦截器类,实现  MethodInterceptor 接口
 * 
 */
public class CGlibMyMethodInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable
 {
        System.out.println("开始CGLib动态代理");
        Object object=proxy.invokeSuper(obj, args);
        System.out.println("结束CGLib动态代理");
        return object;
    }
}

2、使用Cglib提供的工具类实现动态代理：通过Enhancer.create()方法创建代理对象；

/**
 * 

 *     可以看出使用Enhancer生成代理类，需要设置被代理类，也就是父类（从这里可以看出是使用继承，生成的子类），
 *     设置回调方法
 * 
 */
public class Test3 {
  public static void main(String[] args) {
    //可以指定 CGLIB 将动态生成的代理类保存至指定的磁盘路径下
    System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY,"E:\\code\\test\\src\\main\\java\\design_module\\ProxyPattern\\dynamicProxy2");


    Enhancer enhancer=new Enhancer();
    enhancer.setSuperclass(SubjectA.class);
    enhancer.setCallback(new CGlibMyMethodInterceptor());
    //生成代理类
    SubjectA ud=(SubjectA) enhancer.create();
    ud.find();
    enhancer.setSuperclass(SubjectB.class);
    SubjectB ud2=(SubjectB) enhancer.create();
    ud2.find();
  }
}
class SubjectA {
  void find(){
    System.out.println("SubjectA");
  }
}
class SubjectB {
  void find(){
    System.out.println("SubjectB");
  }
}

输出动态代理类代码：

CGlib动态生成代理类

同样我们可以走读下Cglib生产的动态代理类代码：

1、动态代理类直接继承了 被代理对象 SubjectA/SubjectB，同时实现了Factory接口；

2、动态代理类覆盖了 find() 方法，同时也是我们的重点关注代理对象方法。

public class SubjectA$$EnhancerByCGLIB$$7411087d extends SubjectA implements Factory {
    private boolean CGLIB$BOUND;
    public static Object CGLIB$FACTORY_DATA;
    private static final ThreadLocal CGLIB$THREAD_CALLBACKS;
    private static final Callback[] CGLIB$STATIC_CALLBACKS;
    private MethodInterceptor CGLIB$CALLBACK_0;
    private static Object CGLIB$CALLBACK_FILTER;
    private static final Method CGLIB$find$0$Method;
    private static final MethodProxy CGLIB$find$0$Proxy;
    private static final Object[] CGLIB$emptyArgs;
    private static final Method CGLIB$equals$1$Method;
    private static final MethodProxy CGLIB$equals$1$Proxy;
    private static final Method CGLIB$toString$2$Method;
    private static final MethodProxy CGLIB$toString$2$Proxy;
    private static final Method CGLIB$hashCode$3$Method;
    private static final MethodProxy CGLIB$hashCode$3$Proxy;
    private static final Method CGLIB$clone$4$Method;
    private static final MethodProxy CGLIB$clone$4$Proxy;


    static void CGLIB$STATICHOOK1() {
        CGLIB$THREAD_CALLBACKS = new ThreadLocal();
        CGLIB$emptyArgs = new Object[0];
        Class var0 = Class.forName("design_module.ProxyPattern.dynamicProxy2.SubjectA$$EnhancerByCGLIB$$7411087d");
        Class var1;
        Method[] var10000 = ReflectUtils.findMethods(new String[]{"equals", "(Ljava/lang/Object;)Z", "toString", "()Ljava/lang/String;", "hashCode", "()I", "clone", "()Ljava/lang/Object;"}, (var1 = Class.forName("java.lang.Object")).getDeclaredMethods());
        CGLIB$equals$1$Method = var10000[0];
        CGLIB$equals$1$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/Object;)Z", "equals", "CGLIB$equals$1");
        CGLIB$toString$2$Method = var10000[1];
        CGLIB$toString$2$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/String;", "toString", "CGLIB$toString$2");
        CGLIB$hashCode$3$Method = var10000[2];
        CGLIB$hashCode$3$Proxy = MethodProxy.create(var1, var0, "()I", "hashCode", "CGLIB$hashCode$3");
        CGLIB$clone$4$Method = var10000[3];
        CGLIB$clone$4$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/Object;", "clone", "CGLIB$clone$4");
        CGLIB$find$0$Method = ReflectUtils.findMethods(new String[]{"find", "()V"}, (var1 = Class.forName("design_module.ProxyPattern.dynamicProxy2.SubjectA")).getDeclaredMethods())[0];
        CGLIB$find$0$Proxy = MethodProxy.create(var1, var0, "()V", "find", "CGLIB$find$0");
    }


    final void CGLIB$find$0() {
        super.find();
    }


    final void find() {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }


        if (var10000 != null) {
            var10000.intercept(this, CGLIB$find$0$Method, CGLIB$emptyArgs, CGLIB$find$0$Proxy);
        } else {
        //调用父类的find()方法
            super.find();
        }
    }


    //...省略了其他方法实现
}

代码分析：

走读代理对象反编译源码可以知道，代理对象继承于 SubjectA，拦截器调用intercept()方法，intercept()方法由自定义 CGlibMyMethodInterceptor 实现。

所以，最后调用 CGlibMyMethodInterceptor 中的intercept()方法，从而完成了由代理对象访问到目标对象的动态代理实现。

好处：不用实现额外接口，只操作我们关心类，也额外提高了性能。

JDK的动态代理存在限制，那就是被代理的类必须是一个实现了接口的类，代理类需要实现相同的接口，代理接口中声明的方法。若需要代理的类没有实现接口，此时JDK的动态代理将没有办法使用，于是Spring会使用CGLib的动态代理来生成代理对象：因为CGLib直接操作字节码，生成类的子类，重写类的方法完成代理。

JDK动态代理与CGLib动态代理的区别

JDK动态代理模式和CGLib动态代理的应用区别:

JDK动态代理需要被代理类实现接口，而CGLib则是生成被代理类的子类；

JDK动态代理模式和CGLib动态代理的性能区别:

CGLib动态代理创建代理实例速度慢，但是运行速度快；JDK动态代理创建实例速度快，但是运行速度慢。如果实例是单例的，推荐使用CGLib方式动态代理，反之则使用JDK方式进行动态代理。

Spring的实例默认是单例，所以这时候使用CGLib性能高。

在1.6和1.7的时候，JDK动态代理的速度要比CGLib动态代理的速度要慢，但是并没有教科书上的10倍差距，在JDK1.8的时候，JDK动态代理的速度已经比CGLib动态代理的速度快很多了。

总结

总结一下，文章概要分析了代理模式下的动态代理和静态代理两种实现方式；同时由于动态代理有JDK和Cglib两种工具，所以也做了简要分析和比较。

后面我们理解Spring AOP，涉及到的JDK和CGLib动态代理便是与本文有关，后续我们再细细分析。

往期推荐

《源码系列》

《JDK之Object 类》

《JDK之BigDecimal 类》

《JDK之String 类》

《JDK之Lambda表达式》

《Spring源码：Event事件发布与监听》

《经典书籍》

《Java并发编程实战：第1章 多线程安全性与风险》

《Java并发编程实战：第2章 影响线程安全性的原子性和加锁机制》

《Java并发编程实战：第3章 助于线程安全的三剑客：final & volatile & 线程封闭》

《服务端技术栈》

《Docker 核心设计理念》

《Kafka史上最强原理总结》

《HTTP的前世今生》

《算法系列》

《读懂排序算法（一）：冒泡&直接插入&选择比较》

《读懂排序算法（二）：希尔排序算法》

《读懂排序算法（三）：堆排序算法》

《读懂排序算法（四）：归并算法》

《读懂排序算法（五）：快速排序算法》

《读懂排序算法（六）：二分查找算法》

《设计模式》

《设计模式之六大设计原则》

《设计模式之创建型(1)：单例模式》

《设计模式之创建型(2)：工厂方法模式》

《设计模式之创建型(3)：原型模式》

《设计模式之创建型(4)：建造者模式》

《设计模式之创建型(5)：抽象工厂设计模式》

扫描二维码

获取技术干货

后台技术汇

点个“在看”表示朕

已阅