JDK动态代理源码解析

用户9347382

发布于 2022-01-10 16:47:46

21200

代码可运行

文章被收录于专栏：程序员阿杰程序员阿杰

运行总次数：0

代码可运行

JDK动态代理

在学习之前、请学习静态代理进入正文我们定义了一个接口、同样也需要去实现这个接口、当需要为接口增加新功能时、需要去修改实现的接口之内的方法、又可能这个代码不是你写的、但是你需要增加功能、但是保证不破坏代码

于是产生了动态代理：相比于静态代理、更方便实现代理的类、效率也更高 举个粒子：

/**
 * 定义一个接口叫 people
 * 他有很多种属性：1.要吃 2.要老婆
 */
public interface People {
    void eat();
    void love();
}

我们现在去实现这个接口

/**
 * 此时小王实现了people的所有接口
 * 但是这些行为的方法是固定的
 * 小王这个时候需要增加新的需求
 * 1.要吃饭之前要喝水
 * 2.吃饭之后要拉稀
 */
@Slf4j
public class xiaowang implements People{
    @Override
    public void eat() {
        log.debug("要吃饭");
    }

    @Override
    public void love() {
        log.debug("要找老婆");
    }
}

但是小王出现了新的需求、于是我们使用动态代理去实现小王新的需求

public class ProxyPeople {
    //需要被代理的类
    public Object target;
    @Slf4j
    public static class Proxys implements InvocationHandler{
        public Object target;
        public Proxys(Object target){
            this.target = target;
        }
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            log.debug("吃饭之前要喝水");
            method.invoke(target, args);
            log.debug("吃饭之后要打豆豆");
            return null;
        }
    }
    public ProxyPeople(Object target){
        this.target = target;
    }
    public Object getProxy(){
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new Proxys(target));
    }
}

编写测试类

public class Test {
    public static void main(String[] args) throws IOException {
        People obj = (People) new ProxyPeople(new xiaowang()).getProxy();
        obj.eat();

//        byte[] $Proxy0s = ProxyGenerator.generateProxyClass("$Proxy0", new Class[]{People.class});
//        FileOutputStream os = new FileOutputStream("$Proxy0.class");
//        os.write($Proxy0s);
//        os.close();
    }
}

看到结果

13:52:50.373 [main] DEBUG com.sync.juc.proxy.ProxyPeople$Proxys - 吃饭之前要喝水
13:52:50.375 [main] DEBUG com.sync.juc.proxy.xiaowang - 要吃饭
13:52:50.375 [main] DEBUG com.sync.juc.proxy.ProxyPeople$Proxys - 吃饭之后要打豆豆

从日志看到了我们功能实现了、但是出现了一个我们没有定义的类、我们可以通过被我注释的方法进行运行、可以得到ProxyPeople$Proxys这个类的全部内容

public final class $Proxy0 extends Proxy implements People {
    private static Method m1;
    private static Method m3;
    private static Method m2;
    private static Method m4;
    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 eat() throws  {
        try {
            super.h.invoke(this, m3, (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 love() throws  {
        try {
            super.h.invoke(this, m4, (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"));
            m3 = Class.forName("com.sync.juc.proxy.People").getMethod("eat");
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m4 = Class.forName("com.sync.juc.proxy.People").getMethod("love");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

jdk自动生成的类的前缀都带有美元符号、可以知道jdk在执行我们的代码时、创建了一个$Proxy0 接下来我们配合Proxy.newProxyInstance（）来查看源码

protected InvocationHandler h;
public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException{
/**
*省略
/*
}

可以看出我们通过Proxy.newProxyInstance（）实际上创建了一个$Proxy0类并且继承了Proxy实现了People的全部接口之后为我们返回的实际上了$Proxy0对象、这就是为什么返回接受对象时、需要对象向上转

People obj = (People) new ProxyPeople(new xiaowang()).getProxy();
obj.eat();

eat方法调用时、实际上调用的是$Proxy0中的方法

public final void eat() throws  {
        try {
            // return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new Proxys(target));
            // 此时的super.h是父类的h就是我们传入的new Proxys(target)对象**
            //super.h.invoke调用的就是我们重写的invoke方法、那么m3的参数是什么呢、我们向下面的静态代码块中看
            //m3是怎么获取的、此时下面这段代码就会调用我们重写的invoke方法
            //        @Override
            //        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            //            log.debug("吃饭之前要喝水");
            //            method.invoke(target, args);
            //            log.debug("吃饭之后要打豆豆");
            //            return null;
            //        }
            //到这里就结束了方法流程就调用成功了、大家可以思考一下我们传入的target.getClass().getClassLoader()起到了什么作用？？
            super.h.invoke(this, m3, (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"));
       //可能有同学要问了、forname中的参数是怎么获得的呢、其实就是我们在构造$Proxy0对象去传入new xiaowang()取得的
       //只是不是new xiaowang（） 本身的对象、而是他的所有的接口的Class对象 
       //拿到Class对象之后就可以获取指定的Method属性了
       //我们在回到eat()方法
        m3 = Class.forName("com.sync.juc.proxy.People").getMethod("eat");
        m2 = Class.forName("java.lang.Object").getMethod("toString");
        m4 = Class.forName("com.sync.juc.proxy.People").getMethod("love");
        m0 = Class.forName("java.lang.Object").getMethod("hashCode");
    } catch (NoSuchMethodException var2) {
        throw new NoSuchMethodError(var2.getMessage());
    } catch (ClassNotFoundException var3) {
        throw new NoClassDefFoundError(var3.getMessage());
    }
}

//就是我
public ProxyPeople(Object target){
    this.target = target;
}
public Object getProxy(){
                                                                                                                //就是我
    return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new Proxys(target));
}

本站文章除注明转载/出处外，均为本站原创或翻译，转载前请务必署名,转载请标明出处最后编辑时间为: 2021/11/24 06:32

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2021-11-24，如有侵权请联系 cloudcommunity@tencent.com 删除

网络安全