代理模式

一、概念

1、定义

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

2、举例

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

3、场景

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

二、静态代理

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、总结

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

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

图解

3、存在的问题

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

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

1、反射与类加载

在这之前我们需要先了解Java反射类加载

同时还可以参考知乎回答——Java 动态代理作用是什么?(膜拜大佬啊!)

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

接着上面的劳动仲裁的例子,不过这次我们用动态代理去实现

但是需要用到Proxy类的两个静态方法

  • getProxyClass
    • 这个方法, 会从你传入的接口Class中,“拷贝”类结构信息到一个新的Class对象中,但新的Class对象带有构造器,是可以创建对象的
  • newProxyInstance(一般直接用这个)
    • 封装了得到代理类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);
}

newProxynewInstance方法的前面部分的代码

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;
}

图解

总结

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

4、为什么必须实现接口

通过

lawyerProxy.getClass().getSuperclass()

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

class java.lang.reflect.Proxy

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

四、基于CGLib的动态代理

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

CGLib是一个强大、高性能的Code生产类库,可以实现运行期动态扩展java类

1、使用CGLib实现动态代理

被代理的类

public class XiaoWen {
   public void prepareApp() {
      System.out.println("准备仲裁申请");
   }

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

   public void debate() {
      System.out.println("开庭辩论");
   }
}

自定义拦截器实现MethodInterceptor接口

public class LawyerInterceptor implements MethodInterceptor {
   @Override
   public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
      // 前置增强
      System.out.println("律师给出建议");

      // 被代理类执行的方法(被增强的方法)
      // 注意这里是调用invokeSuper而不是invoke,否则死循环;
      // methodProxy.invokeSuper执行的是原始类的方法;
      // method.invoke执行的是子类的方法;
      Object invoke = methodProxy.invokeSuper(o, objects);

      // 后置增强
      System.out.println("律师帮忙");

      return invoke;
   }
}

使用Enhancer创建代理对象

public class Main {
   public static void main(String[] args) {
      // 创建增强器
      Enhancer enhancer = new Enhancer();

      // 传入被代理的Class对象(作为代理对象的父类)
      enhancer.setSuperclass(XiaoWen.class);

      // 设置回调函数,传入自定义的拦截器
      enhancer.setCallback(new LawyerInterceptor());

      // 获取代理对象
      XiaoWen proxy = (XiaoWen) enhancer.create();

      System.out.println("小文委托律师帮忙进行劳动仲裁");
      System.out.println("-------第一步-------");
      proxy.prepareApp();

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

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

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

运行结果

小文委托律师帮忙进行劳动仲裁
-------第一步-------
律师给出建议
准备仲裁申请
律师帮忙
-------第二步-------
律师给出建议
收集证据
律师帮忙
-------第三步-------
律师给出建议
开庭辩论
律师帮忙

仲裁结束

2、CGLib实现原理

CGLib可以为没有实现接口的类创建代理类。其原理是CGLib底层使用了ASM框架,该框架可以通过修改字节码,来创建一个被代理类的子类,也就是代理类。并在子类中采用方法拦截的技术拦截所有父类方法的调用,顺势织入横切逻辑。这种思想符合里氏替换原则,即子类可以扩展父类的功能,但是不能改变父类原有的功能。

代理类的父类

就上面的例子,我们通过

proxy.getClass().getSuperclass();

来获取代理类的父类,可以看到其父类是

class com.nyima.study.day01.XiaoWen

也就是我们的被代理类,这也从一定程度上说明自定义拦截器在调用被拦截对象的方法时,需要调用

Object invoke = methodProxy.invokeSuper(o, objects);

本博客所有文章除特别声明外,均采用 CC BY-SA 4.0 协议 ,转载请注明出处!

Redis设计与实现 Previous
集合源码 Next