首页 > 软件编程 > Java > 详解Java如何使用责任链默认优雅地进行参数校验

详解Java如何使用责任链默认优雅地进行参数校验

福牛 3月 28, 2023 40 0

前言

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

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

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

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

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

定义用户注册和验证结果类

1.定义一个SignUpCommand类用来接受用户注册的属性信息。并且使用 @Value 注解让这个类不可变。

  1. import lombok.Value;
  2.  
  3. import Javax.validation.constraints.*;
  4.  
  5. @Value
  6. public class SignUpCommand {
  7.  
  8.      @Min(2)
  9.      @Max(40)
  10.      @NotBlank
  11.      private final String firstName;
  12.  
  13.      @Min(2)
  14.      @Max(40)
  15.      @NotBlank
  16.      private final String lastName;
  17.  
  18.      @Min(2)
  19.      @Max(40)
  20.      @NotBlank
  21.      private final String username;
  22.  
  23.      @NotBlank
  24.      @Size(max = 60)
  25.      @Email
  26.      private final String email;
  27.  
  28.      @NotBlank
  29.      @Size(min = 6, max = 20)
  30.      private final String rawpassword;
  • 使用javax.validation中的注解如@NotBlank、@Size来验证用户注册信息是否有效。
  • 使用lombok的注解@Value，因为我希望命令对象是不可变的。注册用户的数据应与注册表中填写的数据相同。

2.定义存储验证结果类ValidationResult，如下所示：

  1. @Value
  2. public class ValidationResult {
  3.      private final boolean isValid;
  4.      private final String errorMsg;
  5.  
  6.      public static ValidationResult valid() {
  7.          return new ValidationResult(true, null);
  8.      }
  9.  
  10.      public static ValidationResult invalid(String errorMsg) {
  11.          return new ValidationResult(false, errorMsg);
  12.      }
  13.  
  14.      public boolean notValid() {
  15.          return !isValid;
  16.      }
  17. }

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

3.既然是责任链，还需要定义一个“链”类ValidationStep，它是这些验证步骤的超类，我们希望将它们相互“链接”起来。

  1. public abstract class ValidationStep<T> {
  2.  
  3.      private ValidationStep<T> next;
  4.  
  5.      public ValidationStep<T> linkWith(ValidationStep<T> next) {
  6.          if (this.next == null) {
  7.              this.next = next;
  8.              return this;
  9.          }
  10.          ValidationStep<T> lastStep = this.next;
  11.          while (lastStep.next != null) {
  12.              lastStep = lastStep.next;
  13.          }
  14.          lastStep.next = next;
  15.          return this;
  16.      }
  17.  
  18.      public abstract ValidationResult validate(T toValidate);
  19.  
  20.      protected ValidationResult checkNext(T toValidate) {
  21.          if (next == null) {
  22.              return ValidationResult.valid();
  23.          }
  24.  
  25.          return next.validate(toValidate);
  26.      }
  27. }

核心验证逻辑

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

1.我们定义一个用于注册验证的接口类SignUpValidationService

  1. public interface SignUpValidationService {
  2.      ValidationResult validate(SignUpCommand command);
  3. }

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

  1. import lombok.AllArgsConstructor;
  2. import org.springframework.stereotype.Service;
  3.  
  4. import javax.validation.ConstraintViolation;
  5. import javax.validation.Validation;
  6. import javax.validation.Validator;
  7. import javax.validation.ValidatorFactory;
  8. import java.util.Set;
  9.  
  10. @Service
  11. @AllArgsConstructor
  12. public class DefaultSignUpValidationService implements SignUpValidationService {
  13.  
  14.      private final UserRepository userRepository;
  15.  
  16.      @Override
  17.      public ValidationResult validate(SignUpCommand command) {
  18.          return new CommandConstraintsValidationStep()
  19.                  .linkWith(new UsernameDuplicationValidationStep(userRepository))
  20.                  .linkWith(new EmailDuplicationValidationStep(userRepository))
  21.                  .validate(command);
  22.      }
  23.  
  24.      private static class CommandConstraintsValidationStep extends ValidationStep<SignUpCommand> {
  25.  
  26.          @Override
  27.          public ValidationResult validate(SignUpCommand command) {
  28.              try (ValidatorFactory validatorFactory = Validation.buildDefaultValidatorFactory()) {
  29.                  final Validator validator = validatorFactory.getValidator();
  30.                  final Set<ConstraintViolation<SignUpCommand>> constraintsViolations = validator.validate(command);
  31.  
  32.                  if (!constraintsViolations.isEmpty()) {
  33.                      return ValidationResult.invalid(constraintsViolations.iterator().next().getMessage());
  34.                  }
  35.              }
  36.              return checkNext(command);
  37.          }
  38.      }
  39.  
  40.      @AllArgsConstructor
  41.      private static class UsernameDuplicationValidationStep extends ValidationStep<SignUpCommand> {
  42.  
  43.          private final UserRepository userRepository;
  44.  
  45.          @Override
  46.          public ValidationResult validate(SignUpCommand command) {
  47.              if (userRepository.findByUsername(command.getUsername()).isPresent()) {
  48.                  return ValidationResult.invalid(String.format(“Username [%s] is already taken”, command.getUsername()));
  49.              }
  50.              return checkNext(command);
  51.          }
  52.      }
  53.  
  54.      @AllArgsConstructor
  55.      private static class EmailDuplicationValidationStep extends ValidationStep<SignUpCommand> {
  56.  
  57.          private final UserRepository userRepository;
  58.  
  59.          @Override
  60.          public ValidationResult validate(SignUpCommand command) {
  61.              if (userRepository.findByEmail(command.getEmail()).isPresent()) {
  62.                  return ValidationResult.invalid(String.format(“Email [%s] is already taken”, command.getEmail()));
  63.              }
  64.              return checkNext(command);
  65.          }
  66.      }
  67. }
  • validate方法是核心方法，其中调用linkWith方法组装参数的链式校验器，其中涉及多个验证类，先做基础验证，如果通过的话，去验证用户名是否重复，如果也通过的话，去验证Email是否重复。
  • CommandConstraintsValidationStep类，此步骤是一个基础验证，所有的javax validation annotation都会被验证，比如是否为空，Email格式是否正确等等。这非常方便，我们不必自己编写这些验证器。如果一个对象是有效的，那么调用checkNext方法让流程进入下一步，checkNext，如果不是，ValidationResult 将立即返回。
  • UsernameDuplicationValidationStep类，此步骤验证用户名是否重复，主要需要去查数据库了。如果是，那么将立即返回无效的ValidationResult，否则的话继续往后走，去验证下一步。
  • EmailDuplicationValidationStep 类，电子邮件重复验证。因为没有下一步，如果电子邮件是唯一的，则将返回ValidationResult.valid()。

总结

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

到此这篇关于详解Java如何使用责任链默认优雅地进行参数校验的文章就介绍到这了,更多相关Java责任链实现参数校验内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！

标签

相关推荐

发表评论