【设计模式】代理模式

概述：

1. 什么是代理

2. 代理的分类

3. Spring AOP对动态代理的应用

 

一、什么是代理

你需要乘飞机，但是去不了机场，机票代理点就能让你实现买机票的需求。

你需要办理车过户，但是你不知道流程，在门口找一个专门代你办理的人，他都给你办了，这就是代理。

可见代理是个中间商，他代替原来的事务部门，满足你的需求，这就是代理模式的意义。

想象一下，你想修改某个类以实现特殊的功能，但是这个类在SDK包里，或者在远程机器上，怎么办？

这时候你可以找个代理，不就是想实现自定义功能吗？不用去改原始类了，你在我这随便改，我把原始类集成进来，这样我既有原始类的功能，又有你自定义的功能，不就完美了。

这就是代理模式。

二、代理的分类

1. 静态代理

这个 不好类比说明，因为java程序中有运行中的概念，静态代理就相当于运行前，你就已经写好了代理类，然后编译直接调用。

比如有如下场景，目前有个生产玩具的类，在不改变这个类的前提下，增加统计这个类生产玩具方法用时的功能，这个怎么实现？

/**
 * 委托者，原始类,一个生产玩偶的工厂
 */
public class ToyFactory implements Produce {
    @Override
    public void produce_cat() {
        System.out.println("生产了一只小猫");
        try {
            Thread.sleep(new Random().nextInt(1000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void produce_deer() {
        System.out.println("生产了一只小鹿");
        try {
            Thread.sleep(new Random().nextInt(1000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

 

/**
 * 生产方法统计时间的代理类
 */
public class ToyFactoryTimeProxy implements Produce{
    private ToyFactory toyFactory;


    public ToyFactoryTimeProxy(ToyFactory toyFactory) {
        this.toyFactory = toyFactory;
    }

    @Override
    public void produce_cat() {
        long startTime = System.currentTimeMillis();
        this.toyFactory.produce_cat();
        long endTime = System.currentTimeMillis();
        long takeTime = endTime - startTime;
        System.out.println("log-----cat take time="+takeTime);
    }

    @Override
    public void produce_deer() {
        long startTime = System.currentTimeMillis();
        this.toyFactory.produce_deer();
        long endTime = System.currentTimeMillis();
        long takeTime = endTime - startTime;
        System.out.println("log-----deer take time="+takeTime);
        
    }
}

 

public static void main(String[] args) {
        ToyFactory toyFactory = new ToyFactory();
        ToyFactoryTimeProxy toyFactoryTimeProxy = new ToyFactoryTimeProxy(toyFactory);
        toyFactoryTimeProxy.produce_cat();
    }

 

执行结果：

生产了一只小猫
log-----cat take time=226

 

这就是静态代理的实现，这种方式属于聚合的方式，其实还有一种方式能实现类似的效果，就是继承。

我们可以继承工厂类，然后重写造小猫的方法，在这方法中写统计时间的逻辑，但是继承方式有弊端，如果我们再要一个功能，就是在统计完时间后，还打印日志，这无非就是再写一个子类，继承时间代理类，但是如果新的需求是先打印日志，再统计时间，对于继承来说，之前写的就要不了了，得再写一个工厂类的子类，作为日志代理类，再写一个日志代理类的子类，作为时间代理类。

然而通过聚合的方式，可以利用java多态的特性，既然所有的代理类和委托类都需要实现同一个接口，那么我们就直接都聚合接口，而不是具体的委托类，这样就可以实现代理类之间也可以互相代理了。

首先把时间代理类中的ToyFactory改成Produce。

/**
 * 生产方法统计时间的代理类
 */
public class ToyFactoryTimeProxy implements Produce{
    private Produce produce;


    public ToyFactoryTimeProxy(Produce produce) {
        this.produce = produce;
    }

    @Override
    public void produce_cat() {
        long startTime = System.currentTimeMillis();
        this.produce.produce_cat();
        long endTime = System.currentTimeMillis();
        long takeTime = endTime - startTime;
        System.out.println("log-----cat take time="+takeTime);
    }

    @Override
    public void produce_deer() {
        long startTime = System.currentTimeMillis();
        this.produce.produce_deer();
        long endTime = System.currentTimeMillis();
        long takeTime = endTime - startTime;
        System.out.println("log-----deer take time="+takeTime);
        
    }
}

/**
 * 这是个生产方法打日志的代理类
 */
public class ToyFactoryLogProxy implements Produce{
    private Produce Produce;


    public ToyFactoryLogProxy(Produce Produce) {
        this.Produce = Produce;
    }

    @Override
    public void produce_cat() {
        this.Produce.produce_cat();
        System.out.println("log-----cat is produced");
    }

    @Override
    public void produce_deer() {
        this.Produce.produce_deer();
        System.out.println("log-----deer is produced");
    }
}

    public static void main(String[] args) {
        ToyFactory toyFactory = new ToyFactory();
        ToyFactoryTimeProxy toyFactoryTimeProxy = new ToyFactoryTimeProxy(toyFactory);
        ToyFactoryLogProxy toyFactoryLogProxy = new ToyFactoryLogProxy(toyFactoryTimeProxy);
        toyFactoryLogProxy.produce_cat();
    }

 

执行结果：

生产了一只小猫
log-----cat take time=914
log-----cat is produced

 

如果想反过来，只需要把main方法中的聚合顺序调整一下就可以了。

这里跑题一下，积累一下多态的知识：

面向接口编程的概念，用电脑主板和显卡来举例。
如果你主板上链接的是具体的某个内存条，那么会造成一种什么情况：
在组装电脑之处，你对内存的要求就是2G就能满足，你new了一个2G的内存条，随着使用2G不够了，这个时候你已经没法切换了。
《面向对象软件构造（Object Oriented Software Construction）》中提出了开闭原则，它的原文是这样：“Software entities should be open for extension,but closed for modification”。
翻译过来就是：“软件实体应当对扩展开放，对修改关闭”。这句话说得略微有点专业，我们把它讲得更通俗一点，也就是：软件系统中包含的各种组件，例如模块（Modules）、类（Classes）以及功能（Functions）等等，应该在不修改现有代码的基础上，引入新功能。
开闭原则中“开”，是指对于组件功能的扩展是开放的，是允许对其进行功能扩展的；开闭原则中“闭”，是指对于原有代码的修改是封闭的，即修改原有的代码对外部的使用是透明的。
然而要解决这个问题，答案其实就在接口上了，你约定好了一个规范接口，所有显卡对象要想接入主板，必须实现这个接口，那么你在设计功能的时候，压根不用考虑具体实现，
2G不够直接拔了换4G，ArrayList不行就直接换LinkList，具体实现与主体类就实现了解耦，而面向接口编程，本质上就是运用了java多态的特性。

 

静态代理虽然也实现了功能，但是存在两个问题：

　　1. 如果SDK包里有100个委托类需要代理，那么就得写100个代理类，这个在现实工作中并不稀奇，最常用到的就是AOP，你需要拦截符合条件的所有类的方法，给他们附加上功能，这个要用静态代理实现就是把每个类都加上代码。

　　2. 就算委托类很少，但是里面的方法很多，也会造成很大的工作量，而且同样的代码会重复写很多次，100个方法就得写一百次统计时间的那段代码，极其繁琐。

　　如果我们自己去解决这两个问题，会怎么写，首先，需要根据委托类灵活的去生成对应的代理类，这个必须是一个自动的过程，如问题1，可能巨量的类需要代理，必须全自动才能解决量的问题。

　　再有就是对于委托类中方法的解决方案，如果你动态生成的代理类里，还是一个一个的去实现方法，问题2就解决不掉，最好是有一个通用的方法，这个方法能代表委托类中的所有方法（或者符合条件的方法），然后在这个类中加上你想加的代码，就等于所有方法都有了，实现了这两种解决方案的，就是动态代理。

 2. 动态代理

继续上面的思路，我们的问题转移到怎么生成一个动态代理上面来了。

继续思考，你要生成这个样的一个代理，首先你要获取到委托类实现了哪些接口，因为我们将要生成的代理类也要实现接口，其次是咱们要这个代理类干啥活，打日志也好，筛选返回值也好，你得告诉它。

我们看看JDK的是否跟我们说的一样：

public class Proxy implements java.io.Serializable {

  public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h) throws IllegalArgumentException
    {
        final Class<?>[] intfs = interfaces.clone();
        /*
         * Look up or generate the designated proxy class.
         */
        Class<?> cl = getProxyClass0(loader, intfs);
        /*
         * Invoke its constructor with the designated invocation handler.
         */
        try {
            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 (NoSuchMethodException e) {
            throw new InternalError(e.toString(), e);
        }
    }
}

 

 可以看到，在生成动态代理类的方法中，跟我们预想的只多了一个ClassLoader，委托类实现的一些接口（Class<?>[] interfaces），和我们需要的委托类做的事（InvocationHandler h），这里都有。

 我们需要重点关注Class<?> cl = getProxyClass0(loader, intfs)这句代码，这里产生了代理类，这个类就是动态代理的关键。

可以通过java自带的类方法ProxyGenerator.generateProxyClass，看看jdk给我生成的代理文件是什么样子的：

byte[] Proxy0s = ProxyGenerator.generateProxyClass("12345", ToyFactory.class.getInterfaces());
        String path = "C:\\Users\\panda_zhu\\Desktop\\12345.class";
        try{
            FileOutputStream fos = new FileOutputStream(path);
            fos.write(Proxy0s);
            fos.flush();
            System.out.println("编译文件生成完毕！");
        } catch (Exception e) {
            e.printStackTrace();
        }

 

 委托类：

/**
 * 委托者，原始类,一个生产玩偶的工厂
 */
public class ToyFactory implements Produce {
    @Override
    public void produce_cat() {
        System.out.println("生产了一只小猫");
        try {
            Thread.sleep(new Random().nextInt(1000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void produce_deer() {
        System.out.println("生产了一只小鹿");
        try {
            Thread.sleep(new Random().nextInt(1000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

 

 

生成的class文件反编译后如下（部分）：

public final class 12345 extends Proxy implements Produce
{
  private static Method m1;
  private static Method m4;
  private static Method m2;
  private static Method m3;
  private static Method m0;

  public 12345(InvocationHandler paramInvocationHandler)throws
  {
    super(paramInvocationHandler);
  }
//从这里可以很清晰的看到，利用反射，把委托类中的方法取出，聚合到代理类中，然后通过父类的属性InvocationHandler中的invoke方法执行，这个方法后续说。从而实现了代理委托类的功能。
  static
  {
    try
    {
      m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
      m4 = Class.forName("com.example.design.proxy.Produce").getMethod("produce_deer", new Class[0]);
      m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
      m3 = Class.forName("com.example.design.proxy.Produce").getMethod("produce_cat", new Class[0]);
      m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
      return;
    }

  }
  public final boolean equals(Object paramObject)
    throws
  {
    try
    {
      return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();
    }

  }

  public final void produce_deer()
    throws
  {
    try
    {
      this.h.invoke(this, m4, null);
      return;
    }

  }
  }
  public final void produce_cat()
    throws
  {
    try
    {
      this.h.invoke(this, m3, null);
      return;
    }

  }
}

到此为止，我们至少解决了一个问题，那就是动态生成一个代理文件。

但是，这里其实有一个疑问点，就是这个生成的代理类，是怎么知道我的委托类是谁的，这里也就依据和委托类实现同一个接口而写了方法的空壳子而已，真正实现都是人家InvocationHandler的invoke方法去实现的，不论是生产鹿也好生产猫也好，就这一个方法，当然这也是咱们最初的设想，即上一节通用方法的解决方案，但是是怎么实现的呢？又是怎么精准定位委托类的呢？

我们看看这个类的源码：

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

 

就一个方法，第一个参数传入代理类，咱们自动生成的代理类，传入的是他自己。

第二个是需要执行的方法，这个代理类传的是他反射出来接口的方法。

第三个是这些方法的参数，这里为了方便看咱们没有参数。

通过这个方法也得不出这个答案，因为代理类本来也没法说清楚委托类是谁，第二个顶多告诉这个通用的方法，我要执行的是哪个方法，所以可以推断，这些都应该落在自己定义的Invocation上。

/**
 *  自定义的invoaction类，
 */

public class MyInvocationHandler implements InvocationHandler {
    private ToyFactory toyFactory;

    public MyInvocationHandler(ToyFactory toyFactory){
        this.toyFactory = toyFactory;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("开始执行自定义方法。。");
        long startTime = System.currentTimeMillis();
        method.invoke(toyFactory,new Object[]{});
        long endTime = System.currentTimeMillis();
        System.out.println("执行"+method.getName()+"方法共耗时："+(endTime-startTime));
        return null;
    }
}

 

答案在这里，跟预想的一样，是在自定义invacation类里聚合了委托类，并且通过method.invoke()方法，实现传入哪个方法，调用托管类哪个方法这种灵活性的。

这里有一个疑问，就是传进来的proxy对象好像没有用上，这个是干啥的，其实这个参数是为了返回值，jdk文档中表示，这个invoke方法的返回值必须跟传入的proxy返回值对应。

        ToyFactory toyFactory = new ToyFactory();
        //使用动态代理
        Produce o = (Produce)Proxy.newProxyInstance(toyFactory.getClass().getClassLoader(), toyFactory.getClass().getInterfaces(), new MyInvocationHandler(toyFactory));
        o.produce_deer();

开始执行自定义方法。。
生产了一只小鹿
执行produce_deer方法共耗时：974

 

 至此，咱们静态变量遇到的问题就算是彻底解决了。

动态生成代理类解决了需要一直自己写代理类的事，method.invoke方法解决了每个方法都需要写重复代码的问题。

 

3. Spring AOP 对动态代理的应用

Spring AOP是基于动态代理的，如果要代理的对象，实现了某个接口，那么Spring AOP会使用JDK Proxy，去创建代理对象，而对于没有实现接口的对象，就无法使用 JDK Proxy 去进行代理了，这时候Spring AOP会使用Cglib ，这时候Spring AOP会使用 Cglib 生成一个被代理对象的子类来作为代理。

在web开发中，我们通常将项目分为controller、service、dao层，这种分层是一种纵向的，我们为了好理解，可以把它想象层一个竖状的圆柱形，数据从中川流不息。

而AOP则是从这个圆柱截面中插入一个滤网，也就是我们说的面向切面。

在日常开发中，日志拦截、权限处理、异常拦截、事务等，都是基于这种切面完成的。

那spring在哪调用了动态代理呢？

final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {
    public Object getProxy(@Nullable ClassLoader classLoader) {
    if (logger.isTraceEnabled()) {
    logger.trace("Creating JDK dynamic proxy: " + this.advised.getTargetSource());
    }

    return Proxy.newProxyInstance(classLoader, this.proxiedInterfaces, this);
    }
}

 

最后那个返回值是不是很眼熟了。 

题外知识点练习：

如何使用spring aop。

POM中引入依赖：

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
            <version>2.2.6.RELEASE</version>
        </dependency>

 

由于springboot默认配置启动aop，所以不用另外配置了。

@Aspect
@Component
public class WebAspect {
    /*
    *  切点，用来匹配需要切入的并增强的目标方法
    *  下面的表示com.example.design.proxy.aop包下所有类的所有方法
    *   匹配规则很灵活可以自行百度
    */
    @Pointcut("execution(* com.example.design.proxy.aop.*.*(..))")
    public void pointCut(){

    }

    /*
    * 在方法执行前开始执行
    * */
    @Before("pointCut()")
    public void beforeAdvice(JoinPoint joinPoint){
        System.out.println("前置通知开始。。");
        Signature signature = joinPoint.getSignature();
        System.out.println("目前代理的是哪一个方法："+ signature.getName());
    }

    /*
     * 在方法执行后开始执行
     * */
    @After("pointCut()")
    public void afterAdvice(){
        System.out.println("后置通知开始。。");
    }


    @AfterReturning(value = "execution(* com.example.design.proxy.aop.*.*(..))",returning = "args")
    public void afterReturningAdvice(JoinPoint joinPoint,String args){
        System.out.println("后置返回通知开始。。");
        System.out.println("返回值是："+args);
    }



}

 

写一个切面类，确定拦截那些目标类，如果是使用动态代理的话，这一步就是挑选委托类和组装自定义invocation的地方，这里只是挑选了几个基本的通知方式，其实还有环绕通知，异常通知等等，对应的是咱们在自定义invocation中方法执行不同位置写入的增强代码。

@RestController
@RequestMapping("/aop")
public class AopController {
    @RequestMapping("before")
    public String testBeforeAdvice(){
        return "testBeforeAdvice方法开始执行！";
    }
}

http://localhost:8080/aop/before

前置通知开始。。
目前代理的是哪一个方法：testBeforeAdvice
后置返回通知开始。。
返回值是：testBeforeAdvice方法开始执行！
后置通知开始。。

 全文涉及知识点：

1. 代理模式，包括动态代理，静态代理。

2. java多态。

3. spring aop对于动态代理的使用。

4. aop在springboot中使用示例。

 

 

练习源码：https://github.com/panda-zhu/design

全文借鉴：

Spring AOP实现原理： https://blog.csdn.net/moreevan/article/details/11977115/

10分钟看懂动态代理模式： https://www.cnblogs.com/faster/p/10874371.html