欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

Java jdk动态代理实现及原理

程序员文章站 2024-03-14 20:33:11
...

1. 动态代理和 class 字节码的关系

1.1 动态代理有什么作用及应用场景

1、日志集中打印
2、事务
3、权限管理
4、AOP

1.2 在 Spring AOP 中有哪些方式及实现

1、Java Proxy:动态构建字节码(动态构建全新字节码, bean 初始化的时候)
2、cglib:动态构建字节码(动态构建全新字节码, bean 初始化的时候)
3、AspectJ :修改目标类的字节,织入代理的字节在程序编译的时候插入动态代理事务字节码,不会生成全新的 Class
4、instrumentation :修改目标类的字节码,类装载的时候动态拦截去修改

从上可以看出:
无论哪种方式实现动态代理,其本质都是对字节码的修改,其区别是从哪里进行切入修改字节码

所以如果能对 class 文件的修改,也就相当于对源程序进行修改了。后面两种c,d就是通过对字节码进行修改,把你要增强的逻辑编译成字节码,然后插入到源程序编译好的字节码里面的对应位置,就实现了增强

2. 什么是动态代理

定义网上有很多,省略…

动态代理中涉及的几个对象之间的关系,如下图所示
调用接口的调用方就是客户,接口的实现类就是委托类,再对委托类进行包装增强就是代理类,客户直接调用代理类就可以了

Java jdk动态代理实现及原理
动态代理好处在于,通过代理类这中间一层,能有效控制对委托类对象的直接访问,可以很好地隐藏和保护委托类对象,同时也为实施不同控制策略预留了空间,从而在设计上获得了更大的灵活性

2.1 动态代理的执行过程

Java jdk动态代理实现及原理
客户类去调用 Proxy 类,Proxy 类调用实现了 InvocationHandler 的类,InvocationHandler 类再通过反射去调用目标业务方法。 实现了InvocationHandler 类的作用就是织入代理的前置逻辑和后置逻辑

2.2 案例演示

接口:
一个食物加工厂

public interface FoodFactory {
    public void createFood();
}

接口的实现类,即委托类:
苹果加工厂

//委托类
public class AppleFactory implements FoodFactory {

    public void createFood() {
        System.out.println("生产苹果....");
    }
}

对委托类进行包装,即代理类:
下面代码中 getProxy 就是我们获取代理类的方法

/**
 * 这个类主要是帮助我们生成一个代理对象
 * 1、Proxy 类,创建出代理对象
 * 2、InvocationHandler 接口:提供服务的接口
 */
public class MyProxyClass implements InvocationHandler {

    //传入目标对象,根据目标对象生成代理类
    private Object target;

    public void setTarget(Object target) {
        this.target = target;
    }

    // 获取代理对象
    public Object getProxy(){
        // 参数含义:类加载器,委托类实现的全部接口,一个实现了InvocationHandler的类
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
    }

    //提供服务的方法,可以对委托类里面的方法进行增强
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("开始生产了.....");
        //反射代码,执行目标代码的方法
        Object result= method.invoke(target);

        System.out.println("生产结束了.....");
        return result;
    }
}

Tip:Proxy.newProxyInstance 三个参数里面会传一个委托类实现的全部接口,目的在于让最终的代理类也能实现这些接口,为什么代理类和委托类要实现相同的接口?为了让访问者看来两者没有丝毫的区别。

调用接口的类就是客户:

// 客户类
public class CustomClass {
    public static void main(String[] args) {
        //创建一个目标对象
        FoodFactory appleFactory=new AppleFactory();

        MyProxyClass myProxyClass=new MyProxyClass();
        //设置委托类
        myProxyClass.setTarget(appleFactory);
        //得到一个代理类,这个类就是程序帮我们生成的类
        FoodFactory proxy= (FoodFactory) myProxyClass.getProxy();

        //调用代理对象的方法
        proxy.createFood();
    }
}

代理对象是程序帮我们生成的,那么它是怎么生成的呢?

3. 从源码解析代理对象生成过程

一般对象的生命周期:
Java jdk动态代理实现及原理
代理对象的生命周期和一般对象不一样的就在于,他没有 Java源文件,而且这个 Java 字节码文件是在内存中生成的,且本质是一个字节数组,通过类加载器加载之后变成 Class 对象,再根据这个 Class 对象,利用反射最终创建出来 代理对象

源码实现过程和上面说的差不多,我截代码省略了不重要的部分:

 @CallerSensitive
    public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
    ...省略一部分代码
    /**
    * 查找或生成指定的代理的类,这句话做了两件事情:
    * 1、生成 Java 字节码文件
    * 2、把字节码文件加载进内存中,生成 Class 对象
    */
        Class<?> cl = getProxyClass0(loader, intfs);
....省略
	// 拿到构造器对象
		final Constructor<?> cons = cl.getConstructor(constructorParams);
... 省略
	//通过反射初始化一个实例对象
	 return cons.newInstance(new Object[]{h});
...省略
    }
    private static Class<?> getProxyClass0(ClassLoader loader,
                                           Class<?>... interfaces) {
 ...省略
 // 从缓存中获取字节码对象,如果没有就创建一个新的字节码对象
        return proxyClassCache.get(loader, interfaces);
    }
    public V get(K key, P parameter) {
    // 这行代码就在帮你生成字节码文件和 Class 对象
        Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
    }

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

        //这个 byte 数组就是我们的字节码文件
        byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                proxyName, interfaces, accessFlags);
        try {
            // 根据字节码文件生成 Class 对象,应该就是加载字节码,然后创建对象一系列的
            return defineClass0(loader, proxyName,
                    proxyClassFile, 0, proxyClassFile.length);
            ...省略
    }

最终会调用类 generateProxy 的 generateProxyClass 方法帮我们生成一个字节数组,然后利用类加载器把这个字节对象进行加载,就可以生成一个 Class 对象,有了 Class 对象就可以通过反射创建一个实例对象,即我们的代理对象

这个 ProxyGeneration 类是 sun.misc包下的一个类,这个类里面的这些数字,其实就是 JVM 字节码的表现形式,所谓的拼接一个程序(拼接一个代理类),就是把这些数字拼装起来,最后再把他序列化成一个文件。这个类就相当于一个简单版的 JVM 编译器

Java jdk动态代理实现及原理
这个对象里面有个方法叫做:generateProxyClass 。这个方法就是直接帮我们生成代理类 字节 的方法(序列化好的字节),他的返回值byte[]就是序列化好了的字节对象

public static byte[] generateProxyClass(final String var0, Class<?>[] var1, int var2) {
        ProxyGenerator var3 = new ProxyGenerator(var0, var1, var2);
        final byte[] var4 = var3.generateClassFile();
        if (saveGeneratedFiles) {
            AccessController.doPrivileged(new PrivilegedAction<Void>() {
                public Void run() {
                    try {
                        int var1 = var0.lastIndexOf(46);
                        Path var2;
                        if (var1 > 0) {
                            Path var3 = Paths.get(var0.substring(0, var1).replace('.', File.separatorChar));
                            Files.createDirectories(var3);
                            var2 = var3.resolve(var0.substring(var1 + 1, var0.length()) + ".class");
                        } else {
                            var2 = Paths.get(var0 + ".class");
                        }

                        Files.write(var2, var4, new OpenOption[0]);
                        return null;
                    } catch (IOException var4x) {
                        throw new InternalError("I/O exception saving generated file: " + var4x);
                    }
                }
            });
        }

        return var4;
    }

补充:

什么时候去调用的 实现 InvocationHandler 那个类的 invoke 方法的以及怎么调用的?

程序帮我们生成的代理类是隐藏的,但是我们可以通过上面提到的 ProxyGeneration 类来自己生成代理类,就可以查看了,代码如下

    public static void main(String[] args) throws IOException {
        //参数含义:即将生成的代理类的名字(自己随便定义),委托类实现的接口,
        byte[] bytes= ProxyGenerator.generateProxyClass("FoodFactory$Proxy",new Class[]{AppleFactory.class});
        //生成的文件所存放的位置,然后你可以在这个位置找到这个文件
        Files.write(new File("D:\\Code\\Java\\Idea\\Test\\target\\classes\\com\\xp\\FodFactory$Proxy.class").toPath(),bytes);
    }

这是生成的代理类中的 invoke 方法,他去调用了super.h.invoke(this, m3, (Object[])null);,super 什么意思,他的父类
Java jdk动态代理实现及原理

再看所生成的代理的继承关系,他继承了 Proxy,我传的 AppleFactor是一个类,这里他应该是指的 AppleFactory 所实现的接口。

点击 h.invoke 这个方法,你会发现他指向的是 InvocationHandler 那个接口。接口里面又没有方法实现,所以他真正指向的是我们自己实现 InvocationHandler 接口的那个类里面的 invoke 方法。

所以这个代理类被执行的时候,就是我们自己定义的 invoke 方法被执行的时候。

Java jdk动态代理实现及原理
代理类什么时候被执行就是我们自己调用的问题了,比如我写的案例,我自己去调用了生成的代理类的 createFood() 方法,就执行了代理类啊
Java jdk动态代理实现及原理