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

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

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

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

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

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

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

2. @NonNull

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

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行代码。

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` 就能得到和上面功能一样的类，如下所示：

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`，如下所示。

@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` 构造函数如下：

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` 注解实现同样的功能，减少模板代码让类变得更简洁。

@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` 看起来像下面这样：

@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` 实现同样的功能：

@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 生成的代码如下：

@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` 代码如下：

@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` 实现相同的功能。

@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`。

@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` 精简后的代码如下：

@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` 对象，就必须在创建对象的地方提供足够的灵活性。

@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`。

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。下面是使用示例：

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

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

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

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

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

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

添加一个日期对象：

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

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

5. 日志

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

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

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

@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

builder方法确实很实用，大家可以尝试自己实现下builder方式。

编译：ImportNew/唐尤华

dzone.com/articles/introduction-to-lombok