Java 动态代理与class字节码动态修改技术

Bertha 。 2022-12-16 09:16 229阅读 0赞

代理分两种技术，一种是jdk代理（机制就是反射，只对接口操作），一种就是字节码操作技术。前者不能算技术，后者算是新的技术。未来将有大的动作或者较为广泛的应用和变革，它可以实现代码自我的编码（人工智能，代码智能）。

先看看jvm class技术：

![Center][]

字节码改写：

![Center 1][]

（一）jdk 动态代理：

1.定义业务逻辑

1.  `public interface Service {`
2.  `//目标方法`
3.  `public abstract void add();`
4.  `}`
5.   
6.  `public class UserServiceImpl implements Service {`
7.  `public void add() {`
8.  `System.out.println("This is add service");`
9.  `}`
10. `}`

2. 利用 `java.lang.reflect.Proxy` 类和 `java.lang.reflect.InvocationHandler` 接口定义代理类的实现。

1.  `class MyInvocatioHandler implements InvocationHandler {`
2.  `private Object target;`
3.   
4.  `public MyInvocatioHandler(Object target) {`
5.  `this.target = target;`
6.  `}`
7.   
8.  `@Override`
9.  `public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {`
10. `System.out.println("-----before-----");`
11. `Object result = method.invoke(target, args);`
12. `System.out.println("-----end-----");`
13. `return result;`
14. `}`
15. `// 生成代理对象`
16. `public Object getProxy() {`
17. `ClassLoader loader = Thread.currentThread().getContextClassLoader();`
18. `Class<?>[] interfaces = target.getClass().getInterfaces();`
19. `return Proxy.newProxyInstance(loader, interfaces, this);`
20. `}`
21. `}`

3.使用动态代理

1.  `public class ProxyTest {`
2.  `public static void main(String[] args) {`
3.  `Service service = new UserServiceImpl();`
4.  `MyInvocatioHandler handler = new MyInvocatioHandler(service);`
5.  `Service serviceProxy = (Service)handler.getProxy();`
6.  `serviceProxy.add();`
7.  `}`
8.  `}`

执行结果：

1.  `-----before-----`
2.  `This is add service`
3.  `-----end-----`

代理对象的生成过程由Proxy类的newProxyInstance方法实现，分为3个步骤：  
1、`ProxyGenerator.generateProxyClass`方法负责生成代理类的字节码，生成逻辑比较复杂，了解原理继续分析源码 sun.misc.ProxyGenerator；

byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces, accessFlags);

2、native方法`Proxy.defineClass0`负责字节码加载的实现，并返回对应的Class对象。

Class clazz = defineClass0(loader, proxyName, proxyClassFile, 0, proxyClassFile.length);

3、利用`clazz.newInstance`反射机制生成代理类的对象；

使用 [反编译工具 jad][jad] `jad com.sun.proxy.$Proxy.1` 看看代理类如何实现，反编译出来的java代码如下：

1.  `public final class $proxy1 extends Proxy implements Service {`
2.   
3.  `public $proxy1(InvocationHandler invocationhandler) {`
4.  `super(invocationhandler);`
5.  `}`
6.   
7.  `public final boolean equals(Object obj) {`
8.  `try {`
9.  `return ((Boolean)super.h.invoke(this, m1, new Object[] {`
10. `obj`
11. `})).booleanValue();`
12. `}`
13. `catch(Error _ex) { }`
14. `catch(Throwable throwable) {`
15. `throw new UndeclaredThrowableException(throwable);`
16. `}`
17. `}`
18.  
19. `public final String toString() {`
20. `try {`
21. `return (String)super.h.invoke(this, m2, null);`
22. `}`
23. `catch(Error _ex) { }`
24. `catch(Throwable throwable) {`
25. `throw new UndeclaredThrowableException(throwable);`
26. `}`
27. `}`
28.  
29. `public final void add() {`
30. `try {`
31. `super.h.invoke(this, m3, null);`
32. `return;`
33. `}`
34. `catch(Error _ex) { }`
35. `catch(Throwable throwable) {`
36. `throw new UndeclaredThrowableException(throwable);`
37. `}`
38. `}`
39.  
40. `public final int hashCode() {`
41. `try {`
42. `return ((Integer)super.h.invoke(this, m0, null)).intValue();`
43. `}`
44. `catch(Error _ex) { }`
45. `catch(Throwable throwable) {`
46. `throw new UndeclaredThrowableException(throwable);`
47. `}`
48. `}`
49.  
50. `private static Method m1;`
51. `private static Method m2;`
52. `private static Method m3;`
53. `private static Method m0;`
54.  
55. `static {`
56. `try {`
57. `m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] {`
58. `Class.forName("java.lang.Object")`
59. `});`
60. `m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);`
61. `m3 = Class.forName("zzzzzz.Service").getMethod("add", new Class[0]);`
62. `m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);`
63. `}`
64. `catch(NoSuchMethodException nosuchmethodexception) {`
65. `throw new NoSuchMethodError(nosuchmethodexception.getMessage());`
66. `}`
67. `catch(ClassNotFoundException classnotfoundexception) {`
68. `throw new NoClassDefFoundError(classnotfoundexception.getMessage());`
69. `}`
70. `}`
71. `}`

从上述代码可以发现：  
1、生成的$proxy1继承自Proxy类，并实现了Service接口。  
2、执行代理对象的方法，其实就是执行InvocationHandle对象的invoke方法，传入的参数分别是当前代理对象，当前执行的方法和参数。

jdk动态代理使用的局限性  
通过反射类`Proxy`和`InvocationHandler`回调接口实现的jdk动态代理，要求委托类必须实现一个接口，但事实上并不是所有类都有接口，对于没有实现接口的类，便无法使用该方方式实现动态代理。

（二）字节码修改技术

了解该技术必然先了解Java class文件格式 [《读《深入jvm原理》之class文件》][jvm_class]

目前字节码修改技术有ASM，javassist等。cglib就是基于封装的Asm. Spring 就是使用cglib代理库。

ASM 是一个 Java 字节码操控框架。它能够以二进制形式修改已有类或者动态生成类。ASM 可以直接产生二进制 class 文件，也可以在类被加载入 Java 虚拟机之前动态改变类行为。ASM 从类文件中读入信息后，能够改变类行为，分析类信息，甚至能够根据用户要求生成新类。  
不过ASM在创建class字节码的过程中，操纵的级别是底层JVM的汇编指令级别，这要求ASM使用者要对class组织结构和JVM汇编指令有一定的了解。

Java字节码生成开源框架介绍--Javassist：

Javassist是一个开源的分析、编辑和创建Java字节码的类库。是由东京工业大学的数学和计算机科学系的 Shigeru Chiba （千叶 滋）所创建的。它已加入了开放源代码JBoss 应用服务器项目,通过使用Javassist对字节码操作为JBoss实现动态AOP框架。javassist是jboss的一个子项目，其主要的优点，在于简单，而且快速。直接使用java编码的形式，而不需要了解虚拟机指令，就能动态改变类的结构，或者动态生成类。

[Center]: /images/20221123/b392672a9bd04dfda7564f4400e20aab.png
[Center 1]: /images/20221123/58811acfb123468e83e73b365f3fe81d.png
[jad]: http://varaneckas.com/jad/
[jvm_class]: http://blog.csdn.net/lxlmycsdnfree/article/details/71403698