带你认识简化 Java 代码的工具 Lombok

作者: 433c801e5456 | 来源:发表于2019-07-02 10:08 被阅读5次

带你认识简化 Java 代码的工具 Lombok
lombok 简化 Java 代码
lombok 注解简单介绍
使用lombok提升代码开发效率
Spring Boot中使用lombok
Lombok语法详解
Lombok 上手教程
SpringBoot2.0实战 | 第七章：SpringBoot
【Spring-boot】Lombok
Lombok学习与应用

相比其他编程语言，Java 通常被批评代码过于冗长。Lombok 通过注解把这些模板代码从类中移到后台保持了代码的整洁，让代码更易于阅读与维护。本文将介绍 Lombok 特性，并展示如何利用它生成更简洁、清晰的代码。

本地变量类型推断：val and var

许多语言通过等号右边的表达式推断变量类型。在 Java 10 之前的版本中，只有借助 Lombok 才能做到这一点。下面的代码是一个显式指定本地类型的示例：

```java
final Map<String, Integer> map = new HashMap<>();
map.put("Joe", 21);

用 Lombok 可以使用 val 简化为下面的代码：

```java
val valMap = new HashMap<String, Integer>();
valMap.put("Sam", 30);

注意：val 背后生成了一个 final 不可变对象。如果只需要一个本地变量，可以使用 var。

@NonNull

检查参数是否为 null，尤其在提供给其他开发者使用的 API 中是必要的。尽管检查本身不复杂，但是参数很多时会让代码变得冗长。像下面这段代码，不但降低了可读性而且分散了阅读者的注意力。

```java
public void nonNullDemo(Employee employee, Account account){
    if(employee == null){
      throw new IllegalArgumentException("Employee is marked @NonNull but is null");
    }
    if(account == null){
      throw new IllegalArgumentException("Account is marked @NonNull but is null");
    }
    // 开始工作
}

要避免这样的“代码噪音”，可以使用 @NonNull 注解。Lombok 会为标记的参数生成一个 null 检查。不仅代码变得整洁，而且不会丢失 null 防御性检查。

```java
public void nonNullDemo(@NonNull Employee employee, @NonNull Account account){
      // 只有实现代码
}

Lombok 在进行 null 检查时默认抛出 NullPointerException，也可以根据需要配置成 IllegalArgumentException，个人推荐使用后者。

更简洁的数据类

Lombok 另一个特性是可以大量减少数据类模板代码。在开始介绍前，让我们考虑一下通常有哪些模板代码。数据类一般会包括以下内容：

构造函数：带参数或无参数

私有成员变量 Getter 方法

非 final 私有成员变量 Setter 方法

toString 方法记录日志

equals 与 hashCode 方法

上述代码可以通过 IDE 生成，所以问题不在于写代码需要花费时间，而是简单的数据类会迅速变得冗长。让我们看看使用 Lombok 后带来的效果：

3.1 @Getter 与 @Setter

下面以 Car 为例，生成 getter 和 setter 方法后，这个仅有5个成员变量的数据类生成了近50行代码。

```java
public class Car {
  private String make;
  private String model;
  private String bodyType;
  private int yearOfManufacture;
  private int cubicCapacity;
  public String getMake() {
    return make;
  }
  public void setMake(String make) {
    this.make = make;
  }
  public String getModel() {
    return model;
  }
  public void setModel(String model) {
    this.model = model;
  }
  public String getBodyType() {
    return bodyType;
  }
  public void setBodyType(String bodyType) {
    this.bodyType = bodyType;
  }
  public int getYearOfManufacture() {
    return yearOfManufacture;
  }
  public void setYearOfManufacture(int yearOfManufacture) {
    this.yearOfManufacture = yearOfManufacture;
  }
  public int getCubicCapacity() {
    return cubicCapacity;
  }
  public void setCubicCapacity(int cubicCapacity) {
    this.cubicCapacity = cubicCapacity;
  }
}

Lombok 能替你生成 getter 和 setter，只要为变量加上@Getter 和 @Setter 就能得到和上面功能一样的类，如下所示：

```java
public class Car {
  @Getter @Setter
  private String make;
  @Getter @Setter
  private String model;
  @Getter @Setter
  private String bodyType;
  @Getter @Setter
  private int yearOfManufacture;
  @Getter @Setter
  private int cubicCapacity;
}

注意：Lombok 只能在非 final 成员变量使用 @Setter 方法，否则会报告编译错误。

如果要为类中每个成员变量提供 getter 和 setter 方法，还可以在类上添加 @Getter 和 @Setter，如下所示。

```java
@Getter
@Setter
public class Car {
  private String make;
  private String model;
  private String bodyType;
  private int yearOfManufacture;
  private int cubicCapacity;
}

3.2 @AllArgsConstructor

数据类通常包含一个构造函数，每个成员变量接受一个参数。IDE 生成的 Car 构造函数如下：

```java
public class Car {
  @Getter @Setter
  private String make;
  @Getter @Setter
  private String model;
  @Getter @Setter
  private String bodyType;
  @Getter @Setter
  private int yearOfManufacture;
  @Getter @Setter
  private int cubicCapacity;
  public Car(String make, String model, String bodyType, int yearOfManufacture, int cubicCapacity) {
    super();
    this.make = make;
    this.model = model;
    this.bodyType = bodyType;
    this.yearOfManufacture = yearOfManufacture;
    this.cubicCapacity = cubicCapacity;
  }
}

与上面类似，也可以使用 @AllArgsConstructor 注解实现同样的功能，减少模板代码让类变得更简洁。

```java
@AllArgsConstructor
public class Car {
  @Getter @Setter
  private String make;
  @Getter @Setter
  private String model;
  @Getter @Setter
  private String bodyType;
  @Getter @Setter
  private int yearOfManufacture;
  @Getter @Setter
  private int cubicCapacity;
}

更进一步，可以用 @RequiredArgsConstructor 为每个 final 变量接受一个参数；用 @NoArgsConstructor 创建一个无参构造函数。

3.3 @ToString

在数据类中重写 toString 方法是一种日志记录最佳实践。IDE 生成的 toString 看起来像下面这样：

```java
@AllArgsConstructor
public class Car {
  @Getter @Setter
  private String make;
  @Getter @Setter
  private String model;
  @Getter @Setter
  private String bodyType;
  @Getter @Setter
  private int yearOfManufacture;
  @Getter @Setter
  private int cubicCapacity;
  @Override
  public String toString() {
    return "Car [make=" + make + ", model=" + model + ", bodyType=" + bodyType + ", yearOfManufacture="
        + yearOfManufacture + ", cubicCapacity=" + cubicCapacity + "]";
  }
}

Lombok 可以使用 @ToString 实现同样的功能：

```java
@ToString
@AllArgsConstructor
public class Car {
  @Getter @Setter
  private String make;
  @Getter @Setter
  private String model;
  @Getter @Setter
  private String bodyType;
  @Getter @Setter
  private int yearOfManufacture;
  @Getter @Setter
  private int cubicCapacity;

Lombok 会默认生成一个包含了所有成员变量的 toString 方法，可以用 @ToString(exclude={"someField", "someOtherField"}) 排除不需要的成员。

3.4 @EqualsAndHashCode

对数据类进行对象比较时，需要重写 equals 和 hashCode 方法。通常，相等性与具体的业务规则有关。比如，在 Car 类中，两个对象相等意味着 make、model 和 bodyType 相等。IDE 生成的代码如下：

```java
@Override
public boolean equals(Object obj) {
  if (this == obj)
    return true;
  if (obj == null)
    return false;
  if (getClass() != obj.getClass())
    return false;
  Car other = (Car) obj;
  if (bodyType == null) {
    if (other.bodyType != null)
      return false;
  } else if (!bodyType.equals(other.bodyType))
    return false;
  if (make == null) {
    if (other.make != null)
      return false;
  } else if (!make.equals(other.make))
    return false;
  if (model == null) {
    if (other.model != null)
      return false;
  } else if (!model.equals(other.model))
    return false;
  return true;
}

对应的 hashCode 代码如下：

```java
@Override
public int hashCode() {
  final int prime = 31;
  int result = 1;
  result = prime * result + ((bodyType == null) ? 0 : bodyType.hashCode());
  result = prime * result + ((make == null) ? 0 : make.hashCode());
  result = prime * result + ((model == null) ? 0 : model.hashCode());
  return result;
}

尽管 IDE 通过生成解决了繁重的模板代码工作，但代码依然冗长。Lombok 可以在类上添加 @EqualsAndHashCode 实现相同的功能。

```java

@ToString
@AllArgsConstructor
@EqualsAndHashCode(exclude = { "yearOfManufacture", "cubicCapacity" })
public class Car {
  @Getter @Setter
  private String make;
  @Getter @Setter
  private String model;
  @Getter @Setter
  private String bodyType;
  @Getter @Setter
  private int yearOfManufacture;
  @Getter @Setter
  private int cubicCapacity;
}

添加 @EqualsAndHashCode 后，Lombok 会默认生成一个包含了所有成员变量的 equals 和 hashCode 方法，可以用 exclude 排除不需要的成员。例如，上面在生成的 equals 和 hashCode 方法中排除了 yearOfManufacture 和 cubicCapacity。

3.5 @Data

如果希望更进一步简化，可以直接添加 @Data 注解，它会自动添加 @Getter、@Setter、@ToString、@EqualsAndHashCode 和 @RequiredArgsConstructor。

```java
@ToString
@RequiredArgsConstructor
@EqualsAndHashCode(exclude = { "yearOfManufacture", "cubicCapacity" })
public class Car {
  @Getter @Setter
  private String make;
  @Getter @Setter
  private String model;
  @Getter @Setter
  private String bodyType;
  @Getter @Setter
  private int yearOfManufacture;
  @Getter @Setter
  private int cubicCapacity;
}

应用 @Data 精简后的代码如下：

```java
@Data
public class Car {
  private String make;
  private String model;
  private String bodyType;
  private int yearOfManufacture;
  private int cubicCapacity;
}

使用 @Builder 创建对象

应用 Builder 模式可以灵活创建对象，Lombok 对此也提供了便捷的方法。以 Car 为例，如果我们希望创建多种多样的 Car 对象，就必须在创建对象的地方提供足够的灵活性。

```java
@AllArgsConstructor
public class Car {
  private String make;
  private String model;
  private String bodyType;
  private int yearOfManufacture;
  private int cubicCapacity;
  private List<LocalDate> serviceDate;
}

例如，我们希望创建一个 Car 对象，但只设置 make 和 model。应用标准的 all 参数意味着填入 make 和 model 后其他参数都要置为 null。

```java
Car2 car2 = new Car2("Ford", "Mustang", null, null, null, null);

虽然可行，但看起并不优雅；如果创建一个新的构造函数，只接受 make 和 model 参数又不够灵活。如果需要不同字段组合 Car 对象，最后会搞出一堆构造函数。

Lombok 提供一个既优雅又灵活 @Builder 注解解决了此问题，使用步骤如下：

为 Car 添加一个私有构造函数

创建一个 static CarBuilder 类

为 Car 中每个成员变量在 CarBuilder 中创建 setter 风格的函数

在 CarBuilder 中新增 build 方法创建一个 @Car 的新实例

Carbuilder 中的每个 setter 方法能返回自己的实例，这样可以进行链式调用，为对象创建提供了一个很好的流式 API。下面是使用示例：

```java
Car muscleCar = Car.builder().make("Ford")
                             .model("mustang")
                             .bodyType("coupe")
                             .build();

新建一个只有 make 和 model 的 Car 对象看起来很简洁。只要调用 builder 方法就可以获得 CarBuilder 示例，接着根据需要调用感兴趣的 setter 方法，最后调用 build 创建 Car 实例。

除此之外，还有一个更方便的 @Singular 注解，在为集合变量创建 setter 方法后，可以方便地添加对象。例如，下面的示例中包含了一个 serviceDate 列表：

```java
Car muscleCar = Car.builder().make("Ford")
                   .model("mustang")
                   .serviceDate(Arrays.asList(LocalDate.of(2016, 5, 4)))
                   .build();

在集合对象上添加 @Singular 后，就可以直接向列表添加对象：

```java
@Builder
public class Car {
  private String make;
  private String model;
  private String bodyType;
  private int yearOfManufacture;
  private int cubicCapacity;
  @Singular
  private List<LocalDate> serviceDate;
}

添加一个日期对象：

```java
Car muscleCar3 = Car.builder()
                    .make("Ford")
                    .model("mustang")
                    .serviceDate(LocalDate.of(2016, 5, 4))
                    .build();

这样，即使是处理集合也能保持代码整洁。

日志

Lombok 另一个特性是 logger。使用 Lombok 前，实例化一个标准的 SLF4J logger 像下面这样：

```java
public class SomeService {
  private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(LogExample.class);
  public void doStuff(){
    log.debug("干点啥....");
  }
}

这些 logger 看起来把类代码搞得不那么简洁。Lombok 用一个注解搞定。添加注解，开始使用。

```java
@Slf4j
public class SomeService {
  public void doStuff(){
    log.debug("doing stuff....");
  }
}

这里仅以 @SLF4J 为例，Lombok 支持 Java 大多数的常用 logger。更多选项，请查阅文档。

Lombok 让你随心所欲

我钟爱 Lombok 的一个理由在于它的非侵扰性。如果已有代码提供了自己的实现，已有代码会优先于 @Getter、@Setter 或 @ToString。可以选择 Lombok，也可以根据需要提供自己的实现。

用更少的代码完成更多的工作

过去4、5年，几乎每个项目我都用到了 Lombok。不仅减少了混乱，又让它变得更简洁、更易于阅读。虽然 IDE 能够搞定自动生成，但就我而言 Clean Code 更重要。

深入理解

本文介绍了 Lombok 常用功能，如果向了解更多用法，请查阅 Lombok 文档。

带你认识简化 Java 代码的工具 Lombok
相比其他编程语言，Java 通常被批评代码过于冗长。Lombok 通过注解把这些模板代码从类中移到后台保持了代码的...
lombok 简化 Java 代码
lombok 简化 Java 代码 1.介绍 Lombok 是一种 Java 实用工具，可用来帮助开发人员消除 J...
lombok 注解简单介绍
一、Lombok 的简单介绍和使用 Lombok是一个可以帮助我们简化 Java 代码编写的工具类，通过采用注解...
使用lombok提升代码开发效率
一、lombok介绍 lombok是一款为了简化代码而生的工具。按照java传统开发方式,我们每定义一个POJO,...
Spring Boot中使用lombok
lombok是一种工具，提供了简单的注解来简化重复冗长的Java代码，用一次就会爱上他。一、引入lombok 二...
Lombok语法详解
lombok是一个可以帮助我们简化java代码编写的工具类，尤其是简化javabean的编写，即通过采用注解的方式...
Lombok 上手教程
lombok是一个可以帮助我们简化java代码编写的工具类，尤其是简化javabean的编写，即通过采用注解的方式...
SpringBoot2.0实战 | 第七章：SpringBoot
Lombok 可以通过简单的注解来简化 Java 代码，提高开发效率相关知识 Lombok官网：https://...
【Spring-boot】Lombok
一、Lombok简介 Lombok 是一种 Java实用工具，用来简化getter and setter 等等二...
Lombok学习与应用
Lombok LomBok存在的意义 Lombok能以简单的注解形式来简化java代码，提高开发人员的开发效率。例...