代理模式

为其他对象提供一种代理以控制对这个对象的访问。

最重要的三要素：

有执行者、被代理人
对被代理人来说，这件事是一定要去做，但是自己因为某些原因暂时不能去做，只能通过代理来做
代理能获取到被代理人的资料（拿到被代理人的引用）

动态代理

动态代理通过反射机制动态地生成代理者的对象，我们在code的时候不必要关心代理谁，代理谁我们将在执行阶段来决定。JDK为我们已提供了很方便的动态代理接口InvocationHandler。

先来定义一个场景，我要去申请专利，这个时候就可以通过专利代理人来进行专利申请。那么我就是被代理者，专利代理人就是代理。

业务接口

public interface Person {
    void apply();
}

业务实现类

public class Apkcore implements Person {
    @Override
    public void apply() {
        System.out.println("apkcore开始申请专利");
    }
}

业务处理类（专利代理人）

public class PatentAgent implements InvocationHandler {

    private Person mPersion;

    public Object getInstance(Person persion) {
        this.mPersion = persion;
        Class clazz = persion.getClass();
        return Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before();
        Object result = method.invoke(mPersion, args);
        after();
        return result;
    }

    private void after() {
        System.out.println("申请提交成功了");
    }

    private void before() {
        System.out.println("准备申请专利的材料");
    }
}

测试类

    public static void main(String[] args) {
        PatentAgent patentAgent = new PatentAgent();
        Person person = (Person) patentAgent.getInstance(new Apkcore());
        person.apply();
    }

可以看到生成的结果为：

准备申请专利的材料
apkcore开始申请专利
申请提交成功了

到此，使用JDK给我们提供的InvocationHandler实现动态代理就已经完成了。

动态代理的实现原理

我们可以打印一下测试中得到的person对象

        PatentAgent patentAgent = new PatentAgent();
        Person person = (Person) patentAgent.getInstance(new Apkcore());
        System.out.println(person.getClass());
        person.apply();

可以看到输出结果为class com.sun.proxy.$Proxy0

我们在生成的class中，是不能找到这个$Proxy0的，它只是JVM在内存中生成的动态代理类。

那么我们可以把这个类用一个文件写出来。

        //获取字节码内容
        byte[] data = ProxyGenerator.generateProxyClass("$Proxy0", new Class[]{Persion.class});
        FileOutputStream os = null;
        try {
            String path = "$Proxy0.class";
            File file = new File(path);
            if (file.exists()) {
                file.delete();
            }
            os = new FileOutputStream("$Proxy0.class");
            os.write(data);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (null != os) {
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

可以在根目录下生成$Proxy0.class文件，打开这个文件

public final class $Proxy0 extends Proxy implements Person {
    private static Method m1;
    private static Method m2;
    private static Method m3;
    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 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);
        }
    }

    //这是person.apply方法调用的地方
    public final void apply() throws  {
        try {
            //是调用了父类的h的invoke方法
            super.h.invoke(this, m3, (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"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            //m3就是apply方法，另外三个都是Object的方法，可以忽略不看
            m3 = Class.forName("com.apkcore.proxy.blog.Person").getMethod("apply");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

可以看到，主要就看apply方法，这是我们调用的方法super.h在父类Proxy中

protected InvocationHandler h;

而我们在PatentAgent中，使用Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), this)这个this就是PatentAgent，它是个InvocationHandler的实现类，所以可以知道，super.h.invoke其实就是调用了PatentAgent中的invoke方法，而invoke的第二个参数m3就是m3 = Class.forName("com.apkcore.proxy.blog.Person").getMethod("apply");，所以我们在PatentAgent中调用method.invoke(mPersion, args)就相当于mPerson.apply方法。

动态代理的过程：

Proxy通过传递给它的参数(interface/invocationHandler)生成代理类$Proxy0

Proxy通过传递给它的参数(ClassLoade)来加载生成的代理类$Proxy0的字节码文件

手写JDK动态代理

我们先看源码中InvocationHandler

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

所以我们可以模仿着实现自己的InvocationHandler

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

那么对应的，我们的动态代理PatentAgent要改为

public class MyPatentAgent implements MyInvocationHandler {

    private Person mPersion;

    public Object getInstance(Person persion) {
        this.mPersion = persion;
        Class clazz = persion.getClass();
        return MyProxy.newProxyInstance(new MyClassLoader(), clazz.getInterfaces(), this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before();
        Object result = method.invoke(mPersion, args);
        after();
        return result;
    }

    private void after() {
        System.out.println("申请提交成功了");
    }

    private void before() {
        System.out.println("准备申请专利的材料");
    }
}

其中的ClassLoader与Proxy都使用自己的而不是JDK提供的。

public class MyProxy {
    public static Object newProxyInstance(MyClassLoader classLoader, Class[] interfaces, MyPatentAgent h) {
        return null;
    }
}

public class MyClassLoader extends ClassLoader{
}

生成java文件并保存

由上面的知识我们可以知道，我们要先在运行时生成一个$Proxy0这样的java文件

public class MyProxy {

    private static final String ln = "\r\n";

    public static Object newProxyInstance(MyClassLoader classLoader, Class[] interfaces, MyPatentAgent h) {
        if (h == null) {
            throw new NullPointerException();
        }
        //1.生成源代码$MyProxy0这个源文件
        //为了实现方便，默认只代理一个接口
        String proxySrc = generateSrc(interfaces[0]);
        //2.保存到文件
        String filePath = MyProxy.class.getResource("").getPath();
        File f = new File(filePath + "$MyProxy0.java");
        FileWriter fw = null;
        try {
            fw = new FileWriter(f);
            fw.write(proxySrc);
            fw.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (null != fw) {
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        return null;
    }

    private static String generateSrc(Class interfaces) {
        Method[] methods = interfaces.getMethods();
        StringBuilder sb = new StringBuilder();
        sb.append("package ")
                .append(MyProxy.class.getPackage().getName()).append(";").append(ln)
                .append("import java.lang.reflect.Method;").append(ln)
                .append("public class $MyProxy0 implements ").append(interfaces.getName()).append("{").append(ln)
                .append("MyInvocationHandler h;").append(ln)
                .append("public $MyProxy0(MyInvocationHandler h) {").append(ln)
                .append("this.h = h;").append(ln)
                .append("}").append(ln);

        for (Method method : methods) {
            sb.append("public ")
                    //使用最简单的不传参的方法
                    .append(method.getReturnType().getName()).append(" ").append(method.getName())
                    .append(" () {").append(ln)
                    .append("try {").append(ln)
                    .append("Method m = ").append(interfaces.getName()).append(".class.getMethod(\"").append(method.getName()).append("\",new Class[]{});").append(ln)
                    .append("this.h.invoke(this,m,null);").append(ln)
                    .append("}catch(Throwable throwable){ }").append(ln)
                    .append("}").append(ln);
        }
        sb.append("}");

        return sb.toString();
    }
}

append手写代码的时候，可以边写边生成，查看哪里写得有问题

调用

    public static void main(String[] args) {
        MyPatentAgent patentAgent = new MyPatentAgent();
//        Person person = (Person)
                patentAgent.getInstance(new Apkcore());
//        System.out.println(person.getClass());
//        person.apply();

    }
}

来进行文件的生成，生成的文件在

然后把这个java文件复制到我们的工程中，可以查看我们是否写漏或者写错。

生成的$MyProxy0文件内容如下

package com.apkcore.proxy.blog.custom;

import java.lang.reflect.Method;

public class $MyProxy0 implements com.apkcore.proxy.blog.Person {
    MyInvocationHandler h;

    public $MyProxy0(MyInvocationHandler h) {
        this.h = h;
    }

    public void apply() {
        try {
            Method m = com.apkcore.proxy.blog.Person.class.getMethod("apply", new Class[]{});
            this.h.invoke(this, m, null);
        } catch (Throwable throwable) {
        }
    }
}

把java文件编译成class文件

JavaCompiler：jdk用来编译java的源程式，提供在运行期动态编译java代码为字节码的功能

            //3.编译源代码，并生成class文件
            JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
            StandardJavaFileManager manager = compiler.getStandardFileManager(null, null, null);
            Iterable iterable = manager.getJavaFileObjects(f);

            JavaCompiler.CompilationTask task = compiler.getTask(null, manager, null, null, null, iterable);
            task.call();
            manager.close();

运行测试代码，就会在编译目录下生成一个class文件。如图

将class文件中的内容，加载到JVM中

现在我们已经得到了我们所需要的class文件，只需要把它加载到jvm中即可

            //4.将class文件中的内容动态加载到JVM中
            //5.返回被代理的代理对象
            Class proxyClass = classLoader.findClass("$MyProxy0");
            Constructor constructor = proxyClass.getConstructor(MyInvocationHandler.class);
            return constructor.newInstance(h);

整个MyProxy的代码如下

public class MyProxy {

    private static final String ln = "\r\n";

    public static Object newProxyInstance(MyClassLoader classLoader, Class[] interfaces, MyPatentAgent h) {
        if (h == null) {
            throw new NullPointerException();
        }
        //1.生成源代码$MyProxy0这个源文件
        //为了实现方便，默认只代理一个接口
        String proxySrc = generateSrc(interfaces[0]);
        //2.保存到文件
        String filePath = MyProxy.class.getResource("").getPath();
        File f = new File(filePath + "$MyProxy0.java");
        FileWriter fw = null;
        try {
            fw = new FileWriter(f);
            fw.write(proxySrc);
            fw.flush();

            //3.编译源代码，并生成class文件
            JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
            StandardJavaFileManager manager = compiler.getStandardFileManager(null, null, null);
            Iterable iterable = manager.getJavaFileObjects(f);

            JavaCompiler.CompilationTask task = compiler.getTask(null, manager, null, null, null, iterable);
            task.call();
            manager.close();

            //4.将class文件中的内容动态加载到JVM中
            //5.返回被代理的代理对象
            Class proxyClass = classLoader.findClass("$MyProxy0");
            Constructor constructor = proxyClass.getConstructor(MyInvocationHandler.class);
            return constructor.newInstance(h);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (null != fw) {
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return null;
    }

    private static String generateSrc(Class interfaces) {
        Method[] methods = interfaces.getMethods();
        StringBuilder sb = new StringBuilder();
        sb.append("package ")
                .append(MyProxy.class.getPackage().getName()).append(";").append(ln)
                .append("import java.lang.reflect.Method;").append(ln)
                .append("public class $MyProxy0 implements ").append(interfaces.getName()).append("{").append(ln)
                .append("MyInvocationHandler h;").append(ln)
                .append("public $MyProxy0(MyInvocationHandler h) {").append(ln)
                .append("this.h = h;").append(ln)
                .append("}").append(ln);

        for (Method method : methods) {
            sb.append("public ")
                    //使用最简单的不传参的方法
                    .append(method.getReturnType().getName()).append(" ").append(method.getName())
                    .append(" () {").append(ln)
                    .append("try {").append(ln)
                    .append("Method m = ").append(interfaces.getName()).append(".class.getMethod(\"").append(method.getName()).append("\",new Class[]{});").append(ln)
                    .append("this.h.invoke(this,m,null);").append(ln)
                    .append("}catch(Throwable throwable){ }").append(ln)
                    .append("}").append(ln);
        }
        sb.append("}");

        return sb.toString();
    }
}

可以知道，我们现在只需要在MyClassLoader中findClasss进行加载

public class MyClassLoader extends ClassLoader{

    private File baseDir;

    public MyClassLoader() {
        this.baseDir = new File(MyClassLoader.class.getResource("").getPath());
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        String className = MyClassLoader.class.getPackage().getName()+"."+name;
        if (null!=baseDir) {
            File classFile = new File(baseDir,name.replaceAll("\\.","/")+".class");
            if (classFile.exists()){
                FileInputStream in = null;
                ByteArrayOutputStream out = null;
                try {
                    //先把class文件转化为字节流
                    in = new FileInputStream(classFile);
                    out = new ByteArrayOutputStream();
                    byte[] buff = new byte[1024];
                    int len;
                    while ((len = in.read(buff)) != -1) {
                        out.write(buff, 0, len);
                    }
                    //使用defineClass把字节流传jvm中
                    return defineClass(className, out.toByteArray(), 0, out.size());
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    if (null != in) {
                        try {
                            in.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                    if (null!=out){
                        try {
                            out.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
        return super.findClass(name);
    }
}

运行测试代码

    public static void main(String[] args) {
        MyPatentAgent patentAgent = new MyPatentAgent();
        Person person = (Person)
                patentAgent.getInstance(new Apkcore());
        System.out.println(person.getClass());
        person.apply();

    }

class com.apkcore.proxy.blog.custom.$MyProxy0
准备申请专利的材料
apkcore开始申请专利
申请提交成功了

这时我们发现，在我们的编译目录下是有$MyProxy0.,java和.class两个文件存在的，我们也可以在使用完之后增加一个删除语句，分别在MyProxy和MyClassLoader的finally语句中加入文件delete()方法就行了

总结

通过手写了JDK的动态代理，对代理模式的动态代理认识又加深了一步，原理就是拿到被代理对象的引用，然后获取它的接口，jdk代理重新生成一个类，同时实现我们给的代理对象所实现的接口，把被代理的对象引用也拿到了，重新动态生成一个class字节码，然后编译。

参考

手写jdk动态代理

我的CSDN

下面是我的公众号，欢迎大家关注我