使用工厂方法模式

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 是一个抽象 class 有许多子 classes 我不希望用户直接访问。我应该如何更好地处理这些事情？

我不明白什么时候创建一个 class 赞

比较好

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

而不是像我之前展示的那样实现 Validatable 接口。

有人不能解释一下我怎样才能做出正确的决定吗？什么潜在情况需要实施 FactoryMethod 一个糟糕的决定，什么时候才是真正好的决定？

更新：

public interface Validator{
    public ErrorCode validate();
}

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

ErrorCode class 封装了验证结果（null 如果验证成功完成）。

Answer 1

我在两种主要情况下使用此模式：

A) 对象的构建并非微不足道 - 我不相信 API 的用户能够正确地完成它

B)实现比较多，想自己选一个合适的

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

始终以简单易用为目标。问自己这些问题：

API容易理解吗？
API easy/fun 可以用吗？
万无一失吗？（我必须非常努力才能滥用它）

Answer 2

单一职责原则

Validator 的构造是一种责任，Filter 或Rule 可能承担另一种责任。这意味着我们应该拆分它，通常我们这样做是将实例化逻辑封装在工厂模式中。

另请注意，实现 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

验证器界面可能如下所示：

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();
     }
 }
}

通过接口 Rule、Filter，您可以从客户端强制执行您希望的行为。然后客户端可以从工厂获取实例并将 rule/filter 个实例传递给它进行验证。

使用工厂方法模式

Using FactoryMethod pattern

java

factory