重新认识Lombok

# Lombok插件

简介

那么lombok到底是个什么呢，lombok是一个可以通过简单的注解的形式来帮助我们简化消除一些必须有但显得很臃肿的 Java 代码的工具，简单来说，比如我们新建了一个类，然后在其中写了几个字段，然后通常情况下我们需要手动去建立getter和setter方法啊，构造函数啊之类的，lombok的作用就是为了省去我们手动创建这些代码的麻烦，它能够在我们编译源码的时候自动帮我们生成这些方法。

lombok能够达到的效果就是在源码中不需要写一些通用的方法，但是在编译生成的字节码文件中会帮我们生成这些方法，这就是lombok的神奇作用。

虽然有人可能会说IDE里面都自带自动生成这些方法的功能，但是使用lombok会使你的代码看起来更加简洁，写起来也更加方便。

安装

一、idea下载安装插件

打开 IDEA 的 Settings 面板，并选择 Plugins 选项，然后点击 “Browse repositories”

在输入框输入”lombok”，得到搜索结果，点击安装，然后安装提示重启 IDEA，安装成功;

二、引入依赖

在自己的项目里添加 lombok 的编译支持，在 pom 文件里面添加 dependency

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.16.18</version>
    <scope>provided</scope>
</dependency>

三、简单使用

在实体类上引入相关的注解即可！

Lombok实现原理

​ 要讲 Lombok 的实现原理，在此之前就需要来说下注解的两种解析方式：运行时注解和编译时注解
​ 首先来看下运行时解析，比如 Spring 配置的 AOP 切面这些注解都是在程序运行的时候通过反射来获取的注解值，但是只有在程序运行时才能获取到这些注解值，导致运行时代码效率很低，并且如果想在编译阶段利用这些注解来进行检查，比如对用户的不合理代码作出错误报告，反射的方法就行不通了。
​ 这就引出了第二种在编译时解析，Lombok 工具就是运行在编译时解析的
​ 那如何把注解与 Java 编译器结合使用呢？Java 也提供了两种解决方案：第一种方案是注解处理器（Annotation Processing Tool），它最早是在 JDK 1.5 与注解（Annotation） 一起引入的，它是一个命令行工具，能够提供构建时基于源代码对程序结构的读取功能，能够通过运行注解处理器来生成新的中间文件，进而影响编译过程，不过它在 JDK 1.8 中被移除了，取而代之的是** JSR 269 插入式注解处理器（Pluggable Annotation Processing API）**，它是实现了 JSR 269 的机制，作为注解处理器的替代方案。

我们通过一个流程图来进一步说明注解处理器的工作原理：

常用注解

1. @getter / @setter :自动生成getter/setter方法

import lombok.AccessLevel;
    import lombok.Getter;
    import lombok.Setter;
    public class GetterSetterExample {
        @Getter @Setter private int age = 10;
        @Setter(AccessLevel.PROTECTED) private String name;
    }

2. @NoArgsConstructor:自动生成无参构造函数
3. @AllArgsConstructor:自动生成全参构造函数
4. @Date : 自动为所有字段添加@ToString,@EqualsAndHashCode,@Getter,方法为非final修饰的字段添加@Setter,@RequiredArgsConstructor方法
5. @NonNull :校验参数，避免空指针,给方法参数增加这个注解会自动在方法内对该参数进行是否为空的校验，如果为空，则抛出 NPE（NullPointerException）

import lombok.NonNull;
    public class NonNullExample extends Something {
        private String name;  
        public NonNullExample(@NonNull Person person) {
        super("Hello");
        this.name = person.getName();
    }
}

6.@Cleanup:自动调用close()方法,自动管理资源，用在局部变量之前，在当前变量范围内即将执行完毕退出之前会自动清理资源，自动生成 ty-finally 这样的代码来关闭流

import lombok.Cleanup;
import java.io.*;
public class CleanupExample {
    public static void main(String[] args) throws IOException {
        @Cleanup InputStream in = new FileInputStream(args[0]);
        @Cleanup OutputStream out = new FileOutputStream(args[1]);
        byte[] b = new byte[10000];
        while (true) {
            int r = in.read(b);
            if (r == -1) break;
            out.write(b, 0, r);
        }
    }
}

7. val：用在局部变量前面，相当于将变量声明为final

8. @ToString:用在类上可以自动覆写 toString 方法，当然还可以加其他参数，例如 @ToString(exclude=”id”) 排除 id 属性，或者 @ToString(callSuper=true, includeFieldNames=true) 调用父类的 toString 方法，包含所有属性

9. @EqualAndHashCode:用在类上自动生成equals方法和hashCode方法
10. @NoArgsConstructor, @RequiredArgsConstructor and @AllArgsConstructor:用在类上，自动生成无参构造和使用所有参数的构造函数以及把所有 @NonNull 属性作为参数的构造函数，如果指定 staticName="of" 参数，同时还会生成一个返回类对象的静态工厂方法，比使用构造函数方便很多
11. @Value:用在类上，是@Date的不可变形式，相当于为属性添加final声明，只提供getter方法，而且不提供setter方法
12. @Builder：用在类、构造器、方法上，为你提供复杂的builder APIs，让你可以像如下方式一样调用

Person.builder().name("xxx").city("xxx").build()

13. @SneakyThrows:自动抛受检异常，而无需显式在方法上使用throws语句
14. @Synchronized:用在方法上，将方法声明为同步的，并自动加锁，而锁对象是一个私有的属性
15. @Getter(lazy=true):可以替代经典的**Double Check Lock **样板代码
16. @Log:根据不同的注解生成不同类型的log对象，但实例名称都是log，有六中可选实现类

注解使用详细介绍

一、@Builder注解

1@Builder注解在项目中使用

Person.builder()
    .name("Adam Savage")
    .city("San Francisco")
    .job("Mythbusters")
    .job("Unchained Reaction")
    .build();

• @Builder注解为你的类生成相对略微复杂的构建器API。@Builder可以让你以上面显示的那样调用你的代码，来初始化你的实例对象

• @Builder可以放在类，构造函数或方法上。 放在类上和放在构造函数上这两种模式是最常见的用例，但@Builder最容易用放在方法的用例来解释。

• 使用@Builder注解的方法可以帮助我们完成很多事情：

  一个名为FooBuilder的**内部静态类**，并具有和实体类形同的属性（称为构建器）。
  在构建器中：对于目标类中的所有的属性和未初始化的final字段，都会在构建器中创建对应属性；
  在构建器中：创建一个无参的default构造函数。
  在构建器中：对于实体类中的每个参数，都会对应创建类似于“setter”的方法，只不多方法名与该参数名相同。 并且返回值是构建器本身（便于链式调用），如上例所示。
  在构建器中：一个build()方法，调用此方法，就会根据设置的值进行创建实体对象。
  在构建器中：同时也会生成一个toString()方法。
  在实体类中：会创建一个builder()方法，它的目的是用来创建构建器。

代码实例：

@Builder
public class User {
    private String username;
    private String password;
}

// 编译后：
public class User {
    private String username;
    private String password;
    User(String username, String password) {
        this.username = username; this.password = password;
    }
    public static User.UserBuilder builder() {
        return new User.UserBuilder();
    }

    public static class UserBuilder {
        private String username;
        private String password;
        UserBuilder() {}

        public User.UserBuilder username(String username) {
            this.username = username;
            return this;
        }
        public User.UserBuilder password(String password) {
            this.password = password;
            return this;
        }
        public User build() {
            return new User(this.username, this.password);
        }
        public String toString() {
            return "User.UserBuilder(username=" + this.username + ", password=" + this.password + ")";
        }
    }
}

2. @Builder中使用@Singular 注释集合

2.1 Singular注解在项目中使用

@Bulider注解也可以为集合类型的参数或字段生成一种特殊的方法。 它采用修改列表中一个元素而不是整个列表的方式，可以是增加一个元素，也可以是删除一个元素
代码示例：

Person.builder()
    .job("Mythbusters")
    .job("Unchained Reaction")
    .build();

这样就可以轻松地将List <String>字段中包含2个字符串。 但是想要这样来操作集合，你需要使用@Singular来注释字段或参数。

在使用@Singular注释一个集合字段（使用@Builder注释类），lombok会将该构建器节点视为一个集合，并生成两个adder方法而不是setter方法

• 一个向集合添加单个元素
• 一个将另一个集合的所有元素添加到集合中。

将不生成仅设置集合（替换已添加的任何内容）的setter。 还生成了clear方法。 这些singular构建器相对而言是有些复杂的，主要是来保证以下特性：

在调用build()时，生成的集合将是不可变的。

在调用build()之后调用其中一个adder方法或clear方法不会修改任何已经生成的对象。如果对集合修改之后，再调用build()，则会创建一个基于上一个对象创建的对象实体。

生成的集合将被压缩到最小的可行格式，同时保持高效。

@Singular只能应用于lombok已知的集合类型。目前，支持的类型有：

​ java.util:
Iterable, Collection, 和List (一般情况下，由压缩的不可修改的ArrayList支持).
Set, SortedSet, and NavigableSet (一般情况下，生成可变大小不可修改的HashSet或者TreeSet).
Map, SortedMap, and NavigableMap (一般情况下，生成可变大小不可修改的HashMap或者TreeMap).
​ Guava’s com.google.common.collect:
ImmutableCollection and ImmutableList
ImmutableSet and ImmutableSortedSet
ImmutableMap, ImmutableBiMap, and ImmutableSortedMap
ImmutableTable

@Singular注解之后的编译情况：

@Builder
public class User {
    private final Integer id;
    private final String zipCode = "215500";
    private String username;
    private String password;
    @Singular
    private List<String> hobbies;
}

// 编译后：
public class User {
    private final Integer id;
    private final String zipCode = "215500";
    private String username;
    private String password;
    private List<String> hobbies;
    User(Integer id, String username, String password, List<String> hobbies) {
        this.id = id; this.username = username;
        this.password = password; this.hobbies = hobbies;
    }

    public static User.UserBuilder builder() {return new User.UserBuilder();}

    public static class UserBuilder {
        private Integer id;
        private String username;
        private String password;
        private ArrayList<String> hobbies;
        UserBuilder() {}
        public User.UserBuilder id(Integer id) { this.id = id; return this; }
        public User.UserBuilder username(String username) { this.username = username; return this; }
        public User.UserBuilder password(String password) { this.password = password; return this; }

        public User.UserBuilder hobby(String hobby) {
            if (this.hobbies == null) {
                this.hobbies = new ArrayList();
            }
            this.hobbies.add(hobby);
            return this;
        }

        public User.UserBuilder hobbies(Collection<? extends String> hobbies) {
            if (this.hobbies == null) {
                this.hobbies = new ArrayList();
            }
            this.hobbies.addAll(hobbies);
            return this;
        }

        public User.UserBuilder clearHobbies() {
            if (this.hobbies != null) {
                this.hobbies.clear();
            }
            return this;
        }

        public User build() {
            List hobbies;
            switch(this.hobbies == null ? 0 : this.hobbies.size()) {
            case 0:
                hobbies = Collections.emptyList();
                break;
            case 1:
                hobbies = Collections.singletonList(this.hobbies.get(0));
                break;
            default:
                hobbies = Collections.unmodifiableList(new ArrayList(this.hobbies));
            }
            return new User(this.id, this.username, this.password, hobbies);
        }
        public String toString() {
            return "User.UserBuilder(id=" + this.id + ", username=" + this.username + ", password=" + this.password + ", hobbies=" + this.hobbies + ")";
        }
    }
}

lombok在进行build()来创建实例对象时，并没有直接使用Collections.unmodifiableList(Collection)此方法来创建实例，而是分为三种情况：
1. 第一种，当集合中没有元素时，创建一个空list；
2. 第二种情况，当集合中存在一个元素时，创建一个不可变的单元素list；
3. 第三种情况，根据当前集合的元素数量创建对应合适大小的list；

当然我们看编译生成的代码，创建了三个关于集合操作的方法：

• hobby(String hobby)：向集合中添加一个元素
• hobbies(Collection<? extends String> hobbies)：添加一个集合所有的元素
• clearHobbies()：清空当前集合数据

2.2@Singular注解配置详解

@Singular 注解的详情：

@Target({FIELD, PARAMETER})
@Retention(SOURCE)
public @interface Singular {
	// 修改添加集合元素的方法名
	String value() default "";
}

• 测试如何使用注解属性vlaue

@Builder
public class User {
    private final Integer id;
    private final String zipCode = "215500";
    private String username;
    private String password;
    @Singular(value = "testHobbies")
    private List<String> hobbies;
}

// 测试类
public class BuilderTest {
    public static void main(String[] args) {
        User user = User.builder()
                .testHobbies("reading")
                .testHobbies("chatting")
                .id(1)
                .password("jdkong")
                .username("jdkong")
                .build();
        System.out.println(user);
    }
}

说明，当我们使用了注解属性value之后，我们在使用添加集合元素时的方法名发生相应的改变。但是，同时生成的添加整个集合的方法名发生改变了吗？我们再来看看编译后的代码：

// 编译后：
public class User {
	// 省略部分代码，只看关键部分
    public static class UserBuilder {
		public User.UserBuilder testHobbies(String testHobbies) {
            if (this.hobbies == null) {
                this.hobbies = new ArrayList();
            }
            this.hobbies.add(testHobbies);
            return this;
        }

        public User.UserBuilder hobbies(Collection<? extends String> hobbies) {
            if (this.hobbies == null) {
                this.hobbies = new ArrayList();
            }
            this.hobbies.addAll(hobbies);
            return this;
        }
        
        public User.UserBuilder clearHobbies() {
            if (this.hobbies != null) {
                this.hobbies.clear();
            }
            return this;
        }
    }
}

可以看到，只有添加一个元素的方法名发生了改变。

2.3 @Builder.Default 使用

比如有这样一个实体类：

@Builder
@ToString
public class User {
    @Builder.Default
    private final String id = UUID.randomUUID().toString();
    private String username;
    private String password;
    @Builder.Default
    private long insertTime = System.currentTimeMillis();
}

在类中我在id和insertTime上都添加注解@Builder.Default，当我在使用这个实体对象时，我就不需要在为这两个字段进行初始化值，如下面这样：

public class BuilderTest {
    public static void main(String[] args) {
        User user = User.builder()
                .password("jdkong")
                .username("jdkong")
                .build();
        System.out.println(user);
    }
}

// 输出内容：
User(id=416219e1-bc64-43fd-b2c3-9f8dc109c2e8, username=jdkong, password=jdkong, insertTime=1546869309868)

lombok在实例化对象时就为我们初始化了这两个字段值。

当然，你如果再对这两个字段进行设值的话，那么默认定义的值将会被覆盖掉，如下面这样：

public class BuilderTest {
    public static void main(String[] args) {
        User user = User.builder()
                .id("jdkong")
                .password("jdkong")
                .username("jdkong")
                .build();
        System.out.println(user);
    }
}
// 输出内容
User(id=jdkong, username=jdkong, password=jdkong, insertTime=1546869642151)

2.4@Builder 详细配置

下面我们再来详细看看@Builder这个注解类地详细实现：

@Target({TYPE, METHOD, CONSTRUCTOR})
@Retention(SOURCE)
public @interface Builder {
	// 如果@Builder注解在类上，可以使用 @Builder.Default指定初始化表达式
	@Target(FIELD)
	@Retention(SOURCE)
	public @interface Default {}
	// 指定实体类中创建 Builder 的方法的名称，默认为: builder (个人觉得没必要修改)
	String builderMethodName() default "builder";
	// 指定 Builder 中用来构件实体类的方法的名称，默认为：build (个人觉得没必要修改)
	String buildMethodName() default "build";
	// 指定创建的建造者类的名称，默认为：实体类名+Builder
	String builderClassName() default "";
	// 使用toBuilder可以实现以一个实例为基础继续创建一个对象。（也就是重用原来对象的值）
	boolean toBuilder() default false;
	
	@Target({FIELD, PARAMETER})
	@Retention(SOURCE)
	public @interface ObtainVia {
		// 告诉lombok使用表达式获取值
		String field() default "";
		// 告诉lombok使用表达式获取值
		String method() default "";

		boolean isStatic() default false;
	}
}

以上注解属性，我只测试一个比较常用的toBuilder，因为我们在对实体对象进行操作时，往往会存在对某些实体对象的某个字段进行二次赋值，这个时候就会用到这一属性。但是，这会创建一个新的对象，而不是原来的对象，原来的对象属性是不可变的，除非你自己想要给这个实体类再添加上@Data或者@setter方法（我是这么干过，哈哈）。下面就来测试一下：

@Builder(toBuilder = true)
@ToString
public class User {
    private String username;
    private String password;
}
// 测试类
public class BuilderTest {
    public static void main(String[] args) {
        User user1 = User.builder()
                .password("jdkong")
                .username("jdkong")
                .build();
        System.out.println(user1);

        User user2 = user1.toBuilder().username("jdkong2").build();
        // 验证user2是否是基于user1的现有属性创建的
        System.out.println(user2);
        // 验证对象是否是同一对象
        System.out.println(user1 == user2);
    }
}
// 输出内容
User(username=jdkong, password=jdkong)
User(username=jdkong2, password=jdkong)
false

2.5 @Builder 全局配置

# 是否禁止使用@Builder
lombok.builder.flagUsage = [warning | error] (default: not set)
#是否使用Guaua
lombok.singular.useGuava = [true | false] (default: false)
# 是否自动使用singular，默认是使用
lombok.singular.auto = [true | false] (default: true)