Lombok 常用功能介绍与代码示例

[Real200000]

Lombok 常用功能介绍与代码示例

(偷懒超级利器!)

前言:
本帖旨在简单介绍 Lombok 常用功能。
在平时的开发中，我发现很多开发者都会手动完成一些非常耗时的东西，比如 getter setter ，甚至为其手写链式调用，但是这些都可以用 Lombok 简单的完成 (偷懒)。

笔者水平有限，这里并没有介绍全部功能，而是一些常用的。
如有错误还请指正，想要了解更多 Lombok 功能，请查看这里: https://projectlombok.org/features/.

1.
val
功能: 通过使用 val 关键字，Lombok 能够根据初始值自动推断 final 局部变量的类型，避免了繁琐的类型声明。
示例代码:

public void example() {
    val number = 42; // Lombok 会推断 number 为 int 类型。
    val text = "Hello, World!"; // Lombok 会推断 text 为 String 类型。
    // number = 23; // 错误！'val' 关键字使变量变为 final。
}

2.
var
功能: 通过使用 var 关键字，Lombok 能够根据初始值自动推断可变局部变量的类型，减少了冗长的类型声明。
示例代码:

public void example() {
    var name = "John Doe"; // Lombok 会推断 name 为 String 类型。
    var age = 30; // Lombok 会推断 age 为 int 类型。
    age = 31; // 'var' 关键字允许重新赋值。
}

3.
@NonNull
功能: 使用 @NonNull 注解，Lombok 能够在方法参数中自动生成对应的空值检查代码，确保参数不为 null。
示例代码:

public void example(@NonNull String name) {
    // Lombok 会生成空值检查代码，保证 name 不为 null。
    System.out.println("Name: " + name.length());
}

4.
@Cleanup
功能: 使用 @Cleanup 注解，Lombok 能够确保资源在代码块结束时自动关闭，避免了手动处理资源的繁琐工作。
示例代码:

import java.io.*;

public void example() throws IOException {
    @Cleanup FileInputStream inputStream = new FileInputStream("input.txt");
    @Cleanup FileOutputStream outputStream = new FileOutputStream("output.txt");
    // 资源会在代码块结束时自动关闭。
}

5.
@Getter/@Setter
功能: 使用 @Getter 和 @Setter 注解，Lombok 能够自动生成类的 getter 和 setter 方法，简化代码。
示例代码:

public class GetterSetterExample {
    @Getter @Setter private int age;
    @Getter @Setter private String name;
}

6.
@ToString
功能: 使用 @ToString 注解，Lombok 能够自动生成类的 toString() 方法。
示例代码:

import lombok.ToString;

@ToString
public class ToStringExample {
    private int age;
    private String name;
}

7.
@EqualsAndHashCode
功能: 使用 @EqualsAndHashCode 注解，Lombok 能够自动生成类的 hashCode() 和 equals() 方法，简化对象的比较和哈希码生成。
示例代码:

import lombok.EqualsAndHashCode;

@EqualsAndHashCode
public class EqualsAndHashCodeExample {
    private int age;
    private String name;
}

8.
@NoArgsConstructor、@RequiredArgsConstructor 和 @AllArgsConstructor
功能: 通过这些注解，Lombok 能够根据类的字段自动生成无参构造函数、根据 final 或非 null 字段生成构造函数以及生成包含所有字段的构造函数。
示例代码:

import lombok.*;

@NoArgsConstructor // 无参构造
@AllArgsConstructor // 有参构造 (所有字段)
// @RequiredArgsConstructor 有参构造 (只限 final 或非 null 字段)
public class ConstructorsExample {
    private int age;
    private String name;
}

9.
@Data
功能: 使用 @Data 注解相当于同时使用 @ToString、@EqualsAndHashCode、@Getter 和 @Setter。
示例代码:

import lombok.Data;

@Data
public class DataExample {
    private int age;
    private String name;
}

10.
@Value
功能: 使用 @Value 注解，Lombok 能够自动生成包含 final 字段的不可变类，使得对象在创建后不可修改。
示例代码:

import lombok.Value;

@Value
public class ValueExample {
    private final int age;
    private final String name;
}

11.
@Builder
功能: 使用 @Builder 注解，Lombok 能够自动生成建造者模式的构建器。
示例代码:

import lombok.Builder;

@Builder
public class BuilderExample {
    private int age;
    private String name;
}

12.
@SneakyThrows
功能: 使用 @SneakyThrows 注解，Lombok 能够自动处理受检异常的抛出，使得在方法中抛出异常更加简便。
示例代码:

import lombok.SneakyThrows;

public void example() {
    @SneakyThrows
    void myMethod() {
        throw new Exception("Oops!");
    }
}

13.
@Synchronized
功能: 使用 @Synchronized 注解，Lombok 能够为方法提供简单的同步机制，保证方法的线程安全性。
示例代码:

import lombok.Synchronized;

public class SynchronizedExample {
    private int count;

    @Synchronized
    public void increment() {
        count++;
    }
}

14.
@With
功能: @With 注解生成不可变 "修改器" 方法，用于创建一个新的对象，其中仅有一个或多个字段被更改。
示例代码:

import lombok.*;

@Value
@With
public class WithExample {
    private final int age;
    private final String name;
}

15.
@Getter(lazy=true)
功能: 使用 @Getter(lazy=true) 注解，Lombok 能够生成 lazy-loading 的 getter 方法，在首次调用时才实例化并返回结果。
示例代码:

import lombok.Getter;

@NoArgsConstructor
public class LazyGetterExample {
    @Getter(lazy=true)
    private final String name = computeName();

    private String computeName() {
        System.out.println("Computing name...");
        return "Real2000000";
    }
}

16.
@Log
功能: 使用 @Log 注解，Lombok 能够自动生成日志记录器，方便在代码中添加日志输出。
示例代码:

import lombok.extern.java.Log;

@Log // private static final java.util.logging.Logger log = java.util.logging.Logger.getLogger(LogExample.class.getName());
// @CommonsLog private static final org.apache.commons.logging.Log log = org.apache.commons.logging.LogFactory.getLog(LogExample.class);
// @Flogger private static final com.google.common.flogger.FluentLogger log = com.google.common.flogger.FluentLogger.forEnclosingClass();
// @JBossLog private static final org.jboss.logging.Logger log = org.jboss.logging.Logger.getLogger(LogExample.class);
// @Log4j private static final org.apache.log4j.Logger log = org.apache.log4j.Logger.getLogger(LogExample.class);
// @Log4j2 private static final org.apache.logging.log4j.Logger log = org.apache.logging.log4j.LogManager.getLogger(LogExample.class);
// @Slf4j private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(LogExample.class);
// @XSlf4j private static final org.slf4j.ext.XLogger log = org.slf4j.ext.XLoggerFactory.getXLogger(LogExample.class);
// @CustomLog private static final com.foo.your.Logger log = com.foo.your.LoggerFactory.createYourLogger(LogExample.class);
// @CustomLog 需要您将配置添加到 lombok.config 文件中以指定 @CustomLog 应执行的操作。
public class LogExample {
    public void example() {
        log.info("This is an info message.");
        log.error("This is an error message.");
    }
}

17.
@UtilityClass (为实验性)
功能: 使用 @UtilityClass 注解，Lombok 将自动生成一个私有构造函数，该构造函数会抛出异常，将任何显式构造函数标记为错误，并标记该类为 final。如果该类是内部类，则该类将标记为 static。所有成员都会自动标记为 static 甚至字段和内部类。
示例代码:

import lombok.experimental.UtilityClass;

@UtilityClass
public class MathUtils {
    public int add(int a, int b) {
        return a + b;
    }
}

18.
@ExtensionMethod (此功能的相关错误较多，对代码风格影响很大，为实验性)
功能: 使用 @ExtensionMethod 注解，它允许您向现有类添加静态扩展方法，从而扩展这些类的功能。您可以创建一个类包含一些公共静态方法，这些方法至少有一个参数，这些方法将作为扩展方法，扩展了第一个参数的类型，就像它们是实例方法一样。
示例代码:

import lombok.experimental.ExtensionMethod;

@ExtensionMethod({ObjectExtensions.class})
public class ExtensionMethodExample {
    public static void main(String[] args) {
        String x = null;
        System.out.println(x.or("Hello, World!")); // 输出 Hello, World!
    }
}

class ObjectExtensions {
    public static <T> T or(T object, T ifNull) {
        return object != null ? object : ifNull;
    }
}

19.
@FieldNameConstants (为实验性)
功能: 使用 @FieldNameConstants 注解，类中将自动生成包含字段名常量的内部类或枚举类，目的是为了在代码中避免硬编码字段名，通过常量进行引用，这在需要将字段名用作字符串的场景非常有用，例如在编写序列化、反序列化、日志记录等代码时。
示例代码:

import lombok.experimental.FieldNameConstants;

@AllArgsConstructor
@FieldNameConstants
public class FieldNameConstantsExample {
    private final int age;
    private final String name;
    @FieldNameConstants.Exclude private final double salary;
}

20.
@SuperBuilder (为实验性)
功能: 使用 @SuperBuilder 注解，用于为类生成复杂的构建器 API，与 @Builder 不同的是，@SuperBuilder 还支持使用来自超类 (在面向对象编程中，一个类可以从另一个类继承，被继承的类称为超类、父类、基类，继承它的类称为子类、派生类、衍生类) 的字段，但它仅适用于类，并且要求所有的超类也都拥有 @SuperBuilder 注解。
示例代码:

import lombok.experimental.SuperBuilder;

@SuperBuilder
public class Person {
    private String name;
    private int age;
}

在上面的例子中，我们使用 @SuperBuilder 注解在 Person 类上。现在我们可以像这样创建 Person 类的实例:

Person person = Person.builder()
                    .name("John")
                    .age(30)
                    .build();

使用 @SuperBuilder 注解后，我们不仅可以构建 Person 类的实例，还可以使用父类中的字段，如果 Person 类继承自一个名为 BasePerson 的类，BasePerson 有一个字段 address，那么我们也可以使用构建器来设置 address 字段:

Person person = Person.builder()
                    .name("John")
                    .age(30)
                    .address("123 Main Street")
                    .build();

21.
@Tolerate (用处不大，为实验性)
功能: 使用 @Tolerate 注解，将允许在已存在的方法或构造函数上添加注解，让 Lombok 继续生成与该方法或构造函数名称相同的代码，即使在原本的情况下会因为可能发生冲突而跳过生成。
示例代码:

import lombok.Setter;
import lombok.experimental.Tolerate;
import java.util.Date;

public class TolerateExample {
    @Setter
    private Date date;

    @Tolerate
    public void setDate(String date) {
        this.date = Date.valueOf(date);
    }
}

由于已经有了手动添加的 setDate 方法，Lombok 默认情况下不会生成与字段名相同的 setter 方法，但是通过使用 @Tolerate 注解，我们告诉 Lombok 忽略掉手动添加的方法，并继续生成与字段名相同的 setter 方法。


22.
@Jacksonized (为实验性)
功能: 它是 @Builder 和 @SuperBuilder 的附加注解，使用 @Jacksonized 注解， 可以自动配置生成的构建器类，以便在 Jackson 的反序列化中使用。
示例代码:

@Builder
@Jacksonized
public class Person {
    private String name;
    private int age;
}

在上面的示例中，我们使用 @Jacksonized 注解与 @Builder 注解一起使用，意味着不需要手动配置构建器类来适配 Jackson 的反序列化。
@Jacksonized 会自动处理 Jackson 相关的配置，确保生成的构建器类可以与 Jackson 框架无缝集成。


23.
@StandardException (为实验性)
功能: 使用 @StandardException 注解，它可以简化自定义异常类的构造器生成过程，当自定义的异常类上添加 @StandardException 注解后，Lombok 会自动为该异常类生成最多四个构造器:
无参构造器、只含消息的构造器 (String message)、只含原因的构造器 (Throwable cause)、全参构造器 (String message, Throwable cause)，您可以手动编写其中的任何一个或多个构造器，Lombok 不会再生成它们。
示例代码:

import lombok.experimental.StandardException;

@StandardException
public class ExampleException extends Exception {
}

24.
@Accessors (为实验性)
功能: 用于配置生成更加流畅的 getter、setter 和 with-er 方法，Lombok 遵循 JavaBean 规范生成 getter 和 setter 方法，例如，字段 pepper 会生成 getPepper 方法。然而，有些开发者希望在生成的 API 中使用更加优雅的命名方式。@Accessors 注解就可以满足这一需求。
@Accessors 提供了四个选项:
1. fluent - 如果设置为 true，getter 方法将直接使用字段名，setter 方法将使用字段名作为前缀。
2. chain - 如果设置为 true，生成的 setter 方法返回 this 而不是 void (链式调用)。
3. makeFinal - 如果设置为 true，生成的 getter、setter 和 with-er 方法将被标记为 final。
4. prefix - 字符串列表，如果指定该选项，字段必须以列表中的任意前缀开头，每个字段名会与列表中的前缀逐个比较，如果匹配，则去掉前缀，以此作为字段的基本名称。
示例代码:

import lombok.experimental.Accessors;
import lombok.Getter;
import lombok.Setter;

@Accessors(fluent = true)
public class AccessorsExample {
  @Getter @Setter
  private int age = 10;
}

class PrefixExample {
  @Accessors(prefix = "f") @Getter
  private String fName = "Hello, World!";
}

在上述示例中，我们使用 @Accessors 注解配置生成更加流畅的 getter、setter 和 with-er 方法。通过设置 fluent = true，我们可以直接使用字段名来调用 getter 和 setter 方法，让 API 使用起来更加简洁。
另外，我们还可以通过设置 prefix 来指定字段的前缀，例如 fName 字段的 getter 方法会生成 getName()，而不是 getfName()。这样，我们可以根据项目需求，定制更加优雅的 API。


结语:
除了这些常用功能以外，Lombok 还提供了一些更高级、更复杂的功能，比如 @Delegate、@AllArgsConstructor(staticName="of")、@Builder.Default 等，如果您对此感兴趣，那么可以去这里看看: https://projectlombok.org/features/

如果此帖对您有用，那么这是极好的! Like! Like! Like! Like! Like! Like!
任何问题? 您可以在这个帖子下留言!


真·结语:
想要保护自己的插件 mod或者任何可能的东西吗! 想要给这些东西添加付费机制吗!
CryptoVerifier：高效、经济的许可证验证解决方案 (保护您的 Minecraft 插件 或 Mod 等) : https://bbs.mc9y.net/resources/634/

 

[Taiyi]

离谱，这么长的细致教学