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

（给 ImportNew 加星标，提高Java技能）

编译：ImportNew/唐尤华

dzone.com/articles/introduction-to-lombok

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

1. 本地变量类型推断： 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`。

2. @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`，个人推荐使用后者。

3. 更简洁的数据类

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;
}
```

4. 使用 @Builder 创建对象

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

[1]:https://en.wikipedia.org/wiki/Builder_pattern

``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();
```

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

5. 日志

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。 更多选项，请查阅[文档][2]。

[2]:https://projectlombok.org/features/log

6. Lombok 让你随心所欲

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

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

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

8. 深入理解

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

[3]:https://projectlombok.org/features/all

看完本文有收获？请转发分享给更多人

关注「ImportNew」，提升Java技能

好文章，我 在看 :heart: