Java Lombok：让你的代码更简洁优雅

前言

在 Java 开发中，我们经常需要编写大量的样板代码（boilerplate code），比如 getter、setter、toString、equals、hashCode 等方法。这些代码虽然必要，但写起来繁琐且容易出错。Lombok 就是为了解决这个问题而生的一个优秀的 Java 库。

什么是 Lombok？

Lombok 是一个 Java 库，通过注解的方式，在编译时自动生成常用的方法，从而减少样板代码的编写。它可以让你的代码更加简洁、易读，同时减少出错的可能性。

为什么要使用 Lombok？

传统方式的痛点

让我们先看一个传统的 Java 实体类：

public class User {
    private Long id;
    private String username;
    private String email;
    private Integer age;

    public User() {}

    public User(Long id, String username, String email, Integer age) {
        this.id = id;
        this.username = username;
        this.email = email;
        this.age = age;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public Integer getAge() {
        return age;
    }

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

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

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

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", email='" + email + '\'' +
                ", age=" + age +
                '}';
    }
}

这个简单的实体类就有 70+ 行代码，而真正有意义的只有 4 个字段！

使用 Lombok 后

import lombok.Data;
import lombok.AllArgsConstructor;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    private Long id;
    private String username;
    private String email;
    private Integer age;
}

仅仅 10 行代码就实现了同样的功能！这就是 Lombok 的魅力。

Lombok 的安装和配置

Maven 依赖

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.30</version>
    <scope>provided</scope>
</dependency>

Gradle 依赖

dependencies {
    compileOnly 'org.projectlombok:lombok:1.18.30'
    annotationProcessor 'org.projectlombok:lombok:1.18.30'
}

IDE 插件安装

• IntelliJ IDEA: 安装 Lombok Plugin
• Eclipse: 下载 lombok.jar 并运行安装程序
• VS Code: 安装 Language Support for Java 扩展

常用注解详解

1. @Getter 和 @Setter

自动生成 getter 和 setter 方法。

import lombok.Getter;
import lombok.Setter;

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

    @Getter @Setter
    private Double price;

    @Getter
    private String id; // 只生成 getter，不生成 setter
}

使用场景: 当你只需要部分字段的 getter/setter 时，或者想要精确控制访问权限时。

2. @ToString

自动生成 toString 方法。

import lombok.ToString;

@ToString
public class Order {
    private String orderId;
    private String customerName;
    private Double amount;

    @ToString.Exclude
    private String internalNotes; // 排除敏感信息
}

// 生成的 toString 方法类似于：
// Order(orderId=ORD001, customerName=张三, amount=99.99)

高级用法:

@ToString(includeFieldNames = false) // 不包含字段名
@ToString(callSuper = true) // 包含父类的 toString
@ToString(onlyExplicitlyIncluded = true) // 只包含标记的字段
public class AdvancedOrder {
    @ToString.Include
    private String orderId;

    private String secretKey; // 不会包含在 toString 中
}

3. @EqualsAndHashCode

自动生成 equals 和 hashCode 方法。

import lombok.EqualsAndHashCode;

@EqualsAndHashCode
public class Customer {
    private Long id;
    private String email;
    private String name;

    @EqualsAndHashCode.Exclude
    private Date lastLoginTime; // 排除不参与比较的字段
}

使用场景: 在集合操作、缓存键值对比时非常有用。

4. @Data

这是最常用的注解，相当于 @Getter + @Setter + @ToString + @EqualsAndHashCode + @RequiredArgsConstructor 的组合。

import lombok.Data;

@Data
public class Employee {
    private final Long id; // final 字段会包含在构造函数中
    private String name;
    private String department;
    private Double salary;
}

5. 构造函数注解

import lombok.*;

@NoArgsConstructor  // 无参构造函数
@AllArgsConstructor // 全参构造函数
@RequiredArgsConstructor // 必需参数构造函数（final 字段和 @NonNull 字段）
public class Book {
    private final String isbn; // 必需参数

    @NonNull
    private String title; // 必需参数

    private String author;
    private Double price;
}

6. @Builder

实现建造者模式。

import lombok.Builder;
import lombok.Data;

@Data
@Builder
public class ApiResponse {
    private Integer code;
    private String message;
    private Object data;
    private Long timestamp;
}

// 使用方式
ApiResponse response = ApiResponse.builder()
    .code(200)
    .message("操作成功")
    .data(userList)
    .timestamp(System.currentTimeMillis())
    .build();

使用场景: 当对象有很多可选参数时，Builder 模式比构造函数更清晰。

7. @Slf4j

自动生成日志对象。

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class UserService {

    public void createUser(User user) {
        log.info("开始创建用户: {}", user.getUsername());

        try {
            // 业务逻辑
            log.debug("用户创建成功: {}", user);
        } catch (Exception e) {
            log.error("用户创建失败", e);
            throw e;
        }
    }
}

其他日志注解:

• @Log4j2: 生成 Log4j2 日志对象
• @CommonsLog: 生成 Apache Commons Logging 对象

8. @Value

创建不可变对象。

import lombok.Value;

@Value
public class Point {
    int x;
    int y;
}

// 等价于：
// - 所有字段都是 private final
// - 生成全参构造函数
// - 生成 getter（没有 setter）
// - 生成 equals、hashCode、toString

9. @NonNull

空值检查。

import lombok.NonNull;

public class EmailService {

    public void sendEmail(@NonNull String recipient, @NonNull String subject, String content) {
        // Lombok 会自动生成空值检查代码
        // if (recipient == null) throw new NullPointerException("recipient is marked non-null but is null");

        // 发送邮件的逻辑
    }
}

实际应用场景

场景1: 数据传输对象（DTO）

import lombok.Data;
import lombok.Builder;

@Data
@Builder
public class UserRegistrationRequest {
    private String username;
    private String email;
    private String password;
    private String confirmPassword;
    private Integer age;
    private String phoneNumber;
}

@Data
public class UserRegistrationResponse {
    private Boolean success;
    private String message;
    private Long userId;
    private String token;
}

场景2: 实体类

import lombok.*;
import javax.persistence.*;

@Entity
@Table(name = "users")
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class UserEntity {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(unique = true, nullable = false)
    private String username;

    @Column(nullable = false)
    private String email;

    @ToString.Exclude // 密码不应该出现在日志中
    @EqualsAndHashCode.Exclude // 密码不参与对象比较
    private String password;

    private Integer age;

    @CreationTimestamp
    private LocalDateTime createdAt;

    @UpdateTimestamp
    private LocalDateTime updatedAt;
}

场景3: 配置类

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Data
@Component
@ConfigurationProperties(prefix = "app.security")
public class SecurityConfig {
    private String jwtSecret;
    private Long jwtExpiration;
    private Integer maxLoginAttempts;
    private Boolean enableTwoFactor;
}

场景4: API 响应包装

import lombok.Data;
import lombok.Builder;

@Data
@Builder
public class ApiResult<T> {
    private Integer code;
    private String message;
    private T data;
    private Long timestamp;

    public static <T> ApiResult<T> success(T data) {
        return ApiResult.<T>builder()
            .code(200)
            .message("操作成功")
            .data(data)
            .timestamp(System.currentTimeMillis())
            .build();
    }

    public static <T> ApiResult<T> error(String message) {
        return ApiResult.<T>builder()
            .code(500)
            .message(message)
            .timestamp(System.currentTimeMillis())
            .build();
    }
}

最佳实践

1. 合理使用 @Data

虽然 @Data 很方便，但不是所有情况都适用：

// ✅ 好的使用方式：简单的数据类
@Data
public class UserDto {
    private String name;
    private String email;
}

// ❌ 不推荐：复杂的业务类
@Data // 不要在 Service 类上使用
public class UserService {
    private UserRepository userRepository;
    // ...
}

2. 注意继承关系

@Data
@EqualsAndHashCode(callSuper = true) // 重要：包含父类字段
public class AdminUser extends User {
    private String adminLevel;
}

3. 排除敏感字段

@Data
public class User {
    private String username;

    @ToString.Exclude
    @EqualsAndHashCode.Exclude
    private String password; // 密码不应该出现在日志或比较中
}

4. 使用 @Builder 的默认值

@Data
@Builder
public class EmailConfig {
    @Builder.Default
    private Integer timeout = 30000;

    @Builder.Default
    private Boolean enableSsl = true;

    private String host;
    private Integer port;
}

注意事项和限制

1. IDE 支持

确保你的 IDE 安装了 Lombok 插件，否则会出现编译错误。

2. 调试困难

由于代码是编译时生成的，调试时可能看不到具体的实现。

3. 团队协作

确保团队所有成员都了解 Lombok，并且开发环境都正确配置。

4. 版本兼容性

注意 Lombok 版本与 JDK 版本的兼容性，特别是使用新版本 JDK 时。

5. 性能考虑

虽然 Lombok 生成的代码通常是高效的，但在性能敏感的场景下，可能需要手动优化。

总结

Lombok 是一个优秀的 Java 库，它可以显著减少样板代码，提高开发效率。通过合理使用 Lombok 的各种注解，我们可以让代码更加简洁、易读、易维护。

主要优势:

• 减少样板代码
• 提高开发效率
• 降低出错概率
• 代码更加简洁

使用建议:

• 在数据类、DTO、实体类中大胆使用
• 注意排除敏感字段
• 合理处理继承关系
• 确保团队成员都熟悉 Lombok

记住，工具是为了让开发更高效，但不要过度依赖。在某些特殊场景下，手动编写代码可能是更好的选择。

---

本作品采用《CC 协议》，转载必须注明作者和本文链接