揭开动态代理的神秘面纱

转x33g5p2x  于2022-03-21 转载在 其他  
字(8.2k)|赞(0)|评价(0)|浏览(162)

本篇文章针对的是对动态代理想要进行深入研究的小伙伴而写，即我们深入源码进行研究

JDK动态代理

小例子

先上一个动态代理的小例子:

public interface IRequest {
    public void doGet() throws InterruptedException ;
}
public class Request implements IRequest{
    @Override
    public void doGet() throws InterruptedException {
        System.out.println("处理请求中...");
        Thread.sleep(new Random().nextInt(10));
    }
}
public class Main {
    public static void main(String[] args) throws InterruptedException {
        Request request=new Request();
        IRequest proxyInstance = (IRequest)Proxy.newProxyInstance(request.getClass().getClassLoader(),
                request.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        long start = System.currentTimeMillis();
                        Object invoke = method.invoke(request, args);
                        long end = System.currentTimeMillis();
                        System.out.println("请求耗时为 :" + String.valueOf(end - start) + "毫秒");
                        return invoke;
                    }
                });
      proxyInstance.doGet();
    }
}

JDK动态代理源码探究

首先，我们利用ProxyGenerator来手动生成上面Request的代理对象，放入到当前项目的target目录下面，这样我们就可以利用编译器自动反编译class文件的功能，而不需要自己手动去反编译了

public class Main {
    public static void main(String[] args) throws InterruptedException {
      //生成Request类的代理对象
        byte[] proxyClass = ProxyGenerator.generateProxyClass("$Proxy0", Request.class.getInterfaces());
        //将这个二进制class流写入文件中
        String path=System.getProperty("user.dir")+"/target/classes/com/RequestProxy.class";
        try(FileOutputStream out=new FileOutputStream(path))
        {
            out.write(proxyClass);
            out.flush();
            System.out.println("写入完毕");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

生成的代理对象源码如下:

import com.staticProxy.IRequest;
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 IRequest {
    private static Method m1;
    private static Method m2;
    private static Method m3;
    private static Method m0;

    //父类有一个InvocationHandler  h成员变量
    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
             //调用 InvocationHandler  的invoke方法，也就是需要我们自己去实现的这个invoke方法
            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 String toString() throws  {
        try {
              //调用 InvocationHandler  的invoke方法，也就是需要我们自己去实现的这个invoke方法
            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 doGet() throws InterruptedException {
        try {
              //调用 InvocationHandler  的invoke方法，也就是需要我们自己去实现的这个invoke方法
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | InterruptedException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final int hashCode() throws  {
        try {
              //调用 InvocationHandler  的invoke方法，也就是需要我们自己去实现的这个invoke方法
            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"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            //代理对象只会重写被代理对象实现的接口中的方法，而不会实现被代理对象自身额外添加的方法
            m3 = Class.forName("com.staticProxy.IRequest").getMethod("doGet");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

InvocationHandler接口

我相信看了上面jdk默认生成的代理对象源码，大家肯定对InvocationHandler和Proxy特别感兴趣，下面我们逐个击破，首先是InvocationHandler接口的分析

public interface InvocationHandler {
    //代理对象，当前执行的方法，当前方法需要的参数
    public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable;
}

其实这就是个函数式接口，只有一个需要用户实现的invoke方法。

IRequest proxyInstance = (IRequest)Proxy.newProxyInstance(request.getClass().getClassLoader(),
                request.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        long start = System.currentTimeMillis();
                        Object invoke = method.invoke(request, args);
                        long end = System.currentTimeMillis();
                        System.out.println("请求耗时为 :" + String.valueOf(end - start) + "毫秒");
                        return invoke;
                    }
                });

在我们通过Proxy对象的newProxyInstance方法创建代理对象的时候，我们会在该方法第三个参数传入InvocationHandler 接口的一个实现类，然后生成的代理对象继承Proxy类，并且通过Proxy类的InvocationHandler类型的成员变量保存了我们传入的InvocationHandler接口的实现类，然后在代理对象执行每个被代理对象方法时，都是通过InvocationHandler的invoke方法执行的

Proxy类

我们来分析一下神秘的newProxyInstance方法:

@CallerSensitive
    public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
        Objects.requireNonNull(h);
        
        //将被代理对象实现的接口数组克隆一份
        final Class<?>[] intfs = interfaces.clone();
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }

        /*
         * Look up or generate the designated proxy class.
         */
         //生成代理对象的class---通过传入的类加载器和被代理对象实现的接口数组
         //这里还会让代理对象继承Proxy类
        Class<?> cl = getProxyClass0(loader, intfs);

        /*
         * Invoke its constructor with the designated invocation handler.
         */
        try {
            if (sm != null) {
                checkNewProxyPermission(Reflection.getCallerClass(), cl);
            }
             
             //获取代理对象的构造器
            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;
                    }
                });
            }
            //生成代理对象的实例，传入InvocationHandler h作为构造器参数
            return cons.newInstance(new Object[]{h});
        } catch (IllegalAccessException|InstantiationException e) {
            throw new InternalError(e.toString(), e);
        } catch (InvocationTargetException e) {
            Throwable t = e.getCause();
            if (t instanceof RuntimeException) {
                throw (RuntimeException) t;
            } else {
                throw new InternalError(t.toString(), t);
            }
        } catch (NoSuchMethodException e) {
            throw new InternalError(e.toString(), e);
        }
    }

Proxy其他注意点:

public class Proxy implements java.io.Serializable {

    private static final long serialVersionUID = -2222568056686623797L;

    //规定了生成的代理对象构造方法参数类型
    private static final Class<?>[] constructorParams =
        { InvocationHandler.class };

    //会缓存已经生成的代理类
    private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
        proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());
    
    //Proxy类中通过h变量保存从构造方法中传入的InvocationHandler对象实例
    protected InvocationHandler h;

 
    private Proxy() {
    }

     //需要传入InvocationHandler的父类构造函数 
    protected Proxy(InvocationHandler h) {
        Objects.requireNonNull(h);
        this.h = h;
    }
    .....

坑

结论: 红色画出的那一行代码会造成死循环，大家思考为什么?

上面说过代理对象的方法调用最终会调用InvocationHandler的invoke方法，那如果我们在InvocationHandler的invoke方法中继续调用代理对象的方法，不就进入一个死循环了吗?

我们这里的本意是通过InvocationHandler的invoke方法对被代理对象的方法进行增强，因此这里method对象关联的实例对象应该是被代理的对象，这里大家不要搞混了。

Cglib代理

CGLIB是一个强大的高性能的代码生成包。

CGLIB是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法（继承）；

利用ASM开源包，对代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。

Cglib的原理这里不会剖析的特别深入，感兴趣的小伙伴可以自行去查看他的源码，顺便还可以学习一下ASM框架的使用

导入相关依赖

<dependency>
        <groupId>cglib</groupId>
        <artifactId>cglib</artifactId>
        <version>3.3.0</version>
    </dependency>

小例子

public class Request{
    public void doGet() throws InterruptedException {
        System.out.println("处理请求中...");
        Thread.sleep(new Random().nextInt(10));
    }
}
//实现MethodInterceptor接口
public class ProxyFactory implements MethodInterceptor
{
    //需要代理的目标对象
    private  Object target;

    public ProxyFactory(Object target)
    {
        this.target=target;
    }

    //获取代理对象的方法
    public Object getProxyInstance()
    {
        // 通过CGLIB动态代理获取代理对象的过程
        Enhancer enhancer=new Enhancer();
        // 设置enhancer对象的父类,因为Cglib是针对指定的类生成一个子类，所以需要指定父类
        enhancer.setSuperclass(target.getClass());
        //设置enhancer的回调对象
        enhancer.setCallback(this);
        // 创建代理对象
        return enhancer.create();
    }

    /**
     * @param o cglib生成的代理对象
     * @param method 被代理对象的方法
     * @param objects     传入方法的参数
     * @param methodProxy 代理的方法
     */
    @Override
    public Object intercept(Object o, Method method, Object[] objects,
                            MethodProxy methodProxy) throws Throwable {
        long start = System.currentTimeMillis();
        //这里必须传入被代理的对象，否则会死循环
        //因为代理对象方法调用会触发拦截器
        Object ret= method.invoke(target, objects);
        long end = System.currentTimeMillis();
        System.out.println("请求耗时为 :" + String.valueOf(end - start) + "毫秒");
        return ret;
    }
}
public class Main {
    public static void main(String[] args) throws InterruptedException {
        ProxyFactory proxyFactory=new ProxyFactory(new Request());
        Request proxyInstance = (Request) proxyFactory.getProxyInstance();
        proxyInstance.doGet();
    }
}

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://cjdhy.blog.csdn.net/article/details/123619701

内容来源于网络，如有侵权，请联系作者删除！

Javaspring源码研读

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备2022004421号-2 NULL123 https://www.null123.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com