手写JDK动态代理-蒲公英云

一，JDK动态代理

在纯手写动态代理前，首先分析一套标准JDK动态代理的执行流程。

1，目标类顶层接口

public interface ProxyInterface {
    public void targetMethod();
}

2，目标类

public class JDKProxyTarget implements ProxyInterface{
    @Override
    public void targetMethod() {
        System.out.println("代理方法...");
    }
}

3，代理类

public class JDKProxy {
    private ProxyInterface proxyInterface;
    public JDKProxy(ProxyInterface proxyInterface) {
        this.proxyInterface = proxyInterface;
    }
    public Object instanceProxy() {
        System.out.println("代理方法开始...");
        ProxyInterface instance = (ProxyInterface) Proxy.newProxyInstance(
                proxyInterface.getClass().getClassLoader(),
                proxyInterface.getClass().getInterfaces(),
                new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                method.invoke(proxyInterface, args);
                System.out.println("代理方法结束...");
                return null;
            }
        });
        return instance;
    }
}

4，测试类

public class JDKProxyTest {
    public static void main(String[] args) throws Exception {
        JDKProxy proxy = new JDKProxy(new JDKProxyTarget());
        ProxyInterface proxyInterface = (ProxyInterface) proxy.instanceProxy();
        System.out.println(proxyInterface.getClass());
        proxyInterface.targetMethod();
    }
}

5，代码解析

a，Proxy.newInstance()方法
    \* 第一个参数为目标类的类加载器
    \* 第二个参数为目标类的接口集合，JDK动态代理目标类必须实现一个接口，这是为了保证生成的代理类和目标类之前的强一致性关系
    \* 第三个参数为InvocationHandler接口的实现类，这里直接通过匿名内部类实现，重写了invoke方法
b，InvocationHandler接口实现类
    \* 实现该类必须重写invoke()方法，动态代理实现在代理类中该接口的实现类调用该方法，并在该方法中反射执行该方法完成整个动态代理流程；
    \* 第一个参数为生成的动态代理对象；
    \* 第二个参数为动态代理在客户端执行的方法；
    \* 第三个参数为该方法的参数列表；
    \* 通过反射来完成方法调用；
c，通过a步骤后，JDK会虚拟生成一个$Proxy0类，该类也实现了目标类实现的接口，从而多态返回该虚拟类对象，可以通过代码输出该类
\* 代码
public class JDKProxyTest {
    public static void main(String[] args) throws Exception {
        JDKProxy proxy = new JDKProxy(new JDKProxyTarget());
        ProxyInterface proxyInterface = (ProxyInterface) proxy.instanceProxy();
        System.out.println(proxyInterface.getClass());
        proxyInterface.targetMethod();
        byte[] bytes = ProxyGenerator.generateProxyClass("$Proxy0", new Class[]{ProxyInterface.class});
        FileOutputStream outputStream = new FileOutputStream("E:\\$Proxy0.class");
        outputStream.write(bytes);
        outputStream.close();
    }
}
\* $Proxy0类 --- 生成为.class文件，直接通过IDEA进行反编译

70 1

public final class $Proxy0 extends Proxy implements ProxyInterface {
    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})).booleanValue();
        } 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);
        }
    }
    public final void targetMethod() throws  {
        try {
            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)).intValue();
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }
    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});
            m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
            m3 = Class.forName("com.gupao.designpattern.proxy.jdk.ProxyInterface").getMethod("targetMethod", new Class[0]);
            m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}
d， 可以看到该虚拟类继承Proxy类并实现了目标类顶层接口，并反射获取了目标类中的所有方法的Method对象；
e， 同时，虚拟类也同时重写了目标类的所有方法，并通过下列方式进行调用
super.h.invoke(this, m3, (Object[])null);
    super ： 指该代理类的超类，也就是Proxy；
    h ： 点进源码可以看到这样一行声明
protected InvocationHandler h;

在虚拟类的构造器中，也获取了InvocationHandler的引用，所以，这里的h，指的也就是在匿名内部类定义的实现类对象；

    h.invoke()：就是调用匿名内部类中重写的invoke()方法，分别传递参数该对象(this)，执行的方法(method)，方法参数(null)；

二，手写动态代理步骤分析

从上面标准的JDK动态流程可以看出，手写动态代理，需要这样几个类
1，SelfProxy类，定义newInstance()方法，进行代理对象创建
    \* 在该方法中首先需要输出代理类的.java文件
    \* 编译该.java文件生成.class文件
    \* 通过类加载器加载该.class文件
    \* 生成该.class文件的事例对象作为代理对象返回
2，SelfInvocationHandler接口，定义invoke()方法，在代理类中进行目标方法调用
    \* 在.java文件中，定义构造器，传递该类引用
    \* 通过SelfInvocationHandler实现类对象调用invoke()方法，实现代理方式的方法调用
3，SelfClassloader，自定义类加载器，继承JDK的ClassLoader类，实现自定义的加载方式
4，SelfJDKProxy，实现SelfInvocationHandler接口，重写invoke()方法，实现最终方法运行

三，手写动态代理代码实现

1，目标类顶层接口

public interface SelfProxyInterface {
    public void targetMethod();
}

2，目标类

public class SelfJDKProxyTarget implements SelfProxyInterface{
    @Override
    public void targetMethod() {
        System.out.println("代理方法...");
    }
}

3，SelfClassLoader类 — 自定义类加载器，加载.class到JVM内存中

public class SelfClassLoader extends ClassLoader{
    private File classPathFile;
    public SelfClassLoader() {
        String classPath = SelfClassLoader.class.getResource("").getPath();
        this.classPathFile = new File(classPath);
    }
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        String className = SelfClassLoader.class.getPackage().getName() + "." + name;
        if (null != classPathFile) {
            File classFile = new File(classPathFile, name + ".class");
            if (classFile.exists()) {
                FileInputStream in = null;
                ByteArrayOutputStream out = null;
                try {
                    in = new FileInputStream(classFile);
                    out = new ByteArrayOutputStream();
                    byte[] bytes = new byte[1024];
                    int len;
                    while((len = in.read(bytes)) != -1) {
                        out.write(bytes, 0, len);
                    }
                    return defineClass(className, out.toByteArray(), 0, out.size());
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    try {
                        if (null != in) {
                            in.close();
                        }
                        if (null != out) {
                            out.close();
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        }
        return null;
    }
}

4，SelfProxy类 — 生成虚拟代理类，创建代理对象

public class SelfProxy {
    private static final String ENTER = "\r\n";
    public static Object newInstance(SelfClassLoader classLoader, Class<?>[] interfaces, SelfInvocationHandler h) {
        try {
            // 动态生成源代码
            String srcClass = generateSrc(interfaces);
            // 输出Java文件
            String filePath = SelfProxy.class.getResource("").getPath()  + "$ProxyO.java";
            System.out.println(filePath);
            FileWriter fileWriter = new FileWriter(filePath);
            fileWriter.write(srcClass);
            fileWriter.flush();
            fileWriter.close();
            // 编译Java文件为class文件
            JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
            StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);
            Iterable iterable = fileManager.getJavaFileObjects(filePath);
            JavaCompiler.CompilationTask task = compiler.getTask(null, fileManager, null, null, null, iterable);
            task.call();
            fileManager.close();
            // 加载编译生成的class文件到JVM
            Class<?> proxyClass = classLoader.findClass("$ProxyO");
            Constructor<?> constructor = proxyClass.getConstructor(SelfInvocationHandler.class);
            // 删掉虚拟代理类
            File file = new File(filePath);
            file.delete();
            // 返回字节码重组以后的代理对象
            return constructor.newInstance(h);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    private static String generateSrc(Class<?>[] interfaces) {
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("package com.gupao.designpattern.proxy.self;" + ENTER + ENTER);
        stringBuilder.append("import com.gupao.designpattern.proxy.jdk.ProxyInterface;" + ENTER);
        stringBuilder.append("import java.lang.reflect.Method;" + ENTER);
        stringBuilder.append("public class $ProxyO implements " + interfaces[0].getName() + "{" + ENTER);
            stringBuilder.append("SelfInvocationHandler h;" + ENTER);
            stringBuilder.append("public $ProxyO(SelfInvocationHandler h) {" + ENTER);
                stringBuilder.append("this.h = h;" + ENTER);
            stringBuilder.append("}" + ENTER);
        for (Method method : interfaces[0].getMethods()) {
            stringBuilder.append("public " + method.getReturnType().getName() + " " + method.getName() + "() {" + ENTER);
                stringBuilder.append("try {" + ENTER);
                    stringBuilder.append("Method m = " + interfaces[0].getName() + ".class.getMethod(\"" + method.getName() + "\", new Class[]{});" + ENTER);
                    stringBuilder.append("this.h.invoke(this, m, null);" + ENTER);
                stringBuilder.append("} catch(Throwable able) {" + ENTER);
                stringBuilder.append("able.getMessage();" + ENTER);
                stringBuilder.append("}" + ENTER);
            stringBuilder.append("}" + ENTER + ENTER);
        }
        stringBuilder.append("}" + ENTER);
        return stringBuilder.toString();
    }
}
该类代码的具体步骤在注释中已经写明；

5，查看生成的.java文件

package com.gupao.designpattern.proxy.self;
import com.gupao.designpattern.proxy.jdk.ProxyInterface;
import java.lang.reflect.Method;
public class $ProxyO implements com.gupao.designpattern.proxy.self.SelfProxyInterface {
    SelfInvocationHandler h;
    public $ProxyO(SelfInvocationHandler h) {
        this.h = h;
    }
    public void targetMethod() {
        try {
            Method m = com.gupao.designpattern.proxy.self.SelfProxyInterface.class.getMethod("targetMethod", new Class[]{});
            this.h.invoke(this, m, null);
        } catch (Throwable able) {
            able.getMessage();
        }
    }
}

6，查看生成的.class文件

package com.gupao.designpattern.proxy.self;
import java.lang.reflect.Method;
public class $ProxyO implements SelfProxyInterface {
    SelfInvocationHandler h;
    public $ProxyO(SelfInvocationHandler var1) {
        this.h = var1;
    }
    public void targetMethod() {
        try {
            Method var1 = SelfProxyInterface.class.getMethod("targetMethod", new Class[0]);
            this.h.invoke(this, var1, (Object[])null);
        } catch (Throwable var2) {
            var2.getMessage();
        }
    }
}

7，SelfInvocationHandler接口，定义invoke()方法

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

8，SelfJdkProxy，定义newInstance()方法创建代理对象，并实现InvocationHandler接口，重写invoke()方法，通过反射实现方法最终运行

public class SelfJDKProxy implements SelfInvocationHandler{
    private SelfProxyInterface proxyInterface;
    public SelfJDKProxy(SelfProxyInterface proxyInterface) {
        this.proxyInterface = proxyInterface;
    }
    public Object instanceProxy() {
        System.out.println("代理方法开始...");
        SelfProxyInterface instance = (SelfProxyInterface) SelfProxy.newInstance(
                new SelfClassLoader(),
                proxyInterface.getClass().getInterfaces(), this);
        return instance;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) {
        try {
            method.invoke(proxyInterface, args);
            System.out.println("代理方法结束...");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

9，客户端执行

public class SelfTest {
    public static void main(String[] args) {
        SelfJDKProxy proxy = new SelfJDKProxy(new SelfJDKProxyTarget());
        SelfProxyInterface proxyInterface = (SelfProxyInterface) proxy.instanceProxy();
        System.out.println(proxyInterface);
        proxyInterface.targetMethod();
    }
}

70 2

10，总结

整个手写动态代理以说明问题为目的，整个流程中所有环境创建都是按照最简单方式在运行，旨在熟悉整个JDK动态代理的执行流程和底层实现；

手写JDK动态代理

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 JDK动态代理实现原理以及手写实现JDK动态代理

相关 Spring设计模式——代理模式[手写实现JDK动态代理]

相关手写实现精简版的jdk动态代理

相关手写JDK动态代理

相关手写JDK动态代理

相关手写jdk动态代理

相关手写Java动态代理

相关手写JAVA动态代理

相关动态代理（JDK 动态代理）

相关手写实现JDK动态代理

随便看看

12步搞定WSL 2，安装、交互、迁移、VSCode远程调试应有尽有

图像纹理特征总体简述

力扣-187题重复的DNA序列（C++）- 找指定长度的目标子串+哈希

大数据之Hive 实战完整使用（第十一章）

发现个mysql的id用尽的问题，待解决

❤️国庆七天的总结

教程文章

热评文章

1江湖小白之一起学Python （二）爬取数据的保存

2Java Shiro：简化身份验证和授权的安全框架

3Java中try()catch{}的使用方法

4Swagger注解-@ApiModel 和 @ApiModelProperty

5windows下强制杀死tomcat进程

6uni-app 条形码(一维码)/二维码生成实现

标签列表