Java高效开发工具: Lombok

Lombok, 一个Java开发必备效率工具,可以大大避免编写一些常用方法(get/set, hashcode等),简化开发。虽然现在IDE很多都可以通过快捷键生成POJO的一些方法了,但是如果该POJO字段发生变动后,还是需要程序员再次手动重新生成相关方法。而Lombok只需要使用注解即可,且是在代码编译期间将注解替换为相应的代码,而非通过反射。同时会使得源码文件更简洁

figure

配置

IDEA环境下的的Lombok的配置:

  1. 首先在Maven中添加Lombok包

    1
    2
    3
    4
    5
    <dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.8</version>
    </dependency>
  2. 在IDEA的Plugins Marketplace 中搜索安装 IntelliJ Lombok plugin 插件

POJO 方法

POJO类的很多方法get、setequals、canEquals、hashCode、toStringConstructor 都可以通过Lombok的相关注解实现

@Data 注解

放置在类上,为该类的所有属性添加get、set方法,为该类添加equals、canEquals、hashCode、toString方法。非常适用于POJO类。

示例源码如下:

1
2
3
4
5
6
7
8
@Data
class Pc1 implements Serializable
{
private static final long serialVersionUID = 1;
private int id;
private double prcie;
private String pcname;
}

编译后class文件如下,可以看到提供了上述提到的所有方法,并且源码依然很简洁

figure 1.jpeg

Note:

如果无构造器方法,Java会提供一个默认的无参构造器。所以class文件中的那个无参构造器可不是Lombok的功劳哦~

@Getter, @Setter 注解

  • 放置在属性上,为该属性添加Get/Set方法

示例源码如下:

1
2
3
4
5
6
7
8
9
class Pc2 implements Serializable
{
private static final long serialVersionUID = 1;
private int id;
@Setter
private double prcie;
@Getter
private String pcname;
}

编译后class文件如下,可以看到字段上添加了相应的方法

figure 2.jpeg

  • 放置在类上,则为该类的所有属性添加Get/Set方法

@EqualsAndHashCode 注解

放置在类上,为该类添加equals、canEqual、hashCode方法

示例源码如下:

1
2
3
4
5
6
7
8
@EqualsAndHashCode
class Pc5 implements Serializable
{
private static final long serialVersionUID = 1;
private int id;
private double prcie;
private String pcname;
}

编译后class文件如下,该类添加了equals、canEqual、hashCode方法

figure 3.jpeg

@ToString 注解

放置在类上,为该类添加toString方法

示例源码如下:

1
2
3
4
5
6
7
@ToString
class Pc6
{
private int id;
private double price;
private String pcname;
}

编译后class文件如下,该类添加了toString方法

figure 4.jpg

构造器: @AllArgsConstructor 注解

放置在类上,为该类添加一个全参构造器。需要注意的是:由于此时已经有构造器了,Java不再提供无参构造器

示例源码如下:

1
2
3
4
5
6
7
8
9

@AllArgsConstructor
class Pc3 implements Serializable
{
private static final long serialVersionUID = 1;
private int id;
private double prcie;
private String pcname;
}

编译后class文件如下,该类添加了一个全参构造器

figure 5.jpeg

构造器: @NoArgsConstructor 注解

放置在类上,为该类添加一个无参构造器

示例源码如下:

1
2
3
4
5
6
7
8
@NoArgsConstructor
class Pc4 implements Serializable
{
private static final long serialVersionUID = 1;
private int id;
private double prcie;
private String pcname;
}

编译后class文件如下,该类添加了一个无参构造器

figure 6.jpeg

@NonNull

放置在属性上,将对该属性进行非空检查,如果为空(null),将会抛出NullPointerException;同时为该类添加一个由所有@NonNull属性组成的有参构造器。需要注意的是:由于此时已经有构造器了,Java不再提供无参构造器

示例代码如下:

1
2
3
4
5
6
7
8
@Data
class Pc7
{
@NonNull
private Integer id;
private double price;
private String pcname;
}

编译后class文件如下,该类中对id属性的操作均进行了非空检查,添加了一个所有@NonNull属性组成(id属性)的有参构造器

figure 7.jpeg

@RequiredArgsConstructor 注解 简化依赖注入

通常我们在实现Spring依赖注入,常常是在需要注入的属性添加@Autowired注解实现(如下所示)。但如果一个类下有很多属性需要注入时,@Autowired就要写一堆了……

1
2
3
4
5
6
7
8
9
...
@Controller
public class Controller1{
@Autowired
private Service1 service1;
@Autowired
private Service2 service2;
...
}

这里可以使用这里@RequiredArgsConstructor注解来简化依赖注入操作:首先需要将该注解放在类上,然后在 需要注入的属性前添加final(用法1) 或 在需要注入的属性上添加注解@NonNull(用法2)

对上述示例的改进写法如下:

1
2
3
4
5
6
7
8
9
10
11
...
@RequiredArgsConstructor(onConstructor = @__(@Autowired))
@Controller
public class Controller1{
// 用法 1
private final Service1 service1;
// 用法 2
@NonNull
private Service2 service2;
...
}

用法1 和 用法2 虽然效果一样,但是很明显用法1更常用……

log对象

@Log4j

放置在类上,为该类添加一个属性名为log的Log4J日志对象

示例源码如下:

1
2
3
4
5
6
7
8
@Log4j
public class Student {
private int id;
private String username;
private String sex;
private String address;
...
}

编译后的class文件如下,该类添加了一个属性名为log的Log4J日志对象

figure 8.jpg

@Slf4j

放置在类上,为该类添加一个属性名为log的SLF4J日志对象

示例源码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import lombok.extern.slf4j.Slf4j;
@Slf4j
public class User {
private int id;
private String name;
private int age;

public int getAge() {
log.error("SLF4J getAge: " + age );
log.debug("SLF4J getAge: " + age );
return age;
}
...
}

编译后的class文件如下,该类添加了一个属性名为log的SLF4J日志对象

figure 9.jpg

0%