本文正在参与「金石计划」

前言

项目中参数校验十分重要，它能够保护咱们应用程序的安全性和合法性。我想咱们一般的做法是像下面这样做的:

@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
}

这么做最大的优势就是简略直接，可是假如验证逻辑很杂乱，会导致这个类变得很巨大，而且上面是经过抛出反常来改动代码执行流程，这也是一种不引荐的做法。

那么有什么更好的参数校验的办法呢？本文就引荐一种经过职责链设计模式来高雅地完成参数的校验功能，咱们经过一个用户注册的比方来讲明白怎么完成。

  • 有用的注册数据——姓名、姓氏、电子邮件、用户名和暗码。
  • 用户名有必要是仅有的。
  • 电子邮件有必要是仅有的。

界说用户注册和验证结果类

  1. 界说一个SignUpCommand类用来接受用户注册的属性信息。而且运用 @Value 注解让这个类不可变。
import lombok.Value;
import javax.validation.constraints.*;
@Value
public class SignUpCommand {
    @Min(2)
    @Max(40)
    @NotBlank
    private final String firstName;
    @Min(2)
    @Max(40)
    @NotBlank
    private final String lastName;
    @Min(2)
    @Max(40)
    @NotBlank
    private final String username;
    @NotBlank
    @Size(max = 60)
    @Email
    private final String email;
    @NotBlank
    @Size(min = 6, max = 20)
    private final String rawPassword;
  • 运用javax.validation中的注解如@NotBlank、@Size来验证用户注册信息是否有用。
  • 运用lombok的注解@Value，由于我期望指令对象是不可变的。注册用户的数据应与注册表中填写的数据相同。
  1. 界说存储验证结果类ValidationResult，如下所示：
@Value
public class ValidationResult {
    private final boolean isValid;
    private final String errorMsg;
    public static ValidationResult valid() {
        return new ValidationResult(true, null);
    }
    public static ValidationResult invalid(String errorMsg) {
        return new ValidationResult(false, errorMsg);
    }
    public boolean notValid() {
        return !isValid;
    }
}
  • 在我看来，这是一种十分便利的办法回来类型，而且比抛出带有验证消息的反常要好。
  1. 既然是职责链，还需要界说一个“链”类ValidationStep，它是这些验证进程的超类，咱们期望将它们彼此“链接”起来。
public abstract class ValidationStep<T> {
    private ValidationStep<T> next;
    public ValidationStep<T> linkWith(ValidationStep<T> next) {
        if (this.next == null) {
            this.next = next;
            return this;
        }
        ValidationStep<T> lastStep = this.next;
        while (lastStep.next != null) {
            lastStep = lastStep.next;
        }
        lastStep.next = next;
        return this;
    }
    public abstract ValidationResult validate(T toValidate);
    protected ValidationResult checkNext(T toValidate) {
        if (next == null) {
            return ValidationResult.valid();
        }
        return next.validate(toValidate);
    }
}

中心验证逻辑

现在咱们开端进行参数校验的中心逻辑，也就是怎么把上面界说的类给串联起来。

  1. 咱们界说一个用于注册验证的接口类SignUpValidationService 
public interface SignUpValidationService {
    ValidationResult validate(SignUpCommand command);
}
  1. 现在咱们能够运用上面界说的类和职责链模式来轻松的完成，代码如下：
import lombok.AllArgsConstructor;
import org.springframework.stereotype.Service;
import javax.validation.ConstraintViolation;
import javax.validation.Validation;
import javax.validation.Validator;
import javax.validation.ValidatorFactory;
import java.util.Set;
@Service
@AllArgsConstructor
public class DefaultSignUpValidationService implements SignUpValidationService {
    private final UserRepository userRepository;
    @Override
    public ValidationResult validate(SignUpCommand command) {
        return new CommandConstraintsValidationStep()
                .linkWith(new UsernameDuplicationValidationStep(userRepository))
                .linkWith(new EmailDuplicationValidationStep(userRepository))
                .validate(command);
    }
    private static class CommandConstraintsValidationStep extends ValidationStep<SignUpCommand> {
        @Override
        public ValidationResult validate(SignUpCommand command) {
            try (ValidatorFactory validatorFactory = Validation.buildDefaultValidatorFactory()) {
                final Validator validator = validatorFactory.getValidator();
                final Set<ConstraintViolation<SignUpCommand>> constraintsViolations = validator.validate(command);
                if (!constraintsViolations.isEmpty()) {
                    return ValidationResult.invalid(constraintsViolations.iterator().next().getMessage());
                }
            }
            return checkNext(command);
        }
    }
    @AllArgsConstructor
    private static class UsernameDuplicationValidationStep extends ValidationStep<SignUpCommand> {
        private final UserRepository userRepository;
        @Override
        public ValidationResult validate(SignUpCommand command) {
            if (userRepository.findByUsername(command.getUsername()).isPresent()) {
                return ValidationResult.invalid(String.format("Username [%s] is already taken", command.getUsername()));
            }
            return checkNext(command);
        }
    }
    @AllArgsConstructor
    private static class EmailDuplicationValidationStep extends ValidationStep<SignUpCommand> {
        private final UserRepository userRepository;
        @Override
        public ValidationResult validate(SignUpCommand command) {
            if (userRepository.findByEmail(command.getEmail()).isPresent()) {
                return ValidationResult.invalid(String.format("Email [%s] is already taken", command.getEmail()));
            }
            return checkNext(command);
        }
    }
}
  • validate办法是中心办法，其间调用linkWith办法组装参数的链式校验器，其间触及多个验证类，先做根底验证，假如经过的话，去验证用户名是否重复，假如也经过的话，去验证Email是否重复。
  • CommandConstraintsValidationStep类，此进程是一个根底验证，所有的javax validation annotation都会被验证，比方是否为空，Email格局是否正确等等。这十分便利，咱们不用自己编写这些验证器。假如一个对象是有用的，那么调用checkNext办法让流程进入下一步，checkNext，假如不是，ValidationResult 将立即回来。
  • UsernameDuplicationValidationStep类，此进程验证用户名是否重复，主要需要去查数据库了。假如是，那么将立即回来无效的ValidationResult，否则的话持续往后走，去验证下一步。
  • EmailDuplicationValidationStep 类，电子邮件重复验证。由于没有下一步，假如电子邮件是仅有的，则将回来ValidationResult.valid()。

总结

上面就是经过职责链模式来完成咱们参数校验的完整进程了，你学会了吗?这种办法能够高雅的将验证逻辑拆分到单独的类中，假如添加新的验证逻辑，只需要添加新的类，然后组装到“校验链”中。可是在我看来，这比较适合于用于校验相对杂乱的场景，假如仅仅简略的校验就彻底没必要这么做了，反而会添加代码的杂乱度。

欢迎关注个人大众号【JAVA旭阳】交流学习