Question

这是我遇到的一般问题/问题。我想知道是否有人知道任何合适的设计模式或技术。

private ExternalObject personObject; 
private String name;
private int age;
private String address;
private String postCode;

public MyBuilderClass(ExternalObject obj)
     this.personObject=obj;
     build();
}

public build() {
    setName(personObject.getName());
    setAge(personObject.getAge());
    setAddress(personObject.getAddress());
    setPostCode(personObject.getPostCode());
    .
    .
    . many more setters
}

上面的类从队列中获取外部对象并构造MyBuilderClass对象。

如果所有字段都已设置为非空的非空值，则成功构建MyBuilderClass对象。

将会有许多MyBuilderClass对象无法构建，因为ExternalObject中缺少数据。

我的问题是，检测对象是否已正确构建的最佳方法是什么？

我可以检查set方法中的null值或空值并抛出异常。这种方法的问题是抛出异常是昂贵的，它会阻塞日志文件，因为会有很多实例无法构建对象;

我可以使用哪些其他方法？

Answer 1

如果我错了，请纠正我：你正试图找到一个检查某个对象是否有效的好方法，如果不是，请在不使用异常的情况下告诉客户端代码。

您可以尝试工厂方法：

private MyBuilderClass(ExternalObject obj)
     this.personObject=obj;
     build();
}

public static MyBuilderClass initWithExternalObject(ExternalObject obj) {
    // check obj's properties...
    if (obj.getSomeProperty() == null && ...) {
        //  invalid external object, so return null
        return null;
    } else {
        // valid
        MyBuilderClass builder = new MyBuilderClass(obj);
        return builder.build();
    }
}

现在您知道对象是否有效而不使用异常。您只需要检查initWithExternalObject返回的值是否为空。

Answer 2

在不例外的情况下，我不会抛出异常。因为构造函数不生成对象的唯一方法是抛出，所以不应该将验证延迟到构造函数。

如果构造函数的结果无效，我仍然会建议抛出构造函数，但在此之前应该进行验证，因此您甚至不会使用无效的ExternalObject调用构造函数。

如果您希望将其实现为静态方法boolean MyBuilderClass.validate(ExternalObject)，或者使用构建器模式进行此验证，则由您决定。

Answer 3

此类验证的另一种方法是使用java Annotations：

制作一个简单的注释课程，让我们说Validate：

@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@interface Validate {
boolean required() default true;
}

然后将您想要出现的字段注释为@Validate(required=true)：

class MyBuilderClass {
private ExternalObject externalObject;

@Validate(required=true)
private String name;

@Validate(required=false) /*since it's a primitive field*/
private int age;

@Validate(required=true)
private String address;

@Validate(required=true)
private String postCode;


MyBuilderClass(ExternalObject externalObject) {
    this.externalObject = externalObject;
    build();
}

public void build() {
    setName(personObject.getName());
    setAge(personObject.getAge());
    setAddress(personObject.getAddress());
    setPostCode(personObject.getPostCode());
}
//.
//.
//. many more setters

 }

然后在MyBuilderClass类中添加此方法，以检查您的Object是否构建正确：

public boolean isCorrectlyBuilt() throws IllegalAccessException {
   boolean retVal = true;
  for (Field f : getClass().getDeclaredFields()) {
    f.setAccessible(true);
    boolean isToBeChecked = f.isAnnotationPresent(Validate.class);
    if (isToBeChecked) {
        Validate validate = f.getAnnotation(Validate.class);
        if (validate.required()/*==true*/) {
            if (f.get(this) == null) {
                retVal = false;
                break;
                /* return false; */
            }
        }
    }
}
return retVal;
}

以下是使用示例：

 public static void main(String[] args) throws Exception {
  ExternalObject personObject = new ExternalObject();
  personObject.setAge(20);
  personObject.setName("Musta");
  personObject.setAddress("Home");
  personObject.setPostCode("123445678");

  MyBuilderClass myBuilderClass = new MyBuilderClass(personObject);
  System.out.println(myBuilderClass.isCorrectlyBuilt());

}

输出：true因为对象已正确构建。

这将允许您通过反射选择要在结构中的字段，而不会带来从基类继承的字段。

Answer 4

从我遇到的情况来看，您可以覆盖对象的equals方法并将其与有效的示例对象进行比较。它很脏，可能只在某些情况下起作用。

你的方法是我能想到的最好的方法。编写一个单独的方法或类，例如静态验证方法。你可以在任何地方重复使用它。

Answer 5

如前面的答案所示，在您尝试设置变量之后，应该添加以下两个选项。

使用反射检查是否有任何变量为空。（如评论中所述，这将检查此对象中的所有字段，但要小心任何超类中的字段。）

public boolean checkNull() throws IllegalAccessException {
    for (Field f : getClass().getDeclaredFields())
        if (f.get(this) != null)
            return false;
    return true;            
}

对每个变量执行空检查。

    boolean isValidObject = !Stream.of(name, age, ...).anyMatch(Objects::isNull);

Previous answer

检查对象是用Java

5 个答案: