【设计模式】代理（Proxy）

概述

由于某些原因我们不能直接访问“目标”对象，需要通过“代理”对象来访问目标对象。代理对象此时就充当了一个“中介”的角色。

举个例子：书店与出版社，二者是代理与被代理的关系。

• 书店可以卖书，卖书同时还可以搞优惠，打折送优惠券。
• 出版社只能卖书，且委托书店代理。

代理模式中的角色

• 抽象主题类 subject：一般为接口或者抽象类。内部定义了真实主题与代理类所需实现的业务。
• 真实主题类 RealSubject：实现了抽象主题定义的具体业务，是代理对象所代表的真实类。
• 代理类Proxy ：提供了与真实主题相同的接口，其内部含有对真实主题的引用，可以访问、控制、扩展真实主题的功能。

因此代理的大致实现如下：

1、创建接口（被代理类的功能抽象出来的）
2、代理类与被代理类实现同一接口(是不是想起了装饰者模式，静态代理与装饰者就是像)
3、代理类中进行功能代理，在代理这个功能前后还可以做些代理类特有的工作

代理分类

Java中的代理按照代理类生成的时机可分为静态代理和动态代理。静态代理的代理类在代码编译期间就生成了，而动态代理则是在代码运行期间生成，存在于内存中。

动态代理又分jdk动态代理和CGLIB动态代理。前者为jdk提供的api后者是一个三方库。

静态代理

先拿书店与出版社的栗子演练下静态代理~

1、创建接口

书店与出版社共同的目标都是把书卖出去，我们抽象业务，抽取个卖书的接口。

/**
 * Create by SunnyDay on 2019/04/14
 */
public interface Subject {
    void sailBook();
}

2、代理类与被代理类实现同一接口

被代理类:

/**
 * Create by SunnyDay on 2019/04/14
 * 出版社，真实主题，被代理的类。
 */
public class Press implements Subject {
    @Override
    public void sailBook() {
        System.out.println("卖书ing");
    }
}

代理类：

/**
 * Create by SunnyDay on 2019/04/14
 * 代理类
 */
public class ProxySubject implements Subject {

    private  Subject subject; // 注意引用的赋值在class内部（对比装饰者思考）

    public ProxySubject() {

    }

    /**
     * 代理卖书功能，自己还做点功能。
     */
    @Override
    public void sailBook() {
        subject = new Press();
        discount();
        subject.sailBook();
        give();
    }

    /**
     * 打折
     * */
    private void discount() {
        System.out.println("打折券一张");
    }
    /**
     * 赠品
     * */
    private void give() {
        System.out.println("买书赠品一个");
    }
}

3、测试类

public class Test {
    public static void main(String[] args) {
        // 代理商卖书（客户直接与代理商沟通了，不与出版社沟通）
        ProxySubject proxySubject = new ProxySubject();
        proxySubject.sailBook();
    }
}

log:

打折券一张
卖书ing
买书赠品一个

可见ProxySubject就是代理商，Test类可以当做客户，客户直接与代理商进行沟通。

4、UML类图

通过类图看这几个角色关系就一目了然了。核心就在代理类中，代理类持有被代理类press的引用，这样就可操作press的sailBook方法了，并且可在操作press#sailBook的前后做其他的事情。

动态代理

动态代理的书写步骤不像我们前面总结的那几步那么死板，前面那个书写步骤书写上更适合静态代理。

为啥是这样呢？因为动态代理的代理类的字节码是在程序运行期间由JVM根据反射等机制动态的生成的，代理类和被代理类的关系是在程序运行时确定。所以不存在代理类的java源文件。

相对静态代理来说，写法上虽看着奇怪，但代理的核心步骤思想是不变的“代理类持有被代理类引用，对被代理类进行代理” 这点后续我们分析代码可留意下。

1、jdk动态代理-代码实现

好了先直接上代码，跑起来再说，新建Handler类：

/**
 * Create by SunnyDay on 2019/04/14
 * 工具类：需要实现JDK#InvocationHandler接口
 */
public class PressProxyHandler implements InvocationHandler {
    private  Subject subject;

    public PressProxyHandler() {}

    /**
     * @param proxy   代理对象，一般我们这里不用。
     * @param method  目标对象业务方法的封装。 被代理对象的哪个方法被代理，这里就是对应的方法对象封装。
     * @param args    目标对象业务方法的方法参数。
     * @return        方法返回值
     * ps： 最好了解点反射的知识点。
     * */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        subject = new Press();
        Object result;
        discount();
        result = method.invoke(subject);//执行被代理的方法。这里需要个被代理对象。
        give();
        return result;
    }

    private void discount() {
        System.out.println("今天的书八折");
    }

    private void give() {
        System.out.println("买书送圆珠笔一支");
    }

    /**
     * 获取代理对象
     * */
    public Subject getPressProxy(){
      return (Subject) Proxy.newProxyInstance(Press.class.getClassLoader(), 
                                              Press.class.getInterfaces(), 
                                              this);
    }
}

测试代码：

public class Test {
   public static void main(String[] args) {
       // 客户从代理商那卖书
       PressProxyHandler handler = new PressProxyHandler();
       Subject press = handler.getPressProxy();  // 代理类代码期间动态生成
       press.sailBook();
   }
}

log：

今天的书八折
卖书ing
买书送圆珠笔一支

2、jdk动态代理-重要方法分析

想要初步理解上述的写法我们最好提前了解下java的反射、jvm的类加载机制。

好了言归正传 上述代码中有两个方法需要说明下

• InvocationHandler#invoke
• Proxy#newProxyInstance

（1）Proxy#newProxyInstance

   public static Object newProxyInstance(ClassLoader loader,
                                         Class<?>[] interfaces,
                                         InvocationHandler h)throws IllegalArgumentException
                                         
  ClassLoader            loader： 类加载器，用于加载生成的代理类。 这里类加载器可通过被代理类来获取。
                                 （需要了解一些类加载的知识）
                                 
  Class<?>[]         interfaces： 代理类实现的接口字节码对象。由于目标类与代理类都实现了同接口（可能多个相同的），
                                  因此也可通过目标类来获取。
                                  
  InvocationHandler           h： 代理对象的调用处理程序。内部核心有个回调方法，代理类调用代理方法时，这个回调方法就会
                                  被执行.

(2)InvocationHandler#invoke

    /**
     * @param proxy   代理对象，一般我们这里不用。
     * 
     * @param method  目标对象业务方法的封装。 被代理对象的哪个方法被代理，这里就是对应的方法对象封装。
     * 
     * @param args    目标对象业务方法的方法参数。
     * 
     * @return        方法返回值
     * 
     * ps： 最好了解点反射的知识点。
     * */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
    

3、jdk 动态代理-代理类查看

注意上述的InvocationHandler并不是代理类，真正的代理类是在程序运行期间动态生成的，存在运行期。那么我们如何看到呢？这里需要借助一个阿里的jar包工具：arthas

（1）保持程序运行

public class Test {
    public static void main(String[] args) {
        PressProxyHandler handler = new PressProxyHandler();
        Subject press = handler.getPressProxy();
        press.sailBook();
     
        System.out.println("代理类:"+press.getClass());
        while (true){}
    }
}

log

代理类:class com.sun.proxy.$Proxy0

程序一直运行，则代理类一直存在。

(2) 运行arthas-boot.jar 包

通过终端进入arthas-boot.jar所在目录，然后执行jar 命令执行jar包，执行jad命令获取代码：

public final class $Proxy0 extends Proxy implements Subject {

    private static Method m1;
    private static Method m3;
    private static Method m2;
    private static Method m0;

    public final void sailBook() {
        try {
            this.h.invoke(this, m3, null);
            return;
        }
        catch (Error | RuntimeException throwable) {
            throw throwable;
        }
        catch (Throwable throwable) {
            throw new UndeclaredThrowableException(throwable);
        }
    }

    public $Proxy0(InvocationHandler invocationHandler) {
        super(invocationHandler);
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m3 = Class.forName("pattern_proxy.static_proxy.Subject").getMethod("sailBook", new Class[0]);
            m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
            m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
            return;
        }
        catch (NoSuchMethodException noSuchMethodException) {
            throw new NoSuchMethodError(noSuchMethodException.getMessage());
        }
        catch (ClassNotFoundException classNotFoundException) {
            throw new NoClassDefFoundError(classNotFoundException.getMessage());
        }
    }

    public final boolean equals(Object object) {
        try {
            return (Boolean)this.h.invoke(this, m1, new Object[]{object});
        }
        catch (Error | RuntimeException throwable) {
            throw throwable;
        }
        catch (Throwable throwable) {
            throw new UndeclaredThrowableException(throwable);
        }
    }

    public final String toString() {
        try {
            return (String)this.h.invoke(this, m2, null);
        }
        catch (Error | RuntimeException throwable) {
            throw throwable;
        }
        catch (Throwable throwable) {
            throw new UndeclaredThrowableException(throwable);
        }
    }

    public final int hashCode() {
        try {
            return (Integer)this.h.invoke(this, m0, null);
        }
        catch (Error | RuntimeException throwable) {
            throw throwable;
        }
        catch (Throwable throwable) {
            throw new UndeclaredThrowableException(throwable);
        }
    }
}

（3）简化代码&分析代码流程

正真的代理类终于被看到了，但是看着不利于代码的分析，我们可以简化下，去除些无关的代码：

• hashCode 去除
• toString 去除
• equals 去除
• try catch块去除

public final class $Proxy0 extends Proxy implements Subject {

    private static Method m3;

    static {
        m3 = Class.forName("pattern_proxy.static_proxy.Subject").getMethod("sailBook", new Class[0]);
    }
    
    public $Proxy0(InvocationHandler invocationHandler) {
        super(invocationHandler);
    }
    
    public final void sailBook() {
            this.h.invoke(this, m3, null);
    }
}

// 父类Proxy有个核心成员，为了方便直接也一并摘来观看：
public class Proxy implements java.io.Serializable {
    ...
    // protected 类型的成员InvocationHandler类。
    protected InvocationHandler h;
    ...
}

这个代理类很简单：
1、继承了系统api Proxy类，实现了我们定义的接口。（到这是否可回忆起步骤：代理类与被代理类实现统一接口）
2、通过反射获取接口的方法对象
3、$Proxy0 对象创建时，需要外部提供个InvocationHandler实现类对象。

4、代理类$Proxy0 实现接口方法。（到这是否回忆起步骤：对被代理类进行代理）

注意，代理类的具体实现是委托给InvocationHandler#invoke方法来实现的。这里是具体的代理细节。

好了代理类剖析个差不多了接下来结合Test类分析一波：

4、cglib动态代理

通过上面的栗子可以知道jdk动态代理只能对 实现接口的类提供代理，而CGLIB是一个功能强大，高性能的代码生成包。它为没有实现接口的类提供代理，为JDK的动态代理提供了很好的补充。

通常可以使用Java的动态代理创建代理，但当要代理的类没有实现接口或者为了更好的性能，CGLIB是一个好的选择。

（1）目标类

/**
 * Create by SunnyDay 2022/10/24 21:58:47
 **/
public class NovelPress {
    public void sailBook() {
        System.out.println("小说出版社卖书");
    }
}

(2) 代理帮助类

/**
 * Create by SunnyDay 2022/10/24 22:04:50
 * 工具类
 **/
public class ProxyHelper {
    private NovelPress mNovelPress;

    public ProxyHelper() {}

    /**
     * 获取 NovelPress 类的代理类对象。
     * 为啥返回值是NovelPress类型？因为cglib中代理类是目标类的子类。（就是这样设计的，就如jdk的动态代理只能对接口实现类进行代理一样）
     */
    public NovelPress getNovelProxyObject() {
        mNovelPress = new NovelPress();
        Enhancer enhancer = new Enhancer(); // cglib 使用这个类
        enhancer.setSuperclass(NovelPress.class);
        enhancer.setCallback(new MethodInterceptor() {
            /**
             * 通过代理类调用代理方法时，这个函数就会被回调。
             * @param o 目标对象
             * @param method 目标方法对象
             * @param objects 目标方法参数
             * */
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                System.out.println("今天小说8折");
                mNovelPress.sailBook();
                System.out.println("买小说送圆珠笔一只");
                return null;
            }
        });
        return (NovelPress) enhancer.create();
    }

}

(3)测试

public class Test {
    public static void main(String[] args) {
        // test cglib
        NovelPress novelPressProxyObject = new ProxyHelper().getNovelProxyObject();
        novelPressProxyObject.sailBook();
    }
}

log:
今天小说8折
小说出版社卖书
买小说送圆珠笔一只

小结

1、三种对比

• jdk与cglib
  cglib底层采用的ASM字节码生成框架，cglib不能为目标类的final方法进行代理，因为cglib生成的代理类是目标类的子类。

  jdk底层是反射，会消耗一些性能，jdk动态代理只能对接口进行代理，因为jdk生成的代理类继承了Proxy，java不支持多继承。

  二者效率对比上就不说了，因为jdk不同版本有过针对性优化我们只需遵循对接口就用JDK动态代理，无接口就用CGLIB动态代理

• 动态代理与静态代理
  动态代理与静态代理相比最大的好处所有的接口方法都被放在InvocationHandler#invoke方法中处理。
  试想假如接口中有多个方法需要被代理时，我们需要再静态代理类的每个实现方法中写代理代码。
  接口增加新方法，不仅目标类要实现此方法，所有的静态代理类也要实现此方法，增加了代码维护复杂度。

2、代理优点

• 可保护目标对象
• 可拓展目标对象
• 一定程度上降低系统耦合（将客户端与目标对象分离）

3、代理缺点

• 增加系统负责度（特别是动态代理实现麻烦，不易理解）

4、使用场景

• 远程代理：可实现远程调用RPC思想。本地服务与远程服务都实现网络通信接口
• 防火墙代理
• 保护代理：控制对象访问。

参考