AI 助理
备案控制台
开发者社区 Java知音 文章 正文

极简代码神器：Lombok使用教程

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

推荐阅读(点击即可跳转阅读)


1. SpringBoot内容聚合

2. 面试题内容聚合

3. 设计模式内容聚合

4. 排序算法内容聚合

5. 多线程内容聚合


Lombok 是一个非常神奇的 java 类库，会利用注解自动生成 java Bean 中烦人的 Getter、Setter，还能自动生成 logger、ToString、HashCode、Builder 等 java特色的函数或是符合设计模式的函数，能够让你 java Bean 更简洁，更美观。


lombok 的思想非常先进，它让我们省略繁琐的样板代码，不要在重复的代码上花费太长时间，它也是Java语言演进过程中必然出现的一种思想，要用20% 的时间做 80%的事情。


下面就来看一下 lombok 的具体用法。


@Data


@Data 是一个很方便的注解，它和@ToString、 @EqualAndHashCode、@Getter/@Setter、和@RequiredArgsConstructor 绑定在一起。换句话说，@Data 生成通常与简单的POJO(Plain Old Java Objects) 和 bean 相关联的所有样板代码，例如：获取所有的属性，设置所有不可继承的属性，适应toString、equals 和 hashcode 的实现，通过构造方法初始化所有final 的属性，以及所有没有使用@NonNull标记的初始化程序的非final字段，以确保该字段永远不为null。


@Data 就像在类上隐含使用 @toString 、 @EqualAndHashCode、 @Getter、


@Setter 和 @RequiredArgsConstructor 注释一样。@Data = @Getter + @Setter +


@ToString + @EqualsAndHashCode + @RequiredArgsConstructor


但是，@Data 无法设置这些注解的参数，例如callSuper、includeFieldNames 和 exclude


如果您需要为这些参数中的任何一个设置非默认值，只需显式添加这些注释;


生成的所有getters/setters 默认都是public 的，为了覆盖访问级别，请使用显式的@Setter \ @Getter批注对字段或类进行注释。你可以使用这个注释(通过与 AccessLevel.NONE结合)来禁止使用 getter或setter。


所有使用 transient 标记的字段都不会视为 hashcode 和 equals。将完全跳过所有静态字段（不考虑任何生成的方法，并且不会为它们创建setter / getter）。


如果类已经包含与通常生成的任何方法具有相同名称和参数计数的方法，则不会生成该方法，也不会发出警告或错误。


例如：如果你使用 equals 标记了一个方法，那么不会再生成 equals 方法，即使从技术上讲，由于具有不同的参数类型，它可能是完全不同的方法。同样的规则适用于构造函数（任何显式构造函数都会阻止 @Data 生成一个），以及toString，equals和所有getter和setter。


您可以使用@ lombok.experimental.Tolerate 标记任何构造函数或方法，以将它们隐藏在 lombok 中


例如：

import lombok.AccessLevel;
import lombok.Data;
import lombok.Setter;
import lombok.ToString;
@Data
public class DataExample {
    private final String name;
    @Setter(AccessLevel.PACKAGE)
    private int age;
    private double score;
    private String[] tags;
    @ToString(includeFieldNames = true)
    @Data(staticConstructor = "of")
    public static class Exercise<T> {
        private final String name;
        private final T value;
    }
}


就相当于是不用 lombok 的如下示例：

import java.util.Arrays;
public class DataExample {
  private final String name;
  private int age;
  private double score;
  private String[] tags;
  public DataExample(String name) {
    this.name = name;
  }
  public String getName() {
    return this.name;
  }
  void setAge(int age) {
    this.age = age;
  }
  public int getAge() {
    return this.age;
  }
  public void setScore(double score) {
    this.score = score;
  }
  public double getScore() {
    return this.score;
  }
  public String[] getTags() {
    return this.tags;
  }
  public void setTags(String[] tags) {
    this.tags = tags;
  }
  @Override public String toString() {
    return "DataExample(" + this.getName() + ", " + this.getAge() + ", " + this.getScore() + ", " + Arrays.deepToString(this.getTags()) + ")";
  }
  protected boolean canEqual(Object other) {
    return other instanceof DataExample;
  }
  @Override public boolean equals(Object o) {
    if (o == this) return true;
    if (!(o instanceof DataExample)) return false;
    DataExample other = (DataExample) o;
    if (!other.canEqual((Object)this)) return false;
    if (this.getName() == null ? other.getName() != null : !this.getName().equals(other.getName())) return false;
    if (this.getAge() != other.getAge()) return false;
    if (Double.compare(this.getScore(), other.getScore()) != 0) return false;
    if (!Arrays.deepEquals(this.getTags(), other.getTags())) return false;
    return true;
  }
  @Override public int hashCode() {
    final int PRIME = 59;
    int result = 1;
    final long temp1 = Double.doubleToLongBits(this.getScore());
    result = (result*PRIME) + (this.getName() == null ? 43 : this.getName().hashCode());
    result = (result*PRIME) + this.getAge();
    result = (result*PRIME) + (int)(temp1 ^ (temp1 >>> 32));
    result = (result*PRIME) + Arrays.deepHashCode(this.getTags());
    return result;
  }
  public static class Exercise<T> {
    private final String name;
    private final T value;
    private Exercise(String name, T value) {
      this.name = name;
      this.value = value;
    }
    public static <T> Exercise<T> of(String name, T value) {
      return new Exercise<T>(name, value);
    }
    public String getName() {
      return this.name;
    }
    public T getValue() {
      return this.value;
    }
    @Override public String toString() {
      return "Exercise(name=" + this.getName() + ", value=" + this.getValue() + ")";
    }
    protected boolean canEqual(Object other) {
      return other instanceof Exercise;
    }
    @Override public boolean equals(Object o) {
      if (o == this) return true;
      if (!(o instanceof Exercise)) return false;
      Exercise<?> other = (Exercise<?>) o;
      if (!other.canEqual((Object)this)) return false;
      if (this.getName() == null ? other.getValue() != null : !this.getName().equals(other.getName())) return false;
      if (this.getValue() == null ? other.getValue() != null : !this.getValue().equals(other.getValue())) return false;
      return true;
    }
    @Override public int hashCode() {
      final int PRIME = 59;
      int result = 1;
      result = (result*PRIME) + (this.getName() == null ? 43 : this.getName().hashCode());
      result = (result*PRIME) + (this.getValue() == null ? 43 : this.getValue().hashCode());
      return result;
    }
  }
}


@NonNull


你可以使用 @NonNull 对方法或者构造器生成 null - check

如果lombok为您生成整个方法或构造函数（例如@Data），Lombok总是将字段上通常称为@NonNull的各种注释视为生成空值检查的信号。但是，现在，在参数上使用lombok自己的@lombok.NonNull会导致在您自己的方法或构造函数中只插入null-check语句。


Null - Check 语句看起来像是如下语句

if(param == null){
  throw new NullPointerException("param is marked @NonNull but is null")
}


这条判空语句会在方法的最开始进行判断


public class NonNullExample {
    @Getter
    private String name;
    public NonNullExample(@NonNull String name){
        this.name = name;
    }
}


这个加上 @NonNull 判空的代码就相当于如下代码


import lombok.NonNull;
public class NonNullExample {
  private String name;
  public NonNullExample(@NonNull String name) {
    if (name == null) {
      throw new NullPointerException("name is marked @NonNull but is null");
    }
    this.name = name;
  }
}


@Getter & @Setter


你可以使用 @Getter 和 @Setter 自动生成任何 getter/setter。


默认的 getter 只返回字段的名称，如果字段的名称为 foo，则返回的是 getFoo()，如果字段类型为 boolean ，则返回 isFoo()。如果字段为 foo 的话，默认的 setter 返回 setFoo，并且类型是 void ，并且带有一个和该属性相同的字段作为参数，用于为此属性字段进行赋值。


除非你指定AccessLevel 访问级别，否则使用 Getter / Setter 生成的方法默认是 public 的作用范围。AccessLevel的访问级别有 PUBLIC, PROTECTED, PACKAGE, and PRIVATE.


你也可以在类上使用 @Getter / @Setter ，在这种情况下，就会对该类中的所有非静态属性生成 get and set 方法


你也可以通过设置 AccessLevel.NONE 禁用任何 get and set 方法的生成。这会使 @Data、@Getter / @Setter 的注解失效。


public class GetterSetterExample {
    @Setter
    @Getter
    private int age = 10;
    @Setter(AccessLevel.PROTECTED)
    private String name;
    @Getter(AccessLevel.PRIVATE)
    private String high;
}


就等同于


public class GetterSetterExample {
  private int age = 10;
  private String name;
  private String high;
  public int getAge() {
    return age;
  }
  public void setAge(int age) {
    this.age = age;
  }
  protected void setName(String name) {
    this.name = name;
  }
  private String getHigh(){
    return high;
  }
}


@ToString


@ToString 注解用来替换掉生成 toString() 方法的实现，默认情况下，它会按顺序打印你的班级名称以及每个字段，并以逗号分隔。


通过设置 includeFieldNames = true 能够使 toString() 方法打印每个字段的属性值和名称。


默认情况下，所有非静态属性都被打印，如果你想要排除某些字段的话，需要设置 @ToString.Exclude，或者，你可以指定ToString(onlyExplicitlyIncluded = true)来指定哪些你希望使用的字段。然后使用@ ToString.Include标记要包含的每个字段。


通过设置 callSuper 为 true ，可以将toString的超类实现的输出包含到输出中。请注意，java.lang.Object 的 toString() 实现没有任何意义，所以你可能不会这样做除非你想要扩展另一个类。


你还可以在toString 中包含方法调用的输出。只能包含不带参数的实例(非静态)方法，为此，请使用@ ToString.Include标记方法。


你可以使用 @ToString.Include（name =“some other name”）更改用于标识成员的名称，并且可以通过 @ ToString.Include（rank = -1）更改成员的打印顺序。没有定义等级的成员默认是0级，等级高的成员优先被打印，优先级相同的成员按照它们在源文件中出现的顺序打印。


@ToString
public class ToStringExample {
  // 静态属性不会包含
  private static final int STATIC_VAR = 10;
  private String name;
  private String[] tags;
  private Shape shape = new Square(5, 10);
  // 排除指定字段不会被 toString 打印
  @ToString.Exclude
  private int id;
  public String getName() {
    return this.name;
  }
  // callSuper 表示是否扩展父类的 toString(), 
  // includeFieldNames 表示是否包含属性名称
  @ToString(callSuper = true, includeFieldNames = true)
  public static class Square extends Shape{
    private final int width, height;
    public Square(int width, int height) {
      this.width = width;
      this.height = height;
    }
  }
  public static class Shape {}
}


测试一下上面的示例


ToStringExample toStringExample = new ToStringExample();
System.out.println(toStringExample);


输出如下


ToStringExample(name=null, tags=null, shape=ToStringExample.Square(super=com.project.lombok.ToStringExample$Square@1b9e1916, width=5, height=10))


注释掉 callSuper = true， 测试结果如下


ToStringExample(name=null, tags=null, shape=ToStringExample.Square(width=5, height=10))


从输出可以看出，如果不扩展父类，不会输出关于 Shape 的内部类信息，callSuper 默认为 false


注释掉 includeFieldNames，测试结果不会发生变化，所以 includeFieldNames 默认值为 true


更改 includeFieldNames = false，测试结果如下


ToStringExample(name=null, tags=null, shape=ToStringExample.Square(super=com.project.lombok.ToStringExample$Square@1b9e1916, 5, 10))


从输出可以看出，如果设置 includeFieldNames = false ，不会输出Shape 中的字段名称信息。


上面用@ToString 注解修饰的例子就相当于是下面这段代码


import java.util.Arrays;
public class ToStringExample {
  private static final int STATIC_VAR = 10;
  private String name;
  private Shape shape = new Square(5, 10);
  private String[] tags;
  private int id;
  public String getName() {
    return this.getName();
  }
  public static class Square extends Shape {
    private final int width, height;
    public Square(int width, int height) {
      this.width = width;
      this.height = height;
    }
    @Override public String toString() {
      return "Square(super=" + super.toString() + ", width=" + this.width + ", height=" + this.height + ")";
    }
  }
  @Override public String toString() {
    return "ToStringExample(" + this.getName() + ", " + this.shape + ", " + Arrays.deepToString(this.tags) + ")";
  }
  public static class Shape {}
}


@EqualsAndHashCode


任何类的定义都可以用@EqualsAndHashCode 标注，让 lombok 为其生成 equals和 hashCode 方法。默认情况下，将会用在非静态，非 transient 标记的字段上，但是你可以通过 @EqualsAndHashCode.Include或 @EqualsAndHashCode.Exclude 标记类型成员来修改使用哪些字段。


或者，你可以通过使用 @EqualsAndHashCode.Include 并使用 @EqualsAndHashCode（onlyExplicitlyIncluded = true）标记它们来准确指定你希望使用的字段或方法。


如果将 @EqualsAndHashCode 应用于扩展另一个的类，这个特性就会变的很危险。通常来说，对类自动生成equals 和 hashcode 方法不是一个好的选择，因为超类也定义了字段，这些字段也需要equals / hashCode方法。通过设置 callSuper 为 true，可以在生成的方法中包含超类的 equals 和 hachcode 方法。


对于 hashCode 来说，super.hashCode 的结果包括了哈希算法，对于 equals 来说，如果超类实现认为它不等于传入的对象，生成的方法将返回 false。请注意，不是所有的equals 实现都能正确处理这种情况。然而，lombok生成的 equals实现可以正确处理这种情况。


如果不扩展类时(只扩展任何java.lang.Object 类)时把 callSuper 设置为 true 会提示编译错误，因为 lombok 会将生成的 equals() 方法和 hashCode() 实现转换为从 Object 继承过来：只有相同的 Object 对象彼此相等并且具有相同的 hashCode 。


当你继承其他类时没有设置 callSuper 为 true 会进行警告，因为除非父类没有相同的属性，lombok无法为您生成考虑超类声明的字段的实现。你需要自己写实现类或者依赖 callSuper 工具。你还可以使用 lombok.equalsAndHashCode.callSuper 配置key。

下面是一个例子



@EqualsAndHashCode
public class EqualsAndHashCodeExample {
    private transient int transientVar = 10;
    private String name;
    private double score;
    @EqualsAndHashCode.Exclude private Shape shape = new Square(5,10);
    private String[] tags;
    @EqualsAndHashCode.Exclude private int id;
    public String getName() {
        return name;
    }
    @EqualsAndHashCode(callSuper = true)
    public static class Square extends Shape {
        private final int width,height;
        public Square(int width,int height){
            this.width = width;
            this.height = height;
        }
    }
    public static class Shape {}
}


@NoArgsConstructor,

@RequiredArgsConstructor,

@AllArgsConstructor


lombok 有三个生成构造函数的注解，下面一起来看一下它们的使用说明和示例

@NoArgsConstructor 将会生成无参数的构造函数，如果有final 修饰的字段并且没有为 final 修饰的字段进行初始化的话，那么单纯的使用 @NoArgsConstructor 注解会提示编译错误


image.png


修改建议：需要为 @NoArgsConstructor 指定一个属性

@NoArgsConstructor(force=true)，lombok会为上面的final 字段默认添加初始值，因为id 是 int 类型，所以 id 的初始值为 0，类似的不同类型的字段的初始值还有 false / null / 0，特定的 Java 构造，像是 hibernate 和 服务提供接口需要无参数的构造方法。此注解主要与 @Data 或生成注解的其他构造函数组合使用。


这里有个需要注意的地方：@NonNull 不要和 @NoArgsConstructor 一起使用

@NoArgsConstructor
@Getter
public class NoArgsConstructorExample {
    private  Long id ;
    private @NonNull String name;
    private Integer age;
    public static void main(String[] args) {
        System.out.println(new NoArgsConstructorExample().getName());
    }
}


输出结果是 null ，因此如果有 @NonNull 修饰的成员的变量就不要用 @NoArgsConstructor 修饰类


@RequiredArgsConstructor 将为每个需要特殊处理的字段生成一个带有1个参数的构造函数。所有未初始化的 final 字段都会获取一个参数，以及标记为 @NonNull 的任何字段也会获取一个参数。这些字段在声明它们的地方没有初始化。对于这些标记为 @NonNull 的字段，会生成特殊的null 编译检查。如果标记为 @NonNull 的字段的参数为 null，那么构造函数将会抛出 NullPointerException。参数的顺序与字段在类中的显示顺序相匹配。


例如下面这个例子，只有 @NonNull 和 final 修饰的字段才会加入构造函数


@RequiredArgsConstructor
public class RequiredArgsConstructorExample {
    @NonNull
    private int id;
    private final String name;
    private boolean human;
}


生成的结果大概是这样的


public class RequiredArgsConstructorExample {
    @NonNull
    private int id;
    private final String name;
    private boolean human;
    public RequiredArgsConstructorExample(@NonNull int id, String name) {
        if (id == null) {
            throw new NullPointerException("id is marked @NonNull but is null");
        } else {
            this.id = id;
            this.name = name;
        }
    }
}


@AllArgsConstructor: @AllArgsConstructor 为类中的每个字段生成一个带有1个参数的构造函数。标有@NonNull 的字段会导致对这些参数进行空检查。


@AllArgsConstructor
public class AllArgsConstructorExample {
    private int id;
    private String name;
    private int age;
}


相当于自动生成如下代码


public AllArgsConstructorExample(int id, String name, int age) {
    this.id = id;
    this.name = name;
    this.age = age;
}


这些注解中的每一个都允许使用替代形式，其中生成的构造函数始终是私有的，并且生成包含私有构造函数的附加静态工厂方法，通过为注释提供staticName值来启用此模式，

@RequiredArgsConstructor（staticName =“of”）。看下面这个例子


@RequiredArgsConstructor(staticName = "of")
@AllArgsConstructor(access = AccessLevel.PROTECTED)
public class ConstructorExample<T> {
  private int x, y;
  @NonNull private T description;
  @NoArgsConstructor
  public static class NoArgsExample {
    @NonNull private String field;
  }
}


就会变为


public class ConstructorExample<T> {
  private int x, y;
  @NonNull private T description;
  private ConstructorExample(T description) {
    if (description == null) throw new NullPointerException("description");
    this.description = description;
  }
  public static <T> ConstructorExample<T> of(T description) {
    return new ConstructorExample<T>(description);
  }
  @java.beans.ConstructorProperties({"x", "y", "description"})
  protected ConstructorExample(int x, int y, T description) {
    if (description == null) throw new NullPointerException("description");
    this.x = x;
    this.y = y;
    this.description = description;
  }
  public static class NoArgsExample {
    @NonNull private String field;
    public NoArgsExample() {
    }
  }
}


文章参考：

https://www.hellojava.com/a/74973.html

https://www.projectlombok.org/features/constructor

文章标签：
Java
搜索推荐
算法
数据库连接
设计模式
关键词：
教程Java
代码Java
lombok Java
lombok使用教程Java
lombok教程Java
笔记侠
目录
相关文章
蓝易云
|
14天前
|
NoSQL Java 关系型数据库
Liunx部署java项目Tomcat、Redis、Mysql教程
本文详细介绍了如何在 Linux 服务器上安装和配置 Tomcat、MySQL 和 Redis，并部署 Java 项目。通过这些步骤，您可以搭建一个高效稳定的 Java 应用运行环境。希望本文能为您在实际操作中提供有价值的参考。
蓝易云
80 26
栈江湖
|
1天前
|
安全 Java 编译器
深入理解Java中synchronized三种使用方式：助您写出线程安全的代码
`synchronized` 是 Java 中的关键字，用于实现线程同步，确保多个线程互斥访问共享资源。它通过内置的监视器锁机制，防止多个线程同时执行被 `synchronized` 修饰的方法或代码块。`synchronized` 可以修饰非静态方法、静态方法和代码块，分别锁定实例对象、类对象或指定的对象。其底层原理基于 JVM 的指令和对象的监视器，JDK 1.6 后引入了偏向锁、轻量级锁等优化措施，提高了性能。
栈江湖
11 3
cafehaus
|
8天前
|
前端开发 Java 测试技术
java日常开发中如何写出优雅的好维护的代码
代码可读性太差，实际是给团队后续开发中埋坑，优化在平时，没有那个团队会说我专门给你一个月来优化之前的代码，所以在日常开发中就要多注意可读性问题，不要写出几天之后自己都看不懂的代码。
cafehaus
48 2
游客syv66y3m2ksnc
|
21天前
|
安全 Java 编译器
Kotlin教程笔记(27) -Kotlin 与 Java 共存(二)
Kotlin教程笔记(27) -Kotlin 与 Java 共存(二)
游客syv66y3m2ksnc
26 7
游客syv66y3m2ksnc
|
21天前
|
Java 开发工具 Android开发
Kotlin教程笔记(26) -Kotlin 与 Java 共存(一)
Kotlin教程笔记(26) -Kotlin 与 Java 共存(一)
游客syv66y3m2ksnc
30 6
Java开发者
|
23天前
|
Java 编译器 数据库
Java 中的注解（Annotations）：代码中的 “元数据” 魔法
Java注解是代码中的“元数据”标签，不直接参与业务逻辑，但在编译或运行时提供重要信息。本文介绍了注解的基础语法、内置注解的应用场景，以及如何自定义注解和结合AOP技术实现方法执行日志记录，展示了注解在提升代码质量、简化开发流程和增强程序功能方面的强大作用。
Java开发者
63 5
聚优云惠
|
20天前
|
Java 数据库连接 编译器
Kotlin教程笔记(29) -Kotlin 兼容 Java 遇到的最大的“坑”
Kotlin教程笔记(29) -Kotlin 兼容 Java 遇到的最大的“坑”
聚优云惠
37 0
肥猪肥猪-17824
|
22天前
|
安全 Java API
Java中的Lambda表达式：简化代码的现代魔法
在Java 8的发布中，Lambda表达式的引入无疑是一场编程范式的革命。它不仅让代码变得更加简洁，还使得函数式编程在Java中成为可能。本文将深入探讨Lambda表达式如何改变我们编写和维护Java代码的方式，以及它是如何提升我们编码效率的。
肥猪肥猪-17824
24 0
程序猿DD
|
IDE Java API
Lombok：让JAVA代码更优雅
Lombok：让JAVA代码更优雅
程序猿DD
111 0
Lombok：让JAVA代码更优雅
嗯哼9925
|
Java 开发工具 IDE
lombok 简化java代码注解
嗯哼9925
1013 0

Java知音

热门文章

最新文章

  • 1
    从零搭建Web所需服务（四）Java连接ES进行分词并获取结果
  • 2
    迅速了解多例模式竞争者-枚举 | 带你学《Java面向对象编程》之七十四
  • 3
    Java Poi 创建与读取Excel
  • 4
    Java程序内存分析：使用mat工具分析内存占用
  • 5
    Java并发系列（6）java关键字-final
  • 6
    【java】值传递和引用传递---对象作为方法的参数传入属于哪种传递
  • 7
    Java 8 Optional 类 学习
  • 8
    Java最最常用的100个类排序（非官方）
  • 9
    Java.nio vs Java.io
  • 10
    java debug 渗透测试
  • 1
    2024年最全BATJ真题突击：Java基础+JVM+分布式高并发+网络编程+Linux(1)，2024年最新意外的惊喜
    78
  • 2
    Java 8新特性之Lambda表达式
    36
  • 3
    深入理解Java并发编程：线程安全与性能优化
    45
  • 4
    深入理解Java并发编程：线程安全与性能优化
    49
  • 5
    大数据软件基础（2）—— Java、SQL
    45
  • 6
    java云MES 系统源码Java+ springboot+ mysql 一款基于云计算技术的企业级生产管理系统
    116
  • 7
    Java一分钟之——异常分类：检查异常与运行时异常
    186
  • 8
    Java一分钟之——异常链：追踪错误源头
    137
  • 9
    Java一分钟之-泛型擦除与类型安全
    92
  • 10
    深入理解Java并发编程：线程安全与性能优化
    54

    • 相关课程

    更多
  • 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面向对象编写网络通信程序应用
  • Arthas 进阶教程
  • Arthas 基础教程
  • 手动部署Java Web环境（Alibaba Cloud Linux 2）
  • 搭建Java Web开发环境（Anolis OS）
    • 下一篇
    【案例实战】SpringBoot整合阿里云文件上传OSS