Java动态代理的实现和源码分析

林树杰

已于 2022-02-13 00:32:12 修改

阅读量463

点赞数

文章标签： java 代理模式开发语言

于 2022-02-13 00:22:31 首次发布

本文链接：https://blog.csdn.net/Shujie_L/article/details/122902939

版权

一：静态代理的实现

定义接口

/**
 * @description:
 * 加工手机的工厂
 * @date: 2022/2/12
 * @author: linshujie
 */
public interface IPhoneFactory {
    /**
     * 进行手机的定制设计
     * @param design
     */
    void makePhoneDesign(String design);
}
/**
 * @description:
 * 加工笔记本的工厂
 * @date: 2022/2/12
 * @author: linshujie
 */
public interface IComputerFactory {
    /**
     * 进行笔记本的定制设计
     * @param design
     */
    void makeComputerDesign(String design);
}

实现接口

public class ComputerCustomizedFactory implements IComputerFactory{
    @Override
    public void makeComputerDesign(String design) {
        System.out.println("给电脑定制完毕，主题为：" + design);
    }
}
public class PhoneCustomizedFactory implements IPhoneFactory{
    @Override
    public void makePhoneDesign(String design) {
        System.out.println("给手机定制完毕，主题为：" + design);
    }
}

定义代理类

/**
 * @description:
 * 静态代理类，负责笔记本业务
 *
 * @date: 2022/2/12
 * @author: linshujie
 */
public class LaoWang implements IComputerFactory {
    public IComputerFactory computerFactory;

    public LaoWang(IComputerFactory computerFactory) {
        this.computerFactory = computerFactory;
    }

    private void preSalesService(){
        System.out.println("免邮费咨询！！！");
    }

    private void afterSalesService(){
        System.out.println("三年保修服务！！！");
    }

    @Override
    public void makeComputerDesign(String design) {
        preSalesService();
        computerFactory.makeComputerDesign(design);
        afterSalesService();
    }
}

/**
 * @description:
 * 静态代理类，负责手机业务
 *
 * @date: 2022/2/12
 * @author: linshujie
 */
public class ZhangSan implements IPhoneFactory {
    public IPhoneFactory phoneFactory;

    public ZhangSan(IPhoneFactory phoneFactory) {
        this.phoneFactory = phoneFactory;
    }

    private void preSalesService(){
        System.out.println("免邮费咨询！！！");
    }

    private void afterSalesService(){
        System.out.println("三年保修服务！！！");
    }

    @Override
    public void makePhoneDesign(String design) {
        preSalesService();
        phoneFactory.makePhoneDesign(design);
        afterSalesService();
    }
}

定义用户类

/**
 * @description:
 * 用户
 *
 * @date: 2022/2/12
 * @author: linshujie
 */
public class Client {
    public static void main(String[] args) {
        /**
         * 一：静态代理模式
         */
        PhoneCustomizedFactory phoneFactory = new PhoneCustomizedFactory();
        ZhangSan zhangSan = new ZhangSan(phoneFactory);
        zhangSan.makePhoneDesign("蜘蛛侠主题");

        ComputerCustomizedFactory computerCustomizedFactory = new ComputerCustomizedFactory();
        LaoWang laoWang = new LaoWang(computerCustomizedFactory);
        laoWang.makeComputerDesign("钢铁侠主题");
    }
}

运行输出为：

免费咨询！！！
给手机定制完毕，主题为：蜘蛛侠主题
三年保修服务！！！
免费咨询！！！
给电脑定制完毕，主题为：钢铁侠主题
三年保修服务！！！

缺点：

当我们需要添加代理定制手表或者手环等其他电子产品的服务，那么我们必须新建对应的新代理类去实现。当后续需要增加大量代理服务的时候，很显然代码将变得非常臃肿！

二：动态代理的实现

定义动态代理类，用于取代静态代理类：ZhangSan.class和LaoWang.class。并且无需手动创建具体代理类，由代码负责生成。

/**
 * @description:
 * 定制服务公司类，作为代理的入口。根据传入的接口，动态生成代理对象，
 * 无需手动在代理里面new出具体的代理对象
 * @date: 2022/2/12
 * @author: linshujie
 */
public class CustomizedCompany {
    /**
     * 待传入的工厂，真正负责执行定制的工作
     */
    private Object factory;

    public Object getFactory() {
        return factory;
    }

    public void setFactory(Object factory) {
        this.factory = factory;
    }

    /**
     * 通过动态代理对象方法进行增强
     * @return
     */
    public Object getProxyInstance(){
        return Proxy.newProxyInstance(factory.getClass().getClassLoader(), factory.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                preSalesService();
                Object result = method.invoke(factory,args);
                afterSalesService();
                return result;
            }
        });
    }

    private void preSalesService(){
        System.out.println("免费咨询！！！");
    }

    private void afterSalesService(){
        System.out.println("三年保修服务！！！");
    }
}

接下来在Client类中执行：

 /**
         * 二：动态代理模式
         */
        //创建自定义设计公司，负责各种代理定制服务，包括手机、电脑、手表、平板等电子设备
        CustomizedCompany company = new CustomizedCompany();

        //手机定制工厂
        IPhoneFactory phoneCustomizedFactory = new PhoneCustomizedFactory();
        company.setFactory(phoneCustomizedFactory);
        //动态生成负责手机业务的员工
        IPhoneFactory employeePhone = (IPhoneFactory) company.getProxyInstance();
        employeePhone.makePhoneDesign("超人主题");

        //电话定制工厂
        IComputerFactory computerFactory = new ComputerCustomizedFactory();
        company.setFactory(computerFactory);
        //动态生成负责笔记本业务的员工
        IComputerFactory employeeComputer = (IComputerFactory) company.getProxyInstance();
        employeeComputer.makeComputerDesign("美国队长主题");

执行：

免费咨询！！！
给手机定制完毕，主题为：超人主题
三年保修服务！！！
免费咨询！！！
给电脑定制完毕，主题为：美国队长主题
三年保修服务！！！

到这里我们会有个困惑代码：

 IPhoneFactory employeePhone = (IPhoneFactory) company.getProxyInstance();
        employeePhone.makePhoneDesign("超人主题");

执行这两行代码的时候，这个代理对象的字节码文件在哪里呢？我们找到编译后的字节码文件夹
在这里插入图片描述
很奇怪，并没有找到。我们知道在使用动态代理的时候编译器是会自动给我们生成代理对象的，而代理对象的生成必然依赖于它的Class字节码。那么动态生成的代理对象的Class字节码究竟存在于哪里呢？通过debug查看对象：
在这里插入图片描述
生成的对象是Proxy0。这个对象是通过哪个字节码生成的呢？
由此我们需要深入到jdk源码中一探究竟。

三：动态代理的实现和源码分析

java中提供了代理类Proxy.java,从newProxyInstance方法入手分析：

 public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
        ...

        /*
         * Look up or generate the designated proxy class.
         */
        Class<?> cl = getProxyClass0(loader, intfs);

        /*
         * Invoke its constructor with the designated invocation handler.
         */
        try {
            ...

            final Constructor<?> cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            if (!Modifier.isPublic(cl.getModifiers())) {
                AccessController.doPrivileged(new PrivilegedAction<Void>() {
                    public Void run() {
                        cons.setAccessible(true);
                        return null;
                    }
                });
            }
            return cons.newInstance(new Object[]{h});
        } ...
    }

我们看到getProxyClass0返回了一个Class类，推测出是重点代码，而后面的代码就是典型的通过反射传入了InvocationHandler接口，以提供给 Proxy.newProxyInstance方法回调使用。
点进getProxyClass0方法：

 private static Class<?> getProxyClass0(ClassLoader loader,
                                           Class<?>... interfaces) {
        ...

        // If the proxy class defined by the given loader implementing
        // the given interfaces exists, this will simply return the cached copy;
        // otherwise, it will create the proxy class via the ProxyClassFactory
        return proxyClassCache.get(loader, interfaces);
    }

这里通过把类加载器和类的接口作为参数拿到代理类的缓存，点进proxyClassCache.get(loader, interfaces)的get方法：

 public V get(K key, P parameter) {
        ...

        // create subKey and retrieve the possible Supplier<V> stored by that
        // subKey from valuesMap
        Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
        Supplier<V> supplier = valuesMap.get(subKey);
        Factory factory = null;
        
		...
    }

在代码Supplier supplier = valuesMap.get(subKey);中可以推出supplier就是缓存中的对象，方法后面都是围绕supplier进行一些业务逻辑的处理。而该方法的参数subKey是如何取得的呢？
在代码Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));中，我们点开
apply方法：

   R apply(T t, U u);

在这里插入图片描述
看到实现类中，与之相关的只有最后一个，点开：
从名字可以看出这是一个代理工厂类

  private static final class ProxyClassFactory
        implements BiFunction<ClassLoader, Class<?>[], Class<?>>
    {
        // prefix for all proxy class names
        private static final String proxyClassNamePrefix = "$Proxy";

        // next number to use for generation of unique proxy class names
        private static final AtomicLong nextUniqueNumber = new AtomicLong();

        @Override
        public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {

            Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
            for (Class<?> intf : interfaces) {
                /*
                 * Verify that the class loader resolves the name of this
                 * interface to the same Class object.
                 */
                Class<?> interfaceClass = null;
                try {
                    interfaceClass = Class.forName(intf.getName(), false, loader);
                } catch (ClassNotFoundException e) {
                }
                ...
            }
			...

            /*
             * Choose a name for the proxy class to generate.
             */
            long num = nextUniqueNumber.getAndIncrement();
            String proxyName = proxyPkg + proxyClassNamePrefix + num;

            /*
             * Generate the specified proxy class.
             */
            byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                proxyName, interfaces, accessFlags);
            try {
                return defineClass0(loader, proxyName,
                                    proxyClassFile, 0, proxyClassFile.length);
            } ...
        }
    }

在这里我们找到一丝线索：

        private static final String proxyClassNamePrefix = "$Proxy";

"$Proxy"这里名字正好是我们前面debug中看到的代理对象名的一部分。

long num = nextUniqueNumber.getAndIncrement();
            String proxyName = proxyPkg + proxyClassNamePrefix + num;

而上面两行就是代理类全类名的拼接操作，也就是我们在debug时候看到的"$Proxy0"对象，接着：

 byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                proxyName, interfaces, accessFlags);

generateProxyClass方法的调用返回了字节数组，我们知道class字节码文件正是通过字节数组进行存储的，至于存放于存放到什么地方，jvm规范中并没有明确的规定，我们既可以存放到硬盘中，也能存放到内存中，甚至存放在数据库中或者网络中都是没有问题的。
点开方法ProxyGenerator.generateProxyClass，我们进入的是一个字节码文件，而非java文件。
但是这里基本可以得知，就是这里动态地生成了我们的代理类。
接着看：

return defineClass0(loader, proxyName,
                                    proxyClassFile, 0, proxyClassFile.length);

这行代码把类加载器、代理类名等参数传入，并返回defineClass0给上级方法使用，也就是我们前面看到的从缓存中获取class类的操作。点击进去，看到defineClass0是个本地方法。可不做深究。
到这里可以得知其实前面我们在项目中编译后的class文件夹中找不到代理类字节码的原因所在了，就是通过动态代理生成的字节码文件是保存到程序的缓存中的。
到此动态代理的源码分析结束。

四：手动调用jdk方法生成代理类字节码。

但是，很好奇
我们怎样才能看到编译器给我们生成的字节码文件呢？
我们能否直接拿jdk中的生成代理类字节码的代码为我所用呢？如下：

 byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                proxyName, interfaces, accessFlags);

写个工具类：

public class ProxyUtils {
    public static void generateClassFile(Class clazz,String proxyName){
        /*ProxyGenerator.generateProxyClass(
                proxyName, interfaces, accessFlags);*/
        byte[] proxyClassFile =ProxyGenerator.generateProxyClass(
                proxyName, new Class[]{clazz});
        String paths = clazz.getResource(".").getPath();
        System.out.println(paths);
        FileOutputStream out = null;

        try {
            out = new FileOutputStream(paths+proxyName+".class");
            out.write(proxyClassFile);
            out.flush();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

调用：

    ProxyUtils.generateClassFile(phoneCustomizedFactory.getClass(),
                employeePhone.getClass().getSimpleName());
        ProxyUtils.generateClassFile(computerFactory.getClass(),
                employeeComputer.getClass().getSimpleName());

在这里插入图片描述
点开$Proxy0字节码，通过IDE的反编译功能，可以看到代理类是这样的：

public final class $Proxy0 extends Proxy implements PhoneCustomizedFactory {
    private static Method m1;
    private static Method m8;
    private static Method m2;
    private static Method m3;
    private static Method m5;
    private static Method m4;
    private static Method m7;
    private static Method m9;
    private static Method m0;
    private static Method m6;

    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 notify() throws  {
        try {
            super.h.invoke(this, m8, (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 void makePhoneDesign(String var1) throws  {
        try {
            super.h.invoke(this, m3, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final void wait(long var1) throws InterruptedException {
        try {
            super.h.invoke(this, m5, new Object[]{var1});
        } catch (RuntimeException | InterruptedException | Error var4) {
            throw var4;
        } catch (Throwable var5) {
            throw new UndeclaredThrowableException(var5);
        }
    }

    public final void wait(long var1, int var3) throws InterruptedException {
        try {
            super.h.invoke(this, m4, new Object[]{var1, var3});
        } catch (RuntimeException | InterruptedException | Error var5) {
            throw var5;
        } catch (Throwable var6) {
            throw new UndeclaredThrowableException(var6);
        }
    }

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

    public final void notifyAll() throws  {
        try {
            super.h.invoke(this, m9, (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);
        }
    }

    public final void wait() throws InterruptedException {
        try {
            super.h.invoke(this, m6, (Object[])null);
        } catch (RuntimeException | InterruptedException | 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"));
            m8 = Class.forName("com.lsj.prox_sample.PhoneCustomizedFactory").getMethod("notify");
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m3 = Class.forName("com.lsj.prox_sample.PhoneCustomizedFactory").getMethod("makePhoneDesign", Class.forName("java.lang.String"));
            m5 = Class.forName("com.lsj.prox_sample.PhoneCustomizedFactory").getMethod("wait", Long.TYPE);
            m4 = Class.forName("com.lsj.prox_sample.PhoneCustomizedFactory").getMethod("wait", Long.TYPE, Integer.TYPE);
            m7 = Class.forName("com.lsj.prox_sample.PhoneCustomizedFactory").getMethod("getClass");
            m9 = Class.forName("com.lsj.prox_sample.PhoneCustomizedFactory").getMethod("notifyAll");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
            m6 = Class.forName("com.lsj.prox_sample.PhoneCustomizedFactory").getMethod("wait");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

如此，谜题彻底解开。

五：Retrofit框架中的动态代理

掌握了动态代理的实现原理和源码执行流程之后，再去看开源框架，会发现很多第三方框架的中的动态代理使用的都是这样的方式。
著名的例子如Retrofit，我们只需要定义好接口，Retrofit就能通过动态代理的方式去和OkHttp配合，去执行接口的具体实现。

林树杰

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java动态代理的实现和源码分析

一：静态代理的实现定义接口/** * @description: * 加工手机的工厂 * @date: 2022/2/12 * @author: linshujie */public interface IPhoneFactory { /** * 进行手机的定制设计 * @param design */ void makePhoneDesign(String design);}/** * @description: * 加工笔记本的工厂
复制链接

扫一扫