手写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();
    }
}

手写JDK动态代理_第1张图片

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进行反编译

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();
    }
}

手写JDK动态代理_第2张图片

10,总结

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

你可能感兴趣的:(动态代理)