带你认识简化 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技能
好文章，我在看❤️