java设计模式——代理模式

名词解释

代理模式（ProxyPattern）是指为其他对象提供一种代理，以控制对这个对象的访问。

• 代理对象在客服端和目标对象之间起到中介作用。
• 代理模式属于结构型设计模式。
• 使用代理模式主要有两个目的：一保护目标对象，二增强目标对象。

写法分类

静态代理

先定义一个接口Dancer

public interface Dancer {
    void dance();
}

现在有个 Student 类

public class Student implements Dancer {
    public void dance() {
        System.out.println("学生跳舞，她只会跳舞");
    }
}

可是光会跳舞还不行，我们需要由老师来帮领学生做很多事情，比如：

public class Teacher implements Dancer {

    private Student student; //这个是被代理的对象

    public void dance() { //这里就可以做很多事情了，所以增加了 Student 类的dance功能
        System.out.println("这里可以做其他事情，比如要教学生跳舞，报名参见舞蹈比赛。。。");
        this.student.dance();
        System.out.println("处理后续事情，比如做一下点评或总结");
    }

    public Teacher(Student student) {
        this.student = student;
    }

    public Student getStudent() {
        return student;
    }

    public void setStudent(Student student) {
        this.student = student;
    }
}

从上面的例子可以看出，Teacher类可以保护Student类，因为我们不会修改Student类的任何代码，就可以达到扩展这个类功能。这就体现了开头说的保护和增强的作用。

动态代理

​ 上面的静态代理虽然可实现我们想要的增强和和保护功能，但是如果我们被代理的类不只一个需要代理的方法呢，那是不是要为每个方法都写一个代理方法呢，这样就会显得很繁琐。

动态代理 就是可以动态代理一个类，并且可以为所有需要代理的方法提供一个公共的代理入口，如果我们所有的方法的被代理逻辑都是一样的，那用动态代理就很方便了，比如我们的数据库操作，每访问一次数据库都需要做大量重复的操作，我们就可以把这些所有重复的操作放到一个代理类来处理。

​ 当然如果代理需要处理的逻辑会根据数据状态不同而不同，我们也可以通过动态代理来处理，再结合策略模式等其他方式实现更优雅的代码，笑脸。

JDK动态代理

用法

1. 代理类

新的代理类不用继承被代理类的所属接口，而是将被代理类放到了代理类的属性中，同时代理类需要继承InvocationHandler接口，因为Proxy类的构造方法需要传入一个该接口的实现类来做一些初始化操作，代码如下：

public class JdkTeacher implements InvocationHandler {
    
    private Student target; //一定要拿到被代理对象的引用，可以通过构造行数来进行赋值
    public JdkTeacher(Student target) {
        this.target = target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before();
        Object reObj = method.invoke(this.target,args); //这里就可以对被引用的对象做一次代理处理，可以在前后包装我们的处理逻辑
        after();
        return reObj;
    }
    private void before(){ System.out.println("前置处理。。。"); }
    private void after(){System.out.println("扫尾处理。。。"); }
}

2. 调用

public class JdkTeacherTest {

    public static void main(String[] args) {

        try {         
            Student st = new Student();
            JdkTeacher teacher = new JdkTeacher(st);
            Dancer proxyStudent = (Dancer)Proxy.newProxyInstance(st.getClass().getClassLoader(),
                    st.getClass().getInterfaces(),teacher);     
            proxyStudent.dance();

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

执行结果：

前置处理。。。
学生跳舞，她只会跳舞
扫尾处理。。。

原理

要从Proxy.newProxyInstance这个方法开始讲起（以前觉得这个名字不好记，现在发现挺好理解和记忆的，就是一个创建一个新的代理对象实例的意思，哈哈）。

源码还是有点绕，一时没有完全理清，但大致流程如下：

newProxyInstance 》 Class<?> cl = getProxyClass0(loader, intfs); 》proxyClassCache.get(loader, interfaces)

这个 proxyClassCache 是一个静态变量，用来缓存代理类

 /**
     * a cache of proxy classes
     */
    private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
        proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());

在 new ProxyClassFactory() 的构造函数中会生成代理类

 /*
             * Generate the specified proxy class.
             */
            byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                proxyName, interfaces, accessFlags); //这里才是生成代理类的真正实现
            try {
                return defineClass0(loader, proxyName, proxyClassFile, 0, proxyClassFile.length);  //这个方法时一个本地方法
            } catch (ClassFormatError e) {
                /*
                 * A ClassFormatError here means that (barring bugs in the
                 * proxy class generation code) there was some other
                 * invalid aspect of the arguments supplied to the proxy
                 * class creation (such as virtual machine limitations
                 * exceeded).
                 */
                throw new IllegalArgumentException(e.toString());
            }

其中defineClass0是一个本地方法

private static native Class<?> defineClass0(ClassLoader loader, String name, byte[] b, int off, int len);

小常识

在sun.misc.ProxyGenerator类中会有如下常量

private static final boolean saveGeneratedFiles = (Boolean)AccessController.doPrivileged(new GetBooleanAction("sun.misc.ProxyGenerator.saveGeneratedFiles"));

在 generateProxyClass方法中会根据这个常量来判断是否保存生成的文件

 public static byte[] generateProxyClass(final String var0, Class<?>[] var1, int var2) {
        ProxyGenerator var3 = new ProxyGenerator(var0, var1, var2);
        final byte[] var4 = var3.generateClassFile();
        if (saveGeneratedFiles) { // 这里会进行保存生成的文件
            ...
        }
 }

所以我们可以通过

System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");

来实现保存jdk生成的代理类class文件到本地磁盘，路径在本地工程根目录下的com/sun/proxy，从而进行分析，生成代理类的逻辑还是有点复杂，就不具体分析了（其实是还没有看懂，吼吼），直接上文件分析

$Proxy0.class

package com.sun.proxy;

import com.hq.study.java.desginpattern.proxy.staticproxy.Dancer;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class $Proxy0 extends Proxy implements Dancer {
    private static Method m1;
    private static Method m3;
    private static Method m2;
    private static Method m0;

    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

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

    public final void dance() throws  {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m3 = Class.forName("com.hq.study.java.desginpattern.proxy.staticproxy.Dancer").getMethod("dance");
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

总结

jdk的动态代理还是要先写一个代理类，并且这个代理类要拿到被代理的对象，这样还是不能达到通用的目的，因为要为每一个被代理类都要写一个代理的 InvocationHandler ，这个InvocationHandler 就充当了我们所说的中介角色

CGLIB动态代理

什么是CGLIB

​ CGLIB（Code Generator Library）是一个强大的、高性能的代码生成库。其被广泛应用于AOP框架（Spring、dynaop）中，用以提供方法拦截操作。Hibernate作为一个比较受欢迎的ORM框架，同样使用CGLIB来代理单端（多对一和一对一）关联（延迟提取集合使用的另一种机制）
​ CGLIB底层使用了ASM（一个短小精悍的字节码操作框架）来操作字节码生成新的类。除了CGLIB库外，脚本语言（如Groovy何BeanShell）也使用ASM生成字节码。ASM使用类似SAX的解析器来实现高性能。我们不鼓励直接使用ASM，因为它需要对Java字节码的格式足够的了解

CGLIB相关产品机构如下：

用法

1.代理类

public class CglibTeacher implements MethodInterceptor {
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        before();
        Object obj = methodProxy.invokeSuper(o,objects);
        after();
        return obj;
    }
    private void before(){
        System.out.println("cglib 前置");
    }
    private void after(){
        System.out.println("cglib 扫尾");
    }
}

2.调用

public class CglibTeacherTest {

    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(Student.class);
        enhancer.setCallback(new CglibTeacher());
        Student st = (Student)enhancer.create();
        st.sing();
    }
}

当然我们可以将这部分初始化的代码放到代理类中，这样会使整个逻辑更清晰些，符合 迪米特法则

现在来改写一下代理类，添加如下方法：

 public Object getInstance(Class clazz) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(clazz);
        enhancer.setCallback(this);
        return enhancer.create();
    }

这样调用类就变成这样了：

Student st = (Student) new CglibTeacher().getInstance(Student.class);
        st.dance();

这样就很清爽了。而且可以发现，如果我们要代理其他类，直接向 getInstance传入相应的 Class 对象就可以了。

原理

CGLIB也是通过动态生成class文件的方式来生成代理

小常识

通过如下设置可以将生成的额代理类class文件保存的磁盘

System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY,             "E:\\workspace\\idea\\javastudy\\net\\sf\\cglib\\cglib_proxy_class/");

得到文件及目录结构如下

简单分析

上面的包staticproxy是我定义Student这个被代理类的包。从上图可以看出，Cglib生成的代理类相关的class文件有3个，另外两个是核心class文件，暂不研究

通过查看类图

可以发现 CGLIB是通过继承被代理对象的方式来实现代理的，所以CGLIB不能代理被final修饰的类或者方法

JDK动态代理和CGLIB动态代理对比

1. JDK代理的类必须实现接口，如果一个类没有实现任何一个接口，则不能不JDK动态代理
2. JDK 和CGLib 都是在运行期生成字节码，JDK 是直接写Class 字节码，CGLib 使用ASM框架写Class 字节码，Cglib 代理实现更复杂，生成代理类比JDK 效率低。
3. JDK 调用代理方法，是通过反射机制调用，CGLib 是通过FastClass 机制直接调用方法，CGLib 执行效率更高。

spring中应用

• 当Bean 有实现接口时，采用用JDK 的动态代理
• 当Bean 没有实现接口时，采用CGLIB

可以通过配置强制使用CGLIB，加入如下配置即可：

<aop:aspectj-autoproxy proxy-target-class="true"/>

参见这里：https://docs.spring.io/spring/docs/current/spring-framework-reference/core.html