Lombok 常用注解

1. @Constructor 注解

@Constructor 注解标注于类上，用于生成类的构造函数。它一共有三种：

还有其它的包、库自定义了 @NonNull 注解，注意你 import 的是哪一个。

另外，@AllArgsContructor 和 @RequiredArgsConstructor 可以使用一个叫 staticName

的属性用于生成对象的静态构造方法。 这个方法通常叫 of 或 getInstance 。

1.  @AllArgsConstructor(staticName = "of")
2.  public class Human { ... }
3.
4.  Human human = Human.of(name, age);

2. @Builder 注解

@Builder 同样是用于构造对象。它标注于类上，用于在类中生成该类的一个 Builder，以便

使用 Builder 方式以链式的方式实例化对象。

1.  @Builder
2.  public class Human { ... }
3.
4.  Human h = Human.builder().name(name).age(age).build();

通常的编码习惯是在使用 Builder 时多折行显示，形如:

1.  Human h = Human.builder()
2.  .name(name)
3.  .age(age)
4.  ...
5.  .build();

::: details @Builder 注解的内部逻辑

示例

public class Department
2.  {
3.  private Integer deptno;
4.  private String dname;;
5.  private String loc;
6.
7.  public Department() {
8.  super();
9.  }
10.
11.  public Department(Builder builder) {
12.  this.deptno = builder.deptno;
13.  this.dname = builder.dname;
14.  this.loc = builder.loc;
15.  }
16.
17.  public Integer getDeptno() {
18.  return deptno;
19.  }
20.
21.  public String getDname() {
22.  return dname;
23.  }
24.
25.  public String getLoc() {
26.  return loc;
27.  }
28.
29.  /**
30.  * Department 的静态内部类，成员变量和 Department 的一致
31.  */
32.  public static class Builder {
33.  private Integer deptno; // 可选属性
34.  private final String dname; // 必选，final 类型需要在构造器中初始化
，不允许不初始化它的构造器存在
35.  private String loc; // 可选
36.
37.  /**
38.  * 含必选参数的构造方法
39.  */
40.  public Builder(String dname) {
41.  this.dname = dname;
42.  }
43.
44.  public Builder deptno(Integer deptno) {
45.  this.deptno = deptno;
46.  return this;
47.  }
48.
49.  public Builder loc(String loc) {
50.  this.loc = loc;
51.  return this;
52.  }
53.
54.  /**
55.  * 最终构建方法，返回一个 Department 对象，参数是当前 Builder 对象
56.  */
57.  public Department build() {
58.  return new Department(this);
59.  }
60.  }
61.
62.  }

3. @Getter / @Setter 注解

在属性上标注，即生成该属性的 getter/setter 方法。

在类上标注，则是为该类的『所有属性』生成 getter/setter 方法。

@Getter / @Setter 注解有一个 value 属性 （默认属性） 可以设置所生成的 getter/setter 方

法的访问权限。默认为 lombok.AccessLevel.PUBLIC 。

  @Getter(lombok.AccessLevel.PROTECTED

::: warning 注意

这里有一个 lombok 的『著名的坑』：对于基本类型 boolean 和它的包装类 Boolean

，@Getter 注解所生成的方法名的名字不一样！

1.  private boolean male; // 生成 isMale() 方法
2.  private Boolean male; // 生成 getMale() 方法

4. @ToString 注解

@ToString 注解标注于类上，用于生成 toString 方法。

默认的 toString 格式为：ClassName(fieldName=fieleValue, fieldName1=fieleValue,...)

如果想排除某些属性 （特别是因为循环引用问题） 时，可以使用 exclude 属性。

1.  @ToString(exclude = { "id", ... })
2.  public class Human { ... }

如果因为继承，你想要在 toSting 方法中包括继承自父类的属性，那么可以使用 callSuper

属性。

1.  @ToString(callSuper = true) // 默认值是 false
2.  public class Human { ... }

如果为了简化内容，你可以使用 includeFieldNames 属性在 toString 方法中去掉属性的名

字。

1.  @ToString(includeFieldNames = false) // 默认值是 true
2.  public class Human { ... }

5. @EqualsAndHashCode 注解

@EqualsAndHashCode 注解标注于类上，用于生成 equals 方法和 hashCode 方法。

和之前的 @ToString 一样，可是使用 exclude 选项除掉不想要的属性。也可以通过

callSuper 包含父类的 equals 和 hashCode 。

需要注意的是，如果类的属性中有 Array（数组）类型的变量，最好是『手写』equals

和 hashCode 方法。因为最好是调用工具类 Arrays 中的 deepHashCode 方法，

deepEquals 方法进行比较。

6. @Data 注解

1.  @Data
2.  = @ToString
3.  + @EqualsAndHashCode
4.  + @Getter
5.  + @Setter
6.  + @RequiredArgsConstrutor

@Data 注解标注于类上，一个顶 5 个，对于 JavaBean 类十分有用。

另外，@Value 注解是 @Data 的不可变形式，相当于为属性添加 final 声明，只提供 getter

方法，而不提供 setter 方法。即，使用它的 JavaBean 都是「只读」的 JavaBean 。

::: tip 提示

通常，对于一个 JavaBean 的定义，如果没有特殊要求，一般惯例都是如下 3 个注解：

1.  @Data
2.  @NoArgsConstructor
3.  @Builder
4.  public class Student {
5.      ...
6.  }

7. @Slf4j 注解

自动实例化日志对象 log 。

pom 依赖：

1.  <!-- 自动依赖 slf4j-api -->
2.  <dependency>
3.      <groupId>ch.qos.logback</groupId>
4.      <artifactId>logback-classic</artifactId>
5.      <version>1.2.3</version>
6.  </dependency>

需要将日志的配置文件 （logback.xml） 放置到 classpath 下。

在类上标注 @Slf4j

1.  @Slf4j
2.  public class App { ... }

使用 log 对象输出打印日志

1.  log.info("info");
2.  log.warn("warn");
3.  log.debug("debug");

8. @SneakyThrows 注解

@SneakyThrows 的用法比较简单，其实就是对于异常的一个整理，将 checked exception

看做 unchecked exception，不处理，直接扔掉 （上抛） ，减少了到处写 catch 的不便利性。

比如在线程中，catch 所有异常，再比如在一些不太可能发生异常的地方，但是你又必须

catch checked exception 的地方使用这个 annotation 会显得代码比较规整，易读。

1.  public class SneakyThrowsExample implements Runnable {
2.
3.      @SneakyThrows(UnsupportedEncodingException.class)
4.      public String utf8ToString(byte[] bytes) {
5.          return new String(bytes, "UTF-8");
6.      }
7.
8.      @SneakyThrows
9.      public void run() {
10.          throw new Throwable();
11.      }
12.  }

9. @Synchronized 注解

类似于 Synchronized 关键字 但是可以隐藏同步锁

1.  import lombok.Synchronized;
2.
3.  public class SynchronizedExample {
4.      private final Object readLock = new Object();
5.
6.      @Synchronized
7.      public static void hello() {
8.          System.out.println("world");
9.      }
10.
11.      @Synchronized
12.      public int answerToLife() {
13.          return 42;
14.      }
15.
16.      @Synchronized("readLock")
17.      public void foo() {
18.          System.out.println("bar");
19.      }
20.  }