兄弟们，鹏磊今天来聊聊 Java 22 里的类文件 API（Class-File API）这个新特性，这玩意儿是 JEP 457 引入的，专门用来解析、生成和转换 Java 类文件的。说实话，以前操作类文件要么用 ASM、要么用 Javassist，虽然功能强大，但 API 设计得不够统一，而且容易出错，写起来也复杂。类文件 API 就是为了解决这些问题来的，它提供了一个标准化的、类型安全的、易用的 API 来操作类文件，让咱们开发字节码工具变得更简单。
类文件 API 是 Java 22 的预览特性，它定义在 java.lang.classfile 包里，完全符合 JVM 规范里的类文件格式。核心思想是：用不可变对象表示类文件的各个部分（字段、方法、属性、字节码指令等），用构建器模式来生成类文件，用转换函数来修改类文件。这玩意儿特别适合开发字节码分析工具、代码生成工具、代码增强工具、依赖分析工具啥的。
为什么需要类文件 API
先说说传统方式的问題。以前操作类文件，主要用 ASM 或者 Javassist：
// ASM 的典型用法（比较底层，容易出错）
import org.objectweb.asm.*;
public class AsmExample {
public static void modifyClass(byte[] classBytes) {
ClassReader reader = new ClassReader(classBytes); // 读取类文件
ClassWriter writer = new ClassWriter(reader, ClassWriter.COMPUTE_FRAMES); // 写入类文件
ClassVisitor visitor = new ClassVisitor(Opcodes.ASM9, writer) {
@Override
public MethodVisitor visitMethod(int access, String name, String descriptor,
String signature, String[] exceptions) {
// 修改方法
if (name.startsWith("debug")) {
return null; // 删除 debug 方法
}
return super.visitMethod(access, name, descriptor, signature, exceptions);
}
};
reader.accept(visitor, ClassReader.EXPAND_FRAMES); // 处理类文件
byte[] newBytes = writer.toByteArray(); // 获取修改后的字节码
}
}
// 问题1：API 设计不够统一，访问者模式用起来复杂
// 问题2：容易出错，比如栈帧计算、标签处理等
// 问题3：类型不够安全，很多地方用字符串和整数常量
// 问题4：不够直观，需要理解底层字节码结构
类文件 API 就是为了解决这些问题。它提供了更高级的抽象，用不可变对象表示类文件结构，用模式匹配来处理字节码指令，用构建器来生成类文件，写起来更简单、更安全、更直观。
核心概念
类文件 API 的核心概念包括：
- Element（元素）：不可变的类文件组件描述，比如指令、属性、字段、方法或整个类文件
- Builder（构建器）：每个复合元素都有对应的构建器，比如
ClassBuilder::withMethod，用来构建类文件 - Transform（转换）：接受元素和构建器的函数，用来转换类文件
- Model（模型）：解析后的类文件表示，比如
ClassModel、MethodModel、CodeModel等 - Lazy Parsing（惰性解析）：只在需要时才解析类文件的某些部分，提高性能
基本用法
解析类文件
最基础的用法就是解析一个类文件，看看它里面有什么：
import java.lang.classfile.*; // 导入类文件 API 包
import java.lang.classfile.attribute.*; // 导入属性相关类
import java.nio.file.Files; // 文件操作
import java.nio.file.Path; // 路径操作
// 解析类文件：读取类文件并分析其结构
public void parseClassFile(Path classFilePath) throws Exception {
// 读取类文件的字节码
byte[] classBytes = Files.readAllBytes(classFilePath); // 读取文件内容
// 创建 ClassFile 实例，用来解析和生成类文件
ClassFile cf = ClassFile.of(); // 获取默认的 ClassFile 实例
// 解析类文件，得到 ClassModel
ClassModel classModel = cf.parse(classBytes); // 解析字节码，返回类模型
// 打印类的基本信息
System.out.println("类名: " + classModel.thisClass().asInternalName()); // 获取类名（内部格式）
System.out.println("父类: " + classModel.superclass().map(ClassDesc::asInternalName).orElse("无")); // 获取父类
System.out.println("接口数: " + classModel.interfaces().size()); // 获取接口数量
// 遍历字段
System.out.println("\n字段:");
for (FieldModel field : classModel.fields()) { // 遍历所有字段
System.out.println(" " + field.fieldName().stringValue() + " : " +
field.fieldType().stringValue()); // 打印字段名和类型
}
// 遍历方法
System.out.println("\n方法:");
for (MethodModel method : classModel.methods()) { // 遍历所有方法
System.out.println(" " + method.methodName().stringValue() +
method.methodType().stringValue()); // 打印方法名和签名
// 如果有代码属性，打印字节码指令数
method.code().ifPresent(code -> { // 如果方法有代码
int instructionCount = 0; // 指令计数器
for (CodeElement element : code) { // 遍历代码元素
if (element instanceof Instruction) { // 如果是指令
instructionCount++; // 计数
}
}
System.out.println(" 指令数: " + instructionCount); // 打印指令数
});
}
}
这玩意儿的好处是，解析后的类文件用不可变对象表示，可以安全地共享和传递，而且 API 设计得很直观，不需要理解底层字节码格式。
使用模式匹配解析字节码
类文件 API 支持 Java 的模式匹配，可以很方便地处理不同类型的字节码指令：
import java.lang.classfile.*; // 导入类文件 API 包
import java.lang.classfile.instruction.*; // 导入指令相关类
import java.lang.constant.ClassDesc; // 类描述符
import java.util.HashSet; // 集合类
import java.util.Set; // 集合接口
// 收集类依赖：分析方法的字节码，找出所有依赖的类
public Set<ClassDesc> collectDependencies(ClassModel classModel) {
Set<ClassDesc> deps = new HashSet<>(); // 用来存储依赖的类
// 遍历所有方法
for (MethodModel method : classModel.methods()) { // 遍历类的方法
method.code().ifPresent(code -> { // 如果方法有代码
// 遍历代码元素，使用模式匹配处理不同类型的指令
for (CodeElement element : code) { // 遍历代码元素
switch (element) { // 使用 switch 表达式和模式匹配
// 字段访问指令：getfield、putfield、getstatic、putstatic
case FieldInstruction fieldInst -> {
deps.add(fieldInst.owner()); // 添加字段所属的类
}
// 方法调用指令：invokevirtual、invokestatic、invokespecial、invokeinterface
case InvokeInstruction invokeInst -> {
deps.add(invokeInst.owner()); // 添加方法所属的类
}
// instanceof 指令：检查对象类型
case TypeCheckInstruction typeCheck -> {
deps.add(typeCheck.type()); // 添加检查的类型
}
// 类型转换指令：checkcast
case TypeConversionInstruction typeConv -> {
deps.add(typeConv.type()); // 添加转换的目标类型
}
// 其他指令：new、anewarray 等
case NewObjectInstruction newObj -> {
deps.add(newObj.className()); // 添加新建对象的类
}
// 默认情况：其他指令不处理
default -> {
// 其他指令不需要处理
}
}
}
});
}
return deps; // 返回依赖集合
}
这玩意儿用模式匹配来处理字节码指令，代码更简洁、更直观，比传统的 if-else 或者访问者模式好多了。
生成类文件
类文件 API 还支持生成新的类文件，用构建器模式来构建：
import java.lang.classfile.*; // 导入类文件 API 包
import java.lang.classfile.instruction.*; // 导入指令相关类
import java.lang.constant.ClassDesc; // 类描述符
import java.lang.constant.MethodTypeDesc; // 方法类型描述符
import java.lang.reflect.AccessFlag; // 访问标志
import java.util.Set; // 集合接口
// 生成一个简单的类：创建一个新的类文件
public byte[] generateSimpleClass() {
ClassFile cf = ClassFile.of(); // 获取 ClassFile 实例
// 定义类描述符
ClassDesc className = ClassDesc.of("com.example.SimpleClass"); // 类名（内部格式）
ClassDesc objectClass = ClassDesc.of("java.lang.Object"); // Object 类
// 生成类文件
byte[] classBytes = cf.build(className, classBuilder -> { // 开始构建类
// 设置访问标志：public class
classBuilder.withFlags(AccessFlag.PUBLIC); // 设置为 public
// 设置父类
classBuilder.withSuperclass(objectClass); // 继承 Object
// 添加一个方法：public void hello()
classBuilder.withMethod("hello", // 方法名
MethodTypeDesc.ofDescriptor("()V"), // 方法签名：无参数，返回 void
Set.of(AccessFlag.PUBLIC), // 访问标志：public
methodBuilder -> { // 方法构建器
methodBuilder.withCode(codeBuilder -> { // 开始构建方法体
// 生成字节码：System.out.println("Hello, World!");
codeBuilder
.getstatic(ClassDesc.of("java.lang.System"), "out",
ClassDesc.of("java.io.PrintStream")) // 获取 System.out
.ldc("Hello, World!") // 加载字符串常量
.invokevirtual(ClassDesc.of("java.io.PrintStream"),
"println",
MethodTypeDesc.of(ClassDesc.of("java.lang.Object"),
ClassDesc.of("java.lang.String"))) // 调用 println
.return_(); // 返回
});
});
// 添加另一个方法：public int add(int a, int b)
classBuilder.withMethod("add", // 方法名
MethodTypeDesc.ofDescriptor("(II)I"), // 方法签名：两个 int 参数，返回 int
Set.of(AccessFlag.PUBLIC), // 访问标志：public
methodBuilder -> { // 方法构建器
methodBuilder.withCode(codeBuilder -> { // 开始构建方法体
// 生成字节码：return a + b;
codeBuilder
.iload(1) // 加载第一个参数（a）
.iload(2) // 加载第二个参数（b）
.iadd() // 相加
.ireturn(); // 返回结果
});
});
});
return classBytes; // 返回生成的类文件字节码
}
这玩意儿用构建器模式来生成类文件，API 设计得很直观，不需要手动计算栈帧、标签偏移啥的，构建器会自动处理这些细节。
条件分支和方法调用
生成更复杂的代码，比如条件分支和方法调用：
import java.lang.classfile.*; // 导入类文件 API 包
import java.lang.classfile.instruction.*; // 导入指令相关类
import java.lang.constant.ClassDesc; // 类描述符
import java.lang.constant.MethodTypeDesc; // 方法类型描述符
import java.lang.reflect.AccessFlag; // 访问标志
import java.util.Set; // 集合接口
// 生成带条件分支的方法：根据布尔参数决定调用哪个方法
public byte[] generateConditionalMethod(ClassDesc targetClass) {
ClassFile cf = ClassFile.of(); // 获取 ClassFile 实例
// 定义常量
ClassDesc voidType = ClassDesc.of("void"); // void 类型
ClassDesc booleanType = ClassDesc.of("boolean"); // boolean 类型
ClassDesc intType = ClassDesc.of("int"); // int 类型
// 生成类文件
byte[] classBytes = cf.build(targetClass, classBuilder -> { // 开始构建类
classBuilder.withFlags(AccessFlag.PUBLIC); // 设置为 public
// 添加方法：public void fooBar(boolean flag, int value)
classBuilder.withMethod("fooBar", // 方法名
MethodTypeDesc.of(voidType, booleanType, intType), // 方法签名
Set.of(AccessFlag.PUBLIC), // 访问标志
methodBuilder -> { // 方法构建器
methodBuilder.withCode(codeBuilder -> { // 开始构建方法体
// 创建标签：用于跳转
Label label1 = codeBuilder.newLabel(); // 第一个标签：if false 分支
Label label2 = codeBuilder.newLabel(); // 第二个标签：方法结束
// 生成字节码：
// if (flag) {
// this.foo(value);
// } else {
// this.bar(value);
// }
codeBuilder
.iload(1) // 加载第一个参数（flag，boolean 在局部变量表中是 int）
.ifeq(label1) // 如果 flag == false，跳转到 label1
// true 分支：调用 foo(value)
.aload(0) // 加载 this
.iload(2) // 加载第二个参数（value）
.invokevirtual(targetClass, "foo",
MethodTypeDesc.of(voidType, intType)) // 调用 foo(value)
.goto_(label2) // 跳转到方法结束
// false 分支：调用 bar(value)
.labelBinding(label1) // 绑定 label1
.aload(0) // 加载 this
.iload(2) // 加载第二个参数（value）
.invokevirtual(targetClass, "bar",
MethodTypeDesc.of(voidType, intType)) // 调用 bar(value)
.labelBinding(label2) // 绑定 label2
.return_(); // 返回
});
});
});
return classBytes; // 返回生成的类文件字节码
}
这玩意儿用标签来处理跳转，构建器会自动计算跳转偏移，不需要手动计算，写起来简单多了。
转换类文件
类文件 API 还支持转换类文件，可以修改、删除、添加类文件的各个部分：
删除方法
删除类文件中所有以 "debug" 开头的方法：
import java.lang.classfile.*; // 导入类文件 API 包
import java.nio.file.Files; // 文件操作
import java.nio.file.Path; // 路径操作
// 删除 debug 方法：移除所有以 "debug" 开头的方法
public byte[] removeDebugMethods(Path classFilePath) throws Exception {
ClassFile cf = ClassFile.of(); // 获取 ClassFile 实例
// 读取并解析原始类文件
byte[] originalBytes = Files.readAllBytes(classFilePath); // 读取文件
ClassModel classModel = cf.parse(originalBytes); // 解析类文件
// 构建新的类文件，过滤掉 debug 方法
byte[] newBytes = cf.build(classModel.thisClass().asSymbol(), classBuilder -> { // 开始构建
// 遍历原始类文件的所有元素
for (ClassElement element : classModel) { // 遍历类元素
// 如果是方法，检查方法名
if (element instanceof MethodModel method) { // 如果是方法模型
String methodName = method.methodName().stringValue(); // 获取方法名
// 如果方法名以 "debug" 开头，跳过（不添加到新类中）
if (methodName.startsWith("debug")) { // 检查方法名
continue; // 跳过这个方法
}
}
// 其他元素直接添加
classBuilder.with(element); // 添加元素到新类
}
});
return newBytes; // 返回修改后的类文件字节码
}
这玩意儿用转换的方式来修改类文件，代码很简洁，不需要理解底层字节码结构。
添加方法
给类文件添加一个新方法：
import java.lang.classfile.*; // 导入类文件 API 包
import java.lang.constant.ClassDesc; // 类描述符
import java.lang.constant.MethodTypeDesc; // 方法类型描述符
import java.lang.reflect.AccessFlag; // 访问标志
import java.util.Set; // 集合接口
// 添加方法：给类文件添加一个新方法
public byte[] addMethod(ClassModel originalClass, String methodName,
MethodTypeDesc methodType) {
ClassFile cf = ClassFile.of(); // 获取 ClassFile 实例
// 构建新的类文件，包含原始内容和新方法
byte[] newBytes = cf.build(originalClass.thisClass().asSymbol(), classBuilder -> { // 开始构建
// 先复制原始类的所有元素
for (ClassElement element : originalClass) { // 遍历原始类元素
classBuilder.with(element); // 添加元素
}
// 添加新方法
classBuilder.withMethod(methodName, // 方法名
methodType, // 方法签名
Set.of(AccessFlag.PUBLIC), // 访问标志
methodBuilder -> { // 方法构建器
methodBuilder.withCode(codeBuilder -> { // 开始构建方法体
// 生成简单的返回语句（根据返回类型）
if (methodType.returnType().descriptorString().equals("V")) { // 如果返回 void
codeBuilder.return_(); // void 返回
} else if (methodType.returnType().descriptorString().equals("I")) { // 如果返回 int
codeBuilder.iconst_0().ireturn(); // 返回 0
} else if (methodType.returnType().descriptorString().equals("Z")) { // 如果返回 boolean
codeBuilder.iconst_0().ireturn(); // 返回 false
} else { // 其他类型
codeBuilder.aconst_null().areturn(); // 返回 null
}
});
});
});
return newBytes; // 返回修改后的类文件字节码
}
这玩意儿可以很方便地给类文件添加新方法，构建器会自动处理常量池、方法表啥的。
修改方法体
修改现有方法的方法体，比如添加日志：
import java.lang.classfile.*; // 导入类文件 API 包
import java.lang.classfile.instruction.*; // 导入指令相关类
import java.lang.constant.ClassDesc; // 类描述符
import java.lang.constant.MethodTypeDesc; // 方法类型描述符
// 添加方法入口日志：在方法开始处添加日志输出
public byte[] addMethodEntryLog(ClassModel originalClass, String methodName) {
ClassFile cf = ClassFile.of(); // 获取 ClassFile 实例
// 构建新的类文件
byte[] newBytes = cf.build(originalClass.thisClass().asSymbol(), classBuilder -> { // 开始构建
// 遍历原始类的所有元素
for (ClassElement element : originalClass) { // 遍历类元素
if (element instanceof MethodModel method) { // 如果是方法
String currentMethodName = method.methodName().stringValue(); // 获取方法名
if (currentMethodName.equals(methodName)) { // 如果是要修改的方法
// 重新构建方法，添加日志
classBuilder.withMethod(method.methodName(), // 方法名
method.methodType(), // 方法签名
method.flags(), // 访问标志
methodBuilder -> { // 方法构建器
// 复制方法的其他属性（注解、异常等）
for (MethodElement me : method) { // 遍历方法元素
if (!(me instanceof CodeModel)) { // 如果不是代码
methodBuilder.with(me); // 复制属性
}
}
// 重新构建方法体，添加日志
methodBuilder.withCode(codeBuilder -> { // 开始构建代码
// 添加日志：System.out.println("Entering method: " + methodName);
codeBuilder
.getstatic(ClassDesc.of("java.lang.System"), "out",
ClassDesc.of("java.io.PrintStream")) // 获取 System.out
.ldc("Entering method: " + methodName) // 加载日志消息
.invokevirtual(ClassDesc.of("java.io.PrintStream"),
"println",
MethodTypeDesc.of(ClassDesc.of("java.lang.Object"),
ClassDesc.of("java.lang.String"))) // 调用 println
// 复制原始方法体的所有指令
.with(method.code().orElseThrow()); // 添加原始代码
});
});
} else { // 其他方法直接复制
classBuilder.with(element); // 添加元素
}
} else { // 其他元素直接复制
classBuilder.with(element); // 添加元素
}
}
});
return newBytes; // 返回修改后的类文件字节码
}
这玩意儿可以很方便地修改方法体，添加日志、性能监控、安全检查啥的都很简单。
实际应用场景
类文件 API 在实际开发中有很多应用场景：
1. 依赖分析工具
分析类文件的依赖关系，构建依赖图：
import java.lang.classfile.*; // 导入类文件 API 包
import java.lang.classfile.instruction.*; // 导入指令相关类
import java.lang.constant.ClassDesc; // 类描述符
import java.util.*; // 集合类
import java.util.stream.Collectors; // 流操作
// 依赖分析工具：分析类文件的所有依赖
public class DependencyAnalyzer {
// 分析单个类文件的依赖
public Set<ClassDesc> analyzeClass(byte[] classBytes) {
ClassFile cf = ClassFile.of(); // 获取 ClassFile 实例
ClassModel classModel = cf.parse(classBytes); // 解析类文件
Set<ClassDesc> dependencies = new HashSet<>(); // 依赖集合
// 添加父类和接口
classModel.superclass().ifPresent(dependencies::add); // 添加父类
dependencies.addAll(classModel.interfaces()); // 添加所有接口
// 分析字段类型
for (FieldModel field : classModel.fields()) { // 遍历字段
dependencies.add(field.fieldType().asClass()); // 添加字段类型（如果是类）
}
// 分析方法签名中的类型
for (MethodModel method : classModel.methods()) { // 遍历方法
// 添加返回类型
method.methodType().returnType().asClass().ifPresent(dependencies::add); // 添加返回类型
// 添加参数类型
for (var paramType : method.methodType().parameterList()) { // 遍历参数类型
paramType.asClass().ifPresent(dependencies::add); // 添加参数类型
}
// 分析方法体中的指令
method.code().ifPresent(code -> { // 如果方法有代码
for (CodeElement element : code) { // 遍历代码元素
switch (element) { // 使用模式匹配
case FieldInstruction fi -> dependencies.add(fi.owner()); // 字段访问
case InvokeInstruction ii -> dependencies.add(ii.owner()); // 方法调用
case TypeCheckInstruction ti -> dependencies.add(ti.type()); // 类型检查
case TypeConversionInstruction tci -> dependencies.add(tci.type()); // 类型转换
case NewObjectInstruction noi -> dependencies.add(noi.className()); // 新建对象
default -> {} // 其他指令
}
}
});
}
return dependencies; // 返回依赖集合
}
// 分析整个 JAR 文件的依赖
public Map<String, Set<String>> analyzeJar(Path jarPath) throws Exception {
// 这里需要解压 JAR 文件，然后分析每个类文件
// 具体实现省略，主要思路是遍历 JAR 中的类文件，调用 analyzeClass
Map<String, Set<String>> result = new HashMap<>(); // 结果映射
// TODO: 实现 JAR 文件解析和类文件分析
// 1. 使用 ZipFile 或 JarFile 打开 JAR
// 2. 遍历 JAR 中的 .class 文件
// 3. 对每个类文件调用 analyzeClass
// 4. 将结果存储到 result 中
return result; // 返回分析结果
}
}
这玩意儿可以用来构建依赖图、检测循环依赖、分析模块依赖啥的。
2. 代码生成工具
生成样板代码，比如 getter/setter、builder 模式等：
import java.lang.classfile.*; // 导入类文件 API 包
import java.lang.constant.ClassDesc; // 类描述符
import java.lang.constant.MethodTypeDesc; // 方法类型描述符
import java.lang.reflect.AccessFlag; // 访问标志
import java.util.Set; // 集合接口
// 代码生成工具：为类自动生成 getter 和 setter 方法
public class CodeGenerator {
// 为类生成 getter 和 setter 方法
public byte[] generateGettersAndSetters(ClassModel originalClass) {
ClassFile cf = ClassFile.of(); // 获取 ClassFile 实例
// 构建新的类文件
byte[] newBytes = cf.build(originalClass.thisClass().asSymbol(), classBuilder -> { // 开始构建
// 先复制原始类的所有元素
for (ClassElement element : originalClass) { // 遍历类元素
classBuilder.with(element); // 添加元素
}
// 为每个私有字段生成 getter 和 setter
for (FieldModel field : originalClass.fields()) { // 遍历字段
// 只处理私有字段
if (field.flags().contains(AccessFlag.PRIVATE)) { // 如果是私有字段
String fieldName = field.fieldName().stringValue(); // 获取字段名
String capitalizedName = capitalize(fieldName); // 首字母大写
ClassDesc fieldType = field.fieldType().asClass().orElseThrow(); // 获取字段类型
// 生成 getter 方法：public FieldType getFieldName()
classBuilder.withMethod("get" + capitalizedName, // getter 方法名
MethodTypeDesc.of(fieldType), // 返回字段类型
Set.of(AccessFlag.PUBLIC), // public 方法
methodBuilder -> { // 方法构建器
methodBuilder.withCode(codeBuilder -> { // 开始构建代码
codeBuilder
.aload(0) // 加载 this
.getfield(originalClass.thisClass().asSymbol(),
fieldName, fieldType) // 获取字段值
.return_(); // 返回字段值（根据类型选择 ireturn、lreturn 等）
});
});
// 生成 setter 方法：public void setFieldName(FieldType value)
classBuilder.withMethod("set" + capitalizedName, // setter 方法名
MethodTypeDesc.of(ClassDesc.of("void"), fieldType), // void 返回，参数是字段类型
Set.of(AccessFlag.PUBLIC), // public 方法
methodBuilder -> { // 方法构建器
methodBuilder.withCode(codeBuilder -> { // 开始构建代码
codeBuilder
.aload(0) // 加载 this
.aload(1) // 加载参数（value）
.putfield(originalClass.thisClass().asSymbol(),
fieldName, fieldType) // 设置字段值
.return_(); // 返回 void
});
});
}
}
});
return newBytes; // 返回生成的类文件字节码
}
// 首字母大写工具方法
private String capitalize(String str) {
if (str == null || str.isEmpty()) { // 如果字符串为空
return str; // 直接返回
}
return str.substring(0, 1).toUpperCase() + str.substring(1); // 首字母大写
}
}
这玩意儿可以用来生成样板代码，减少重复劳动，提高开发效率。
3. 代码增强工具
给方法添加日志、性能监控、安全检查等：
import java.lang.classfile.*; // 导入类文件 API 包
import java.lang.classfile.instruction.*; // 导入指令相关类
import java.lang.constant.ClassDesc; // 类描述符
import java.lang.constant.MethodTypeDesc; // 方法类型描述符
// 代码增强工具：给方法添加性能监控
public class CodeEnhancer {
// 给方法添加执行时间监控
public byte[] addPerformanceMonitoring(ClassModel originalClass) {
ClassFile cf = ClassFile.of(); // 获取 ClassFile 实例
// 构建新的类文件
byte[] newBytes = cf.build(originalClass.thisClass().asSymbol(), classBuilder -> { // 开始构建
// 遍历原始类的所有元素
for (ClassElement element : originalClass) { // 遍历类元素
if (element instanceof MethodModel method) { // 如果是方法
// 跳过构造函数和静态初始化块
String methodName = method.methodName().stringValue(); // 获取方法名
if (methodName.equals("<init>") || methodName.equals("<clinit>")) { // 如果是构造函数或静态初始化
classBuilder.with(element); // 直接复制，不修改
continue; // 跳过
}
// 重新构建方法，添加性能监控
classBuilder.withMethod(method.methodName(), // 方法名
method.methodType(), // 方法签名
method.flags(), // 访问标志
methodBuilder -> { // 方法构建器
// 复制方法的其他属性
for (MethodElement me : method) { // 遍历方法元素
if (!(me instanceof CodeModel)) { // 如果不是代码
methodBuilder.with(me); // 复制属性
}
}
// 重新构建方法体，添加性能监控
methodBuilder.withCode(codeBuilder -> { // 开始构建代码
// 在方法开始处：long startTime = System.nanoTime();
codeBuilder
.invokestatic(ClassDesc.of("java.lang.System"),
"nanoTime",
MethodTypeDesc.of(ClassDesc.of("long"))) // 调用 System.nanoTime()
.lstore(1) // 存储到局部变量 1（假设局部变量 0 是 this，1 是 startTime）
// 复制原始方法体的所有指令
.with(method.code().orElseThrow()) // 添加原始代码
// 在方法结束处：System.out.println("Method " + methodName + " took " + (System.nanoTime() - startTime) + " ns");
.getstatic(ClassDesc.of("java.lang.System"), "out",
ClassDesc.of("java.io.PrintStream")) // 获取 System.out
.ldc("Method " + methodName + " took ") // 加载日志消息前缀
.lload(1) // 加载 startTime
.invokestatic(ClassDesc.of("java.lang.System"),
"nanoTime",
MethodTypeDesc.of(ClassDesc.of("long"))) // 调用 System.nanoTime()
.lsub() // 计算时间差
.invokevirtual(ClassDesc.of("java.io.PrintStream"),
"println",
MethodTypeDesc.of(ClassDesc.of("java.lang.Object"),
ClassDesc.of("long"))) // 打印执行时间
// 注意：这里需要根据原始方法的返回类型来调整返回语句
// 如果原始方法返回 void，直接 return_
// 如果原始方法有返回值，需要在打印日志之前保存返回值
});
});
} else { // 其他元素直接复制
classBuilder.with(element); // 添加元素
}
}
});
return newBytes; // 返回修改后的类文件字节码
}
}
这玩意儿可以用来添加各种横切关注点，比如日志、性能监控、事务管理、安全检查啥的。
启用预览特性
类文件 API 是 Java 22 的预览特性，使用前需要启用预览功能：
# 编译时启用预览特性
javac --release 22 --enable-preview ClassFileExample.java
# 运行时启用预览特性
java --enable-preview ClassFileExample
# 或者使用源码启动器
java --source 22 --enable-preview ClassFileExample.java
总结
类文件 API 是 Java 22 引入的一个强大的新特性，它提供了一个标准化、类型安全、易用的 API 来操作类文件。相比传统的 ASM 或 Javassist，类文件 API 有以下优势：
- API 设计更统一：用不可变对象表示类文件结构，用构建器来生成类文件，API 设计得很直观
- 类型更安全：用
ClassDesc、MethodTypeDesc等类型描述符，而不是字符串，减少错误 - 支持模式匹配：可以用 switch 表达式和模式匹配来处理字节码指令，代码更简洁
- 惰性解析：只在需要时才解析类文件的某些部分，提高性能
- 易于使用：不需要理解底层字节码格式，构建器会自动处理栈帧、标签偏移等细节
这玩意儿特别适合开发字节码分析工具、代码生成工具、代码增强工具、依赖分析工具等。虽然现在是预览特性，但已经可以开始使用了，未来可能会成为标准 API。
兄弟们，如果你们需要开发字节码相关的工具，不妨试试类文件 API，比 ASM 和 Javassist 好用多了。当然，如果你们还在用 Java 8 或者更老的版本，那还是得用 ASM 或者 Javassist，毕竟类文件 API 是 Java 22 才有的。
好了，今天就聊到这里，有啥问题欢迎留言讨论。