秒懂Java动态编程（Javassist研究）

女爷i 2022-05-18 03:07 323阅读 0赞

> 版权申明】非商业目的可自由转载  
> 博文地址：[https://blog.csdn.net/ShuSheng0007/article/details/81269295][https_blog.csdn.net_ShuSheng0007_article_details_81269295]  
> 出自：shusheng007

*  概述
 *  什么是动态编程
    
     *  反射
     *  动态编译
     *  调用JavaScript引擎
     *  动态生成字节码
 *  动态编程解决什么问题
 *  Java中如何使用
    
     *  Javassit使用方法
     *  动态生成一个类
     *  动态添加构造函数及方法
     *  动态修改方法体
 *  什么原理
 *  总结

# 概述 #

什么是动态编程？动态编程解决什么问题？Java中如何使用？什么原理？如何改进？（需要我们一起探索，由于自己也是比较菜，一般深入不到这个程度）。

# 什么是动态编程 #

动态编程是相对于静态编程而言的,平时我们讨论比较多的就是**静态编程语言**，例如Java，与**动态编程语言**，例如JavaScript。那二者有什么明显的区别呢？简单的说就是在静态编程中，类型检查是在**编译时**完成的，而动态编程中类型检查是在**运行时**完成的。所谓动态编程就是绕过编译过程在运行时进行操作的技术，在Java中有如下几种方式：

## 反射 ##

这个搞Java的应该比较熟悉，原理也就是通过在运行时获得类型信息然后做相应的操作。

## 动态编译 ##

动态编译是从`Java 6`开始支持的，主要是通过一个`JavaCompiler`接口来完成的。通过这种方式我们可以直接编译一个已经存在的java文件，也可以在内存中动态生成Java代码，动态编译执行。

## 调用JavaScript引擎 ##

`Java 6`加入了对`Script(JSR223)`的支持。这是一个脚本框架，提供了让脚本语言来访问Java内部的方法。你可以在运行的时候找到脚本引擎，然后调用这个引擎去执行脚本。这个脚本API允许你为脚本语言提供Java支持。

## 动态生成字节码 ##

这种技术通过操作Java字节码的方式在`JVM`中生成新类或者对已经加载的类动态添加元素。

# 动态编程解决什么问题 #

在静态语言中引入动态特性，主要是为了解决一些使用场景的痛点。其实完全使用静态编程也办的到，只是付出的代价比较高，没有动态编程来的优雅。例如依赖注入框架**Spring**使用了反射，而**Dagger2** 却使用了代码生成的方式（APT）。

例如  
1： 在那些依赖关系需要动态确认的场景:  
2： 需要在运行时动态插入代码的场景，比如动态代理的实现。  
3： 通过配置文件来实现相关功能的场景

# Java中如何使用 #

此处我们主要说一下通过**动态生成字节码**的方式，其他方式可以自行查找资料。

操作java字节码的工具有两个比较流行，一个是[ASM][]，一个是[Javassit][] 。

**ASM** ：直接操作字节码指令，执行效率高，要是使用者掌握Java类字节码文件格式及指令，对使用者的要求比较高。

**Javassit** 提供了更高级的API，执行效率相对较差，但无需掌握字节码指令的知识，对使用者要求较低。

应用层面来讲一般使用建议优先选择**Javassit**，如果后续发现`Javassit` 成为了整个应用的效率瓶颈的话可以再考虑`ASM`.当然如果开发的是一个基础类库，或者基础平台，还是直接使用`ASM`吧，相信从事这方面工作的开发者能力应该比较高。

![这里写图片描述][70]  
上一张国外博客的图，展示处理Java字节码的工具的关系。

接下来介绍如何使用`Javassit`来操作字节码

## Javassit使用方法 ##

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

**Javassist**中最为重要的是`ClassPool`，`CtClass` ，`CtMethod` 以及 `CtField`这几个类。

**ClassPool**：一个基于`HashMap`实现的`CtClass`对象容器，其中键是类名称，值是表示该类的`CtClass`对象。默认的`ClassPool`使用与底层`JVM`相同的类路径，因此在某些情况下，可能需要向`ClassPool`添加类路径或类字节。

**CtClass**：表示一个类，这些`CtClass`对象可以从`ClassPool`获得。

**CtMethods**：表示类中的方法。

**CtFields** ：表示类中的字段。

## 动态生成一个类 ##

下面的代码会生成一个实现了`Cloneable`接口的类`GenerateClass`

public void DynGenerateClass() {
         ClassPool pool = ClassPool.getDefault();
         CtClass ct = pool.makeClass("top.ss007.GenerateClass");//创建类
         ct.setInterfaces(new CtClass[]{pool.makeInterface("java.lang.Cloneable")});//让类实现Cloneable接口
         try {
             CtField f= new CtField(CtClass.intType,"id",ct);//获得一个类型为int，名称为id的字段
             f.setModifiers(AccessFlag.PUBLIC);//将字段设置为public
             ct.addField(f);//将字段设置到类上
             //添加构造函数
             CtConstructor constructor=CtNewConstructor.make("public GeneratedClass(int pId){this.id=pId;}",ct);
             ct.addConstructor(constructor);
             //添加方法
             CtMethod helloM=CtNewMethod.make("public void hello(String des){ System.out.println(des);}",ct);
             ct.addMethod(helloM);
    
             ct.writeFile();//将生成的.class文件保存到磁盘
    
             //下面的代码为验证代码
             Field[] fields = ct.toClass().getFields();
             System.out.println("属性名称：" + fields[0].getName() + " 属性类型：" + fields[0].getType());
         } catch (CannotCompileException e) {
             e.printStackTrace();
         } catch (IOException e) {
             e.printStackTrace();
         } catch (NotFoundException e) {
             e.printStackTrace();
         }
     }

上面的代码就会动态生成一个.class文件，我们使用反编译工具，例如**Bytecode Viewer**，查看生成的字节码文件`GenerateClass.class`，如下图所示。

![这里写图片描述][70 1]

## 动态添加构造函数及方法 ##

有很多种方法添加构造函数，我们使用`CtNewConstructor.make`,他是一个的静态方法，其中有一个重载版本比较方便，如下所示。第一个参数是**source text** 类型的方法体，第二个为类对象。

CtConstructor constructor=CtNewConstructor.make("public GeneratedClass(int pId){this.id=pId;}",ct);
     ct.addConstructor(constructor);

这段代码执行后会生成如下java代码，代码片段是使用反编译工具`JD-GUI`产生的，可以看到构造函数的参数名被修改成了`paramInt`。

public GeneratedClass(int paramInt)
      {
        this.id = paramInt;
      }

同样有很多种方法添加函数，我们使用`CtNewMethod.make`这个比较简单的形式

CtMethod helloM=CtNewMethod.make("public void hello(String des){ System.out.println(des);}",ct);
    ct.addMethod(helloM);

这段代码执行后会生成如下java代码：

public void hello(String paramString)
      {
        System.out.println(paramString);
      }

## 动态修改方法体 ##

动态的修改一个方法的内容才是我们关注的重点，例如在`AOP`编程方面，我们就会用到这种技术，动态的在一个方法中插入代码。  
例如我们有下面这样一个类

public class Point {
        private int x;
        private int y;
    
        public Point(){}
        public Point(int x, int y) {
            this.x = x;
            this.y = y;
        }
    
        public void move(int dx, int dy) {
            this.x += dx;
            this.y += dy;
        }
    }

我们要动态的在内存中在`move()`方法体的前后插入一些代码

public void modifyMethod()
        {
            ClassPool pool=ClassPool.getDefault();
            try {
                CtClass ct=pool.getCtClass("top.ss007.Point");
                CtMethod m=ct.getDeclaredMethod("move");
                m.insertBefore("{ System.out.print(\"dx:\"+$1); System.out.println(\"dy:\"+$2);}");
                m.insertAfter("{System.out.println(this.x); System.out.println(this.y);}");
    
                ct.writeFile();
                //通过反射调用方法，查看结果
                Class pc=ct.toClass();
                Method move= pc.getMethod("move",new Class[]{int.class,int.class});
                Constructor<?> con=pc.getConstructor(new Class[]{int.class,int.class});
                move.invoke(con.newInstance(1,2),1,2);
            }
            ...
        }

使用反编译工具查看修改后的`move`方法结果：

public void move(int dx, int dy) {
        System.out.print("dx:" + dx);System.out.println("dy:" + dy);
        this.x += dx;
        this.y += dy;
        Object localObject = null;//方法返回值
        System.out.println(this.x);System.out.println(this.y);
      }

可以看到，在生成的字节码文件中确实增加了相应的代码。  
函数输出结果为：

dx:1dy:2
    2
    4

Javassit 还有许多功能，例如在方法中调用方法，异常捕捉，类型强制转换，注解相关操作等，而且其还提供了字节码层面的API(`Bytecode level API`)。

# 什么原理 #

**反射**：由于Java执行过程中是将类型载入虚拟机中的，在**运行时**我们就可以动态获取到所有类型的信息。只能获取却不能修类型信息。  
**动态编译与动态生成字节码**：这两种方法比较相似，原理也都是利用了Java的设计原理，存在一个虚拟机执行字节码，这就使我们在此处有了改变字节码的操作空间。

# 总结 #

有关动态编程的知识在平时的应用层使用不是特别多，多是用在构建框架。例如`Spring`框架使用反射来构建，而用于AOP编程的动态代理则多是采用生成字节码的方式,例如`JBoss`，`Spring`中的`AOP`部分。了解这部分知识可以在日后遇到相关问题时比别人多一条思考的思路也是好的，做一个思路开阔的**Developer**。

[https_blog.csdn.net_ShuSheng0007_article_details_81269295]: https://blog.csdn.net/ShuSheng0007/article/details/81269295
[ASM]: https://asm.ow2.io/index.html
[Javassit]: http://www.javassist.org/
[70]: /images/20220518/e15f32cd01554c509fcd4f377db932a5.png
[70 1]: /images/20220518/b00caf88d1754f56a047dd41b48dddb5.png