Java高级之反射
反射应用之动态代理
问题的起源
- 适逢学生暑期，现在驾校里有许多学生趁着假期开始学车，目前正在练习科目二，整体流程固定，如下：
/**
* 驾校学生接口
*/
interface DrivingStudent{
//准备科目二的考试
void prepare();
}
/**
* 正常驾校学生的考试流程
*/
class CommonStudents implements DrivingStudent{
@Override
public void prepare() {
System.out.println("在驾校正常上班时间点，听教练讲要点、然后练习，熟练后去考试！");
}
}
-
一切都在按部就班的进行着。这天，新加入了一个学员，她是驾校老板的女儿，作为老板的女儿，教练为了让老板开心好给自己加薪，自然要给她VVIP的练车待遇：在
prepare()方法执行之前，先好好的跟她讲一些注意事项，prepare()方法执行之后，也就是驾校下班后，单独指导她练车技巧以及传授经验。 -
现在，科二整体流程固定，可以比喻为类
CommonStudents已经加载到内存，成为运行时的类，众所周知，java在运行时的类是不允许被修改的，那么教练该如何实现给老板女儿开小灶的功能？
问题的扩展
- 回到
java编程世界中，Spring框架在当下非常热门，AOP、IOC这些耳熟能详的词在java编程世界中经常出现，那么AOP解决了码农的什么样需求？ - 联想到开发应用程序过程中，我们或多或少都会遇到类似于这样的需求：比如为方便排查问题，要在某些函数（例如上面的：
prepare()函数）的调用前后加上相应的日志记录；为了保持数据的安全性，要给某些函数加上事务的支持等等。xml和注解的盛行，使我们程序员可以在xml和注解中声明要在哪一类函数前后加上日志以及日志等，但是这些类已经是运行状态，我们声明了要在这些运行中的函数前后加功能，但是运行时的类java是不允许被修改的，那么该如何实现此需求呢？
问题的思路
分析
- 在上篇反射1中我们提到，
java世界中有这么一个类java.lang.Class，它是描述类的类，它对应的便是那一个个运行时的类，我们可以通过它去拿到运行时的类的所有类型信息，包括方法、属性等。也可以通过它去创建一个运行时的类的对象。 - 回到驾校的问题：教练希望能给老板女儿开小灶，但是对外宣称也必须是走的是驾校的正常流程，也就是调用的是
prepare()方法；回到java编程世界，比如有个添加数据的函数add()，我们希望在add()函数前后加上日志以打印出入参出参。但是在调用方看来，他应该只是调用了add()函数，他并不知道额外做了添加日志其他的操作。 - 换句话说，我们通过
Class获取到了运行时的prepare()、add()方法，并在这些方法前后添加了自己的额外功能，而调用方还认为自己只是调用的是正常的方法。
方案整理
- 为了实现了新的功能，我们可以在类运行时动态的去创建一个新的类，这个新的类便是我们要实现某个函数的类(即被代理类也是目标对象)的代理类。
- 以教练为例，创建目标对象
CommonStudents的代理类的需要我们考虑两个问题：CommonStudents被加载到内存中，成为运行时的类，如何通过它创建一个代理类？- 当
CommonStudents类中的prepare()方法被调用时，如何让它去调用代理类中在prepare()方法的基础上添加了额外功能的方法？
问题的解决
解决流程
-
解决问题1：Proxy 是专门完成代理的操作类，通过该类为一个或多个接口动态地生成实现类。它是所有动态代理类的父类；创建一个代理对象的方法源码如下：
public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h) throws IllegalArgumentException{ ********** } -
解决问题2：创建一个类实现接口InvocationHandler的类，在该类中实现
invoke()方法，在该方法中添加上我们需要添加的逻辑。这样在调用目标对象的方法时，调用的是代理类中的invoke()方法。
具体实现
-
解决问题2的代码，也就是当调用'目标对象'
CommonStudents的prepare()方法时，如何使其重定向到一个新的方法invoke()，也就是有额外功能的方法。class MyInvocationHandler implements InvocationHandler{ //目标对象，可以通过反射来调用目标对象的方法 private Object target; public MyInvocationHandler(Object target){ this.target = target; } //重写invoke方法，添加上自己的功能 @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("开始练车之前，好好跟你讲一些注意事项，以及快速上手的技巧！"); //反射机制调用目标对象的方法 Object result = method.invoke(target, args); System.out.println("下班后，单独对你做一些练车的指导以及加练！"); return result; } } -
主方法，内含解决问题1的代码。
public static void main(String[] args) { System.out.println("========正常学生流程开始==========="); DrivingStudent student = new CommonStudents(); //正常学生的流程 student.prepare(); System.out.println("========正常学生流程结束==========="); System.out.println("*********************************"); System.out.println("=======老板女儿练车流程开始=========="); //老板女儿的练车流程 //当CommonStudents方法被调用时，走invoke()方法，因此要将CommonStudents当作参数传入。 InvocationHandler handler = new MyInvocationHandler(student); //java提供了动态代理来解决在运行时动态创建一个代理类的方案 DrivingStudent bossStudent = (DrivingStudent)Proxy.newProxyInstance(student.getClass().getClassLoader(), student.getClass().getInterfaces(), handler); bossStudent.prepare(); System.out.println("=======老板女儿练车流程结束=========="); } -
运行结果
问题解决的思考
-
jdk动态代理为什么需要接口？
-
简单理解下源码:
Proxy.newProxyInstance中几行重要代码：
// public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h) throws IllegalArgumentException { Objects.requireNonNull(h); ...... //这一步是查找并生成代理类的Class Class<?> cl = getProxyClass0(loader, intfs); ...... //生成的代理类中存在参数为InvocationHandler的构造函数 final Constructor<?> cons = cl.getConstructor(constructorParams); ...... //将实现了InvocationHandler的类当作参数传入到newProxyInstance方法后，这一行是利用这个参数创建一个代理类 return cons.newInstance(new Object[]{h}); ...... }getProxyClass0(loader, intfs)中逻辑：
private static Class<?> getProxyClass0(ClassLoader loader, Class<?>... interfaces) { ...... //重点在：ProxyClassFactory return proxyClassCache.get(loader, interfaces); }ProxyClassFactory的主要操作：
private static final class ProxyClassFactory implements BiFunction<ClassLoader, Class<?>[], Class<?>> { ...... { //验证参数、接口等 ...... //生成byte类型的代理类，并将其返回 byte[] proxyClassFile = ProxyGenerator.generateProxyClass( proxyName, interfaces, accessFlags); ...... } }-
重点理解一下生成的
byte[]类型的代理类。将byte[]类型的代理类写出到文件上，并且进行反编译，代码如下：byte[] classFile = ProxyGenerator.generateProxyClass( "$Proxy0", new Class[]{DrivingStudent.class}); //自定义的目录 String path = "*****"+ "$Proxy0" + ".class"; try (FileOutputStream fos = new FileOutputStream(path)) { fos.write(classFile); fos.flush(); System.out.println("byte[]类型代理类class文件写入成功"); } catch (Exception e) { System.out.println("byte[]类型代理类发生错误"); } -
写入成功后，对生成的代理类进行反编译后得到的类如下：
public final class $Proxy0 extends Proxy implements DrivingStudent { private static Method m1; private static Method m2; private static Method m3; private static Method m0; //看到这里我们能看到，自动生成的代理类对象有一个入参是InvocationHandler的构造函数，这样在创建代理类时，通过该构造方法便将被代理类(实现了DrivingStudent)和InvocationHandler联系了起来。 public $Proxy0(InvocationHandler paramInvocationHandler) { super(paramInvocationHandler); } //省略的是equals和toString方法 ...... //当调用接口中的prepare()方法时，实际上走的是invoke()方法。invoke()方法中有我们自己加的逻辑 public final void prepare() { try { this.h.invoke(this, m3, null); return; } catch (Error|RuntimeException error) { throw null; } catch (Throwable throwable) { throw new UndeclaredThrowableException(throwable); } } //省略的是hashCode方法 ...... static { try { m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") }); m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]); m3 = Class.forName("com.practice.reflect.DrivingStudent").getMethod("prepare", new Class[0]); m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]); return; } catch (NoSuchMethodException noSuchMethodException) { throw new NoSuchMethodError(noSuchMethodException.getMessage()); } catch (ClassNotFoundException classNotFoundException) { throw new NoClassDefFoundError(classNotFoundException.getMessage()); } } }
-
回到最初的问题：jdk生成的动态代理类是继承于
Proxy类的，而java类是不允许多继承的，为了使代理类和目标对象建立联系，就必须实现一个接口。
结论
java动态代理是根据被代理对象动态的创建了一个新类，当调用被代理对象的方法时，会跳转到调用InvocationHandler中的invoke()方法，在创建代理类方法newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)的入参我们看到，它是根据字节码文件自动生成的代理类，并且传入了InvocationHandler参数。- 通过反编译生成的动态代理类得到的代码，我们看到代理类继承了
Proxy类以及实现了目标对象实现的接口，并且该代理类中的构造函数用到了上面传入的InvocationHandler参数，这样便将目标对象和InvocationHandler联系了起来，InvocationHandler中的invoke()方法中定义了我们需要新添加的功能，当调用目标对象的方法时，使其跳转到调用invoke()方法，这样便实现了在运行时创建新的类以满足我们新增功能的需求。
原创不易，欢迎转载，转载时请注明出处，谢谢！
作者：潇～萧下
原文链接：https://www.cnblogs.com/manongxiao/p/13449480.html