Question

我有两个独立的实体：

public enum Rule implements Validatable, StringRepresentable{ 
     //...
}

和

public inteface Filter extends Validatable, StringRepresentable{
    //...
}

哪里

public inteface Validatable{
    public GenericValidator getValidator();
}

和

public interface StringRepresentable{
    public String getStringRepresentation();
}

GenericValidator是一个抽象类，有许多我不希望用户直接访问的子类。我该如何更好地处理这些事情？

我不明白何时创建像

这样的课程会更好

public class ValidatorFactory{
    public Validator getRuleValidator(Rule r){ ... }
    public Validator getFilterValidator(Filter f){ ... }
}

而不是如前所示实现Validatable接口。

无法解释某人如何做出正确的决定？什么潜在的情况需要执行FactoryMethod一个错误的决定以及什么时候真的很好？

UPD：

public interface Validator{
    public ErrorCode validate();
}

public abstract class GenericValidator implements Validator{
   //...
}

ErrorCode类封装了验证结果（null如果valiadtion完成了，则完成了。{/ p>

Answer 1

我在两个主要案例中使用这种模式：

A）构建对象并非易事 - 我不相信API的用户能够正确地执行它

B）还有更多的实现，我想自己选择合适的实现。

在这两种情况下，我想隐藏实现只是因为用户不知道使用哪一个和/或不知道如何正确构建它。

始终致力于为用户提供简单易用的解决方案。问自己这些问题：

API易于理解吗？
API是否易于使用？
这是万无一失的吗？（我必须努力滥用它）

Answer 2

单一责任原则

构建Validator是一个责任，过滤器或规则可能带有另一个责任。这意味着我们应该拆分它，通常我们这样做是在工厂模式中封装实例化逻辑。

另请注意，实现Validatable意味着是ValidatorFactory。我的答案是 - 结合两种解决方案：

public class FilterImpl implements Filter {
    private final Validator validator;

    public FilterImpl(Validator validator) {
        this.validator = validator;
    }

    @Override
    public getValidator() {
         return this.validator;
    }

    //...
}

public class FilterFactory {
    private final ValidatorFactory validatorFactory = new ValidatorFactory();

    public Filter createFilter() {
        return new FilterImpl(valdatorFactory.createFilterValidator());
    }
}

这称为依赖注入。

Answer 3

Validator接口可以如下所示：

public interface Validator {
   public int validate();
}

过滤器界面可能如下所示：

public interface Filter {
  public String getParameters();   // some related methods..
  public int currentLength();
  ....
}

规则界面：

public interface Rule {
  public String getRule();
}

FilterValidator可能如下所示：

public class FilterValidator implements Validator{

private Filter f;

public FilterValidator(Filter f){
    this.f = f;
}

@Override
public int validate() {
    // validate f and return errorcode
    String params = f.getParameters();
    int strLength = f.currentLength();
    .....

    return 0;
 }

}

创建工厂最好隐藏验证器的内部逻辑。

public class ValidatorFactory {

public Validator getRuleValidator(Rule r){
    return null;
}

public Validator getFilterValidator(Filter f){
    FilterValidator fv = new FilterValidator(f);
    return fv;
}
}

现在客户端会像这样调用这个事实：

public class ClientDemo {

  private class MyFilter implements Filter{

    private String filterInput;
    public MyFilter(String input){
        this.filterInput = input;
    }

    @Override
    public String getParameters() {
        return null;
    }

    @Override
    public int currentLength() {
        return this.filterInput.length();
    }

}

    public void testValidators(){

      ValidatorFactory factory = new ValidatorFactory();
      Validator v = factory.getFilterValidator(new MyFilter("filter string goes here..."));
      v.validate();
     }
 }
}

通过接口规则，过滤器，您可以强制执行您希望从客户端执行的行为。然后，客户端可以从工厂获取实例并将规则/过滤器实例传递给它进行验证。

使用FactoryMethod模式

3 个答案: