AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

使用ASM来书写Java代码

2024-06-21 55
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 使用ASM来书写Java代码

ASM是一套JAVA字节码生成架构。它可以动态生成二进制格式的stub类或其他代理类，或者在类被JAVA虚拟机装入内存之前，动态修改类。 ASM 提供了与 BCEL（ http://jakarta.apache.org/bcel ）和SERP(http://serp.sourceforge.net/ )相似的功能，只有22K的大小，比起350K的BCEL和150K的SERP来说，是相当小巧的，并且它有更高的执行效率，是BCEL的7倍，SERP 的11倍以上。ASM一贯的设计思想就是将其应用于动态生成领域，因此小巧和快捷一直是这个产品的设计和实现的指导思想。

此产品由法国电信公司的研发工程师Eric Bruneton负责。从2002年7月ASM的第一个版本发布至今，此产品已经升级了五次，日臻完美。到目前为止，ASM最新的版本是1.3.5，你可以去 http://asm.objectweb.org/ 下载。

ASM的最终目标是创建一个生成工具，可以被用来执行对任何类的处理操作（不像一些工具，比如Javassit,它只支持预先定义的类操作，然而在许多场合这一功能是有局限性的）。

JAVA的CLASS文件格式

要想驾驭ASM，先要了解一下JAVA的CLASS文件格式。JAVA的CLASS文件通常是树型结构。根节点包含以下元素：

  • ConstantPool：符号表；
  • FieldInfo：类中的成员变量信息；
  • MethodInfo：类中的方法描述；
  • Attribute：可选的附加节点。

FieldInfo节点包含成员变量的名称，诸如public,private,static等的标志。ConstantValue属性用来存储静态的不变的成员变量的值。Deprecated和Synthetic被用来标记一个成员变量是不被推荐的或由编译器生成的。

MethodInfo节点包含方法的名称，参数的类型和和它的返回值，方法是公有的，私有的或静态的等标志。MethodInfo包含可选的附加属性，其中最重要的是Code属性，它包含非抽象的方法的代码。Exceptions属性包含方法将抛出的Exception的名称。Deprecated 和Synthetic属性的信息同上面的FieldInfo的定义一样。

根节点的可选属性有SourceFile，InnerClasses和Deprecated。SourceFile用来存储被编译成字节码的源代码文件的原始名称;InnerClasses存储内部类的信息。由于这些属性的存在，java 的类格式是可以扩展的，也就是说可以在一个class中附加一些非标准的属性, java虚拟机会忽略这些不可识别的属性，正常的加载这个class。

ConstantPool是一个由数字或字符串常量的索引组成的队列，或由此类的树的其他节点引用的，由其他对象创建的被引用常量的索引组成的队列。这个表的目标是为了减少冗余。例如，FieldInfo节点不包含节点的名称，只包含它在这一表中的索引。同样的，GETFIELD和 PUTFIELD不直接包含成员变量的名称，只包含名称的索引。

精通ASM

Asm架构整体都围绕着两个接口，即ClassVisitor和 CodeVisitor，它们能访问每个类的方法，成员变量，包含在每个方法中的字节码指令。ClassReader用来读取class文件；ClassWriter类用来写生成的Class文件。

为了修改已经存在的class,你必须使用分析class文件的ClassReader，类的修正器和写class文件的ClassWriter。类的修正器就是一个ClassVisitor,它可以委派一部分工作到其他的ClassVisitor,但是为了实现预期的修改步骤，它将改变一些参数的值，或者调用一些其他方法。为了比较容易的实现这种类的修正器，ASM提供了一个ClassAdapter和CodeAdapter，这两个适配器类分别实现了ClassVistor和CodeVistor接口。

HelloWorld，体验造类的神奇

下面是一个应用ASM动态生成字节码的类，并调用其中方法的完整的HelloWorld 程序，程序的功能是动态生成一个Example.class类，并实例化一个Example对象,调用对象的main函数，在屏幕上打印出"Hello world!"

 

import java.io.FileOutputStream;
import java.lang.reflect.Method;
 
import org.objectweb.asm.ClassWriter;
 
public class Helloworld extends ClassLoader {
 
  public static void main (final String args[]) throws Exception {
      /* * 此程序将生成一个class,对应的java源代码是:
       * * public class Example {
       *      public static void main (String[] args) {
       *        System.out.println("Hello world!");
       *      }
       *   }
       * */
       // 创建一个ClassWriter
       ClassWriter cw = new ClassWriter(false);
       cw.visit(.ACC_PUBLIC, "Example", "java/lang/Object", null, null);
       // 创建一个 MethodWriter
       CodeVisitor mw = cw.visitMethod(ACC_PUBLIC, "", "()V", null);
       // 推入 磘his 变量
       mw.visitVarInsn(ALOAD, 0);
       // 创建父类的构造函数
       mw.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "", "()V");
       mw.visitInsn( ETURN);
       // 这段代码使用最多一个栈元素和一个本地变量
       mw.visitMaxs(1, 1);
       // 为main方法创建一个 
       MethodWriter mw = cw.visitMethod( ACC_PUBLIC ACC_STATIC, "main","([Ljava/lang/String;)V", null);
       // 使用System类的out成员类
       mw.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
       // pushes the "Hello World!"
       String constant = mw.visitLdcInsn("Hello world!");
       // 调用System.out的磒rintln 函数
       mw.visitMethodInsn(INVOKEVIRTUAL,
                           "java/io/PrintStream",
                            "println",
                             "(Ljava/lang/String;)V");
       mw.visitInsn(RETURN);
       // 这段代码使用最多两个栈元素和两个本地变量
       mw.visitMaxs(2, 2);
       // 生成字节码形式的类
       byte[] code = cw.toByteArray();
       FileOutputStream fos = new FileOutputStream("Example.class");
       //写文件
       fos.write(code);
       //关闭输出流 fos.close();
       //实例化刚刚生成的类
       Helloworld loader = new Helloworld();
       Class exampleClass = loader.defineClass("Example", code, 0, code.length);
      // 使用动态生成的类打印 碒elloworld
      Method main = exampleClass.getMethods()[0];
      main.invoke(null, new Object[] {null});
  }
}

1.   流程控制

说明：JVM提供了基本的流程控制结构，这些结构都是基于Label而实现的。这些跳转指令，包括基于比较结果的有条件跳转和无条件的GOTO指令。另外，JVM也提供了实现switch结构的LOOKUPSWITCH和TABLESWITCH指令，其中LOOKUPSWITCH是基于键比较的，而TABLESWITCH则是基于键索引的，因此后者的匹配速度更快。

2.   接口声明

ClassWriter cw = new ClassWriter(false);
cw.visit(V1_5, ACC_PUBLIC + ACC_ABSTRACT + ACC_INTERFACE, "asm/IA", null, "java/lang/Object", null);
cw.visitSource("IA.java", null);
cw.visitEnd();

等价于：

public interface IA{}

3.   类声明

3.1  抽象类

ClassWriter cw =new ClassWriter(false);
cw.visit(V1_5, ACC_PUBLIC + ACC_SUPER + ACC_ABSTRACT, "asm/A", null, "java/lang/Object", null);
cw.visitSource("A.java", null);

 

等价于：

public abstract class A{}

3.2  具体类

ClassWriter cw = new ClassWriter(false);
cw.visit(V1_5, ACC_PUBLIC + ACC_SUPER, "asm/A", null,"java/lang/Object", null);
cw.visitSource("A.java", null);
cw.visitEnd();

等价于：

public class A{}

4.   类

4.1  数组

4.1.1创建
mv.visitInsn(ICONST_3);
mv.visitIntInsn(NEWARRAY, T_INT);
mv.visitVarInsn(ASTORE, 1);      //   将数组引用存到局部变量栈1号的位置

等价于：

int[] a = new int[3];

4.1.2取值

mv.visitVarInsn(ALOAD,1);       //   数组引用在局部变量栈1号的位置
mv.visitInsn(ICONST_1);
mv.visitInsn(IALOAD);
mv.visitVarInsn(ISTORE, 2);

等价于：

int b = a[1];

4.1.3赋值

mv.visitVarInsn(ALOAD,1);
mv.visitInsn(ICONST_1);
mv.visitInsn(ICONST_2);
mv.visitInsn(IASTORE);

等价于：

a[1] = 2;

4.2  构造函数

4.2.1<init>
4.2.1.1   创建
MethodVisitor mv= cw.visitMethod(ACC_PUBLIC, "<init>", "()V", null,null);
mv.visitCode();
mv.visitVarInsn(ALOAD, 0);
mv.visitMethodInsn(INVOKESPECIAL, "java/lang/Object","<init>", ()V");
mv.visitInsn(RETURN);
mv.visitMaxs(1, 1);
mv.visitEnd();

说明：构造函数<init>在执行时，需要首先执行父类的构造函数或者类内部其他构造

函数。

4.2.1.2   调用
mv.visitTypeInsn(NEW,"asm/A");
mv.visitInsn(DUP);
mv.visitMethodInsn(INVOKESPECIAL, "asm/A", "<init>","()V");
mv.visitVarInsn(ASTORE, 1);

等价于：

A a = new A();

说明：在初始化一般对象时，我们需要先调用NEW指令，来创建该对象实例。而由于

后续的INVOKESPECIAL指令是调用类的构造函数，而该指令执行完以后，对对象的引

用将从栈中弹出，所以在NEW指令执行完以后，INVOKESPECIAL指令执行以前，我们

需要调用DUP指令，来增加对象引用的副本。

4.2.2<clinit>
4.2.2.1   创建
MethodVisitor mv= cw.visitMethod(ACC_STATIC, "<clinit>", "()V", null,null);
mv.visitCode();
mv.visitFieldInsn(GETSTATIC, "java/lang/System", "out",
"Ljava/io/PrintStream;");
mv.visitLdcInsn("hello world");
mv.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream","println",
"(Ljava/lang/String;)V");
mv.visitInsn(RETURN);
mv.visitMaxs(2, 0);
mv.visitEnd();

等价于：

static {
    System.out.println("helloworld");
}
4.2.2.2   调用

<clinit>在类被加载时自动调用。

4.3  字段

4.3.1一般字段
4.3.1.1   创建
FieldVisitor fv= cw.visitField(ACC_PRIVATE, "a", "I", null, null);
fv.visitEnd();

等价于：

private int a;
4.3.1.2   读取

读取类当中名字为a，类型为int的字段的值。

mv.visitVarInsn(ALOAD, 0);
mv.visitFieldInsn(GETFIELD, "asm/A", "a", "I");
4.3.1.3   设置
mv.visitVarInsn(ALOAD,0);
mv.visitInsn(ICONST_2);
mv.visitFieldInsn(PUTFIELD, "asm/A", "a", "I");

等价于：

a = 2;

4.3.2静态字段

4.3.2.1   创建
FieldVisitor fv= cw.visitField(ACC_PRIVATE + ACC_STATIC, "a", "I", null,
null);
fv.visitEnd();

等价于：

private static int a;
4.3.2.2   读取
mv.visitFieldInsn(GETSTATIC,"asm/A", "a", "I");
4.3.2.3   设置
mv.visitInsn(ICONST_2);
mv.visitFieldInsn(PUTSTATIC, "asm/A", "a", "I");

等价于：

a = 2;

4.4  方法

4.4.1接口方法
4.4.1.1   定义
mv =cw.visitMethod(ACC_PUBLIC + ACC_ABSTRACT, "getA", "()V",null, null);
mv.visitEnd();
4.4.1.2   调用
mv.visitVarInsn(ALOAD,1);
mv.visitMethodInsn(INVOKEINTERFACE, "asm/IA", "getA","()V");

等价于：

public interface IA{
     public void geA();
}
public class A implements IA{
     public void geA(){…}
}
 
IA a = new A();
a.getA();
4.4.2一般方法
4.4.2.1   定义
MethodVisitor mv= cw.visitMethod(ACC_PUBLIC, "getA", "()V", null, null);
mv.visitCode();
mv.visitInsn(RETURN);
mv.visitMaxs(0, 1);
mv.visitEnd();

等价于：

public void getA() {}
4.4.2.2   调用
mv.visitVarInsn(ALOAD,1);
mv.visitMethodInsn(INVOKEVIRTUAL, "asm/A", "getA","()V");

等价于：

A a = new A():
a.getA();
4.4.3静态方法
4.4.3.1   定义
MethodVisitor mv= cw.visitMethod(ACC_PUBLIC + ACC_STATIC, "getA", "()V",
null, null);
mv.visitCode();
mv.visitInsn(RETURN);
mv.visitMaxs(0, 0);
mv.visitEnd();

等价于：

public static void getA() {}
4.4.3.2   调用
mv.visitMethodInsn(INVOKESTATIC, "asm/A","getB", "()V");

等价于：

A.getB();

说明：一般方法比静态方法在声明和调用时均要多传入一个this引用作为参数。另外，当使用INVOKESPECIAL来调用方法时，虚拟机将直接根据指令当中所指明的类类型来调用方法；而当使用INVOKEVIRTUAL来调用方法时，虚拟机将根据实例的实际类型来调用方法。

 

4.5  异常处理

4.5.1声明
mv.visitTryCatchBlock(l0,l1, l1, "java/lang/Exception");
mv.visitLabel(l0);
mv.visitLabel(l1);
…

等价于：

try {
…
} catch (Exception e) {
…
}

说明：在visitTryCatchBlock()当中，第一，二，三个参数均是Label实例，其中一，二表示try块的范围，三则是catch块的开始位置。而第四个参数则是异常类型。而当异常发生时，JVM将会将异常实例置于运行栈的栈顶。

 

4.5.2Signature

a)  说明：J2SE 5.0为了支持范型，参数化参数，Annotation和枚举等新增特性，因此增加了一个Signature属性，作为类，字段，方法的Description之外的一个辅助机制。

 

4.5.3Annotation

a)  Annotation：

 i.     定义：

cw.visit(V1_5, ACC_PUBLIC + ACC_ANNOTATION + ACC_ABSTRACT + ACC_INTERFACE, "asm/AN", null, "java/lang/Object", new String[]{ "java/lang/annotation/Annotation" });

等价于：

public @interface AN {}

ii.     使用：通过ClassVisitor，FieldVisitor，MethodVisitor上的visitAnnotation()方法，来获取一个AnnotationVisitor实例，从而为类，字段，方法设置Annotation。

AnnotationVisitor av0 = cw.visitAnnotation("Lasm/AN;", false);
av0.visitEnd();
@AN
public class A{}

b)  属性：

 i.     定义

mv = cw.visitMethod(ACC_PUBLIC + ACC_ABSTRACT, "age","()I", null, null);
mv.visitEnd();
 
mv = cw.visitMethod(ACC_PUBLIC + ACC_ABSTRACT, "age","()I", null, null);
mv.visitEnd();
 
mv = cw.visitMethod(ACC_PUBLIC + ACC_ABSTRACT, "name","()Ljava/lang/String;",
null, null);
av0 = mv.visitAnnotationDefault();
av0.visit(null, "A");
av0.visitEnd();
mv.visitEnd();

等价于：

public @interface AN {
     int age();
     String name() default "A";
}

ii.     使用

av0 = cw.visitAnnotation("Lasm/AN;", false);
av0.visit("age", new Integer(1));
av0.visit("name", "B");
av0.visitEnd();

等价于：

@AN(age = 1, name = "B")
public class A {
}

c)  范型

Ø  定义

cw.visit(V1_5, ACC_PUBLIC + ACC_SUPER,"asm/A", "<T::Lasm/IA;G:Lasm/B;>Ljava/lang/Object;Ljava/lang/Comparable;","java/lang/Object", new String[] { "java/lang/Comparable"});

 

等价于：

public class A<T extends IA, G extends B> implements Comparable {
…
}

说明：在类定义当中使用范型时，需要增加Signature字段来添加范型信息。该Signature的组成是“<范型参数名：范型扩展的类：范型扩展的接口…>父类描述接口描述”

Ø  范型字段

1.1定义

FieldVisitor fv = cw.visitField(ACC_PRIVATE, "l","Ljava/util/List;", "Ljava/util/List<Ljava/lang/String;>;", null);
fv.visitEnd();

等价于：

private List<String> l;

说明：在声明范型字段时，需要增加Signature来增加范型信息。该Signature的组成是

“基类型描述<参数类型描述>”

 

1.2使用：由于范型信息只是供编译器在编译时进行类型检查，而在编译以后该信息将会被擦除，因此在使用时与没有范型的情况一致。

Ø  范型方法

1.1 定义

mv = cw.visitMethod(ACC_PUBLIC, "getList","(Ljava/util/Map;)Ljava/util/List;","(Ljava/util/Map<Ljava/lang/String;Ljava/lang/Integer;>;)Ljava/util/List<Ljava/lang/String;>;",null);

 

等价于：

public List<String> getList(Map<String, Integer> maps) {…}

1.2 使用：由于范型信息只是供编译器在编译时进行类型检查，而在编译以后该信息将会被擦除，因此在使用时与没有范型的情况一致。

Ø  枚举

1.1 定义：

ClassWriter cw = new ClassWriter(false);
FieldVisitor fv;
MethodVisitor mv;
AnnotationVisitor av0;
 
cw.visit(V1_5, ACC_PUBLIC + ACC_FINAL + ACC_SUPER + ACC_ENUM,"asm/E",
"Ljava/lang/Enum<Lasm/E;>;", "java/lang/Enum", null);
cw.visitSource("E.java", null);
 
fv = cw.visitField(ACC_PUBLIC + ACC_FINAL + ACC_STATIC + ACC_ENUM,"E1", "Lasm/E;",
null, null);
fv.visitEnd();         //   定义静态字段E1
 
fv = cw.visitField(ACC_PUBLIC + ACC_FINAL + ACC_STATIC + ACC_ENUM,"E2", "Lasm/E;",
ull, null);
fv.visitEnd();         //   定义静态字段E2
 
 
fv = cw.visitField(ACC_PRIVATE + ACC_FINAL + ACC_STATIC + ACC_SYNTHETIC,"ENUM$VALUES",
"[Lasm/E;", null, null);
fv.visitEnd();         //   定义存储所有枚举值的静态字段ENUM$VALUES
 
mv = cw.visitMethod(ACC_STATIC, "<clinit>", "()V",null, null);
mv.visitCode();
 
//   初始化E1
mv.visitTypeInsn(NEW, "asm/E");
mv.visitInsn(DUP);
mv.visitLdcInsn("E1");
mv.visitInsn(ICONST_0);
mv.visitMethodInsn(INVOKESPECIAL, "asm/E", "<init>","(Ljava/lang/String;I)V");
mv.visitFieldInsn(PUTSTATIC, "asm/E", "E1","Lasm/E;");
//   初始化E2
mv.visitTypeInsn(NEW, "asm/E");
mv.visitInsn(DUP);
mv.visitLdcInsn("E2");
mv.visitInsn(ICONST_1);
mv.visitMethodInsn(INVOKESPECIAL, "asm/E", "<init>","(Ljava/lang/String;I)V");
mv.visitFieldInsn(PUTSTATIC, "asm/E", "E2","Lasm/E;");
//   初始化ENUM$VALUES，将E1，E2存入ENUM$VALUES当中
mv.visitInsn(ICONST_2);
mv.visitTypeInsn(ANEWARRAY, "asm/E");
mv.visitInsn(DUP);
mv.visitInsn(ICONST_0);
mv.visitFieldInsn(GETSTATIC, "asm/E", "E1","Lasm/E;");
mv.visitInsn(AASTORE);
mv.visitInsn(DUP);
mv.visitInsn(ICONST_1);
mv.visitFieldInsn(GETSTATIC, "asm/E", "E2","Lasm/E;");
mv.visitInsn(AASTORE);
mv.visitFieldInsn(PUTSTATIC, "asm/E", "ENUM$VALUES","[Lasm/E;");
mv.visitInsn(RETURN);
mv.visitMaxs(8, 0);
mv.visitEnd();
 
 
mv = cw.visitMethod(ACC_PRIVATE, "<init>","(Ljava/lang/String;I)V", null, null);
mv.visitCode();
mv.visitVarInsn(ALOAD, 0);
mv.visitVarInsn(ALOAD, 1);
mv.visitVarInsn(ILOAD, 2);
mv.visitMethodInsn(INVOKESPECIAL, "java/lang/Enum","<init>", "(Ljava/lang/String;I)V");
mv.visitInsn(RETURN);
mv.visitMaxs(3, 3);
mv.visitEnd();
 
//   使用arraycopy()方法，将ENUM$VALUES的值存入一个新数组当中，并返回。
mv = cw.visitMethod(ACC_PUBLIC + ACC_FINAL + ACC_STATIC, "values","()[Lasm/E;", null,
null);
...
mv.visitEnd();
 
//   返回某个枚举值的字符表示
mv = cw.visitMethod(ACC_PUBLIC + ACC_FINAL + ACC_STATIC, "valueOf","(Ljava/lang/String;)Lasm/E;", null, null);
...
mv.visitEnd();
 
cw.visitEnd();

等价于：

public enum E {
     E1, E2
}

 

b)  使用：

mv.visitFieldInsn(GETSTATIC, "asm/E", "E1","Lasm/E;");

等价于：

E e = E.E1;

说明：从上面的代码可以看到，即使是一个简单的枚举，也需要使用很多的代码才能定义，因此更可行的办法是使用Java编译器来生成枚举。

文章标签：
服务网格
Java
索引
编译器
存储
关键词：
Java代码
asm Java
服务网格代码
服务网格java
Java asm
一叶飘舟
目录
相关文章
Java开发者
|
24天前
|
Java
在 Java 中捕获和处理自定义异常的代码示例
本文提供了一个 Java 代码示例，展示了如何捕获和处理自定义异常。通过创建自定义异常类并使用 try-catch 语句，可以更灵活地处理程序中的错误情况。
Java开发者
48 1
东方睿赢
|
2月前
|
存储 安全 Java
Java Map新玩法：探索HashMap和TreeMap的高级特性，让你的代码更强大！
【10月更文挑战第17天】Java Map新玩法：探索HashMap和TreeMap的高级特性，让你的代码更强大！
东方睿赢
72 2
众所周知
|
2月前
|
存储 Java API
键值对魔法：如何优雅地使用Java Map，让代码更简洁？
键值对魔法：如何优雅地使用Java Map，让代码更简洁？
众所周知
134 2
潇洒洒
|
2月前
|
安全 Java API
Java 17新特性让你的代码起飞！
【10月更文挑战第4天】自Java 8发布以来，Java语言经历了多次重大更新，每一次都引入了令人兴奋的新特性，极大地提升了开发效率和代码质量。本文将带你从Java 8一路走到Java 17，探索那些能让你的代码起飞的关键特性。
潇洒洒
88 1
m1a6
|
1月前
|
XML 安全 Java
Java反射机制：解锁代码的无限可能
Java 反射(Reflection)是Java 的特征之一，它允许程序在运行时动态地访问和操作类的信息，包括类的属性、方法和构造函数。 反射机制能够使程序具备更大的灵活性和扩展性
m1a6
42 5
Java反射机制：解锁代码的无限可能
肥猪肥猪-17824
|
9天前
|
安全 Java API
Java中的Lambda表达式：简化代码的现代魔法
在Java 8的发布中，Lambda表达式的引入无疑是一场编程范式的革命。它不仅让代码变得更加简洁，还使得函数式编程在Java中成为可能。本文将深入探讨Lambda表达式如何改变我们编写和维护Java代码的方式，以及它是如何提升我们编码效率的。
肥猪肥猪-17824
13 0
喜欢猪猪
|
1月前
|
存储 安全 Java
系统安全架构的深度解析与实践：Java代码实现
【11月更文挑战第1天】系统安全架构是保护信息系统免受各种威胁和攻击的关键。作为系统架构师，设计一套完善的系统安全架构不仅需要对各种安全威胁有深入理解，还需要熟练掌握各种安全技术和工具。
喜欢猪猪
105 10
众所周知
|
1月前
|
jenkins Java 测试技术
如何使用 Jenkins 自动发布 Java 代码，通过一个电商公司后端服务的实际案例详细说明
本文介绍了如何使用 Jenkins 自动发布 Java 代码，通过一个电商公司后端服务的实际案例，详细说明了从 Jenkins 安装配置到自动构建、测试和部署的全流程。文中还提供了一个 Jenkinsfile 示例，并分享了实践经验，强调了版本控制、自动化测试等关键点的重要性。
众所周知
66 3
游客e5e3x7gfcq5jq
|
1月前
|
分布式计算 Java MaxCompute
ODPS MR节点跑graph连通分量计算代码报错java heap space如何解决
任务启动命令：jar -resources odps-graph-connect-family-2.0-SNAPSHOT.jar -classpath ./odps-graph-connect-family-2.0-SNAPSHOT.jar ConnectFamily 若是设置参数该如何设置
游客e5e3x7gfcq5jq
43 2
老皮皮不会弹舌
|
1月前
|
Java
Java代码解释++i和i++的五个主要区别
本文介绍了前缀递增（++i）和后缀递增（i++）的区别。两者在独立语句中无差异，但在赋值表达式中，i++ 返回原值，++i 返回新值；在复杂表达式中计算顺序不同；在循环中虽结果相同但使用方式有别。最后通过 `Counter` 类模拟了两者的内部实现原理。
老皮皮不会弹舌
58 0
Java代码解释++i和i++的五个主要区别

热门文章

最新文章

  • 1
    Kubernetes上的服务网格 Istio - 分布式追踪篇
  • 2
    动态代理解释-JDK,CGLIB,JAVASSIST,ASM
  • 3
    11gR2 RAC ASM启动揭秘
  • 4
    AIX平台下磁盘的PVID对ASM磁盘的破坏
  • 5
    服务网格实施周期缩短 50%，丽迅物流基于阿里云 ACK 和 ASM 的云原生应用管理实践
  • 6
    ASM REACTING TO PARTITION ERRORS [ID 1062954.1]
  • 7
    RAC 下使用DBCA 建立ASM出错（ORA-15032，ORA-15063）
  • 8
    使用eBPF加速阿里云服务网格ASM
  • 9
    AIX添加ASM的裸盘
  • 10
    针对11.2 RAC丢失OCR和Votedisk所在ASM Diskgroup的恢复手段
  • 1
    面试官：素有Java锁王称号的‘StampedLock’你知道吗？我：这什么鬼？
    99
  • 2
    Java的取余如何编写代码
    75
  • 3
    Java获取字符串最后一位
    574
  • 4
    Java一分钟之-Lambda表达式与函数式接口
    75
  • 5
    Java一分钟之-Java内部类与匿名类
    46
  • 6
    Java一分钟之-Java注解的理解与应用
    49
  • 7
    Java一分钟之-Java反射机制：动态操作类与对象
    79
  • 8
    Java一分钟之线程池：ExecutorService与Future
    146
  • 9
    深入理解Java并发编程：线程安全与性能优化
    47
  • 10
    Java中Lambda表达式的深入理解与应用
    48

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 阿里云平台上进行Java程序的编译与运行
  • 使用Java面向对象编写网络通信程序应用
  • 手动部署Java Web环境（Alibaba Cloud Linux 2）
  • 搭建Java Web开发环境（Anolis OS）
  • RocketMQ中使用Java客户端发送消息和消费的应用
  • 部署基于Dragonwell的Java运行环境
    • 下一篇
    阿里云无影云电脑免费试用，最长可试用3个月