聊聊JDK动态代理

叁歲伎倆 2024-02-19 17:26 37阅读 0赞

> 最近发现对JDK的动态代理以前看过的东西已经模糊了，发现了自己对这块的理解不够，而且没有记录笔记导致如今呵呵哒，所以今天重新梳理下这块

### 代理模式 ###

1.  使用代理模式创建的代理对象，可以控制对目标对象的访问，以及前置、后置处理，代理模式强调的是代表目标对象。装饰器模式而是针对对象的某个行为进行装饰，通过不同的装饰改变被装饰的行为，强调的是挂载，不断的向行为上挂载行为改变行为增强对象。
2.  图片摘自Head First设计模式
3.  ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA1OTc4MTk_size_16_color_FFFFFF_t_70]

### 静态代理 ###

1.  顾名思义，一个代理对象对应一个被代理对象，实现代码

//主题类
    public interface Subject {
        void request();
    }
    
    //真正的主题实现类
    public class RealSubject implements Subject {
    
        @Override
        public void request() {
            System.out.println("我才是真正的主题，哦也 "+this);
        }
    }
    
    //没错，在下就是大名鼎鼎的代理，哦也
    public class SubjectProxy implements Subject {
        private RealSubject realSubject;
    
        public SubjectProxy(RealSubject realSubject) {
            this.realSubject = realSubject;
        }
    
        @Override
        public void request() {
            realSubject.request();
        }
    }

#### 缺点 ####

1.  目标（被代理的）对象增加新方法时，代理对象要随之改变
2.  新增一个目标对象，需要同步增加一个代理对象与之对应

### 动态代理 ###

#### 常见实现方法 ####

1.  JDK动态代理：Proxy代理类、InvocationHandler接口。目标对象必须实现接口，代理是代理的接口行为
2.  Cglib动态代理：补充了JDK的软肋，可以不用实现接口

#### JDK动态代理 ####

##### 使用方法 #####

// 目标对象的接口
    public interface MyBean {
    
        void test();
    
        void setName(String name);
    
        void setAge(Integer age);
    
    }
    // 在下正是目标对象
    public class SimpleBean implements MyBean {
        private String name;
        private Integer age;
    
        public void test(){
            System.out.println(String.format("name:%s,age:%s", name, age));
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Integer getAge() {
            return age;
        }
    
        public void setAge(Integer age) {
            this.age = age;
        }
    }
    // 吾乃常山赵子龙（动态代理）是也。。。HIAHIAHIA
    public class DynamicProxyHandler implements InvocationHandler {
    
        private Object source;
    
        private Object bind(Object source){
            this.source = source;
            return  Proxy.newProxyInstance(source.getClass().getClassLoader(), source.getClass().getInterfaces(), this);
        }
    
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("source 执行");
            return method.invoke(source, args);
        }
    
        public static void main(String[] args) {
            System.setProperty("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
            MyBean bean = new SimpleBean();
            bean.setAge(22);
            bean.setName("superman");
            DynamicProxyHandler handler = new DynamicProxyHandler();
            MyBean proxy = (MyBean) handler.bind(bean);
            proxy.test();
        }
    }

##### 实现原理 #####

1.  根据绑定了目标对象的InvocationHandler接口实现创建代理对象：Proxy.newProxyInstance
2.  查找或者创建代理：Proxy.*proxyClassCache.get*

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

1.  代理缓存的subKeyFactory：KeyFactory，valueFactory：ProxyClassFactory

public WeakCache(BiFunction<K, P, ?> subKeyFactory,
                     BiFunction<K, P, V> valueFactory) {
        this.subKeyFactory = Objects.requireNonNull(subKeyFactory);
        this.valueFactory = Objects.requireNonNull(valueFactory);
    }

1.  从缓存中获取代理：get
2.  根据cacheKey（即目标对象的classloader实例的弱引用）获取缓存的代理对象集合valuesMap，没有则新建
3.  子key工厂中获取subKey：subKeyFactory.apply(key, parameter)，其实就是目标对象实现接口的弱引用
4.  从valuesMap中获取subKey对应的value提供者Supplier（代理对象提供者），如果不为空则get返回
5.  如果工厂（value提供者）为空，则创建

// lazily construct a Factory
    if (factory == null) {
        factory = new Factory(key, parameter, subKey, valuesMap);
    }

1.  如果value提供者为空且缓存中没有老的value提供者，则将factory赋值给supplier，否则supplier取缓存中的value提供者实例
2.  从工厂中获取代理实例：Factory.get
3.  根据key（类加载器），parameters(接口列表)从valueFactory中获取代理实例：ProxyClassFactory.apply
4.  根据参数生成class字节码并实例化对象返回，生成类代码如下，其实就是通过静态方法中反射获取对应的方法并通过InvocationHandler的invoker方法调用

//
    // Source code recreated from a .class file by IntelliJ IDEA
    // (powered by Fernflower decompiler)
    //
    
    package com.sun.proxy;
    
    import com.gallant.dispatch.MyBean;
    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 MyBean {
        private static Method m1;
        private static Method m3;
        private static Method m4;
        private static Method m2;
        private static Method m5;
        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 setName(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 test() throws  {
            try {
                super.h.invoke(this, m4, (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 setAge(Integer var1) throws  {
            try {
                super.h.invoke(this, m5, new Object[]{var1});
            } catch (RuntimeException | Error var3) {
                throw var3;
            } catch (Throwable var4) {
                throw new UndeclaredThrowableException(var4);
            }
        }
    
        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.gallant.dispatch.MyBean").getMethod("setName", Class.forName("java.lang.String"));
                m4 = Class.forName("com.gallant.dispatch.MyBean").getMethod("test");
                m2 = Class.forName("java.lang.Object").getMethod("toString");
                m5 = Class.forName("com.gallant.dispatch.MyBean").getMethod("setAge", Class.forName("java.lang.Integer"));
                m0 = Class.forName("java.lang.Object").getMethod("hashCode");
            } catch (NoSuchMethodException var2) {
                throw new NoSuchMethodError(var2.getMessage());
            } catch (ClassNotFoundException var3) {
                throw new NoClassDefFoundError(var3.getMessage());
            }
        }
    }

### 总结 ###

1.  通过制定该参数可以输出动态代理生成的class文件协助分析排查问题

// JDK输出class文件设置
    System.setProperty("sun.misc.ProxyGenerator.saveGeneratedFiles", "true"); 
    // 最新版本该配置已发生变更，使用下面的配置
    System.setProperty("jdk.proxy.ProxyGenerator.saveGeneratedFiles", "true");
    // cglib输出class文件设置
    System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "D://tmp");

1.  jdk的动态代理可以看到是通过反射调用实现，所以性能会略差于cglib（通过字节码技术实现）。但是jdk对反射也进行了优化，当反射调用超过一个阈值时，会自动生成字节码来优化反射。所以反射这个性能的开销已经不再是jdk动态代理的软肋了，当前最大软肋还是不能代理类。比如：我想要代理Jedis对象，总不能去修改jedis源码使其实现某个接口吧。为什么要代理jedis对象呢？当然是想要拦截某些方法做些事情。哈哈哈

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA1OTc4MTk_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/29/21aaeab1f6b44632b7855679af5a1550.png