Java中如何避免多重if-else实现校验？代码优化咨询

嘿，我太懂你被一堆嵌套if-else缠得头疼的滋味了——这种代码不仅读起来费劲，后续改需求加字段更是要扒一层皮。针对你用org.json.simple.JSONObject做输入、要校验十多个字段的场景，我给你几个实用的优化思路，既能把校验逻辑收拢到一处，又能让代码清爽不少：

方案1：用校验器列表替代嵌套if-else #

这个思路核心是把每个字段的校验逻辑拆成独立的小单元，然后用一个列表统一管理，循环执行校验。完全没有嵌套，而且扩展性极强。

首先定义一个简单的校验函数接口：

@FunctionalInterface
interface FieldValidator {
    // 返回错误信息，null代表校验通过
    String validate(JSONObject input);
}

然后把每个字段的校验逻辑写成这个接口的实现，逐个加入列表：

// 可以把这个列表定义成类的成员变量，避免每次校验都重新创建
private static final List<FieldValidator> VALIDATORS = Arrays.asList(
    // 校验test字段
    input -> {
        String test = (String) input.get("test");
        if (test == null || test.trim().isEmpty()) {
            return "test字段不能为空";
        }
        if (test.length() > 50) {
            return "test字段长度不能超过50";
        }
        return null;
    },
    // 校验age字段
    input -> {
        Integer age = (Integer) input.get("age");
        if (age == null) {
            return "age字段不能为空";
        }
        if (age < 18 || age > 100) {
            return "age必须在18到100之间";
        }
        return null;
    },
    // 其他字段的校验逻辑依次添加...
);

最后写一个统一的校验入口函数，所有逻辑都在这里收拢：

public String validateRequest(JSONObject inputObj) {
    for (FieldValidator validator : VALIDATORS) {
        String errorMsg = validator.validate(inputObj);
        if (errorMsg != null) {
            return errorMsg; // 一旦有校验失败，直接返回错误信息
        }
    }
    return null; // 所有校验通过
}

以后要加新字段校验，只需要往VALIDATORS列表里加新的校验器就行，完全不用改主函数的逻辑。

方案2：结合Optional+Stream简化单字段多条件校验 #

如果不想定义额外接口，也可以用Java 8+的Optional来简化空值判断，再用Stream收集所有校验结果，找到第一个错误：

import java.util.Objects;
import java.util.Optional;
import java.util.stream.Stream;

public String validateRequest(JSONObject inputObj) {
    return Stream.of(
        validateTestField(inputObj),
        validateAgeField(inputObj),
        // 其他字段的校验方法...
    )
    .filter(Objects::nonNull)
    .findFirst()
    .orElse(null);
}

// 单独抽离test字段的校验逻辑
private String validateTestField(JSONObject input) {
    String test = (String) input.get("test");
    return Optional.ofNullable(test)
        .map(String::trim)
        .filter(t -> !t.isEmpty())
        .filter(t -> t.length() <= 50)
        .map(t -> null) // 校验通过返回null
        .orElseGet(() -> {
            if (test == null || test.trim().isEmpty()) {
                return "test字段不能为空";
            } else {
                return "test字段长度不能超过50";
            }
        });
}

// 单独抽离age字段的校验逻辑
private String validateAgeField(JSONObject input) {
    Integer age = (Integer) input.get("age");
    return Optional.ofNullable(age)
        .filter(a -> a >= 18 && a <= 100)
        .map(a -> null)
        .orElseGet(() -> 
            age == null ? "age字段不能为空" : "age必须在18到100之间"
        );
}

这个方案把每个字段的校验逻辑拆成私有方法，主函数只负责收集结果，同样没有嵌套if-else，代码可读性也不错。

方案3：用Bean Validation（适合字段多且允许转Bean的场景） #

如果你的项目可以引入额外依赖，并且愿意把JSONObject转换成Java Bean，那Bean Validation（JSR-380）会是最简洁的方案，用注解就能搞定所有校验规则。

首先定义一个对应请求字段的DTO类，用注解标记校验规则：

import javax.validation.constraints.*;

public class RequestDTO {
    @NotBlank(message = "test字段不能为空")
    @Size(max = 50, message = "test字段长度不能超过50")
    private String test;

    @NotNull(message = "age字段不能为空")
    @Min(value = 18, message = "age不能小于18")
    @Max(value = 100, message = "age不能大于100")
    private Integer age;

    // 其他字段+getter/setter
}

然后在校验函数里完成转换和校验：

import com.fasterxml.jackson.databind.ObjectMapper;
import javax.validation.*;
import java.util.Set;

public String validateRequest(JSONObject inputObj) {
    try {
        // 把JSONObject转成Java Bean
        ObjectMapper mapper = new ObjectMapper();
        RequestDTO dto = mapper.convertValue(inputObj, RequestDTO.class);

        // 初始化校验器
        ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
        Validator validator = factory.getValidator();
        Set<ConstraintViolation<RequestDTO>> violations = validator.validate(dto);

        // 返回第一个错误信息
        if (!violations.isEmpty()) {
            return violations.iterator().next().getMessage();
        }
        return null;
    } catch (Exception e) {
        return "请求格式错误";
    }
}

这个方案几乎不用写硬编码的校验逻辑，所有规则都靠注解配置，维护起来超级省心，适合字段数量多、校验规则复杂的场景。

最后小建议 #

如果不想引入额外依赖，优先选方案1，它的扩展性和可读性都拉满；如果喜欢更简洁的写法，方案2也很实用；字段特别多的话，方案3能帮你省大量代码。

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