使用FactoryMethod模式

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的succsfully完成).

Answer 1

单一责任原则

验证器的构建是一项职责，过滤器或规则可能承担另一项职责。这意味着我们应该将其拆分，通常我们会在工厂模式中封装实例化逻辑。

另请注意，实现 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());
    }
}

这称为依赖注入。