Java 验证输入并相应地执行操作_Java_Validation_Design Patterns

Java 验证输入并相应地执行操作

java validation design-patterns

Java 验证输入并相应地执行操作,java,validation,design-patterns,Java,Validation,Design Patterns,我有两个过程，需要在几个字段上进行验证对于ProcessA类，我需要在几个字段上进行验证。基于这些字段，我将验证这个类对于ProcessB类，我需要在不同的字段上进行验证。如果这些字段有效，那么我将验证这个类我的两个进程都应该将genericord传递给Validator类，现在取决于它是ProcessA还是ProcessB，我的Validator类应该验证这些字段对于ProcessA，我需要在clientId，deviceId，payId上进行验证对于进程B，我需要在cross

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

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

我的两个进程都应该将

genericord

传递给

Validator

类，现在取决于它是

ProcessA

还是

ProcessB

，我的

Validator

类应该验证这些字段

对于ProcessA，我需要在
```
clientId
```
，
```
deviceId
```
，
```
payId
```
上进行验证
对于进程B，我需要在
```
crossId
```
，
```
maxId
```
，
```
minId
```
上进行验证

我可以让它在ProcessA中工作，但我不知道我的

验证程序类在ProcessB
字段验证中是什么样子的。混淆之处在于，Validator
类如何决定我需要在收到构造函数中的genericord
后立即验证ProcessA或ProcessB的字段。如果ProcessA
GenericRecord通过，则对ProcessA字段进行验证；如果ProcessB
GenericRecord通过，则对ProcessB字段进行验证
过程a

我可以将另一个参数processName
传递给Validator
类，它是一个字符串。我们可以用它来实现相应的字段验证吗。
如果您的流程类类型很少，我向您提出的第一个解决方案是可以接受的。

您可以有一个空构造函数，并且在构造函数之后调用的进程可以有一个init方法
只需保留默认构造函数（无需声明）：
在过程A中：
   Validator validation = new Validator();
   validation.initProcessA(payload);  

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中：
   Validator validation = new Validator();
   validation.initProcessB(payload);

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
      }

   ...
}

第一种解决方案有其局限性

如果您有依赖于流程
类的验证特定性，那么更好的解决方案是为每个流程使用不同的验证器类来分解规则，因为它更易于维护
例如，您可以：
public abstract class Validator<T extends Process>{

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

公共抽象类验证程序{
...
//常用和抽象方法
...
公共抽象布尔值是有效的（）；
}

进程A的验证程序A：
   Validator validation = new Validator();
   validation.initProcessA(payload);  

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

}

公共类验证器扩展验证器{
...
公共验证器A（通用记录有效负载）{
clientId=（字符串）DataUtils.parseRecord（有效负载，“clientId”）；
deviceId=（字符串）DataUtils.parseRecord（有效负载，“deviceId”）；
payId=（字符串）DataUtils.parseRecord（有效负载，“payId”）；
}
公共布尔值isValid（）{
//特定于ProcessA的验证规则
}
...
}

流程B的验证器B：
   Validator validation = new Validator();
   validation.initProcessB(payload);

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
      }

   ...
}

公共类验证器B扩展验证器{
...
公共验证器B（通用记录有效负载）{
crossId=（字符串）DataUtils.parseRecord（有效负载，“crossId”）；
maxId=（字符串）DataUtils.parseRecord（有效负载，“maxId”）；
minId=（字符串）DataUtils.parseRecord（有效负载，“minId”）；
}
公共布尔值isValid（）{
//特定于ProcessB的验证规则
}
...
}
对于第一个解决方案，我的isValid方法看起来如何？我的意思是isValid，那么我还需要知道我需要验证ProcessA或ProcessB的字段吗？在您的实际代码中，isValid（）
对于这两个进程都是通用的。如果不需要，我认为您应该遵循第二种解决方案，其中您有一个抽象的验证器
类和一个具体的验证器
类（按流程类型）。通过这种方式，您可以在每个具体的Validator
类中定义验证所需的特定性。isValid（）
对于这两个进程来说都是常见的，我的困惑是，假设我确实执行了initProcessB
，那么isValid方法如何知道它应该只验证ProcessB的字段呢。现在它只是验证ProcessA的字段。因此，如果我为processB初始化，我希望isValid只验证processB的字段，以便从我的processB代码中调用isValid，它只验证processB的字段。我的两个进程都没有公共字段验证，它们都不同。在本例中，isValid（）
根据进程具有不同的行为。因此，请遵循我之前评论中的建议。在我的回答中，我已经向您提供了更多关于第二种解决方案的详细信息。我同意您的看法：）这就是为什么，我在发布我的回答之前发布了第二种解决方案。也许，我以前会删除第一个解决方案：）