如何不使用setAccessible(true)通过反射访问类的私有字段？

针对你的RegisterRequest DTO私有字段非空校验需求，完全可以避开反射的field.setAccessible(true)操作，以下是几种更符合Java封装原则、更安全可靠的实现方式：

1. 为私有字段添加Getter方法，直接调用校验 #

Java封装的核心就是通过公共方法访问私有成员，这是最直接的解决方案：

首先给RegisterRequest添加Getter方法：

public class RegisterRequest {
    private String firstName;
    private String lastName;
    private String username;
    private String email;
    private String fieldOfStudy;
    private String password;

    // 生成所有字段的Getter方法
    public String getFirstName() { return firstName; }
    public String getLastName() { return lastName; }
    public String getUsername() { return username; }
    public String getEmail() { return email; }
    public String getFieldOfStudy() { return fieldOfStudy; }
    public String getPassword() { return password; }

    // 可选：添加Setter或全参构造器用于初始化字段
}

然后直接调用Getter进行非空校验：

public void validateRegisterRequest(RegisterRequest registerRequest) {
    if (registerRequest.getFirstName() == null) {
        throw new AccountException("Vul alle velden in.");
    }
    if (registerRequest.getLastName() == null) {
        throw new AccountException("Vul alle velden in.");
    }
    if (registerRequest.getUsername() == null) {
        throw new AccountException("Vul alle velden in.");
    }
    if (registerRequest.getEmail() == null) {
        throw new AccountException("Vul alle velden in.");
    }
    if (registerRequest.getFieldOfStudy() == null) {
        throw new AccountException("Vul alle velden in.");
    }
    if (registerRequest.getPassword() == null) {
        throw new AccountException("Vul alle velden in.");
    }
}

优势：完全符合Java封装规范，代码可读性强，无运行时安全风险，性能最优。

2. 使用Java Bean Validation（JSR-380）实现注解式校验 #

如果你的项目是Spring/Spring Boot等框架环境，推荐使用标准的Bean Validation规范，通过注解自动完成校验，无需手动编写判断逻辑：

首先在RegisterRequest的字段上添加@NotNull注解：

import jakarta.validation.constraints.NotNull;

public class RegisterRequest {
    @NotNull(message = "Vul alle velden in.")
    private String firstName;
    @NotNull(message = "Vul alle velden in.")
    private String lastName;
    @NotNull(message = "Vul alle velden in.")
    private String username;
    @NotNull(message = "Vul alle velden in.")
    private String email;
    @NotNull(message = "Vul alle velden in.")
    private String fieldOfStudy;
    @NotNull(message = "Vul alle velden in.")
    private String password;

    // 保留Getter方法（框架需要通过Getter访问字段）
}

然后通过Validator进行校验：

import jakarta.validation.Validation;
import jakarta.validation.Validator;
import jakarta.validation.ValidatorFactory;
import java.util.Set;

public void validateRegisterRequest(RegisterRequest registerRequest) {
    try (ValidatorFactory factory = Validation.buildDefaultValidatorFactory()) {
        Validator validator = factory.getValidator();
        Set<jakarta.validation.ConstraintViolation<RegisterRequest>> violations = validator.validate(registerRequest);
        if (!violations.isEmpty()) {
            throw new AccountException(violations.iterator().next().getMessage());
        }
    }
}

如果是Spring环境，还可以直接在控制器方法参数上添加@Valid注解，框架会自动完成校验并抛出异常，无需手动调用Validator。

优势：代码简洁，可复用性强，支持更复杂的校验规则（如邮箱格式、字符串长度等），符合Java EE标准。

3. 改用Java Record（Java 16+） #

如果你的项目使用Java 16及以上版本，可以用Record替代普通DTO类，Record会自动生成公共的访问方法（名称与字段名一致，不是getXxx格式），无需手动编写Getter：

public record RegisterRequest(
    String firstName,
    String lastName,
    String username,
    String email,
    String fieldOfStudy,
    String password
) {}

然后直接调用字段访问方法进行校验：

public void validateRegisterRequest(RegisterRequest registerRequest) {
    if (registerRequest.firstName() == null) {
        throw new AccountException("Vul alle velden in.");
    }
    // 其他字段校验逻辑类似
}

优势：代码极度简洁，自动实现不可变性，访问方法符合规范，无需手动维护Getter/Setter。

4. 在DTO内部封装校验逻辑 #

把校验逻辑直接放在RegisterRequest类内部，对外提供一个校验方法，封装性更好：

public class RegisterRequest {
    private String firstName;
    private String lastName;
    private String username;
    private String email;
    private String fieldOfStudy;
    private String password;

    // Getter方法

    public void validate() {
        if (firstName == null || lastName == null || username == null || email == null || fieldOfStudy == null || password == null) {
            throw new AccountException("Vul alle velden in.");
        }
    }
}

外部调用时只需：

registerRequest.validate();

优势：校验逻辑与DTO绑定，符合单一职责原则，外部调用简单。

为什么不推荐使用反射绕过访问性？ #

• 破坏Java封装原则：私有字段的设计初衷就是限制外部直接访问，反射绕过违背了这一设计理念。
• 安全风险：如果运行环境存在安全管理器，setAccessible(true)可能会被阻止，导致运行时异常。
• 性能开销：反射操作比直接方法调用慢得多，高频场景下会影响性能。
• 可读性差：反射代码逻辑不直观，后续维护难度大。

内容的提问来源于stack exchange，提问作者Elias