lombok常用注解及其使用方法

2021-09-01 约 2208 字预计阅读 5 分钟次阅读

以下类为例

1
2
3
4
5


public class User {
    int id;
    String name;
    List list;
}

@Data、@Value

@Data注解在类上，将类提供的所有属性都添加get、set方法，并添加equals、canEquals、hashCode、toString方法

@Value注解用于修饰类，相当于是@Data的不可变形式，因为字段都被修饰为 private和 final，默认的情况下不会生成 settter。还有一点更狠的，默认类本身也是 final的，不能被继承。

参考

@Setter、@Getter、lombok.config

给类添加set、get方法

参考

@Builder

使用builder模式创建对象

1
2
3
4


//创建新的对象
User aaa = User.builder().id(1).name("aaa").build();
//修改原有对象的属性值;要求实体上添加@Builder(toBuilder=true)
aaa = User.toBuilder().id(2).name("bbb).build();

@Singular和@Builder联合使用

可以给集合更加方便的添加多条数据

1
2


    @Singular(value = "list")
    List list;

1

 User aaa = User.builder().id(1).name("aaa").list("aaa").list("djsij").build();

参考

@NoArgsConstructor、@AllArgsConstructor、@RequiredArgsConstructor

可以创造一个无参构造器、或者有参构造器、第三个生成final或者@notnull修饰的无参或者有参构造器

参考

@ToStirng

可以添加一个toString方法

@NotNull

不能为空，否则抛出空指针异常

@Accessors(chain = true)：使用链式创建

1
2
3
4
5


//添加注解
@Data
@Accessors(chain = true)
//使用方法
User aaa = new User().setId(1).setName("aaa");

@Synchronized、@SneakyThrows

@Sychronized 是一个处理线程安全问题的annotation，他的使用方法和关键字 synchronized比较类似，但是有一些不同点就是，关键字synchronized是锁定当前对象（this指针），而@Synchronized则会锁定一个private的常量。如果当前类中没有这个常量，就会自动生成一个

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


    @Synchronized
    public static void hello(){
        System.out.println("hello");
    }
    @Synchronized
    public int hello2(){
        System.out.println("hello");
        return 1;
    }
    @Synchronized
    public void hello3(){
        System.out.println("hello");
    }

以下是它生成的方法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


private static final Object $LOCK = new Object[0];
private final Object $lock = new Object[0];
private final Object readLock = new Object();

public static void hello() {
  synchronized($LOCK) {
    System.out.println("hello");
  }
}

public int hello2() {
  synchronized($lock) {
    return 1;
  }
}

public void hello3() {
  synchronized(readLock) {
    System.out.println("hello");
  }
}

@SneakyThrows让你的代码拥有try….catch包裹

1
2
3
4
5
6


@SneakyThrows
public static void throwException() {
    String str  = null;
    String[] split = str.split(",");
    System.out.println(split);
}

实际上

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


    public SneakyThrowsTest() {}

    public static void throwException() {
        try {
            String str = null;
            String[] split = ((String)str).split(",");
            System.out.println(split);
        } catch (Throwable var2) {
            throw var2;
        }
    }

@Cleanup: 关闭流、连接点

用于处理写入写出流的异常问题，可以让代码简洁

使用前：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


public class Cleanup01 {
  public static void main(String[] args) throws IOException {
    InputStream in = new FileInputStream(args[0]);
    try {
      OutputStream out = new FileOutputStream(args[1]);
      try {
        byte[] b = new byte[1000];
        while (true) {
          int r = in.read(b);
          if (r == -1) break;
          out.write(b, 0, r);
        }
      } finally {
        if (out != null) {
          out.close();
        }
      }
    } finally {
      if (in != null) {
        in.close();
      }
    }
  }
}

使用后：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


public class Cleanup01 {
  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[1000];
    while (true) {
      int r = in.read(b);
      if (r == -1) break;
      out.write(b, 0, r);
    }
  }
}

@Log

参考

@EqualsAndHashCode

重写equals和hashcode方法。

@UtilityClass

官方文档是这么说的

创建实用程序类的注释。如果使用注释了一个类，则会 @UtilityClass发生以下情况：

它被标记为最终。

如果在其中声明了任何构造函数，则会生成错误。否则，将生成一个私有的无参数构造函数。它抛出一个 UnsupportedOperationException。

所有方法，内部类和类中的字段均标记为静态。

@ExtensionMethod

设置父类

@FieldDefaults

设置属性的使用范围，如private、public等，也可以设置属性是否被final修饰。

@SneakyThrows

@SneakyThrows注解的用途得从java的异常设计体系说起。 java中我们常见的2类异常。 1.普通Exception类,也就是我们常说的受检异常或者Checked Exception。 2.RuntimeException类，既运行时异常。前者会强制要求抛出它的方法声明throws，调用者必须显示的去处理这个异常。设计的目的是为了提醒开发者处理一些场景中必然可能存在的异常情况。比如网络异常造成IOException。

但是现实，往往事与愿违。大部分情况下的异常，我们都是一路往外抛了事。（强制处理我也处理不了啊！臣妾做不到）所以渐渐的java程序员处理Exception的常见手段就是外面包一层RuntimeException，接着往上丢。这种解决思想尤其在Spring中到处出现。参见《Spring in Action》

1
2
3


try{}catch(Exception e){
throw new RuntimeException(e);
}

Lombok的@SneakyThrows就是为了消除这样的模板代码。使用注解后不需要担心Exception的处理

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


import lombok.SneakyThrows;

public class SneakyThrowsExample implements Runnable {
  @SneakyThrows(UnsupportedEncodingException.class)
  public String utf8ToString(byte[] bytes) {
    return new String(bytes, "UTF-8");
  }
  
  @SneakyThrows
  public void run() {
    throw new Throwable();
  }
}

真正生成的代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


import lombok.Lombok;

public class SneakyThrowsExample implements Runnable {
  public String utf8ToString(byte[] bytes) {
    try {
      return new String(bytes, "UTF-8");
    } catch (UnsupportedEncodingException e) {
      throw Lombok.sneakyThrow(e);
    }
  }
  
  public void run() {
    try {
      throw new Throwable();
    } catch (Throwable t) {
      throw Lombok.sneakyThrow(t);
    }
  }
}

原理

显然魔法藏在Lombok.sneakyThrow(t);中。可能大家都会以为这个方法就是new RuntimeException()之类的。然而事实并非如此。阅读代码可以看出整个方法其实最核心的逻辑是throw (T)t;，利用泛型将我们传入的Throwable强转为RuntimeException。虽然事实上我们不是RuntimeException。但是没关系。因为JVM并不关心这个。泛型最后存储为字节码时并没有泛型的信息。这样写只是为了骗过javac编译器。源码中注释有解释。

1
2
3
4
5
6
7
8


    public static RuntimeException sneakyThrow(Throwable t) {
        if (t == null) throw new NullPointerException("t");
        return Lombok.<RuntimeException>sneakyThrow0(t);
    }

    private static <T extends Throwable> T sneakyThrow0(Throwable t) throws T {
        throw (T)t;
    }

目录