uso de lombok
El artículo es extenso y puede leerse bajo demanda.
Importar dependencias
Primero, el proyecto Maven importa dependencias en pom.xml
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.24</version>
</dependency>
一、@getter、@Setter、@toString
1. @getter y @Setter generan los métodos getxxx() y setxxx() respectivamente
Puede agregar anotaciones a las variables miembro que necesitan generar métodos getter y setter.
¿Qué sucede si se agrega a una clase, pero una determinada variable miembro necesita generar captadores y definidores especiales?
Puede escribir directamente manualmente los métodos getter y setter de la variable. Cuando lombok detecte que ha escrito los métodos getter y setter correspondientes para la variable, ya no se generará automáticamente.
2. @toString genera el método toString(), que imprime el nombre de la clase y cada campo en orden, separados por comas.
二、@NoArgsConstructor、@RequiredArgsConstructor、@AllArgsConstructor
1. @NoArgsConstructor constructor sin parámetros
@NoArgsConstructorLas anotaciones tienen cuatro parámetros de atributo: staticName, onConstructor, access y force, que se pueden configurar:
nombre estático
staticName representa si se debe generar un constructor estático, es decir, cuando el atributo staticName tiene un valor, se generará un constructor estático, en este momento el constructor sin argumentos será privado y luego un constructor estático con el especificado Se creará el nombre y será público, como se muestra a continuación:
/**
* 编译前代码
*/
@RequiredArgsConstructor(staticName = "UserStatic")
public class UserInfo() {
private String username;
private String password;
}
/**
* 编译后代码
*/
public class UserInfo() {
private String username;
private String password;
private UserInfo() {
}
public UserStatic() {
return new UserStatic();
}
}
enConstructor
onConstructor
Las personas que suelen escribir código Spring o SpringBoot deben saber que Spring proporciona tres métodos para escribir la inyección de dependencia, a saber, inyección de propiedad, inyección del método Setter e inyección del constructor. Sin embargo, en el trabajo diario confiamos principalmente en @Autowired El método de anotación se utiliza para la inyección de dependencia. . Sin embargo, demasiada inyección de dependencia hará que nuestro código sea demasiado detallado. Incluso este método de escritura ha quedado obsoleto desde Spring 4.0. En su lugar, se recomienda utilizar la inyección del método Setter y la inyección del constructor, y la generación de lombok. El método constructor puede implementar esto fácilmente método de escritura.
Dé un ejemplo de inyección mediante constructor:
@Controller
public class SysLoginController() {
private final TokenUtils tokenUtils;
private final SysLoginService sysLoginService;
/**
* 在这里 @Autowired 是可以省略的，在这里使用只是为了介绍 onConstructor 参数
*/
@Autowired
public SysLoginController (TokenUtils tokenUtils, SysLoginService sysLoginService) {
this.tokenUtils = tokenUtils;
this.sysLoginService = sysLoginService;
}
}
Cuando la cantidad de beans inyectados es grande, todavía necesitamos escribir mucho código. En este momento, podemos usar la anotación @RequiredArgsConstructor para resolver este problema. En cuanto a por qué no usar la anotación @AllArgsConstructor, es porque esta anotación es para todos los parámetros, y en esta situación, solo necesitamos construir las propiedades correspondientes al Bean en lugar de las que no son Bean, por lo que solo necesitamos modificar las propiedades correspondientes al Bean con la palabra clave final para generar solo los parámetros requeridos. constructor, como se muestra a continuación:
/**
* 编译前
*/
@RequiredArgsConstructor(onConstructor = @__(@Autowired))
public class SysLoginController() {
private final TokenUtils tokenUtils;
private final SysLoginService sysLoginService;
}
/**
* 编译后
*/
public class SysLoginController() {
private final TokenUtils tokenUtils;
private final SysLoginService sysLoginService;
@Autowired
public SysLoginController (TokenUtils tokenUtils, SysLoginService sysLoginService) {
this.tokenUtils = tokenUtils;
this.sysLoginService = sysLoginService;
}
}
acceso
A veces usaremos el modo singleton. En este caso, necesitamos crear un constructor privado sin parámetros. Luego podemos usar un atributo como acceso para establecer los permisos del constructor, como se muestra a continuación:
/**
* 编译前代码
*/
@RequiredArgsConstructor(access = AccessLevel.PRIVATE)
public class UserInfo() {
private String username;
private String password;
}
/**
* 编译后代码
*/
public class UserInfo() {
private String username;
private String password;
private UserInfo() {
}
}
Niveles de acceso opcionales:
public enum AccessLevel { PÚBLICO, MÓDULO, PROTEGIDO, PAQUETE, PRIVADO, NINGUNO;
private AccessLevel() {
}
}
fuerza
Cuando un campo modificado por la palabra clave final en una clase no se ha inicializado, el compilador informará un error. En este momento, también puede establecer el atributo de fuerza en verdadero para generar un valor predeterminado de 0/falso/nulo para el campo. Según el tipo, para que el compilador no vuelva a informar un error, como se muestra a continuación:
/**
* 编译前代码
*/
@RequiredArgsConstructor(force = true)
public class UserInfo() {
private final String gender;
private String username;
private String password;
}
/**
* 编译后代码
*/
public class UserInfo() {
private final String gender = null;
private String username;
private String password;
private UserInfo() {
}
}
2、@RequiredArgsConstructor
@RequiredArgsConstructorUtilizada en una clase, esta anotación puede generar un constructor con o sin parámetros.
Si se proporcionan parámetros, solo pueden ser todos los campos no inicializados anotados con @NonNull y modificados con final en la clase, como se muestra a continuación:
/**
* 编译前代码
*/
@RequiredArgsConstructor
public class UserInfo() {
private final String gender;
@NonNull
private String username;
private String password;
}
/**
* 编译后代码
*/
public class UserInfo() {
private final String gender;
@NonNull
private String username;
private String password;
public UserInfo(String gender, @NonNull String username) {
if (username == null) {
throws new NullPointerException("username is marked @NonNull but is null");
} else {
this.gender = gender;
this.username = username;
}
}
}
@NoArgsConstructorConsulte el código fuente para obtener una explicación detallada de la configuración de parámetros.
3、@AllArgsConstructor
@AllArgsConstructor se usa en una clase. Esta anotación puede generar un constructor con parámetros completos y no genera un constructor sin parámetros de forma predeterminada.
Sin embargo, debe tenerse en cuenta que los parámetros completos mencionados aquí no incluyen los campos que han sido inicializados y modificados por la palabra clave final, porque una vez que la palabra clave final modifica un campo y se le asigna un valor, no se puede modificar, como se muestra a continuación. :
/**
* 编译前代码
*/
@RequiredArgsConstructor
public class UserInfo() {
private final String gender;
private final Integer age = 18;
private String username;
private String password;
}
/**
* 编译后代码
*/
public class UserInfo() {
private final String gender;
private final Integer age = 18;
private String username;
private String password;
public User(String gender, String username, String password) {
this.gender = gender;
this.username = username;
this.password = password;
}
}
@NoArgsConstructorConsulte el código fuente para obtener una explicación detallada de la configuración de parámetros.
3. @Datos
La anotación @Data contiene @Getter@Setter y tiene métodos como toString(), equals(), canEqual(), etc.
四, @Builder, @Singular
@Constructor
En los escenarios de uso diario de lombok, siempre nos encontraremos con la situación en la que el objeto contiene una colección. En este caso, necesitamos usar el método set para asignar el valor a la colección en el objeto como otros atributos:
@Data
@Builder
class Student{
private String name;
private List<String> skills;
}
Análisis del código fuente del constructor:
public static class StudentBuilder {
// 省略其他部分
public Student.StudentBuilder skills(List<String> skills) {
this.skills = skills;
return this;
}
}
No se puede decir que esta forma de inicializar las propiedades del conjunto sea incorrecta, pero aún no es lo suficientemente fácil de usar. Cuando construimos un conjunto, principalmente le agregamos elementos, entonces, ¿hay alguna manera de agregar elementos específicamente a este conjunto? Y al mismo tiempo, en cuanto a la creación de instancias de una colección oculta dentro del código, la respuesta es sí. Esta es la función de @Singular que se presenta a continuación.
@Singular
/**
* 编译前代码
*/
@Builder
class Student{
private String name;
@Singular
private List<String> skills;
}
/**
* 编译后代码
*/
class Student {
private String name;
private List<String> skills;
Student(String name, List<String> skills) {
this.name = name;
this.skills = skills;
}
public static StudentBuilder builder() {
return new StudentBuilder();
}
public static class StudentBuilder {
private String name;
private ArrayList<String> skills;
StudentBuilder() {
}
public StudentBuilder name(String name) {
this.name = name;
return this;
}
public StudentBuilder skill(String skill) {
if (this.skills == null) {
this.skills = new ArrayList();
}
this.skills.add(skill);
return this;
}
public StudentBuilder skills(Collection<? extends String> skills) {
if (skills == null) {
throw new NullPointerException("skills cannot be null");
} else {
if (this.skills == null) {
this.skills = new ArrayList();
}
this.skills.addAll(skills);
return this;
}
}
public StudentBuilder clearSkills() {
if (this.skills != null) {
this.skills.clear();
}
return this;
}
public Student build() {
List skills;
switch (this.skills == null ? 0 : this.skills.size()) {
case 0:
skills = Collections.emptyList();
break;
case 1:
skills = Collections.singletonList(this.skills.get(0));
break;
default:
skills = Collections.unmodifiableList(new ArrayList(this.skills));
}
return new Student(this.name, skills);
}
public String toString() {
return "Student.StudentBuilder(name=" + this.name + ", skills=" + this.skills + ")";
}
}
}
En comparación con el código anterior, después de agregar la anotación @Singular, lombok agregó un método skills() para agregar elementos a la colección. Cuando no especificamos el nombre del método, lombok derivará automáticamente el nombre del método según el inglés, como por ejemplo: habilidades -> habilidad, el nombre de la colección es: habilidades, luego eliminará el plural y la palabra restante es el nombre del método. Podemos personalizar el nombre del método @Singular ("addSkill"). Si se utiliza una denominación no estándar, se debe especificar el nombre del método.
Si hay algún error, ¡házmelo saber!
Al reimprimir o citar el contenido de este artículo, indique la fuente y el autor original: Juzu Qingzhong;