java - 验证输入并相应执行操作

Question

我有两个进程需要在几个字段上进行验证。

• 对于 ProcessA 类，我需要验证几个字段。基于这些字段我将验证这个类。
• 对于 ProcessB 类，我需要在不同的字段上进行验证。如果这些字段有效，那么我将验证此类。

我的两个进程都应该将 GenericRecord 传递给 Validator 类，现在取决于它是 ProcessA 还是 ProcessB ，我的 Validator 类应该验证这些字段。

• 对于 ProcessA，我需要验证 clientId、deviceId、payId。
• 对于 ProcessB，我需要验证 crossId、maxId、minId。

我能够使其适用于 ProcessA，但我很困惑我的 Validator 类将如何用于 ProcessB 字段验证。令人困惑的是，Validator 类在构造函数中接收到 GenericRecord 后如何决定我需要验证 ProcessA 或 ProcessB 的字段。如果通过了 ProcessA GenericRecord，则对 ProcessA 字段进行验证，或者如果通过了 ProcessB GenericRecord，则对 ProcessB 字段进行验证。

流程A

try {
  GenericRecordDomainDataDecoder decoder = new GenericRecordDomainDataDecoder(config);
  while (true) {
    ConsumerRecords<byte[], byte[]> records = consumer.poll(1000);
    for (ConsumerRecord<byte[], byte[]> record : records) {
      GenericRecord payload = decoder.decode(record.value());
      String processName = "processA";
      // validation logic
      Validator validation = new Validator(payload);
      if(!validation.isValid())
          continue;

      // some other code
    }
  }
} catch (Exception ex) {
  // logging error
}

流程B

try {
  GenericRecordDomainDataDecoder decoder = new GenericRecordDomainDataDecoder(config);
  while (true) {
    ConsumerRecords<byte[], byte[]> records = consumer.poll(1000);
    for (ConsumerRecord<byte[], byte[]> record : records) {
      GenericRecord payload = decoder.decode(record.value());
      String processName = "processB";
      // validation logic
      Validator validation = new Validator(payload);
      if(!validation.isValid())
          continue;

      // some other code
    }
  }
} catch (Exception ex) {
  // logging error
}

下面是我的 Validator 类，它现在仅适用于 ProcessA 验证。我添加了另一个构造函数，我知道它不起作用，但只是想展示我想为 ProcessB 做什么。然后我需要调用 isValid 方法来告诉我 ProcessB 的字段是否存在。

public class Validator {
  private String clientId, deviceId, payId;

  // for ProcessA
  public Validator(GenericRecord payload) {
    clientId = (String) DataUtils.parseRecord(payload, "clientId");
    deviceId = (String) DataUtils.parseRecord(payload, "deviceId");
    payId = (String) DataUtils.parseRecord(payload, "payId");
  }

  // for ProcessB, I know this doesn't work - just wanted to show the idea
  public Validator(GenericRecord payload) {
    crossId = (String) DataUtils.parseRecord(payload, "crossId");
    maxId = (String) DataUtils.parseRecord(payload, "maxId");
    minId = (String) DataUtils.parseRecord(payload, "minId");
  }

  // this is what I am calling for ProcessA
  public boolean isValid() {
    return isValidClientIdDeviceId() && isValidPayId();
  }

  private boolean isValidPayId() {
    if (payId == null) {
      logger.log("invalid payId.");
      return false;
    }
    return true;
  }

  private boolean isValidClientIdDeviceId() {
    if (clientId == null && deviceId == null) {
      logger.log("invalid clientId and deviceId.");
      return false;
    }
    return true;
  }

  // getters
}

我可以将另一个参数processName(它是一个字符串)传递给Validator类。我们可以用它来实现这一点来相应地验证字段吗？

Answer 1

如果您的 Process 类类型很少，我向您建议的第一个解决方案是可以接受的。

您可以有一个空的构造函数，并在构造函数之后调用 Process 并有一个 init 方法。

只需保留默认构造函数(不需要声明):

  public Validator() {   
  }

  // for ProcessA
  public initProcessA(GenericRecord payload) {
    clientId = (String) DataUtils.parseRecord(payload, "clientId");
    deviceId = (String) DataUtils.parseRecord(payload, "deviceId");
    payId = (String) DataUtils.parseRecord(payload, "payId");
  }

  // for ProcessB, 
  public void initProcessB(GenericRecord payload) {
    crossId = (String) DataUtils.parseRecord(payload, "crossId");
    maxId = (String) DataUtils.parseRecord(payload, "maxId");
    minId = (String) DataUtils.parseRecord(payload, "minId");
  }

进程A中:

   Validator validation = new Validator();
   validation.initProcessA(payload);  

进程B中:

   Validator validation = new Validator();
   validation.initProcessB(payload);

第一个解决方案有其局限性。
如果您的验证特性取决于 Process 类，更好的解决方案是为每个 Process 使用不同的 validator 类来分解规则，因为这样更易于维护。

例如，您可以:

public abstract class Validator<T extends Process>{

   ...
   // common and abstract methods    
   ...
   public abstract boolean isValid();
}

流程 A 的验证程序 A:

public class ValidatorA extends Validator<ProcessA>{
   ...
        public ValidatorA(GenericRecord payload){
           clientId = (String) DataUtils.parseRecord(payload, "clientId");
           deviceId = (String) DataUtils.parseRecord(payload, "deviceId");
           payId = (String) DataUtils.parseRecord(payload, "payId");
        }

       public  boolean isValid(){
           // validation rules specific to ProcessA
       }
    ...

}

流程 B 的验证程序 B:

public class ValidatorB extends Validator<ProcessB>{
   ...
      public ValidatorB(GenericRecord payload) {
         crossId = (String) DataUtils.parseRecord(payload, "crossId");
         maxId = (String) DataUtils.parseRecord(payload, "maxId");
         minId = (String) DataUtils.parseRecord(payload, "minId");
      }

      public  boolean isValid(){
          // validation rules specific to ProcessB
      }

   ...
}