java - 使用工厂方法模式

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 接口(interface)。

没有人能解释一下我怎样才能做出正确的决定？哪些潜在情况要求实现 FactoryMethod 是一个错误的决定，何时才是真正好的决定？

更新:

public interface Validator{
    public ErrorCode validate();
}

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

ErrorCode 类封装了验证的结果(null 如果验证成功完成)。

Answer 1

单一职责原则

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

这称为依赖注入(inject)。