lombok 注解

原创已于 2024-10-14 16:05:32 修改 · 1.2k 阅读

10 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

收录于

Java基础

于 2024-10-14 15:59:26 首次发布

文章目录

@Data 注解在类上；提供类所有属性的 getting 和 setting 方法，此外还提供了equals、canEqual、hashCode、toString 方法
@Setter ：注解在属性上；为属性提供 setting 方法
@Setter ：注解在属性上；为属性提供 getting 方法
@Log4j ：注解在类上；为类提供一个属性名为log 的 log4j 日志对象
@NoArgsConstructor ：注解在类上；为类提供一个无参的构造方法
@AllArgsConstructor ：注解在类上；为类提供一个全参的构造方法
@Cleanup : 可以关闭流
@Builder ：被注解的类加个构造者模式
@Synchronized ：加个同步锁
@SneakyThrows : 等同于try/catch 捕获异常
@NonNull : 如果给参数加个这个注解参数为null会抛出空指针异常
@Value : 注解和@Data类似，区别在于它会把所有成员变量默认定义为private final修饰，并且不会生成set方法
@ToString：无需启动调试器即可查看您的字段，注解会自动重写对应的toStirng方法

@AllArgsConstructor @NoArgsConstructor @Data
使用lombok注解，目的和作用就在于不用再去写经常反复去写的（如Getter，Setter，Constructor等）一些代码了
@Data
使用这个注解，就不用再去手写Getter,Setter,equals,canEqual,hasCode,toString等方法了，注解后在编译时会自动加进去。
@AllArgsConstructor
使用后添加一个构造函数，该构造函数含有所有已声明字段属性参数
@NoArgsConstructor
使用后创建一个无参构造函数
注解@NoArgsConstructor表示在Java类中生成一个无参构造方法。通常情况下，当我们在一个Java类中定义了自定义的构造方法时，编译器会默认提供一个无参构造方法。但是，如果我们手动提供了一个有参构造方法，编译器就不会再自动生成无参构造方法。
使用@NoArgsConstructor注解可以告诉编译器，即使存在其他构造方法，也要为该类生成一个无参构造方法。这样，在使用该类创建对象时，就可以选择使用无参构造方法初始化对象。
@NoArgsConstructor注解通常用于实体类或JavaBean类，方便使用框架、序列化或反射等场景创建对象实例时的操作。

Lombok 常用注解详解

Lombok 是一个非常流行的 Java 库，它通过注解生成样板代码，减少代码冗余，使代码更加简洁。Lombok 通过修改字节码来生成代码，在编译时自动完成，使用时无需手动编写大量的 getter、setter、构造器、equals/hashCode、toString 等常用方法。

@Getter 和 @Setter

import lombok.Getter;
import lombok.Setter;

public class User {
    @Getter @Setter
    private String name;

    @Getter @Setter
    private int age;
}

上述代码会自动生成以下代码：

public String getName() {
    return this.name;
}

public void setName(String name) {
    this.name = name;
}

public int getAge() {
    return this.age;
}

public void setAge(int age) {
    this.age = age;
}

作用：自动为类的字段生成 getter 和 setter 方法。
使用场景：如果需要为类中的某个或多个字段生成 getter 和 setter 方法，使用该注解可以自动生成，不需要手动编写。

@ToString

import lombok.ToString;

@ToString
public class User {
    private String name;
    private int age;
}

生成的 toString() 方法类似于：
@Override
public String toString() {
return “User(name=” + this.name + “, age=” + this.age + “)”;
}
作用：自动生成 toString() 方法，打印对象的所有字段。
参数：
exclude：可以指定某些字段不包含在 toString 方法中。
callSuper：是否调用父类的 toString() 方法。
@EqualsAndHashCode
import lombok.EqualsAndHashCode;

@EqualsAndHashCode

public class User {
    private String name;
    private int age;
}

生成的 equals() 和 hashCode() 方法类似于：

@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    User user = (User) o;
    return age == user.age && Objects.equals(name, user.name);
}

@Override
public int hashCode() {
    return Objects.hash(name, age);
}

作用：自动生成 equals() 和 hashCode() 方法，默认使用所有字段进行比较。
参数：
exclude：可以指定某些字段不包含在 equals 和 hashCode 方法中。
callSuper：是否调用父类的 equals 和 hashCode() 方法。

@NoArgsConstructor

import lombok.NoArgsConstructor;

@NoArgsConstructor
public class User {
    private String name;
    private int age;
}

会生成如下无参构造器：
public User() {}
作用：自动生成无参构造器。

@AllArgsConstructor
import lombok.AllArgsConstructor;

@AllArgsConstructor
public class User {
    private String name;
    private int age;
}

生成的构造器为：
public User(String name, int age) {
this.name = name;
this.age = age;
}
作用：自动生成包含所有字段的构造器。
@RequiredArgsConstructor
import lombok.RequiredArgsConstructor;

@RequiredArgsConstructor
public class User {
private final String name;
private int age;
}
生成的构造器只包含 final 字段 name：
public User(String name) {
this.name = name;
}
作用：自动生成只包含 final 字段或标注了 @NonNull 字段的构造器。

@Builder

import lombok.Builder;

@Builder
public class User {
    private String name;
    private int age;
}

使用时：

User user = User.builder()
                .name("Alice")
                .age(25)
                .build();

作用：自动生成 Builder 模式，简化复杂对象的创建。
参数：
builderMethodName：自定义生成的构建器方法名（默认是 builder()）。
buildMethodName：自定义 build() 方法名。
toBuilder：生成 toBuilder() 方法，允许基于现有实例创建新实例。

@Data

import lombok.Data;

@Data
public class User {
    private String name;
    private int age;
}

作用：自动为类生成 getter、setter、toString、equals、hashCode、requiredArgsConstructor() 等常用方法，类似于同时加上了 @Getter、@Setter、@ToString、@EqualsAndHashCode 和 @RequiredArgsConstructor。
使用场景：适合 POJO 类，自动生成大多数样板代码。

@Value

import lombok.Value;

@Value
public class User {
    String name;
    int age;
}

生成的类类似于：

public final class User {
    private final String name;
    private final int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // getter、equals、hashCode、toString 省略
}

作用：生成不可变类。相当于给所有字段加上 final 并为类加上 @AllArgsConstructor、@Getter、@EqualsAndHashCode、@ToString。
使用场景：适合创建值对象，值对象通常是不可变的。

@Synchronized

import lombok.Synchronized;

public class Counter {
    private int count = 0;

    @Synchronized
    public void increment() {
        count++;
    }
}

作用：代替 synchronized 关键字，避免手动处理同步锁。
参数：
value：可以指定同步的锁对象（默认为 this）。

@Slf4j

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class LogExample {
    public void logSomething() {
        log.info("Logging with Slf4j");
    }
}

作用：自动生成 Slf4j 日志记录器，减少手动定义 Logger 对象的代码。
使用场景：任何需要使用日志记录器的类中都可以使用。

@Cleanup
import lombok.Cleanup;

public class FileReaderExample {
    public void readFile(String path) throws IOException {
        @Cleanup InputStream in = new FileInputStream(path);
        // 使用 InputStream
    }
}

作用：自动调用资源的 close() 方法，常用于自动关闭 IO 流。
使用场景：在使用需要关闭的资源时，如文件、数据库连接等。
总结
Lombok 提供的注解大大简化了样板代码的编写，常见的功能包括自动生成 getter、setter、构造器、equals、hashCode、toString 等。通过使用这些注解，你可以减少大量的冗余代码，使代码更为简洁、易读，提升开发效率。

package com.maxvision.basicinfo.dto;

import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.NoArgsConstructor;

import javax.validation.constraints.NotNull;

/**

@author lc
@date 2023/8/3
*/
@Data
@NoArgsConstructor
public class BaseQueryDTO {

/**
- 每页大小
  /
  @ApiModelProperty(“每页大小”)
  @NotNull
  private Integer pageSize = 10;
  /*
- 页码pageNum
- 0 10 20
  */
  @ApiModelProperty(“”)
  @NotNull
  private Integer offset = 0;
public Integer getPageSize() {
return pageSize;
}
}

Lombok @Builder 注解详解

关于Builder较为复杂一些，Builder的作用之一是为了解决在某个类有很多构造函数的情况，也省去写很多构造函数的麻烦，在设计模式中的思想是：用一个内部类去实例化一个对象，避免一个类出现过多构造函数，
@Data //生成getter,setter等函数
@AllArgsConstructor //生成全参数构造函数
@NoArgsConstructor//生成无参构造函数

@Builder
public class test1 {
    String name;
    String age;
    String

Lombok 的 @Builder 注解用于简化对象的构建过程，它可以帮助你实现 Builder 设计模式，使得对象的创建更加灵活、清晰且易于维护。Builder 模式特别适用于需要构建复杂对象或包含大量参数的类。使用 Lombok 的 @Builder 注解，可以自动生成代码而不需要手动编写冗长的构建器类。
Builder 模式简介
Builder 模式是一种创建对象的设计模式，它允许你分步骤构建对象，并且避免了构造方法参数过多导致的混乱。在传统的 Java 中，构建器通常是通过一个静态内部类实现的，该类有一系列的 setter 方法，用于设置构建对象的各个属性，最后调用 build() 方法返回最终对象。
Lombok @Builder 基本用法

基本示例
我们有一个 User 类：

import lombok.Builder;
import lombok.ToString;

@Builder
@ToString
public class User {
    private String name;
    private int age;
    private String email;
}

这里我们使用了 Lombok 的 @Builder 注解。Lombok 会自动生成一个 UserBuilder 静态内部类，并生成一组链式的构建方法，最终返回 User 对象。
创建对象
你可以这样使用 @Builder 生成的 UserBuilder 来构建 User 对象：

public class Main {
    public static void main(String[] args) {
        User user = User.builder()
                        .name("John Doe")
                        .age(30)
                        .email("john.doe@example.com")
                        .build();

        System.out.println(user);
    }
}

输出结果：
User(name=John Doe, age=30, email=john.doe@example.com)
工作原理
Lombok 自动为你生成了以下构建器类和方法：

public class User {
    private String name;
    private int age;
    private String email;

    // 构建器类
    public static class UserBuilder {
        private String name;
        private int age;
        private String email;

        public UserBuilder name(String name) {
            this.name = name;
            return this;
        }

        public UserBuilder age(int age) {
            this.age = age;
            return this;
        }

        public UserBuilder email(String email) {
            this.email = email;
            return this;
        }

        public User build() {
            return new User(name, age, email);
        }
    }

    // 构建器入口方法
    public static UserBuilder builder() {
        return new UserBuilder();
    }
}

结合 @AllArgsConstructor 和 @NoArgsConstructor
@Builder 通常和 @AllArgsConstructor、@NoArgsConstructor 一起使用，分别生成带参数的构造器和无参数构造器。

import lombok.Builder;
import lombok.AllArgsConstructor;
import lombok.NoArgsConstructor;
import lombok.ToString;

@Builder
@AllArgsConstructor
@NoArgsConstructor
@ToString
public class User {
    private String name;
    private int age;
    private String email;
}

Lombok 会生成如下代码：
一个全参构造函数 (@AllArgsConstructor)
一个无参构造函数 (@NoArgsConstructor)
一个 UserBuilder 静态类，用于构建对象
public User() {}

public User(String name, int age, String email) {
this.name = name;
this.age = age;
this.email = email;
}
3. 默认值
你可以在类属性中设置默认值，@Builder 会在没有显式设置该字段时使用这些默认值。

import lombok.Builder;
import lombok.ToString;

@Builder
@ToString
public class User {
    private String name;
    private int age;
    private String email = "default@example.com"; // 默认值
}
public class Main {
    public static void main(String[] args) {
        User user = User.builder()
                        .name("Alice")
                        .age(25)
                        .build();

        System.out.println(user);
    }
}

输出结果：
User(name=Alice, age=25, email=default@example.com)
4. 自定义构造逻辑
如果你需要在 build() 方法中加入一些自定义逻辑，可以通过自定义构建器类来实现：

import lombok.Builder;
import lombok.ToString;

@Builder
@ToString
public class User {
    private String name;
    private int age;
    private String email;

    // 自定义构建器类
    public static class UserBuilder {
        public User build() {
            // 在这里添加额外的构建逻辑
            if (age < 18) {
                throw new IllegalArgumentException("Age must be 18 or older.");
            }
            return new User(name, age, email);
        }
    }
}

带有继承的 @Builder 使用
对于有继承关系的类，@Builder 默认不支持继承。你需要在子类中重写构建器方法或使用 Lombok 的 @SuperBuilder 来支持继承。

import lombok.Builder;
import lombok.ToString;

@Builder
@ToString
public class Parent {
    private String parentName;
}

@Builder
@ToString(callSuper = true)
public class Child extends Parent {
    private String childName;
}

但推荐使用 Lombok 的 @SuperBuilder 以支持类继承。
6. 单独指定构建器属性
你可以通过 @Builder 指定构建器中只包含某些属性，而不包含全部属性。例如：

import lombok.Builder;
import lombok.ToString;

@Builder(builderMethodName = "customBuilder", buildMethodName = "customBuild")
@ToString
public class Product {
    private String name;
    private double price;
}
public class Main {
    public static void main(String[] args) {
        Product product = Product.customBuilder()
                                 .name("Laptop")
                                 .price(999.99)
                                 .customBuild();

        System.out.println(product);
    }
}

在这个例子中，我们自定义了构建器方法 customBuilder() 和 customBuild()，而不是默认的 builder() 和 build()。
总结
Lombok 的 @Builder 注解简化了 Java 中的 Builder 模式实现，提供了简洁的链式 API 来构建对象。通过 @Builder，可以：
避免繁琐的构建器类编写。
灵活地创建对象，特别适用于参数较多的类。
结合其他注解，如 @NoArgsConstructor 和 @AllArgsConstructor 提供更多功能。
通过自定义构建逻辑满足特殊需求。
@Builder 是开发中极为实用的工具，能够让代码更加简洁、清晰。

Lombok详解(日志记录和简化代码)

作用于类，生成对应的 log 对象，用于记录日志，共有七个注解：
@CommonsLog：org.apache.commons.logging.Log
@Log：java.util.logging.Logger
@JBossLog：org.jboss.logging.Logger
@Log4j：org.apache.log4j.Logger
@Log4j2：org.apache.logging.log4j.Logger
@Slf4j：org.slf4j.Logger
@XSlf4j：org.slf4j.ext.XLogger
在Lombok库中，日志注解用于简化在Java类中添加日志功能的操作。常见的日志注解有以下几种：

@Slf4j：在类上添加@Slf4j注解，会自动为该类生成一个名为"log"的Logger对象，用于输出日志信息。可以使用该Logger对象调用不同级别的日志输出方法，如log.debug、log.info等。
@Log：在类上添加@Log注解，会根据类的名称自动生成一个名为"log"的Logger对象，并在使用时直接使用该对象输出日志信息。
@CommonsLog：在类上添加@CommonsLog注解，会自动为该类生成一个名为"log"的Log对象，并在使用时直接使用该对象输出日志信息。这是基于Apache Commons Logging实现的日志注解。
@Log4j：在类上添加@Log4j注解，会自动为该类生成一个名为"log"的Log对象，并在使用时直接使用该对象输出日志信息。这是基于Log4j实现的日志注解。
使用这些日志注解可以避免手动创建和管理Logger对象，简化了日志输出的代码编写，提高了开发效率。同时，这些注解也使得日志的配置更加灵活，可以通过修改日志框架的配置文件来切换不同的日志输出方式。

标签

#Lombok