f92d0c0dfd2279117247f244ac83d8d4_640_wx_fmt=png&from=appmsg&tp=webp&wxfrom=5&wx_lazy=1&wx_co=1.webp Lombok 是一个 Java 库，它通过注解的方式极大地简化了 Java 代码的编写。它自动生成通常需要手动编写的代码，如 getter 和 setter 方法、构造函数、toString 方法、equals 和 hashCode 方法等。Lombok 旨在减少模板代码的编写，让开发者能够更专注于业务逻辑。

Lombok 的主要特点：

  1. 减少模板代码：自动生成常用的方法，如 getter、setter、构造函数等，减少模板代码的编写。
  2. 提高生产力：通过减少重复代码，提高开发效率。
  3. 增强代码可读性：通过简洁的注解，使代码更加清晰易读。
  4. 与现有代码无缝集成：可以轻松地添加到现有的 Java 项目中，无需对现有代码进行大量修改。
  5. 支持多种构建工具：与 Maven、Gradle 等多种构建工具兼容。

肖哥弹架构 跟大家“弹弹” 框架注解使用，需要代码关注

欢迎 点赞，关注，评论。

关注公号Solomon肖哥弹架构获取更多精彩内容

历史热点文章

Lombok 工作流程图

e4e8b475cb854de9befb6913412c9097_640_wx_fmt=png&from=appmsg&tp=webp&wxfrom=5&wx_lazy=1&wx_co=1.webp

Lombok 架构设计图

f12e14d0443c23efba5ac0d88aab5d8f_640_wx_fmt=png&from=appmsg&tp=webp&wxfrom=5&wx_lazy=1&wx_co=1.webp

1. 基本注解

1.1 @Getter
  • 注解作用介绍

为类中的每个字段生成公共 getter 方法。

  • 注解业务案例
public class User {
    @Getter private String name;
    @Getter private int age;

    public void display() {
        System.out.println("Name: " + getName() + ", Age: " + getAge());
    }
}
  • 注解使用效果： 使用 @Getter 后，Lombok 会自动为 User 类的 name 和 age 字段生成对应的公共 getter 方法，这些方法可以在 display 方法中被调用。
1.2 @Setter
  • 注解作用介绍

为类中的每个字段生成公共 setter 方法。

  • 注解业务案例
public class User {
    @Setter private String name;
    @Setter private int age;

    public void updateDetails(String newName, int newAge) {
        setName(newName);
        setAge(newAge);
        System.out.println("Updated Name: " + getName() + ", Age: " + getAge());
    }
}
  • 注解使用效果： 使用 @Setter 后，Lombok 会自动为 User 类的 name 和 age 字段生成对应的公共 setter 方法，这些方法可以在 updateDetails 方法中被调用。
1.3 @ToString
  • 注解作用介绍

为类生成 toString 方法。

  • 注解业务案例
public class User {
    @ToString private String name;
    @ToString private int age;

    public void printUser() {
        System.out.println(this);
    }
}
  • 注解使用效果： 使用 @ToString 后，Lombok 会自动为 User 类生成一个包含 name 和 age 字段的 toString 方法，该方法可以在 printUser 方法中被调用。
1.4 @EqualsAndHashCode
  • 注解作用介绍

为类生成 equals 和 hashCode 方法。

  • 注解业务案例
public class User {
    @EqualsAndHashCode private String name;
    @EqualsAndHashCode private int age;

    public void checkEquality(User anotherUser) {
        if (this.equals(anotherUser)) {
            System.out.println("Users are equal.");
        } else {
            System.out.println("Users are not equal.");
        }
    }
}
  • 注解使用效果： 使用 @EqualsAndHashCode 后，Lombok 会自动为 User 类生成 equals 和 hashCode 方法，这些方法可以在 checkEquality 方法中被调用。
1.5 @NoArgsConstructor
  • 注解作用介绍

为类生成无参构造函数。

  • 注解业务案例
public class User {
    private String name;
    private int age;

    @NoArgsConstructor
    public void createAndDisplay() {
        User user = new User();
        System.out.println(user.getName() + " " + user.getAge());
    }
}
  • 注解使用效果： 使用 @NoArgsConstructor 后，Lombok 会自动为 User 类生成一个无参构造函数，可以在 createAndDisplay 方法中创建对象。
1.6 @AllArgsConstructor
  • 注解作用介绍

为类生成包含所有参数的构造函数。

  • 注解业务案例
public class User {
    private String name;
    private int age;

    @AllArgsConstructor
    public void createWithAllArgsConstructor() {
        User user = new User("John Doe", 30);
        System.out.println(user);
    }
}
  • 注解使用效果： 使用 @AllArgsConstructor 后，Lombok 会自动为 User 类生成一个包含所有参数的构造函数，可以在 createWithAllArgsConstructor 方法中创建对象。
1.7 @RequiredArgsConstructor
  • 注解作用介绍

为类生成包含所有 final 字段的构造函数。

  • 注解业务案例
public class User {
    private final String name;
    private final int age;

    @RequiredArgsConstructor
    public void createWithRequiredArgsConstructor() {
        User user = new User("John Doe", 30);
        System.out.println(user);
    }
}
  • 注解使用效果： 使用 @RequiredArgsConstructor 后，Lombok 会自动为 User 类生成一个包含所有 final 字段的构造函数，可以在 createWithRequiredArgsConstructor 方法中创建对象。
1.8 @Data
  • 注解作用介绍

组合了 @Getter、@Setter、@RequiredArgsConstructor、@ToString 和 @EqualsAndHashCode。

  • 注解业务案例
public class User {
    private String name;
    private int age;

    @Data
    public void manipulateUser() {
        User user = new User("John Doe", 30);
        user.setName("Jane Doe");
        System.out.println(user);
    }
}
  • 注解使用效果： 使用 @Data 后，Lombok 会自动为 User 类的 name 和 age 字段生成 getter、setter、构造函数、toString 和 equals、hashCode 方法，这些方法可以在 manipulateUser 方法中被调用。

2. 构建器和不可变性

2.1 @Builder
  • 注解作用介绍

为类生成一个 builder 模式的构建器。

  • 注解业务案例
public class User {
    private String name;
    private int age;

    @Builder
    public void createUser() {
        User user = User.builder().name("John Doe").age(30).build();
        System.out.println(user);
    }
}
  • 注解使用效果： 使用 @Builder 后，Lombok 会自动为 User 类生成一个 builder 模式的构建器，可以在 createUser 方法中创建对象。
2.2 @Value
  • 注解作用介绍

为类生成不可变对象的实现，包括 final 字段和 @RequiredArgsConstructor、@Getter、@EqualsAndHashCode、@ToString。

  • 注解业务案例
public class User {
    @Value
    private final String name;
    @Value
    private final int age;

    public void createUser() {
        User user = new User("John Doe", 30);
        System.out.println(user);
    }
}
  • 注解使用效果： 使用 @Value 后，Lombok 会自动为 User 类生成不可变对象的实现，包括 final 字段和对应的构造函数、getter 方法，可以在 createUser 方法中创建对象。
2.3 @SuperBuilder
  • 注解作用介绍

一个更强大的 builder 模式注解，支持继承和更复杂的场景。

  • 注解业务案例
public class User {
    private String name;
    private int age;

    @SuperBuilder
    public void createUser() {
        User user = User.builder().name("John Doe").age(30).build();
        System.out.println(user);
    }
}
  • 注解使用效果： 使用 @SuperBuilder 后，Lombok 会自动为 User 类生成一个更强大的 builder 模式的构建器，支持继承和更复杂的场景，可以在 createUser 方法中创建对象。

3. 日志注解

3.1 @Log
  • 注解作用介绍

为类生成日志对象，支持不同的日志框架。

  • 注解业务案例
public class User {
    private String name;
    private int age;

    @Log
    public void logUser() {
        log.info("User created with name: " + name + " and age: " + age);
    }
}
  • 注解使用效果： 使用 @Log 后，Lombok 会自动为 User 类生成一个日志对象，可以在 logUser 方法中使用。
3.2 @Slf4j
  • 注解作用介绍

为类生成一个 SLF4J 日志对象。

  • 注解业务案例
public class User {
    private String name;
    private int age;

    @Slf4j
    public void logUser() {
        log.info("User created with name: " + name + " and age: " + age);
    }
}
  • 注解使用效果： 使用 @Slf4j 后，Lombok 会自动为 User 类生成一个 SLF4J 日志对象，可以在 logUser 方法中使用。
3.3 @CommonsLog
  • 注解作用介绍 

为类生成 Apache Commons Logging 日志对象。

  • 注解业务案例
public class User {
    private String name;
    private int age;

    @CommonsLog
    public void logUser() {
    log.info("User created with name: " + name + " and age: " + age);
    }
}
  • 注解使用效果： 使用 @CommonsLog 后，Lombok 会自动为 User 类生成一个 Apache Commons Logging 日志对象，可以在 logUser 方法中使用。
3.4 @Log4j
  • 注解作用介绍

为类生成 Log4j 日志对象。

  • 注解业务案例
public class User {
    private String name;
    private int age;

    @Log4j
    public void logUser() {
    log.info("User created with name: " + name + " and age: " + age);
    }
}
  • 注解使用效果： 使用 @Log4j 后，Lombok 会自动为 User 类生成一个 Log4j 日志对象，可以在 logUser 方法中使用。
3.5 @Log4j2
  • 注解作用介绍

为类生成 Log4j2 日志对象。

  • 注解业务案例
public class User {
    private String name;
    private int age;

    @Log4j2
    public void logUser() {
    log.info("User created with name: " + name + " and age: " + age);
    }
}
  • 注解使用效果： 使用 @Log4j2 后，Lombok 会自动为 User 类生成一个 Log4j2 日志对象，可以在 logUser 方法中使用。
3.6 @XSlf4j
  • 注解作用介绍

为类生成一个 SLF4J 日志对象，但使用 XSlf4J 桥接。

  • 注解业务案例
public class User {
    private String name;
    private int age;

    @XSlf4j
    public void logUser() {
    log.info("User created with name: " + name + " and age: " + age);
    }
}
  • 注解使用效果： 使用 @XSlf4j 后，Lombok 会自动为 User 类生成一个 SLF4J 日志对象，使用 XSlf4J 桥接，可以在 logUser 方法中使用。

4. 异常和同步

4.1 @SneakyThrows
  • 注解作用介绍

允许方法抛出被声明的异常之外的异常。

  • 注解业务案例
public class User {
    private String name;
    private int age;

    public void riskyOperation() {
        try {
            // Some risky operation that may throw an exception
        } catch (Exception e) {
            throw new RuntimeException("Failed operation", e);
        }
    }

    @SneakyThrows
    public void performOperation() {
        riskyOperation();
    }
}
  • 注解使用效果： 使用 @SneakyThrows 后，performOperation 方法可以抛出 RuntimeException，即使它没有在方法签名中声明。
4.2 @Synchronized
  • 注解作用介绍

为方法添加同步锁。

  • 注解业务案例
public class User {
    private String name;
    private int age;

    @Synchronized
    public void synchronizedMethod() {
        // Synchronized block of code
        System.out.println("Synchronized method execution");
    }
}
  • 注解使用效果： 使用 @Synchronized 后，synchronizedMethod 方法在执行时会自动添加同步锁，保证线程安全。

5. 工具类和单例

5.1 @UtilityClass
  • 注解作用介绍

标记一个工具类，防止实例化。

  • 注解业务案例
@UtilityClass
public class Utility {
    public void utilityMethod() {
        System.out.println("This is a utility method.");
    }
}
  • 注解使用效果： 使用 @UtilityClass 后，Utility 类无法被实例化，只能通过类名直接调用静态方法。
5.2 @UtilityClassConstructor
  • 注解作用介绍

阻止工具类的实例化。

  • 注解业务案例
@UtilityClassConstructor
public class Utility {
    private Utility() {
        throw new AssertionError("Utility class should not be instantiated.");
    }

    public void utilityMethod() {
        System.out.println("This is a utility method.");
    }
}
  • 注解使用效果： 使用 @UtilityClassConstructor 后，Utility 类的私有构造函数会阻止类的实例化，只能在 utilityMethod 方法中被调用。
5.3 @Singleton
  • 注解作用介绍

标记类为单例模式。

  • 注解业务案例
@Singleton
public class User {
    private String name;
    private int age;

    public void display() {
        System.out.println("Name: " + name + ", Age: " + age);
    }
}
  • 注解使用效果： 使用 @Singleton 后，User 类会被实现为单例模式，确保全局只有一个实例。

6. 委托和延迟加载

6.1 @Delegate
  • 注解作用介绍

为类生成委托方法。

  • 注解业务案例
public class User {
    private SomeService service;

    @Delegate
    public SomeService getService() {
        return service;
    }
}
  • 注解使用效果： 使用 @Delegate 后，User 类可以直接调用 service 对象的方法，就像它们是 User 类的方法一样。
6.2 @DelegateList
  • 注解作用介绍

为类生成委托给列表的方法。

  • 注解业务案例
public class User {
    private List<String> names;

    @DelegateList
    public List<String> getNames() {
        return names;
    }
}
  • 注解使用效果： 使用 @DelegateList 后，User 类可以直接调用 names 列表的方法，就像它们是 User 类的方法一样。
6.3 @DelegateSet
  • 注解作用介绍

为类生成委托给集合的方法。

  • 注解业务案例
public class User {
    private Set<String> roles;

    @DelegateSet
    public Set<String> getRoles() {
        return roles;
    }
}
  • 注解使用效果： 使用 @DelegateSet 后，User 类可以直接调用 roles 集合的方法，就像它们是 User 类的方法一样。
6.4 @DelegateMap
  • 注解作用介绍

为类生成委托给映射的方法。

  • 注解业务案例
public class User {
    private Map<String, String> properties;

    @DelegateMap
    public Map<String, String> getProperties() {
        return properties;
    }
}
  • 注解使用效果： 使用 @DelegateMap 后，User 类可以直接调用 properties 映射的方法，就像它们是 User 类的方法一样。
6.5 @Getter(lazy = true)
  • 注解作用介绍

生成延迟加载的 getter 方法。

  • 注解业务案例
public class User {
    private String name;

    @Getter(lazy = true)
    private String getName() {
        return "Lazy " + name;
    }
}
  • 注解使用效果： 使用 @Getter(lazy = true) 后，getName 方法会延迟加载，每次调用时都会重新计算。

7. 访问级别和空安全

7.1 @FieldDefaults
  • 注解作用介绍

为类中的字段设置默认的访问级别。

  • 注解业务案例
@FieldDefaults(level = AccessLevel.PRIVATE)
public class User {
    private String name;
    private int age;

    public void display() {
        System.out.println("Name: " + name + ", Age: " + age);
    }
}
  • 注解使用效果： 使用 @FieldDefaults 后，User 类中的 name 和 age 字段默认为私有。
7.2 @NonNull
  • 注解作用介绍

标记字段或参数不应为 null。

  • 注解业务案例
public class User { 
  @NonNull private String name; 
  @NonNull private int age;
  public void validateUser() {
      if (name == null || age <= 0) {
          throw new IllegalArgumentException("Name and age must not be null or invalid");
      }
      System.out.println("Name: " + name + ", Age: " + age);
  }
}
  • 注解使用效果： 使用 @NonNull 后，编译器会在 name 或 age 为 null 时抛出编译错误。
7.3 @Nullable
  • 注解作用介绍

标记字段或参数可以为 null。

  • 注解业务案例
public class User {
    @Nullable private String name;
    @Nullable private Integer age;

    public void display() {
        System.out.println("Name: " + (name != null ? name : "Unknown") + ", Age: " + (age != null ? age : "Unknown"));
    }
}
  • 注解使用效果： 使用 @Nullable 后，编译器不会在 name 或 age 为 null 时抛出编译错误。
7.4 @Final
  • 注解作用介绍

标记字段为 final，但允许在初始化时赋值。

  • 注解业务案例
public class User {
    @Final private String name;
    @Final private int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void display() {
        System.out.println("Name: " + name + ", Age: " + age);
    }
}
  • 注解使用效果： 使用 @Final 后，name 和 age 字段在初始化后不能被修改。
7.5 @Setter(AccessLevel.NONE)
  • 注解作用介绍

禁止为字段生成 setter 方法。

  • 注解业务案例
public class User {
    private String name;
    private int age;

    @Setter(AccessLevel.NONE)
    public void setName(String name) {
        this.name = name;
    }

    @Setter(AccessLevel.NONE)
    public void setAge(int age) {
        this.age = age;
    }

    public void display() {
        System.out.println("Name: " + name + ", Age: " + age);
    }
}
  • 注解使用效果： 使用 @Setter(AccessLevel.NONE) 后，User 类不会为 name 和 age 字段生成 setter 方法。

8. 其他

8.1 @Lazy
  • 注解作用介绍

延迟初始化字段。

  • 注解业务案例
public class User {
    @Lazy private SomeService service;

    public void useService() {
        service.performAction();
    }
}
  • 注解使用效果： 使用 @Lazy 后，service 字段会在首次访问时被初始化。
8.2 @Wither
  • 注解作用介绍

为类中的每个字段生成带有 with 前缀的方法。

  • 注解业务案例
public class User {
    private String name;
    private int age;

    @Wither
    public User withName(String name) {
        this.name = name;
        return this;
    }

    @Wither
    public User withAge(int age) {
        this.age = age;
        return this;
    }

    public void display() {
        System.out.println("Name: " + name + ", Age: " + age);
    }
}
  • 注解使用效果： 使用 @Wither 后，User 类会为 name 和 age 字段生成 withName 和 withAge 方法，这些方法可以在链式调用中被使用。
8.3 @Val
  • 注解作用介绍

标记一个字段为局部变量，通常用于不可变对象。

  • 注解业务案例
public class User {
    @Val private final String name = "John Doe";
    @Val private final int age = 30;

    public void display() {
        System.out.println("Name: " + name + ", Age: " + age);
    }
}
  • 注解使用效果： 使用 @Val 后，name 和 age 字段会被标记为局部变量，只能在初始化时赋值。
8.4 @RequiredArgsConstructor(AccessLevel.NONE)
  • 注解作用介绍

为类生成一个私有的构造函数，防止外部实例化。

  • 注解业务案例
@RequiredArgsConstructor(AccessLevel.NONE)
public class User {
    private final String name;
    private final int age;

    public static User createUser(String name, int age) {
        return new User(name, age);
    }

    public void display() {
        System.out.println("Name: " + name + ", Age: " + age);
    }
}
  • 注解使用效果： 使用 @RequiredArgsConstructor(AccessLevel.NONE) 后，User 类的构造函数会被设置为私有，防止外部直接创建实例，只能通过 createUser 方法创建对象。

8. Lombok综合应用案例

/**
 * 使用 Lombok 的@Slf4j 注解为类自动注入一个日志对象。
 */
@Slf4j
/**
 * 使用 Lombok 的@Data 注解组合了 @ToString, @EqualsAndHashCode, @Getter, @Setter 和 @RequiredArgsConstructor。
 * 这将为所有字段生成 getter 和 setter 方法，equals 和 hashCode 方法，以及 toString 方法。
 */
@Data
/**
 * 使用 Lombok 的@RequiredArgsConstructor 注解生成一个包含所有 final 字段的构造函数。
 * AccessLevel.PRIVATE 指定构造函数的访问级别为私有。
 */
@RequiredArgsConstructor(AccessLevel.PRIVATE)
/**
 * 使用 Lombok 的@Builder 注解为类生成一个 Builder 模式的构建器。
 */
@Builder
public class User {

    /**
     * 使用 Lombok 的@Getter 注解为字段生成公共的 getter 方法。
     */
    @Getter
    /**
     * 使用 Lombok 的@NonNull 注解标记字段不应为 null。
     */
    @NonNull
    private final Long id;

    /**
     * 使用 Lombok 的@Getter 和 @Setter 注解为字段生成公共的 getter 和 setter 方法。
     */
    @Getter @Setter
    /**
     * 使用 Lombok 的@NonNull 注解标记字段不应为 null。
     */
    @NonNull
    private String name;

    /**
     * 使用 Lombok 的@Getter(lazy = true) 注解为字段生成延迟加载的 getter 方法。
     */
    @Getter(lazy = true)
    private final String email = "default@email.com";

    /**
     * 使用 Lombok 的@ToString.Exclude 和 @EqualsAndHashCode.Exclude 注解在生成 toString 和 equals/hashCode 方法时排除字段。
     */
    @ToString.Exclude
    @EqualsAndHashCode.Exclude
    private transient String temporaryState;

    /**
     * 使用 Lombok 的@NoArgsConstructor 注解为类生成一个无参构造函数。
     */
    @NoArgsConstructor
    /**
     * 使用 Lombok 的@AllArgsConstructor 注解为类生成一个包含所有参数的构造函数。
     */
    @AllArgsConstructor
    public User(String name, String email) {
        this.name = name;
        this.email = email;
    }

    /**
     * 使用 Lombok 的@RequiredArgsConstructor 注解生成一个包含所有 final 字段的构造函数。
     * AccessLevel.PACKAGE 指定构造函数的访问级别为包级私有。
     */
    @RequiredArgsConstructor(AccessLevel.PACKAGE)
    public User(Long id, String name) {
        this.id = id;
        this.name = name;
    }

    /**
     * 使用 Lombok 的@With 注解为类中的每个字段生成带有 with 前缀的方法。
     */
    @With
    public User withName(String name) {
        return new User(this.id, name);
    }

    /**
     * 使用 Lombok 的@ToString 注解为类生成 toString 方法。
     */
    @ToString
    /**
     * 使用 Lombok 的@Synchronized 注解为方法添加同步锁。
     */
    @Synchronized
    public void performAction() {
        log.info("Performing an action");
    }

    /**
     * 使用 Lombok 的@SneakyThrows 注解允许方法抛出被声明的异常之外的异常。
     */
    @SneakyThrows
    public void riskyAction() {
        throw new RuntimeException("Something went wrong");
    }

    /**
     * 使用 Lombok 的@Delegate 注解为类生成委托方法。
     */
    @Delegate
    private final UserService userService = new UserService();

    /**
     * 使用 Lombok 的@DelegateList 注解为类生成委托给列表的方法。
     */
    @DelegateList
    private final List<String> roles = List.of("USER", "GUEST");

    /**
     * 使用 Lombok 的@DelegateSet 注解为类生成委托给集合的方法。
     */
    @DelegateSet
    private final Set<String> permissions = Set.of("READ", "WRITE");

    /**
     * 使用 Lombok 的@DelegateMap 注解为类生成委托给映射的方法。
     */
    @DelegateMap
    private final Map<String, String> properties = Map.of("key", "value");

    /**
     * 使用 Lombok 的@Lazy 注解延迟初始化字段。
     */
    @Lazy
    private SomeExpensiveService expensiveService = new SomeExpensiveService();

    /**
     * 使用 Lombok 的@FieldDefaults 注解为类中的字段设置默认的访问级别。
     * level = AccessLevel.PRIVATE 指定字段的默认访问级别为私有。
     */
    @FieldDefaults(level = AccessLevel.PRIVATE)
    /**
     * 使用 Lombok 的@Getter(AccessLevel.PUBLIC) 注解为字段设置公共的访问级别。
     */
    @Getter(AccessLevel.PUBLIC)
    /**
     * 使用 Lombok 的@Setter(AccessLevel.NONE) 注解禁止为字段生成 setter 方法。
     */
    @Setter(AccessLevel.NONE)
    private LocalDateTime created = LocalDateTime.now();

    /**
     * 使用 Lombok 的@FieldDefaults 注解为类中的字段设置默认的访问级别。
     * level = AccessLevel.PRIVATE 指定字段的默认访问级别为私有。
     */
    @FieldDefaults(level = AccessLevel.PRIVATE)
    /**
     * 使用 Lombok 的@Getter(AccessLevel.PUBLIC) 注解为字段生成公共的 getter 方法。
     */
    @Getter(AccessLevel.PUBLIC)
    /**
     * 使用 Lombok 的@Setter(AccessLevel.NONE) 注解禁止为字段生成 setter 方法。
     */
    @Setter(AccessLevel.NONE)
    private String status = "ACTIVE";

    public static void main(String[] args) {
        /**
         * 使用 Lombok 的@Builder 注解创建 User 对象。
         */
        User user = User.builder().id(1L).name("John Doe").email("john.doe@example.com").build();
        user.displayUserInfo();
        user.performAction();
        user.riskyAction();
        user.expensiveService.performExpensiveOperation();
    }
}