Java jdk动态代理实现及原理
文章目录
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. 什么是动态代理
定义网上有很多，省略…
动态代理中涉及的几个对象之间的关系，如下图所示
调用接口的调用方就是客户，接口的实现类就是委托类，再对委托类进行包装增强就是代理类，客户直接调用代理类就可以了
动态代理好处在于，通过代理类这中间一层，能有效控制对委托类对象的直接访问，可以很好地隐藏和保护委托类对象，同时也为实施不同控制策略预留了空间，从而在设计上获得了更大的灵活性
2.1 动态代理的执行过程
客户类去调用 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源文件，而且这个 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 编译器
这个对象里面有个方法叫做：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 什么意思，他的父类
再看所生成的代理的继承关系，他继承了 Proxy，我传的 AppleFactor是一个类，这里他应该是指的 AppleFactory 所实现的接口。
点击 h.invoke 这个方法，你会发现他指向的是 InvocationHandler 那个接口。接口里面又没有方法实现，所以他真正指向的是我们自己实现 InvocationHandler 接口的那个类里面的 invoke 方法。
所以这个代理类被执行的时候，就是我们自己定义的 invoke 方法被执行的时候。
代理类什么时候被执行就是我们自己调用的问题了，比如我写的案例，我自己去调用了生成的代理类的 createFood() 方法，就执行了代理类啊
下一篇： Java11新特性