代理模式

一、概念

1、定义

代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。同时代理对象可以调用被代理对象的方法，并对其进行增强。可以总结为代理对象 = 增强代码 + 目标对象（原对象）

2、举例

疫情期间很多公司破产，导致很多劳动者都失业了，小文也是其中之一。公司拖欠小文的工资一直未能下发。小文希望通过劳动仲裁来要回属于自己的工资，所以和公司打官司。基本的仲裁步骤小文都懂，大概有：准备劳动仲裁申请书、收集证据、提交申请、开庭答辩等等，但是小文是第一次进行劳动仲裁，对这些具体的操作没什么经验，同时自己在这期间又有了新的工作，很难抽出时间去进行劳动仲裁。这时小文就掏钱找了一位律师，这位律师就相当于代理对象。律师替小文准备仲裁申请、提交申请、开庭后帮小文进行辩论阐述等等，律师不仅仅是按着仲裁需要的步骤做了，而且每一步都做的比小文更好，这就是对被代理对象方法的增强

image

3、场景

面向切面编程中就用到了代理模式，具体的内容后面有机会再详细介绍吧

4、分类：

静态代理：在编译时就已经实现，编译完成后代理类是一个实际的class文件。
动态代理：在运行时动态生成的，即编译完成后没有实际的class文件，而是在运行时动态生成类字节码，并加载到JVM中。

二、静态代理

1、代码

我们用静态代理来实现上面例子

定义接口:无论是谁进行劳动仲裁，都需要按着这个流程执行

public interface ArbitrationStep {
   /**
    * 准备仲裁申请
    */
   void prepareApp();

   /**
    * 收集证据
    */
   void collectEvi();

   /**
    * 开庭答辩
    */
   void debate();
}

定义被代理类

public class XiaoWen implements ArbitrationStep {

   @Override
   public void prepareApp() {
      System.out.println("准备仲裁申请！");
   }

   @Override
   public void collectEvi() {
      System.out.println("收集证据！");
   }

   @Override
   public void debate() {
      System.out.println("开庭答辩！");
   }
}

定义代理类

可以看到代理类中不仅执行了被代理的方法，同时还对其方法进行了一定的增强

public class LawyerProxy implements ArbitrationStep {
   private XiaoWen xiaoWen;

   public LawyerProxy(XiaoWen xiaoWen) {
      this.xiaoWen = xiaoWen;
   }

   @Override
   public void prepareApp() {
      System.out.println("律师听取小文的想法");
      xiaoWen.prepareApp();
      System.out.println("律师对申请进行修改");
   }

   @Override
   public void collectEvi() {
      xiaoWen.collectEvi();
      System.out.println("律师对证据进行整理");
   }

   @Override
   public void debate() {
      xiaoWen.debate();
      System.out.println("律师更详细的阐述");
   }
}

测试类

public class Tribunal {
   public static void main(String[] args) {
      XiaoWen xiaoWen = new XiaoWen();
      System.out.println("小文委托律师帮忙进行劳动仲裁");
      LawyerProxy proxy = new LawyerProxy(xiaoWen);
      System.out.println("-------第一步-------");
      proxy.prepareApp();

      System.out.println("-------第二步-------");
      proxy.collectEvi();

      System.out.println("-------第三步-------");
      proxy.debate();
      System.out.println();

      System.out.println("仲裁结束");
   }
}

运行结果

小文委托律师帮忙进行劳动仲裁
-------第一步-------
律师听取小文的想法
准备仲裁申请！
律师对申请进行修改
-------第二步-------
收集证据！
律师对证据进行整理
-------第三步-------
开庭答辩！
律师更详细的阐述

仲裁结束

2、总结

通过上面的代码可以总结出静态代理的步骤

定义接口
-- 被代理类和代理类都需要实现该接口
定义被代理类
-- 实现上面定义的接口
定义代理类
-- 实现上面定义的接口
-- 创建被代理对象
-- 调用方法时需要调用被代理对象的方法，同时自己可以对方法进行增加

图解

image

3、存在的问题

如果一个类需要被代理，就得去创建一个代理类。如果被代理的类过多，这样就需要手动创建很多代理类。为了解决这个问题，便有了动态代理

三、基于Java反射的动态代理

1、反射与类加载

在这之前我们需要先了解Java反射与类加载
同时还可以参考知乎回答——Java 动态代理作用是什么？

2、使用反射实现动态代理

接着上面的劳动仲裁的例子，不过这次我们用动态代理去实现
但是需要用到Proxy类的两个静态方法

获得动态代理类Class对象
-- public static Class<?> getProxyClass(ClassLoader loader, Class<?>... interfaces)
-- 参数分别是类加载器和接口的Class对象；
-- 这个方法，会从你传入的接口Class中，“拷贝”类结构信息到一个新的Class对象中，但新的Class对象带有构造器，是可以创建对象的
获得动态代理
-- public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
-- 封装了得到代理类Class对象、构造函数等细节，直接返回了代理对象

接口和被代理类不变

public interface ArbitrationStep {
   /**
    * 准备仲裁申请
    */
   void prepareApp();

   /**
    * 收集证据
    */
   void collectEvi();

   /**
    * 开庭答辩
    */
   void debate();
}

public class XiaoWen implements ArbitrationStep {

   @Override
   public void prepareApp() {
      System.out.println("准备仲裁申请！");
   }

   @Override
   public void collectEvi() {
      System.out.println("收集证据！");
   }

   @Override
   public void debate() {
      System.out.println("开庭答辩！");
   }
}

通过反射获得代理对象：

public class Tribunal2 {
   public static void main(String[] args) throws IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchMethodException {
      // 获取代理类的Class对象
      Class<?> proxyClazz = Proxy.getProxyClass(ArbitrationStep.class.getClassLoader(), ArbitrationStep.class);

      // 获得构造函数
      Constructor<?> constructor = proxyClazz.getConstructor(InvocationHandler.class);

      // 创建代理对象
      ArbitrationStep lawyerProxy = (ArbitrationStep) constructor.newInstance(new InvocationHandler() {
         @Override
         public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            // 创建被代理对象，用于调用方法
            XiaoWen xiaoWen = new XiaoWen();

            // 通过invoke方法调用了被代理对象的方法
            Object invoke = method.invoke(xiaoWen, args);

            // 每个步骤都让律师帮忙处理
            System.out.println("律师帮忙处理！");
            return invoke;
         }
      });

      // 通过代理对象调用方法
      System.out.println("-------第一步-------");
      lawyerProxy.prepareApp();

      System.out.println("-------第二步-------");
      lawyerProxy.collectEvi();

      System.out.println("-------第三步-------");
      lawyerProxy.debate();
      System.out.println();

      System.out.println("仲裁结束");
   }
}

运行结果

-------第一步-------
准备仲裁申请！
律师帮忙处理！
-------第二步-------
收集证据！
律师帮忙处理！
-------第三步-------
开庭答辩！
律师帮忙处理！

仲裁结束

稍微封装一下获得代理对象的方法：

public class Tribunal3 {
   public static void main(String[] args) throws InvocationTargetException, NoSuchMethodException, InstantiationException, IllegalAccessException {
      XiaoWen xiaoWen = new XiaoWen();
      // 获得代理对象
      ArbitrationStep lawyerProxy = (ArbitrationStep) getProxy(xiaoWen);

      // 通过代理对象调用方法
      System.out.println("-------第一步-------");
      lawyerProxy.prepareApp();

      System.out.println("-------第二步-------");
      lawyerProxy.collectEvi();

      System.out.println("-------第三步-------");
      lawyerProxy.debate();
      System.out.println();

      System.out.println("仲裁结束");
   }

   // 该方法返回一个代理对象
   public static Object getProxy(Object target) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
      // target为被代理对象，得到其代理类的Class对象
      Class<?> proxyClazz = Proxy.getProxyClass(target.getClass().getClassLoader(), target.getClass().getInterfaces());

      // 获得构造函数
      Constructor<?> constructor = proxyClazz.getConstructor(InvocationHandler.class);

      // 获得代理对象
      Object targetProxy = constructor.newInstance(new InvocationHandler() {
         @Override
         public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            Object invoke = method.invoke(target, args);
            System.out.println("代理类增强方法");
            return invoke;
         }
      });
      return targetProxy;
   }
}

自己编写了一个getProxy方法，传入被代理的对象，返回一个代理对象。

通过newProxyInstance()获得代理对象

上面的getProxy方法返回代理对象的过程是我们自己写的，通过Proxy类的newProxyInstance()可以直接返回代理对象

public static Object getProxyByProxyMethod(Object target) {
   // 直接返回代理对象
   return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new InvocationHandler() {
      @Override
      public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
         Object invoke = method.invoke(target, args);
         System.out.println("代理对象增强方法");
         return invoke;
      }
   });
}

看看newProxyInstance帮我们做了些什么工作

public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)
    throws IllegalArgumentException
{

    Objects.requireNonNull(h);

    // 下面这一段其实就是getProxyClass方法的内部实现
    // --------------------------------------------------------------
    final Class<?>[] intfs = interfaces.clone();
    final SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
        checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
    }

    /*
     * Look up or generate the designated proxy class.
     */
    // 获得接口加上构造函数后的Class对象
    Class<?> cl = getProxyClass0(loader, intfs);
    // ----------------------------------------------------------------

    /*
     * Invoke its constructor with the designated invocation handler.
     */

    try {
        if (sm != null) {
            checkNewProxyPermission(Reflection.getCallerClass(), cl);
        }

        // 获得构造函数
        final Constructor<?> cons = cl.getConstructor(constructorParams);

        final InvocationHandler ih = h;
        if (!Modifier.isPublic(cl.getModifiers())) {
            AccessController.doPrivileged(new PrivilegedAction<Void>() {
                public Void run() {
                    cons.setAccessible(true);
                    return null;
                }
            });
        }

        // 返回代理对象
        return cons.newInstance(new Object[]{h});

    } catch (IllegalAccessException|InstantiationException e) {
        throw new InternalError(e.toString(), e);
    } catch (InvocationTargetException e) {
        Throwable t = e.getCause();
        if (t instanceof RuntimeException) {
            throw (RuntimeException) t;
        } else {
            throw new InternalError(t.toString(), t);
        }
    } catch (NoSuchMethodException e) {
        throw new InternalError(e.toString(), e);
    }
}

我们自己获取代理对象的步骤是

通过getProxyClass获得代理对象的Class对象（接口+对应的构造函数）
通过Class对象调用得到构造方法
构造方法去创建实例，构造方法传入InvocationHandler实例，需要实现其invoke方法

newProxyInstance帮我们获取代理的步骤和上面类似，只不过Class对象是直接通过getProxyClass0(loader, intfs)来获取的。而我们自己封装的代码中，使用的是getProxyClass方法。但是该方法最终还是调用的getProxyClass0(loader, intfs)来获取的Class对象

getProxyClass方法

public static Class<?> getProxyClass(ClassLoader loader,
                                     Class<?>... interfaces)
    throws IllegalArgumentException
{
    final Class<?>[] intfs = interfaces.clone();
    final SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
        checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
    }

    return getProxyClass0(loader, intfs);
}

3、如何实现方法增强

上面的例子确实将被代理对象的方法增强了，但这是如何实现的呢

InvocationHandler

我们在获得代理类构造器的时候，传入了InvocationHandler

Constructor<?> constructor = proxyClazz.getConstructor(InvocationHandler.class);

InvocationHandler是一个接口，内部只有一个方法invoke

public interface InvocationHandler {
    public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable;
}

在通过constructor获取代理对象时，newInstance方法需要传入一个invocationHandler的实例，这个实例重写了invoke方法，就是通过它代理对象增强了被代理对象的方法

Object targetProxy = constructor.newInstance(new InvocationHandler() {
      @Override
      public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
         // 调用被代理对象的对应方法
         // target 被代理对象
         // args 方法需要的参数
         Object invoke = method.invoke(target, args);
         System.out.println("代理类增强方法");
         return invoke;
      }
   });
   return targetProxy;
}

图解**

image

总结

调用代理对象的方法时，实际上调用的是InvocationHandler的invoke方法，这个方法内部不仅调用了被代理对象的方法，还可以增加其他功能

4、为什么必须实现接口

通过

lawyerProxy.getClass().getSuperclass()

可以获得代理对象的父类，可以看到其父类为：

class java.lang.reflect.Proxy

也就是无论是什么代理类，都会继承自Proxy，而Java又是单继承的，所以想要被代理对象与代理对象产生联系，就只能通过接口来实现了

四、基于CGLib的动态代理

Java动态代理是面向接口的代理模式，如果没有接口，但是想要去实现动态代理，就需要用到CGLib来进行动态代理了

CGLIB原理

cglib是一个java字节码的生成工具，它动态生成一个被代理类的子类，子类重写被代理的类的所有不是final的方法。在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势织入横切逻辑。

示例

被代理类：

public class HelloServiceImpl {
    public void sayHello(){
        System.out.println("Hello Zhanghao");
    }

    public void sayBey(){
        System.out.println("Bye Zhanghao");
    }
}

实现MethodInterceptor接口生成方法拦截器：

public class HelloMethodInterceptor  implements MethodInterceptor{
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("Before: "  + method.getName());
        Object object = methodProxy.invokeSuper(o, objects);
        System.out.println("After: " + method.getName());
        return object;
    }
}

生成代理类对象并打印在代理类对象调用方法之后的执行结果:

public class Client {
    public static void main(String[] args) {
        System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "/Users/zhanghao/Documents/toy/spring-framework-source-study/");
        Enhancer enhancer = new Enhancer();
        //继承被代理类
        enhancer.setSuperclass(HelloServiceImpl.class);
        //设置回调
        enhancer.setCallback(new HelloMethodInterceptor());
        //设置代理类对象
        HelloServiceImpl helloService = (HelloServiceImpl) enhancer.create();
        //在调用代理类中方法时会被我们实现的方法拦截器进行拦截
        helloService.sayBey();
    }
}
result:
Before: sayBey
Bye Zhanghao
After: sayBey

构建代理类过程

我们可以从上面的代码示例中看到，代理类是由enhancer.create()创建的。Enhancer是CGLIB的字节码增强器，可以很方便的对类进行拓展。

创建代理类的过程：

生成代理类的二进制字节码文件；
加载二进制字节码，生成Class对象；
通过反射机制获得实例构造，并创建代理类对象。

enhancer.create()实现：

/**
     * Generate a new class if necessary and uses the specified
     * callbacks (if any) to create a new object instance.
     * Uses the no-arg constructor of the superclass.
     * @return a new instance
     */
    public Object create() {
        classOnly = false;
        argumentTypes = null;
        return createHelper();
    }

     private Object createHelper() {
        validate();
        if (superclass != null) {
            //设置生成类的名称
            setNamePrefix(superclass.getName());
        } else if (interfaces != null) {
            //设置生成类的名称
            setNamePrefix(interfaces[ReflectUtils.findPackageProtected(interfaces)].getName());
        }
        //生成代理类对象（在KEY_FACTORY.newInstance(...）->生成代理类的二进制字节码文件以及加载二进制字节码）
        return super.create(KEY_FACTORY.newInstance((superclass != null) ? superclass.getName() : null,
                                                    ReflectUtils.getNames(interfaces),
                                                    filter,
                                                    callbackTypes,
                                                    useFactory,
                                                    interceptDuringConstruction,
                                                    serialVersionUID));
    }

cglic一共会自动生成三个字节码文件。其中一个类HelloServiceImpl
EnhancerByCGLIB
d855d4dc 继承了被代理类 HelloServiceImpl。这个类就是加强的代理类，其中会生成两个方法CGLIB sayHello1和sayHello()。
其中sayHello():

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

        if(var10000 != null) {
            var10000.intercept(this, CGLIB$sayHello$1$Method, CGLIB$emptyArgs, CGLIB$sayHello$1$Proxy);
        } else {
            super.sayHello();
        }
    }

当代理对象的执行sayHello方法时，会首先判断一下是否存在实现了MethodInterceptor接口的CGLIB$CALLBACK_0;，如果存在，则将调用MethodInterceptor中的intercept方法。

与JDK代理对比

JDK代理要求被代理的类必须实现接口，有很强的局限性。而CGLIB动态代理则没有此类强制性要求。简单的说，CGLIB会让生成的代理类继承被代理类，并在代理类中对代理方法进行强化处理(前置处理、后置处理等)。但是如果被代理类被final修饰，那么它不可被继承，即不可被代理；同样，如果被代理类中存在final修饰的方法，那么该方法也不可被代理。

最后编辑于：2022.03.10 16:38:52

禁止转载，如需转载请通过简信或评论联系作者。

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 224,289评论 6赞 522
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 95,968评论 3赞 402
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 171,336评论 0赞 366
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 60,718评论 1赞 300
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 69,734评论 6赞 399
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 53,240评论 1赞 314
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 41,631评论 3赞 428
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 40,599评论 0赞 279
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 47,139评论 1赞 324
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 39,166评论 3赞 345
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 41,286评论 1赞 354
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 36,917评论 5赞 350
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 42,604评论 3赞 336
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 33,075评论 0赞 25
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 34,205评论 1赞 275
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 49,814评论 3赞 381
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 46,351评论 2赞 365

代理模式

一、概念

1、定义

2、举例

3、场景

4、分类：

二、静态代理

1、代码

2、总结

图解

3、存在的问题

三、基于Java反射的动态代理

1、反射与类加载

2、使用反射实现动态代理

通过反射获得代理对象：

稍微封装一下获得代理对象的方法：

通过newProxyInstance()获得代理对象

3、如何实现方法增强

InvocationHandler

图解**

总结

4、为什么必须实现接口

四、基于CGLib的动态代理

CGLIB原理

示例

构建代理类过程

与JDK代理对比

推荐阅读更多精彩内容