Java开发的效率工具--Lombok

点击上方“ 框架师 ”，选择“ 置顶公众号 ”

我们一起学习进步!

正文

引言

Lombok这个插件Java开发一般都不陌生,正常情况下可以用来简化我们的JavaBean代码量,网上找了很多lombok相关的文章,注解介绍都不怎么全,索性自己摸索一篇出来,供大家参考

Lombok概述

该不该用Lombok

这个问题可以说一直有很大争议,比如最近爆文:为什么要放弃Lombok,等等许多相似抨击Lombok插件的文章,我个人是比较赞成使用Lombok的,至少目前为止使用非常的得心应手,下面是常见的两方观点;

使用Lombok必须要安装Lombok插件,在IDEA应用市场搜索lombok, 定位到 file/setings/plugins/markeptlace 搜索 Lombok

• 在项目中导入依赖,必须是maven项目,如果是普通的项目,添加lombok的jar即可

1<dependencies>
2        <!--Lombok依赖-->
3        <dependency>
4            <groupId>org.projectlombok</groupId>
5            <artifactId>lombok</artifactId>
6            <version>1.18.12</version>
7        </dependency>
8</dependencies>

常用注解介绍

 1@Getter
 2@Setter
 3public class Person {
 4    private String name;
 5    private Integer age;
 6}
 7
 8/**
 9* @Getter @Setter private int age = 10; //其他写法
10* @Setter(AccessLevel.PROTECTED) private String name;
11*/

@ToString

1@Getter
2@Setter
3@ToString
4public class Person {
5    private String name;
6    private Integer age;
7}

@Data

1@Data
2public class Person {
3    private String name;
4    private Integer age;
5}

@NonNull

1if (param == null) {
2        throw new NullPointerException("null");
3}

1@Data
2public class Person {
3    private String name;
4    private Integer age;
5
6    public Person(@NonNull String person) {
7        this.name = person;
8    }
9}

@Cleanup

可以使用@Cleanup来确保在代码执行路径退出当前作用域之前自动清除给定的资源。其实就是关闭注解标注的当前资源。【简单了解一下就行，一般也用不上】

• 使用lombok方式：

 1public static void main(String[] args) throws Exception {
 2    @Cleanup InputStream in = new FileInputStream(args[0]);
 3    @Cleanup OutputStream out = new FileOutputStream(args[1]);
 4    byte[] b = new byte[1024];
 5    while (true) {
 6        int r = in.read();
 7        if (r == -1) break;
 8        out.write(b, 0, r);
 9    }
10}

@EqualsAndHashCode

任何类的定义上都可以被 @EqualsAndHashCode 标注，lombok可以生成一个 equals(Object other) 和hashCode()的实现方法。它将使用所有非静态，但是可以通过使用 @ EqualsAndHashCode.Include 或 @EqualsAndHashCode 标记类型成员来修改使用的字段。

• 官网代码(没看明白)：

 1import lombok.EqualsAndHashCode;
 2
 3@EqualsAndHashCode
 4public class EqualsAndHashCodeExample {
 5  private transient int transientVar = 10;
 6  private String name;
 7  private double score;
 8  @EqualsAndHashCode.Exclude private Shape shape = new Square(5, 10);
 9  private String[] tags;
10  @EqualsAndHashCode.Exclude private int id;
11
12  public String getName() {
13    return this.name;
14  }
15
16  @EqualsAndHashCode(callSuper=true)
17  public static class Square extends Shape {
18    private final int width, height;
19
20    public Square(int width, int height) {
21      this.width = width;
22      this.height = height;
23    }
24  }
25}

@NoArgsConstructor

• 使用Lombok方式：

 1import lombok.AccessLevel;
 2import lombok.RequiredArgsConstructor;
 3import lombok.AllArgsConstructor;
 4import lombok.NonNull;
 5
 6@RequiredArgsConstructor(staticName = "of")
 7@AllArgsConstructor(access = AccessLevel.PROTECTED)
 8public class ConstructorExample<T> {
 9  private int x, y;
10  @NonNull private T description;
11
12  @NoArgsConstructor
13  public static class NoArgsExample {
14    @NonNull private String field;
15  }
16}

@Value使用

@Value是@Data的不可变形式； 默认情况下，所有字段都设为私有和final的字段，并且不会生成setter。

• 使用Lombok方式：

 1import lombok.AccessLevel;
 2import lombok.experimental.NonFinal;
 3import lombok.experimental.Value;
 4import lombok.experimental.Wither;
 5import lombok.ToString;
 6
 7@Value public class ValueExample {
 8  String name;
 9  @Wither(AccessLevel.PACKAGE) @NonFinal int age;
10  double score;
11  protected String[] tags;
12
13  @ToString(includeFieldNames=true)
14  @Value(staticConstructor="of")
15  public static class Exercise<T> {
16    String name;
17    T value;
18  }
19}

@Builder

• @Builder注释会为您的类生成复杂的构建器API。

• @Builder可自动生成使你的类可被实例化的代码。

• 使用Lombok方式：

 1import lombok.Builder;
 2import lombok.Singular;
 3import java.util.Set;
 4
 5@Builder
 6public class BuilderExample {
 7  @Builder.Default private long created = System.currentTimeMillis();
 8  private String name;
 9  private int age;
10  @Singular private Set<String> occupations;
11}

• 也可以在调用的时候使用链式调用

1 Book book = Book.builder()
2         .id(rs.getInt("id"))
3         .bookName(rs.getString("bookname"))
4         .bookDesc(rs.getString("bookdesc"))
5         .pic(rs.getString("pic"))
6         .price(rs.getFloat("price"))
7         .build();

@SneakyThrows

@SneakyThrows可用于偷偷地抛出已检查的异常，而无需在方法的throws子句中实际声明。[这个我经常使用,非常方便]

• 使用Lombok方式：

 1import lombok.SneakyThrows;
 2
 3public class SneakyThrowsExample implements Runnable {
 4  @SneakyThrows(UnsupportedEncodingException.class)
 5  public String utf8ToString(byte[] bytes) {
 6    return new String(bytes, "UTF-8");
 7  }
 8
 9  @SneakyThrows
10  public void run() {
11    throw new Throwable();
12  }
13}

@Synchronized

@Synchronized是同步方法修饰符的更安全的变体。

与同步一样，注释只能在静态和实例方法上使用。 它的操作类似于synchronized关键字，但是它锁定在不同的对象上

• 使用lombok方式：

 1import lombok.Synchronized;
 2
 3public class SynchronizedExample {
 4  private final Object readLock = new Object();
 5
 6  @Synchronized
 7  public static void hello() {
 8    System.out.println("world");
 9  }
10
11  @Synchronized
12  public int answerToLife() {
13    return 42;
14  }
15
16  @Synchronized("readLock")
17  public void foo() {
18    System.out.println("bar");
19  }
20}

@With

The next best alternative to a setter for an immutable property is to construct a clone of the object, but with a new value for this one field. A method to generate this clone is precisely what @With generates: a withFieldName(newValue) method which produces a clone except for the new value for the associated field.

说实话没看明白这段话是什么意思，个人理解为：在类的字段上标注 @With 注解之后，将会自动生成一个 withFieldName(newValue) 的方法，该方法会基于 newValue 调用相应构造函数，创建一个当前类对应的实例。

• 使用lombok方式：

 1import lombok.AccessLevel;
 2import lombok.NonNull;
 3import lombok.With;
 4
 5public class WithExample {
 6  @With(AccessLevel.PROTECTED) @NonNull private final String name;
 7  @With private final int age;
 8
 9  public WithExample(String name, int age) {
10    if (name == null) throw new NullPointerException();
11    this.name = name;
12    this.age = age;
13  }
14}

@Getter

@Getter 注解支持一个 lazy 属性，该属性默认为 false。当设置为 true 时，会启用延迟初始化，即当首次调用 getter 方法时才进行初始化。

• 使用lombok方式：

 1import lombok.Getter;
 2
 3public class GetterLazyExample {
 4  @Getter(lazy=true) private final double[] cached = expensive();
 5
 6  private double[] expensive() {
 7    double[] result = new double[1000000];
 8    for (int i = 0; i < result.length; i++) {
 9      result[i] = Math.asin(i);
10    }
11    return result;
12  }
13}

@Accessors

@Accessors注释用于配置lombok如何生成和查找getter和setter。

默认情况下，lombok遵循针对getter和setter的bean规范：例如，名为Pepper的字段的getter是getPepper。 但是，有些人可能希望打破bean规范，以得到更好看的API。 @Accessors提供3种方式:

fluent--》 一个布尔值。如果为真，pepper的getter就是 pepper()，setter方法就是pepper(T newValue)。并且，除非特别说明，chain默认为真。

chain--》 一个布尔值。如果为真，产生的setter返回的this而不是void。默认是假。如果fluent=true，那么chain默认为真。

prefix--》 一系列string类型。如果显示，属性必须加上某些定义的前缀。

• 使用lombok方式：

 1import lombok.experimental.Accessors;
 2import lombok.Getter;
 3import lombok.Setter;
 4
 5@Accessors(fluent = true)
 6public class AccessorsExample {
 7  @Getter @Setter
 8  private int age = 10;
 9}
10
11class PrefixExample {
12  @Accessors(prefix = "f") @Getter
13  private String fName = "Hello, World!";
14}

今天的内容就到这里了,祝我好运,也祝你们好运,加油!

如果觉得这篇文章还不错的话, 求在看、求转发 ，明人不说暗话，我喜欢这种被大家伙宠爱的感觉。

one more thing！如果大家想要第一时间看到墨白更新的文章，可以扫描下方的二维码，关注我的公众号。我们下篇文章见！