经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » Java相关 » Java » 查看文章
为了简写这行代码，我竟使用静态和动态编译技术
来源：cnblogs　　作者：jtea　　时间：2023/11/1 9:02:33　　对本文有异议

背景

在我们系统中有这么一个需求，业务方会通过mq将一些用户信息传给我们，我们的服务处理完后，再将信息转发给子系统。mq的内容如下：

  1. @Data
  2. public class Person {
  3.     
  4.     //第一部分
  5.     private Integer countryId;    
  6.     private Integer companyId;
  7.     private String uid;
  9.     //第二部分
  10.     private User userBaseInfo;
  11.     private List<UserContact> contactList;
  12.     private List<UserAddress> addressList;
  13.     private UserEducation educationInfo;
  14.     private UserProfession professionInfo;
  15.     private List<Order> orderList;
  16.     private List<Bill> billList;
  17.     private List<UserMerchant> merchantList;
  18.     private List<UserOperate> operateList;
  19.     private BeneficialOwner beneficialOwnerInfo;
  20. }

主要分为两部分，第一部分是用户id，这部分用于唯一标识一个用户，不会改变。第二部分是一些基础信息，账单、订单、联系方式、地址等等，这部分信息内容经常增加。
后面业务新增了一个逻辑，会对第二部某些信息进行剔除，最后这部分信息如果还有，才转发到子系统。所以开发同学新增这么一个很长的条件判断：

  1. public static boolean isNull(BizData bizData) {
  2.     return CollectionUtils.isEmpty(bizData.getBillList()) && CollectionUtils.isEmpty(bizData.getOrderList()) && CollectionUtils.isEmpty(bizData.getAddressList()) && CollectionUtils.isEmpty(bizData.getContactList()) && bizData.getEducationInfo() == null && bizData.getProfessionInfo() == null && bizData.getUserBaseInfo() == null && CollectionUtils.isEmpty(bizData.getMerchantList()) && CollectionUtils.isEmpty(bizData.getOperateList()) && bizData.getBeneficialOwnerInfo() == null;
  3. }

在review代码的时候，发现这里是一个“坑”，是一个会变化的点，以后新增信息，很可能会漏了来改这里，在我的开发过程中，最担心的就是遇到这些会变化点又写死逻辑的，过段时间我就会忘记，如果换个人接手，那更难以发现，容易出现bug。因为这个条件判断并不会自动随着我们新增字段而自动修改，完全靠人记忆，容易遗漏。

思考

那有没有办法做到新增信息不需要修改这里吗，也就是isNull方法可以自动动态判断属性是否为空呢？
首先我们都会想到反射，通过反射可以读取class所有字段，每次处理都反射判断一下字段值是否为空即可做到动态判断。但反射的性能太低了，对于我们来说这是个调用量非常大的方法，尽量做到不损失性能，所以反射不在本次考虑范围内。

既然有不变和变化的两部分，那么我们可以先将其分离，将不变的抽取到一个基类去。为了简化代码，第二部分我们只保留两个属性。

  1. @Data
  2. public class PersonBase {
  3.     
  4.     //第一部分
  5.     private Integer countryId;    
  6.     private Integer companyId;
  7.     private String uid;
  8. }
  10. @Data
  11. public class Person extend PersonBase {
  12.     
  13.     //第二部分...
  14.     private User userBaseInfo;
  15.     private List<UserContact> contactList;
  16. }

要动态生成isNull方法，可以先从结果反推是怎么样的。可以有如下两种方式：
1、在原Person类新增一个isNull方法，这种方式的特点是我们可以直接通过对象直接调用方法，如：

  1. @Data
  2. public class Person extend PersonBase {
  3.         
  4.     private User userBaseInfo;
  5.     private List<UserContact> contactList;
  7.     public boolean isNull() {
  8.         return this.userBaseInfo != null && this.contactList != null;
  9.     }
  10. }

2、动态新增一个类，动态新增一个isNull方法，参数是BizData。这种方式无法通过Preson对象调用方法，甚至无法直接通过生成类调用方法，因为动态类的名称我们都无法预知。如：

  1. public class Person$Generated {
  2.     
  3.     public boolean isNull(BizData bizData) {
  4.         return bizData.getUserBaseInfo() != null && bizData.getContactList() != null;
  5.     }
  6. }

这就是我们本篇要解决的问题，通过静态/动态编译技术生成代码。这里静态是指“编译期”，也就是类和方法在编译期间就存在了，动态是指“运行时”，意思编译期间类还不存在，等程序运行时才被加载，链接，初始化。
这两种方式大家实际都经常接触到，lombok可以帮我们生成getter/setter，本质就是在编译期为类新增方法，spring无处不在的动态代理就是运行时生成的类。

动态编译

我们先来看动态编译，因为动态编译我们都比较熟，也比较简单，在spring中随处可见，例如我们熟悉的动态代理类就是动态生成的。
我们编写的java代码会先经过编译称为字节码，字节码再由jvm加载运行，所以动态生成类就是要编写相应的字节码。
但由于java字节码太复杂了，需要熟悉各种字节码指令，一般我们不会直接编写字节码代码，会借助字节码框架或工具来生成。例如查看简单的hello world类的字节码，idea -> view -> show bytecode。

  1. public class HelloWorld {
  3. 	public static void main(String[] args) {
  4. 		System.out.println("hello world");
  5. 	}
  6. }

ASM 介绍

ASM是一个通用的 Java 字节码操作和分析框架。它可用于直接以二进制形式修改现有类或动态生成类。ASM 提供了一些常见的字节码转换和分析算法，可以从中构建自定义的复杂转换和代码分析工具。ASM 提供与其他 Java 字节码框架类似的功能，但重点关注性能。因为它的设计和实现尽可能小且尽可能快，所以它非常适合在动态系统中使用（但当然也可以以静态方式使用，例如在编译器中）。

接下来我们用asm来生成hello world，如下：

  1. public class HelloWorldGenerator {
  2.     public static void main(String[] args) throws Exception {
  3.         // 创建一个ClassWriter，用于生成字节码
  4.         ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS | ClassWriter.COMPUTE_FRAMES);
  5.         
  6.         // 定义类的头部信息
  7.         cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, "HelloWorld", null, "java/lang/Object", null);
  9.         // 生成默认构造函数
  10.         MethodVisitor constructor = cw.visitMethod(Opcodes.ACC_PUBLIC, "<init>", "()V", null, null);
  11.         constructor.visitCode();
  12.         constructor.visitVarInsn(Opcodes.ALOAD, 0);
  13.         constructor.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
  14.         constructor.visitInsn(Opcodes.RETURN);
  15.         constructor.visitMaxs(1, 1);
  16.         constructor.visitEnd();
  18.         // 生成main方法
  19.         MethodVisitor mainMethod = cw.visitMethod(Opcodes.ACC_PUBLIC + Opcodes.ACC_STATIC, "main", "([Ljava/lang/String;)V", null, null);
  20.         mainMethod.visitCode();
  22.         // 打印"Hello, World!"到控制台
  23.         mainMethod.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
  24.         mainMethod.visitLdcInsn("Hello, World!");
  25.         mainMethod.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
  27.         mainMethod.visitInsn(Opcodes.RETURN);
  28.         mainMethod.visitMaxs(2, 2);
  29.         mainMethod.visitEnd();
  31.         // 完成类的生成
  32.         cw.visitEnd();
  34.         // 将生成的字节码写入一个类文件
  35.         byte[] code = cw.toByteArray();
  36.         MyClassLoader classLoader = new MyClassLoader();
  37.         Class<?> helloWorldClass = classLoader.defineClass("HelloWorld", code);
  38.         
  39.         // 创建一个实例并运行main方法
  40.         helloWorldClass.getDeclaredMethod("main", String[].class).invoke(null, (Object) new String[0]);
  41.     }
  43.     // 自定义ClassLoader用于加载生成的类
  44.     private static class MyClassLoader extends ClassLoader {
  45.         public Class<?> defineClass(String name, byte[] b) {
  46.             return defineClass(name, b, 0, b.length);
  47.         }
  48.     }
  49. }

上面的代码我是用chatgpt生成的，只需要输入：“帮我用java asm字节码框架生成一个hello world，并注释每行代码写明它的作用。”
相比直接编写字节码指令，asm将其封装成各种类和方法，方便我们理解和编写，实际上asm还是比较底层的框架，所以许多框架会再它的基础上继续封装，如cglib,byte buddy等。
可以看到生成的结果和我们自己编写的是一样的。

实现

接下来我们就用asm来动态生成上面的isNull方法，由于目标类是动态生成的，类名我们都不知道，但我们最终是要调用它的isNull方法，这怎么办呢？
我们可以定义一个接口，然后动态生成的类实现它，最终通过接口来调用它，这就是接口的好处之一，我们可以不关注具体类是谁，内部怎么实现。

如定义接口如下：

  1. public interface NullChecker<T> {
  3. 	/**
  4. 	 * 参数固定为origin
  5. 	 *
  6. 	 * @param origin 名称必须为origin
  7. 	 */
  8. 	Boolean isNull(T origin);
  9. }

这是个泛型接口，也就是所有类型都可以这么用。isNull方法参数名称必须为origin，因为在生成字节码时写死了这个名称。
接下来编写核心的生成方法，如下：

  1. public class ClassByteGenerator implements Opcodes {
  3. 	public static byte[] generate(Class originClass) {
  5. 		ClassWriter classWriter = new ClassWriter(0);
  6. 		MethodVisitor methodVisitor;
  8. 		//将.路径替换为/
  9. 		String originClassPath = originClass.getPackage().getName().replace(".", "/") + "/" + originClass.getSimpleName();
  10. 		//动态生成类的名称：原类$ASMGenerated
  11. 		String generateClassName = originClass.getSimpleName() + "$ASMGenerated";
  12. 		String generateClassPatch = ClassByteGenerator.class.getPackage().getName().replace(".", "/") + "/" + generateClassName;
  13. 		String nullCheckerClassPath = NullChecker.class.getPackage().getName().replace(".", "/") + "/" + NullChecker.class.getSimpleName();
  14. 		classWriter.visit(V1_8, ACC_PUBLIC | ACC_SUPER, generateClassPatch, null, "java/lang/Object", new String[]{nullCheckerClassPath});
  16. 		classWriter.visitSource(generateClassName + ".java", null);
  18. 		{
  19. 			methodVisitor = classWriter.visitMethod(ACC_PUBLIC, "<init>", "()V", null, null);
  20. 			methodVisitor.visitCode();
  21. 			Label label0 = new Label();
  22. 			methodVisitor.visitLabel(label0);
  23. 			methodVisitor.visitLineNumber(7, label0);
  24. 			methodVisitor.visitVarInsn(ALOAD, 0);
  25. 			methodVisitor.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
  26. 			methodVisitor.visitInsn(RETURN);
  27. 			Label label1 = new Label();
  28. 			methodVisitor.visitLabel(label1);
  29. 			methodVisitor.visitLocalVariable("this", "L" + generateClassPatch + ";", null, label0, label1, 0);
  30. 			methodVisitor.visitMaxs(1, 1);
  31. 			methodVisitor.visitEnd();
  32. 		}
  33. 		{
  34. 			methodVisitor = classWriter.visitMethod(ACC_PUBLIC, "isNull", "(L" + originClassPath + ";)Ljava/lang/Boolean;", null, null);
  35. 			methodVisitor.visitParameter("origin", 0);
  36. 			methodVisitor.visitCode();
  38. 			Label label0 = new Label();
  39. 			methodVisitor.visitLabel(label0);
  40. 			methodVisitor.visitVarInsn(ALOAD, 1);
  41. 			Label label1 = new Label();
  43. 			int index = 0;
  44. 			//过滤掉基类的
  45. 			PropertyDescriptor[] propertyDescriptors = Arrays.stream(BeanUtils.getPropertyDescriptors(originClass))
  46. 					.filter(p -> p.getReadMethod().getDeclaringClass() == originClass)
  47. 					.toArray(PropertyDescriptor[]::new);
  48. 			for (PropertyDescriptor pd : propertyDescriptors) {
  49. 				String descriptor = "()" + Type.getDescriptor(pd.getPropertyType());
  50. 				if (index == 0) {
  51. 					methodVisitor.visitMethodInsn(INVOKEVIRTUAL, originClassPath, pd.getReadMethod().getName(), descriptor, false);
  52. 				} else if (index > 0 && index < propertyDescriptors.length - 1) {
  53. 					methodVisitor.visitJumpInsn(IFNULL, label1);
  54. 					methodVisitor.visitVarInsn(ALOAD, 1);
  55. 					methodVisitor.visitMethodInsn(INVOKEVIRTUAL, originClassPath, pd.getReadMethod().getName(), descriptor, false);
  56. 				} else {
  57. 					methodVisitor.visitJumpInsn(IFNULL, label1);
  58. 					methodVisitor.visitVarInsn(ALOAD, 1);
  59. 					methodVisitor.visitMethodInsn(INVOKEVIRTUAL, originClassPath, pd.getReadMethod().getName(), descriptor, false);
  60. 					methodVisitor.visitJumpInsn(IFNULL, label1);
  61. 					methodVisitor.visitInsn(ICONST_1);
  62. 				}
  63. 				index++;
  64. 			}
  66. 			Label label2 = new Label();
  67. 			methodVisitor.visitJumpInsn(GOTO, label2);
  68. 			methodVisitor.visitLabel(label1);
  69. 			methodVisitor.visitFrame(Opcodes.F_SAME, 0, null, 0, null);
  70. 			methodVisitor.visitInsn(ICONST_0);
  71. 			methodVisitor.visitLabel(label2);
  72. 			methodVisitor.visitFrame(Opcodes.F_SAME1, 0, null, 1, new Object[]{Opcodes.INTEGER});
  73. 			methodVisitor.visitMethodInsn(INVOKESTATIC, "java/lang/Boolean", "valueOf", "(Z)Ljava/lang/Boolean;", false);
  74. 			methodVisitor.visitInsn(ARETURN);
  75. 			Label label3 = new Label();
  76. 			methodVisitor.visitLabel(label3);
  77. 			methodVisitor.visitLocalVariable("this", "L" + generateClassPatch + ";", null, label0, label3, 0);
  78. 			methodVisitor.visitLocalVariable("origin", "L" + originClassPath + ";", null, label0, label3, 1);
  79. 			methodVisitor.visitMaxs(1, 2);
  80. 			methodVisitor.visitEnd();
  81. 		}
  83. 		{
  84. 			methodVisitor = classWriter.visitMethod(ACC_PUBLIC | ACC_BRIDGE | ACC_SYNTHETIC, "isNull", "(Ljava/lang/Object;)Ljava/lang/Boolean;", null, null);
  85. 			methodVisitor.visitParameter("origin", ACC_SYNTHETIC);
  86. 			methodVisitor.visitCode();
  87. 			Label label0 = new Label();
  88. 			methodVisitor.visitLabel(label0);
  89. 			methodVisitor.visitLineNumber(7, label0);
  90. 			methodVisitor.visitVarInsn(ALOAD, 0);
  91. 			methodVisitor.visitVarInsn(ALOAD, 1);
  92. 			methodVisitor.visitTypeInsn(CHECKCAST, originClassPath);
  93. 			methodVisitor.visitMethodInsn(INVOKEVIRTUAL, generateClassPatch, "isNull", "(L" + originClassPath + ";)Ljava/lang/Boolean;", false);
  94. 			methodVisitor.visitInsn(ARETURN);
  95. 			Label label1 = new Label();
  96. 			methodVisitor.visitLabel(label1);
  97. 			methodVisitor.visitLocalVariable("this", "L" + generateClassPatch + ";", null, label0, label1, 0);
  98. 			methodVisitor.visitMaxs(2, 2);
  99. 			methodVisitor.visitEnd();
  100. 		}
  101. 		classWriter.visitEnd();
  103. 		return classWriter.toByteArray();
  104. 	}
  105. }

代码有点长，可能你会想还是用chatgpt生成，但这种逻辑性比较强的它就无能为力了。不过我们还有工具可以生成它，我使用的是ASM Bytecode Viewer，idea中安装插件即可。
首先将要实现的结果用代码写出来，然后右键使用ASM Bytecode Viewer，就可以看到对应的asm代码。当然实际我们是要遍历类的所有字段，就是for循环遍历属性的那一部分，这需要自己写，也不难，在插件生成代码后稍微调整下即可。

  1. public class MyPersonGenerated implements NullChecker<Person> {
  3. 	@Override
  4. 	public Boolean isNull(Person person) {
  5. 		return person.getUserBaseInfo() != null && person.getContactList() != null;
  6. 	}
  7. }

八股文背多了就知道类生命周期是：加载 -> 链接(验证，准备，解析) -> 初始化 -> 使用 -> 卸载。所以首先要使用ClassLoader将动态类加载到jvm，我们可以定义一个类继承抽象类ClassLoader，调用它的defineClass。

  1. public class MyClassLoader extends ClassLoader {
  3. 	public Class<?> defineClass(byte[] b) {
  4. 		return super.defineClass(null, b, 0, b.length);
  5. 	}
  6. }

使用如下，当然实际情况中我们会将生成的NullChecker赋值给一个全局变量缓存，不用每次都newInstance创建。

  1. MyClassLoader myClassLoader = new MyClassLoader();
  2. byte[] bytes = ClassByteGenerator.generate(Person.class);
  3. Class<?> personNullCheckerCls = myClassLoader.defineClass(bytes);
  4. NullChecker personNullChecker = (NullChecker) personNullCheckerCls.newInstance();
  5. boolean result = o.isNull(person);

也可以将生成类的字节保存到文件，然后拖到idea观察结果，如下：

  1. try (FileOutputStream fos = new FileOutputStream("./Person$ASMGenerated.class")) {
  2. 	fos.write(bytes); // 将字节数组写入.class文件
  3. } catch (IOException e) {
  4. 	throw e;
  5. }

静态编译

看完动态编译我们再看静态编译。java代码编译和执行的整个过程包含三个主要机制：1.java源码编译机制 2.类加载机制 3.类执行机制。其中java源码编译由3个过程组成：1.分析和输入到符号表 2.注解处理 3.语义分析和生成class文件。如下：

在介绍mapstruct这篇时我们也有提到，其中主要就是在源码编译的注解处理阶段，可以插入我们的自定义代码。

例如我们新建工程，定义如下注解，它标识的类就会对应生成一个含isNull方法的类。其中RetentionPolicy.SOURCE表示在源码阶段生效，在运行时是读不到这个注解的，lombok的注解也是这个道理。

  1. @Retention(RetentionPolicy.SOURCE)
  2. @Target(ElementType.TYPE)
  3. public @interface GenerateIsNullMethod {
  4. 	String value() default "";
  5. }

接着编写注解处理器，在发现GenerateIsNullMethod注解时，进入处理逻辑。

  1. @SupportedAnnotationTypes("com.example.mapstruct.processor.GenerateIsNullMethod")
  2. @SupportedSourceVersion(SourceVersion.RELEASE_8)
  3. @AutoService(Processor.class)
  4. public class IsNullAnnotationProcessor extends AbstractProcessor {
  6. 	private ProcessingEnvironment processingEnv;
  8. 	@Override
  9. 	public synchronized void init(ProcessingEnvironment processingEnv) {
  10. 		super.init(processingEnv);
  11. 		this.processingEnv = processingEnv;
  12. 	}
  14. 	@Override
  15. 	public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
  16. 		processingEnv.getMessager().printMessage(Diagnostic.Kind.WARNING, "GenerateIsNullMethod start===");
  17. 		Set<? extends Element> set = roundEnv.getElementsAnnotatedWith(GenerateIsNullMethod.class);
  18. 		for (Element classElement : set) {
  19. 			generateIsNullMethod(classElement);
  20. 		}
  21. 		return true;
  22. 	}
  24. 	private void generateIsNullMethod(Element classElement) {
  25. 		//javapoet只能创建新的文件，不能修改https://github.com/square/javapoet/issues/505
  26. 		String packageName = processingEnv.getElementUtils().getPackageOf(classElement).toString();
  27. 		String className = classElement.getSimpleName().toString();
  28. 		String newClassName = className + "Ext";
  30. 		MethodSpec.Builder p = MethodSpec.methodBuilder("isNull")
  31. 				.addModifiers(Modifier.PUBLIC)
  32. 				.addModifiers(Modifier.STATIC)
  33. 				.addParameter(ClassName.bestGuess(packageName + "." + className), "p")
  34. 				.returns(Boolean.class);
  35. 		String statement = "return ";
  36. 		for (Element ee : classElement.getEnclosedElements()) {
  37. 			if (ee.getKind().isField()) {
  38. 				String eeName = ee.getSimpleName().toString();
  39. 				statement += "p.get" + eeName.substring(0, 1).toUpperCase() + eeName.substring(1, ee.getSimpleName().length()) + "()" + " != null && ";
  40. 			}
  41. 		}
  42. 		statement = statement.substring(0, statement.length() - 4);
  43. 		processingEnv.getMessager().printMessage(Diagnostic.Kind.WARNING, statement + "===");
  44. 		MethodSpec isNullMethod = p.addStatement(statement).build();
  46. 		TypeSpec updatedClass = TypeSpec.classBuilder(newClassName)
  47. 				.addModifiers(Modifier.PUBLIC)
  48. 				.addMethod(isNullMethod)
  49. 				.build();
  51. 		JavaFile javaFile = JavaFile.builder(packageName, updatedClass)
  52. 				.build();
  53. 		try {
  54. 			javaFile.writeTo(processingEnv.getFiler());
  55. 		} catch (IOException e) {
  56. 			processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, "Failed to generate isNull method: " + e.getMessage());
  57. 		}
  58. 	}
  59. }

@AutoService是google一个工具包，帮我们在META-INF/services路径下生成配置，注解处理器才会生效。
这里生成代码使用到了javapoet工具，用于生成.java源文件。
其它的就都是在生成代码了，需要注意的是，既然是在编译期，那就不要想用运行时的东西，例如反射，都还没到那个阶段。
导入这个工程使用GenerateIsNullMethod标记Person类，编译后就可以观察到生成一个PersonExt的类，它的isNull方法会判断Person参数每个属性是否为空。
这里我并没有像lombok一样在原类上新增方法，而是新增一个Ext类，因为那样做要解析语法树，比较复杂，我没有实现，有兴趣的可以参考lombok自己实现一下。

总结

本篇介绍了如何使用静态/动态编译生成代码，这种方式在许多框架、工具都非常常见，只是我们平时比较少接触到。
通过学习我们可以更好了解平时使用的技术的原理，知其然知其所以然，以后遇到类似的场景也能想到用这类解决方案来实现。

更多分享，欢迎关注我的github：https://github.com/jmilktea/jtea

原文链接：https://www.cnblogs.com/jtea/p/17799649.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

Java热门文章

  • 【IDEA】Application context not configured for this file
  • [IDEA] chapter_reader - idea看小说插件 idea阅读插件 idea摸鱼插件
  • thrift常见异常及原因分析
  • Java 调用 PaddleDetection 模型
  • JVM 详解，大白话带你认识 JVM
  • spring-boot-2.0.3不一样系列之番外篇 - @Configuration、Condition与@Conditional
  • Java Comparator.comparing比较导致空指针异常的解决
  • Java使用EasyExcel进行单元格合并的问题详解
  • 死磕 java集合之ArrayBlockingQueue源码分析
  • Java基础之集合Set详解

    • Java推荐文章

  • 面试场景题：一次关于线程池使用场景的讨论。
  • 前端黑科技：使用 JavaScript 实现网页扫码功能
  • 聊一聊 Netty 数据搬运工 ByteBuf 体系的设计与实现
  • 简单设计一个JAVA并行处理工具类
  • 【杂谈】JPA乐观锁改悲观锁遇到的一些问题与思考
  • 认识netty的基本组件
  • Jenkins如何使用CrumbIssuer防御CSRF攻击
  • 如何平稳地从nacos迁移到r-nacos？
  • 线程池遇到父子任务，有大坑，要注意！
  • Java JVM——12. 垃圾回收理论概述

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号