1、使用责任链+ Builder模式优雅的校验参数

1、项目中参数校验

项目中参数校验十分重要，它可以保护我们应用程序的安全性和合法性。这篇文章主要介绍了如何使用责任链默认优雅地进行参数校验，需要的可以参考一下。

2、前言

项目中参数校验十分重要，它可以保护我们应用程序的安全性和合法性。我想大家通常的做法是像下面这样做的:

@Override
public void validate(SignUpCommand command) {
    validateCommand(command); // will throw an exception if command is not valid
    validateUsername(command.getUsername()); // will throw an exception if username is duplicated
    validateEmail(commend.getEmail()); // will throw an exception if email is duplicated
}

这么做最大的优势就是简单直接，但是如果验证逻辑很复杂，比如excel导入数据，每个字段值都需要校验，这会导致这个类变得很庞大，而且上面是通过抛出异常来改变代码执行流程，这也是一种不推荐的做法。

那么有什么更好的参数校验的方式呢？本文就推荐一种通过责任链设计模式来优雅地实现参数的校验功能，我们通过一个用户注册的例子来讲明白如何实现。

• 有效的注册数据——名字、姓氏、电子邮件、用户名和密码。
• 用户名必须是唯一的。
• 电子邮件必须是唯一的。

3、使用责任链模式校验

1.定义一个LoginParam类用来接受用户注册的属性信息。

@Data
public class LoginParam {

    @Min(2)
    @Max(value = 40,message = "1")
    @NotBlank(message = "firstName")
    private String firstName;

    @Min(2)
    @Max(value = 40,message = "2")
    @NotBlank(message = "lastName")
    private String lastName;

    @Min(2)
    @Max(value = 40,message = "3")
    @NotBlank(message = "username")
    private String username;

    @NotBlank(message = "email")
    @Size(max = 60,message = "1")
    @Email
    private String email;

    @NotBlank(message = "rawPassword")
    @Size(min = 6, max = 20)
    private String rawPassword;

}

• 使用javax.validation中的注解如@NotBlank、@Size来验证用户注册信息是否有效。
• 使用lombok的注解@Data，生成getter和setter方法。注册用户的数据应与注册表中填写的数据相同。

2.定义验证结果类

定义验证结果类ValidationResult，如下所示：

@Data
@AllArgsConstructor
public class ValidationResult {
    private boolean isSuccess;
    private String errorMsg;

    public static ValidationResult success() {
        return new ValidationResult(true, null);
    }

    public static ValidationResult fail(String errorMsg) {
        return new ValidationResult(false, errorMsg);
    }

    public boolean existFail() {
        return !isSuccess;
    }

}

在我看来，这是一种非常方便的方法返回类型，并且比抛出带有验证消息的异常要好。

3. 责任链超类

既然是责任链，还需要定义一个“链”类ValidatorService，它是这些验证步骤的超类，我们希望将它们相互“链接”起来。里面有个validate方法，需要子类实现其具体的校验逻辑。

public abstract class ValidatorService<T> {

    private ValidatorService<T> next;

    private void next(ValidatorService next) {
        this.next = next;
    }

    // 构建责任链的Builder
    public static class Builder<T> {

        private ValidatorService<T> head;
        private ValidatorService<T> tail;

        public Builder<T> linkWith(ValidatorService<T> validator) {
            // 第一次设置head和tail，后面head不再改变，只是不断的扩展tail
            if (this.head == null) {
                this.head = this.tail = validator;
                return this;
            }
            // 不断扩展tail
            this.tail.next(validator);
            this.tail = validator;
            return this;
        }

        public ValidatorService<T> build() {
            return this.head;

        }
    }

    public abstract ValidationResult validate(T toValidate);

    protected ValidationResult checkNext(T toValidate) {
        return next == null ? ValidationResult.success() : next.validate(toValidate);
    }

}

4、核心验证逻辑

现在我们开始进行参数校验的核心逻辑，也就是如何把上面定义的类给串联起来。

1. 具体业务类

现在我们可以使用上面定义的类和责任链模式来轻松的实现，代码如下：

@Service
@AllArgsConstructor
public class CheckXLoginParam {

    private final UserRepository userRepository;

    public ValidationResult validate(LoginParam param) {
        return new ValidatorService.Builder().
                linkWith(new ConstraintsValidator()).
                linkWith(new UserNameValidator(userRepository)).
                linkWith(new EmailValidator(userRepository)).
                build().validate(param);
    }

    private static class ConstraintsValidator extends ValidatorService<LoginParam> {

        @Override
        public ValidationResult validate(LoginParam param) {
            try (ValidatorFactory validatorFactory = Validation.buildDefaultValidatorFactory()) {
                final Validator validator = validatorFactory.getValidator();
                final Set<ConstraintViolation<LoginParam>> constraintsViolations = validator.validate(param);

                if (!constraintsViolations.isEmpty()) {
                    return ValidationResult.fail(constraintsViolations.iterator().next().getMessage());
                }
            }

            return checkNext(param);
        }
    }

    @AllArgsConstructor
    private static class UserNameValidator extends ValidatorService<LoginParam> {

        private final UserRepository userRepository;

        @Override
        public ValidationResult validate(LoginParam param) {
            if (userRepository.findByUsername(param.getUsername())) {
                return ValidationResult.fail(String.format("Username [%s] is already taken", param.getUsername()));
            }
            return checkNext(param);
        }
    }

    @AllArgsConstructor
    private static class EmailValidator extends ValidatorService<LoginParam> {

        private final UserRepository userRepository;

        @Override
        public ValidationResult validate(LoginParam param) {
            if (userRepository.findByEmail(param.getEmail())) {
                return ValidationResult.fail(String.format("Email [%s] is already taken", param.getEmail()));
            }
            return checkNext(param);
        }
    }
}

• validate方法是核心方法，其中调用linkWith方法组装参数的链式校验器，其中涉及多个验证类，先做基础验证，如果通过的话，去验证用户名是否重复，如果也通过的话，去验证Email是否重复。
• ConstraintsValidator类，此步骤是一个基础验证，所有的javax validation annotation都会被验证，比如是否为空，Email格式是否正确等等。这非常方便，我们不必自己编写这些验证器。如果一个对象是有效的，那么调用checkNext方法让流程进入下一步，checkNext，如果不是，ValidationResult 将立即返回。
• UserNameValidator类，此步骤验证用户名是否重复，主要需要去查数据库了。如果是，那么将立即返回无效的ValidationResult，否则的话继续往后走，去验证下一步。
• EmailValidator 类，电子邮件重复验证。因为没有下一步，如果电子邮件是唯一的，则将返回ValidationResult.success()。

2、验证类

@RestController
public class Client {

    @Autowired
    private CheckXLoginParam checkXLoginParam;

    @GetMapping("test")
    public ValidationResult test() {
        LoginParam param = new LoginParam();
        param.setUsername("zht");
        param.setEmail("zht@qq.com");
        param.setLastName("san");
        param.setFirstName("zhang");
        param.setRawPassword("jkjkfalkjfalj");
        return checkXLoginParam.validate(param);
    }
}

5、总结

上面就是通过责任链模式来实现我们参数校验的完整过程了，你学会了吗?这种方式可以优雅的将验证逻辑拆分到单独的类中，如果添加新的验证逻辑，只需要添加新的类，然后组装到“校验链”中。但是在我看来，这比较适合于用于校验相对复杂的场景，如果只是简单的校验就完全没必要这么做了，反而会增加代码的复杂度。

6、优化

如果有通用的校验，则可单独拆出来，放到一个单独的类中去。