java动态代理底层探究-轻识

点击上方蓝色字体，选择“标星公众号”

优质文章，第一时间送达

平常面试的时候,有人回问你Spring,你会说什么AOP什么的,然后他会越来越往深问,其实说到AOP那么动态代理是绕不开的,那么今天我们一起来看看这个动态代理是什么个一回事先贴一张图:

上面便是动态代理的结束以及它的实现方式,以及区别(我确实很懒....)but 上面的也挺通俗易懂,只要你不是初学者

-----------------------------------------华丽的分割线----------------------------------------

接下来当然要继续贴图啦:

这张图便是动态代理大概的实现流程,我们看到.只有javaProxy是直接修改字节码的,其他的都是基于ASM来操作字节码ASM我也不太懂,然后那个javassist也是用来操作ASM的,是岛国一位工程师写的,据说dubbo就是用的这项技术.

我们看到无论是何种方式它都是基于对class字节码的修改来进行代理的.

好的这只是一个大概的了解那么我们来写代码感受感受:

整体需求就是一个普通的Service接口,

让后一个普通的实现类,ServiceImpl

最后我们来个测试的小方法:来看看动态代理的实现:

public class ProjexTest {
    public static void main(String[] args) {
        final  serviceImpl impl =new serviceImpl();
        UserServce  servce = (UserServce)Proxy.newProxyInstance(ProjexTest.class.getClassLoader(), new Class[]{UserServce.class}, new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("代理执行前");
                try {
                    return method.invoke(impl, args);
                } finally {
                    System.out.println("代理执行后");
                }
            }
        });
        servce.get();
    }

我们还是很奇怪上面到底是什么东东?用我表达不好语言解释一下:

首先,我们new 了一个newProxyInstance()然后我们在InvocationHandler()里面的invoke方法来实现它的动态代理.

还是贴图方便一点这样我们便实现了一个简单的代理类

这里的我们get()方法就相当于客户端,掉的是userservice接口的方法,委托类就是serviceimpl 代理类就是我们传的userservice.class,这样通过接口屏蔽的底层的实现细节,这样透明化喽.

对啊是如何做到代理目标对象的呢?这个好说我们通过代理类来分析一下:

@Test
public void buildProcyClass() throws IOException {
    byte[] bytes = ProxyGenerator.generateProxyClass("UserService$proxy", new Class[]{
            UserServce.class
    });
    String filename = String.format("%s/target/UserService$proxy.class", System.getProperty("user.dir"));
    File file = new File(filename);
    FileOutputStream outputStream = new FileOutputStream(file);
    outputStream.write(bytes);
    outputStream.flush();
    outputStream.close();
}

这样我就把它代理的类输出出来了:

public final class UserService$proxy extends Proxy implements UserServce {
    private static Method m1;
    private static Method m2;
    private static Method m3;
    private static Method m0;

    public UserService$proxy(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 String get() throws  {
        try {
            return (String)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", Class.forName("java.lang.Object"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m3 = Class.forName("com.yqun.springboot.service.UserServce").getMethod("get");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }

这个就是输出来的类,我们可以看到代理过来的类:

return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue(); 里面的参数就对应着:

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 上问中这个invoke里面要的参数,

其实这样我们可以清楚的看到,代理类回事怎么一回事

我们看看他是怎么生成的:追类可以通过了吗看到它就是生成一个动态代理对对象

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

/*获取查询遍历已经构建好的class类也就是我们接口的代理类
 * Look up or generate the designated proxy class.
 */
Class<?> cl = getProxyClass0(loader, intfs);

// If the proxy class defined by the given loader implementing //点进去首先会通过从load缓存里面取
// 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);

我们看到如果它没有的话回去ProxyClassFactory类里面去实现那么我们就看看里面的方法,

-->ProxyClassFactory.apply 就是装配自动代理的过程动态代理所用的接口

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

//存储所有动态代理所对应的接口

Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);

for (Class<?> intf : interfaces) {

/*验证接口也就是说ClassLoader 对应的接口是否已经存在是否是同一个

* Verify that the class loader resolves the name of this

* interface to the same Class object.

也就是说对代理的类是不service的实现类

当然里面还有许多乱七八糟的方法,但是我只看懂了这个.这里他会对字节码重组也就是修改class文件,相当于吧代码编译成字节码

在往深就是类加载器的方法了,这个便是对字节码的重新装载也就是ClassLoad里面的

@Deprecated
protected final Class<?> defineClass(byte[] b, int off, int len)
    throws ClassFormatError
{
    return defineClass(null, b, off, len, null);
}

的方法

总结两张图结尾:

最后一张图特别重要,也就是写了这么长时间的总计吧算是...

————————————————

原文链接：

https://blog.csdn.net/weixin_39715061/article/details/80394751

锋哥最新SpringCloud分布式电商秒杀课程发布

👇👇👇

👆长按上方微信二维码 2 秒

感谢点赞支持下哈