lombok 的使用及简单实现及注解

Myth丶恋晨 2023-10-04 12:17 5阅读 0赞

### lombok 是什么？ ###

> lombok 是一个非常神奇的 java 类库，会利用注解自动生成 java Bean 中烦人的 Getter、Setting，还能自动生成  
> logger、ToString、HashCode、Builder 等 java 特色的函数或是符合设计模式的函数，能够让你 java Bean 更简洁，更美观。

来先看下使用 lombok 后的 java bean 看起来是怎样的

@Data
    @AllArgsConstructor
    public class User {
        
    private Long id;
    private String name;
    private Integer age;
    
    public static void main(String[] args) {
        
    User user = new User(1L,"张三",18);
    System.out.println("toString:"+user);
    System.out.println("name:"+user.getName());
    }
    }

输出如下

toString():User(id=1, name=张三, age=18)
    getName:张三

看到了吗，仅仅在类中添加 @Data 注解就能做到自动生成 Getter 和 ToString 函数了！ 仅仅添加了 @AllArgsConstructor 注解就再也不用写那些让你心烦的构造函数了！

我第一次使用 lombok 的时候就很喜欢它了。觉得它的思想非常好的，即是不应该花时间去写重复的代码，应该让之自动化。

当然自动化的手段是什么也很重要，我可以通过 ide 的生成器功能、或者是自己写的代码生成器，自动生成 Getter、Setting、ToString，就算不用 lombok 也是可以做到的。而我喜欢 lombok 最主要原因就在于它会让代码更简洁、阅读起来更清晰。

可能会有人说这玩意只适合个人项目，不适合大型合作。。。但知乎有位大神说过亚马逊（重度使用 java 的公司） 内部的项目都在用。不管如何还是先了解再决定吧，我个人还是很喜欢用这种方式。

上面的介绍了一下 lombok 有点简陋，所以下面会介绍得更详细的一点。当然也许会有读者对 lombok 这种像是魔法的写法感到好奇，究竟它是怎么自动生成代码的呢？所以文章的后面会对 lombok 进行简单的探讨，希望读者会喜欢。

### lombok 的安装 ###

##### 安装 #####

得现代的依赖管理 ，引入 lombok 依赖及其简单

**meavn**  
使用 meavn 的朋友在 pom.xml 文件中添加依赖即可

\<dependencies>
    \<dependency>
    \<groupId>org.projectlombok</groupId>
    \<artifactId>lombok</artifactId>
    \<version>1.18.6</version>
    \<scope>provided</scope>
    \</dependency>
    \</dependencies>
    gradle

用 gradle 的朋友 在 build.gradle 在添加依赖即可

repositories {
        
    mavenCentral()
    }
    
    dependencies {
        
    compileOnly 'org.projectlombok:lombok:1.18.6'
    annotationProcessor 'org.projectlombok:lombok:1.18.6'
    }

idea 的插件  
你看 pom.xml 的依赖的作用域（scope） 是 provided，也就是说 lombok 是在编译的时候才起作用的。因此 idea 在正确使用 lombok 的时候也会报错的  
所以你要安装 lombok 插件才能正常使用。

##### 使用 #####

注解的类型  
类型 解释

*  val,var 神奇的类型推到，可以代表任意类型
 *  @Getter and @Setter
 *  @ToString
 *  @EqualsAndHashCode
 *  @NonNull
 *  @AllArgsConstructor、@RequiredArgsConstructor、@NoArgsConstructor 构造函数部分，针对不同情况的构造函数
 *  @Data 相当于 @Getter + @Setter + @ToString + @EqualsAndHashCode + RequiredArgsConstructor
 *  @Value 类变成只读模式
 *  @Builder builder 模式，会创建内 Builder
 *  @Singular 要配合 builder 使用，会对（List、Set）等生成更方便函数
 *  @Cleanup 告别烦人的释放的资源
 *  @Log, @Log4j, @Log4j2, @Slf4j, @XSlf4j
 *  @CommonsLog, @JBossLog, @Flogger 不同框架的日志注解
 *  @SneakyThrows 偷偷摸摸地抛出异常
 *  @Delegate 带实验性质的，能非常方便实现代理模式
 *  @Accessors 带实验性质的存取器
 *  @Wither 带实验性质的，根据被修饰的成员变量创建类

##### val,var #####

可以表示任何类型！  
var 可以用来表示变量，类似其他语言中的 let  
val 可以用来表示常量(final)，类似其他语言中的 const

var str = "hello world";
    val list = Arrays.asList(1,2,3,4);
    System.out.println(str);
    for(val item : list){
        
    System.out.printf("%dt",item);
    }

等价于

String str = "hello world";
    final List<Integer> list = Arrays.asList(1,2,3,4);
    System.out.println(str);
    for(final Integer item : list){
        
    System.out.printf("%dt",item);
    }

##### @Getter、@Setter #####

添加了注解后会根据字段生成对应的 get、set 函数，可以修饰成员变量或者类

@Getter
    @Setter
    public class User {
        
    private Long id;
    private String name;
    private Integer age;
    }

灵活的 lombok 可以通过，下面的方式指定访问级别（PUBLIC、PROTECTED、PACKAGE、PRIVATE）

@Getter
    @Setter
    public class User {
        
    private Long id;
    private String name;

@Setter(AccessLevel.PROTECTED)
    private Integer age;
    }

##### @ToString #####

@ToString
    public class User {
        
    private Long id;
    private String name;
    private Integer age;
    }

ToString 生成后代码大概如下

public String toString() {
        
    return "User(id=" + this.id + ", name=" + this.name + ", age=" + this.age + ")";
    }

选项：

1、@ToString(includeFieldNames=false) 不显示变量名，会直接输出值

public String toString() {
        
    return "User(" + this.id + ", " + this.name + ", " + this.age + ")";
    }

2、@ToString(exclude = \{“age”\}) 生成的结果会排出 age 变量

public String toString(){
        
    return "User(id=" + this.id + ", name=" + this.name + ")";
    }

3、@ToString(of = \{“id”,“name”\}) 生成的结果包括

public String toString(){
        
    return "User(id=" + this.id + ", name=" + this.name + ")";
    }

##### @EqualsAndHashCode #####

只能用于修饰类。

@EqualsAndHashCode
    public class User {
        
    //...
    }

和 ToString 类似，可以用 of 以及 exclude 来排出成员变量

##### ＠NonNull #####

可以用于成员变量、本地变量、参数、方法

@Setter  
public class User \{  
private Long id;

@NonNull  
private String name;  
private Integer age;

\}  
setName 函数实际上会变成这样

public void setName(@NonNull String name) {
        
    if (name == null) {
        
    throw new NullPointerException("name is marked @NonNull but is null");
    } else {
        
    this.name = name;
    }
    }

构造函数 @AllArgsConstructor、@RequiredArgsConstructor、@NoArgsConstructor  
这三者都是处理构造函数的注解，都只能修饰类，都能通过staticName 创建静态工厂方法，使用access控制访问级别。  
不同之处在于 @AllArgsConstructor 会把所有的成员变量都纳入到构造函数中， @RequiredArgsConstructor 只会把 final 和 @NonNull 修饰的成员变量纳入、@NoArgsConstructor 所有的成员变量都不会纳入到构造函数。

##### @AllArgsConstructor #####

构造函数会包含所有字段

@AllArgsConstructor
    public class User {
        
    private Long id;
    private String name;
    private Integer age;
    }

会自动生成

public User(Long id, String name, Integer age) {
        
    this.id = id;
    this.name = name;
    this.age = age;
    }

关于 staticName 和 access 的选项，可以看下面的例子

@AllArgsConstructor(staticName = "of",access = AccessLevel.PRIVATE)
    public class User {
        
    private Long id;
    private String name;
    private Integer age;
    }

会看到构造函数和静态工厂函数的访问级别都变成 private 了

public class User {
        
    private Long id;
    private String name;
    private Integer age;
    
    private User(Long id, String name, Integer age) {
        
    this.id = id;
    this.name = name;
    this.age = age;
    }
    
    private static User of(Long id, String name, Integer age) {
        
    return new User(id, name, age);
    }
    }

##### @RequiredArgsConstructor #####

用 final 修饰和 @NonNull 修饰的参数才会加入构造函数

@RequiredArgsConstructor
    public class User {
        
    @NonNull
    private Long id;
    private final String name;
    private Integer age;
    }

生成的结果大概是这样

public class User {
        
    @NonNull
    private Long id;
    private final String name;
    private Integer age;
    
    public User(@NonNull Long id, String name) {
        
    if (id == null) {
        
    throw new NullPointerException("id is marked @NonNull but is null");
    } else {
        
    this.id = id;
    this.name = name;
    }
    }
    }

##### @NoArgsConstructor #####

顾名思义，使用 @NoArgsConstructor 会生成没有参数的构造函数

但如果是用 final 修饰的成员函数呢？

答：这样会编译出错的，除非是用 @NoArgsConstructor(force=true)，那么所有的 final 字段会被定义为0，false，null等。

如果使用使用的是 @NonNull 修饰的成员字段呢？那么使用无参数的构造函数构造出来的实例成员变量不就是 null 了吗？不就矛盾了吗？

答：是的。。。

比如

@NoArgsConstructor
    @Getter
    public class User {
        
    private Long id ;
    private @NonNull String name;
    private Integer age;
    
    public static void main(String[] args) {
        
    System.out.println(new User().getName());
    }
    }

输出结果是 null

因此如果有 @NonNull 修饰的成员的变量就不要用 @NoArgsConstructor 修饰类

##### @Data #####

@Data = @Getter + @Setter + @ToString + @EqualsAndHashCode + @RequiredArgsConstructor 就是那么的方便

选项，可以通过 staticConstructor 创建静态工厂函数

@Data(staticConstructor = "of")
    public class User {
        
    private Long id ;
    private @NonNull String name;
    private Integer age;
    }

##### @Value #####

将类变成只读模式。会让所有类成员变量都变成 final，然后 + @RequiredArgsConstructor + @ToString + @EqualsAndHashCode

##### @Builder #####

面对复杂的数据结构，使用 builder 模式可以抽离复杂的构造方式，能保证线程安全，我在这篇文章中也有对 Builder 的进行粗略的探讨。

使用 Builder 模式很爽，比如是这样的

User user = User.builder().id(1L)
    .name("张三")
    .age(12).build();

这样虽然好爽，但

代价是什么呢？

就是好多冗余的东西要写。比如是这样

public class User {
        
    private Long id;
    private String name;
    private Integer age;
    
    User(Long id, String name, Integer age) {
        
    this.id = id;
    this.name = name;
    this.age = age;
    }
    
    public static User.UserBuilder builder() {
        
    return new User.UserBuilder();
    }
    
    public static class UserBuilder {
        
    private Long id;
    private String name;
    private Integer age;
    
    UserBuilder() {
        
    }
    
    public User.UserBuilder id(Long id) {
        
    this.id = id;
    return this;
    }
    
    public User.UserBuilder name(String name) {
        
    this.name = name;
    return this;
    }
    
    public User.UserBuilder age(Integer age) {
        
    this.age = age;
    return this;
    }
    
    public User build() {
        
    return new User(this.id, this.name, this.age);
    }
    
    public String toString() {
        
    return "User.UserBuilder(id=" + this.id + ", name=" + this.name + ", age=" + this.age + ")";
    }
    }
    }

用 lombok 后

@Builder
    public class User {
        
    private Long id;
    private String name;
    private Integer age;
    }

清晰明了，爽！

但是这里有个很严重的问题，就是不符合 java bean 的规范，java bean 要求有一个无参数的构造函数的。不符号 java bean 要求会有什么后果能？比如：json 字符不能反序列化成 java 对象。  
解决方式是写成这样，要同时写上 @AllArgsConstructor 和 @NoArgsConstructor 才行

@Builder
    @AllArgsConstructor
    @NoArgsConstructor
    public class User {
        
    private Long id;
    private String name;
    private Integer age;
    }