38个LomBok工具注解：LomBok架构分析与注解使用案例(必须收藏)Lombok 是一个 Java 库，它通过注解

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

Lombok 的主要特点：

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

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

欢迎 点赞，关注，评论。

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

Lombok 工作流程图

Lombok 架构设计图

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