Java学习笔记：代理模式

代理模式

代理模式有三个主要的角色，分别是接口、委托类与代理类。委托类与代理类继承了同样的接口，保证他们的功能是一致的，这样在想调用委托类的时候就可以通过代理类间接地进行调用。
这种间接调用带来的好处是可以使得代理类在将任务交给委托类之前可以进行一些先验的操作或者委托类实现之后实现后续的操作，就起到了方法增强的作用。

根据实现方式的不同，可以分为静态代理和动态代理

静态代理

之所以称之为静态代理，是因为在javac编译代码之前程序就已经确定了，下面给出一个实例
我们想要实现一个将两个字符串类型的数字求和并返回整型的结果，为此我们设计了如下的接口

package com.cui.proxy.staticProxy;

/**
 * 代理类和委托类锁需要共同继承的接口
 */
public interface StringSumInterface {

    /**
     * 根据字符串进行求和运算
     * @param a 数字的字符串
     * @param b 数字的字符串
     * @return 返回整型类型的字符串求和结果
     */
    int getStringSum(String a, String b);
}

根据代理模式的思想，设计了委托类StringSumSubject和代理类StringSumProxy

委托类代码如下，实现了一个解析字符串并求和的过程

public class StringSumSubject implements StringSumInterface {
    @Override
    public int getStringSum(String a, String b) {
        return Integer.parseInt(a) + Integer.parseInt(b);
    }
}

代理类持有委托类，并调用委托类中的方法

public class StringSumProxy implements StringSumInterface {

    //代理类中持有委托类
    private StringSumSubject stringSumSubject;

    public StringSumProxy(StringSumSubject stringSumSubject) {
        this.stringSumSubject = stringSumSubject;
    }

    @Override
    public int getStringSum(String a, String b) {
        return stringSumSubject.getStringSum(a, b);
    }
}

这样就可以通过代理类来间接地调用委托类实现对应的功能了，比如这里实现的就是求和的功能

public class ProxyTest {

    public static void main(String[] args) {
        StringSumProxy stringSumProxy = new StringSumProxy(new StringSumSubject());

        System.out.println("1 + 1的运算结果为" + stringSumProxy.getStringSum("1", "1"));
    }
}

这样间接处理的好处在于，可以对交给委托类的数据进行预处理等等相关的操作，比如在本例子中，委托类的求和方法一定要求输入的是合乎规范的数字类型，否则会报错，那么我们就可以把数据的过滤交给代理类去执行，进行字符串的预处理，比如这里的代理类执行的就是去除空格的操作

/**
改造后的代理类
*/
public class StringSumProxy implements StringSumInterface {

    //代理类中持有委托类
    private StringSumSubject stringSumSubject;

    public StringSumProxy(StringSumSubject stringSumSubject) {
        this.stringSumSubject = stringSumSubject;
    }

    @Override
    public int getStringSum(String a, String b) {
        return stringSumSubject.getStringSum(a, b);
    }

    /**
     * 去除字符串中的空格
     * @param s 字符串
     * @return 处理后 的字符串
     */
    public String cleanString(String s) {
        StringBuilder sb = new StringBuilder();

        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (c >= '0' && c <= '9') sb.append(c);
        }
        
        return sb.toString();
    }
}

public class ProxyTest {

    public static void main(String[] args) {
        StringSumProxy stringSumProxy = new StringSumProxy(new StringSumSubject());

        System.out.println("1 + 1的运算结果为" + stringSumProxy.getStringSum("1        ", "1           "));
    }
}

这就是一个静态代理的典型实例

动态代理

对于动态代理，它之所以是动态的，就是因为它是能在运行中创建代理方法的，而不用像静态代理中一样是编译前就已经确定好的。动态代理有两种方式，分别是jdk动态代理和cglib动态代理，下面分别进行介绍。

动态代理原理

动态代理的原理在于在符合规范的情况下对.class文件进行操作，并通过这些更新后的.class文件获得代理类，由类加载器加载到JVM中使用

jdk动态代理

首先需要定义接口以及实现了这个接口的委托类

public interface PrintInterface {
    void print();
}

public class PrintSubject implements PrintInterface{
    @Override
    public void print() {
        System.out.println("方法执行中");
    }
}

jdk动态代理的实现主要是基于实现了InvocationHandler接口的类（这个类中实现了我们的方法增强逻辑）以及Proxy类中的newInstance方法来创建代理类

/**
 * 代理类
 */
public class MyInvocationHandler<T> implements InvocationHandler {

    //所持有的委托类的对象
    T subject;

    public MyInvocationHandler(T subject) {
        this.subject = subject;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        System.out.println("方法执行前的操作");
        Object result = method.invoke(subject, args);
        System.out.println("方法执行后的操作");
        return result;
    }
}

public class ProxyTest {

    public static void main(String[] args) {
        //基于委托类的实例对象创建代理类
        PrintSubject printSubject = new PrintSubject();
        MyInvocationHandler<PrintSubject> invocationHandler = new MyInvocationHandler<>(printSubject);
        PrintInterface printProxy = (PrintInterface) Proxy.newProxyInstance(PrintInterface.class.getClassLoader(), new Class<?>[]{PrintInterface.class}, invocationHandler);

        //基于代理类执行方法
        printProxy.print();
    }
}

执行结果

这样做的好处在于，就算PrintSubject类中有很多的方法都需要使用同样的逻辑进行加强，那么我们通过动态代理的方式，代码 的编写就容易的多，并且能够实现非侵入式的方法增强。这也是AOP的原理。

jdk动态代理生成的代理类命名方式是$Proxy0，它实现了继承了Proxy类，并实现了在newProxyInstance方法中传入的接口，这样就允许它进行强转了。也正是因为jdk动态代理所生成的代理类已经继承了Proxy类，因此它只能是基于接口来实现动态代理，这一点与cglib动态代理不同。

Cglib动态代理

Cglib动态代理的具体使用和jdk动态代理是类似的，都是调用各种API，但cglib动态代理用的是非常底层的字节码技术，是为委托类创建子类实现代码的增强
委托类

public class Subject {

    public void print() {
        System.out.println("方法执行");
    }
}

MethodInterceptor类

public class MyMethodInterceptor implements MethodInterceptor {
    private Subject subject;

    public Object createProxy() {
        //1.创建核心类
        Enhancer enhancer = new Enhancer();
        //2.设置父类
        enhancer.setSuperclass(subject.getClass());
        //3.设置回调
        enhancer.setCallback(this);
        //4.生成代理
        return enhancer.create();
    }


    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("方法执行前的操作");
        Object o1 = methodProxy.invokeSuper(o, objects);
        System.out.println("方法执行后的操作");
        return o1;
    }
}

动态代理对比

二者在原理上的不同带来了使用上和性能上两个方面的不同

• 原理上，jdk动态代理使用的是反射机制和拦截器生成一个代理接口的匿名实现类，而cglib使用的是底层的字节码技术，为委托类实现一个子类并重写其中的方法，在重写的方法上实现方法 的增强
• 原理上的这两点不同就带来了首先是使用上的不同：jdk动态代理要求委托类必须实现接口，因此委托类没有实现接口的情况下无法完成动态代理。而cglib使用的是继承的方式，这使得final关键字修饰的类或方法无法完成方法的增强。
• 如果使用的是dubbo和zookeeper，必须使用cglib的动态代理方式，因为只有cglib不会改变代理类的包名，dubbo是通过包扫描来完成的。而jdk动态代理生成的代理类都是在java.lang.proxy包下的
• 性能上，早期的cglib性能上更优，而随着jdk动态代理的优化，逐渐从少量调用效率更高优化到了整体效率更高