这种情况下合适的设计模式是什么？ （实例）

Question

我必须使用一个库并且需要检查（如果这个实例）很多。 例如：

if(myInterface instanceof Foo) {
  Foo foo = (Foo) myInterface;
  if(foo.name.equals("Alex")) {
     // use function that can handle Foo with name "Alex"
     handleAlexFooLogic(foo);
  }
  if(foo.name.equals("Michael") {
     // use function that can handle Foo with name "Michael"
     handleMichaleFooLogic(foo);
  }
}
else if(myInterface instanceof Bar) {
  Bar bar = (Bar) myInterface;
  if(bar.name.equals("Smith")) {
     // use function that can handle Bar with name "Smith"
     handleSmithBarLogic(bar);
  }
  // ...
} else if(....) {
  // ...
}

我首先考虑的是工厂模式，然后我就被卡住了，因为有些东西太矛盾了，我无法解释。

我还想将if(foo.name.equals("Name"))部分与不同的 class 分开，以避免过多的不可预测的嵌套 if-else

那么适合这种情况的设计模式是什么？ 谢谢！

Answer 1

当我看到很多这样的特定于实例的检查时，我倾向于问自己是否需要改进我的基本接口，以便我的逻辑可以更加一致。 之所以会发生这些检查，是因为您对每种未由接口或组合封装的类型都有特定的逻辑。

您是否正在尝试在这些代码块中实现的通用操作可以更好地封装在接口、抽象 class、通用组合或包装此逻辑的工厂 object 中？

是否有您正在检查的所有类型都可以实现的基本接口/合同，解决 inheritance 的问题，或者在许多情况下更好，如果它服务于您的架构，使用的共同属性，通过组合解决问题？

这些支票的数量会继续增长吗？ 如果是这样，我会更倾向于组合或 inheritance，而不是工厂或服务 class。

虽然您的问题没有足够的细节让我说使用“X”模式，但这仍然是一件非常主观的事情。 我发现最好能够彻底描述您在设计模式选择中所做的每一个权衡，以及为什么您偏爱一方而不是另一方。 然后，您将真正了解您的选择以及它们对您的团队的影响，并以建设性的方式对它们进行辩论。

模式只是常见解决方案的标签，应该通过彻底的推理来使用，而不是在有限的词汇中严格遵守。 尽管如此，我希望这对您的决定有所帮助。

Answer 2

如果您有多种方法来处理不同的事情，我建议在这种情况下使用接口（鉴于不同名称的 Bars / Foos 在其处理程序方法中确实存在巨大差异）。

public interface HandlerInterface {
  public void handleLogic();
}

为每个 Bars 或 Foos 定义类。

public class AlexBar extends Bar implements HandlerInterface {
  @Override
  public void handleLogic() { ... }
}

然后直接调用它而不必检查它们。

myInterface.handleLogic();

只是一个建议，如果不同名称的酒吧之间只有很小的差异，这种方法可能不是最好的。 这种方法还创建了抽象并降低了可读性（在我看来），但保持了代码库的整洁。

如果能实现 Bar/Foo 的接口就更好了。

Answer 3

基于地图的解决方案可用于通过String键获取Consumer ：

Map<String, Consumer<Foo>> fooActions = Map.of(
    "Alex", MyClass::handleAlexFooLogic,
    "Michael", MyClass::handleMichaelFooLogic
);

Map<String, Consumer<Bar>> barActions = Map.of(
    "Smith", MyClass::handleSmithBarLogic
);

可以与Optional一起使用

if(myInterface instanceof Foo) {
    Foo foo = (Foo) myInterface;
    Optional.ofNullable(fooActions.get(foo.name()))
            .ifPresent(action -> action.accept(foo));
}
else if(myInterface instanceof Bar) {
    Bar bar = (Bar) myInterface;
    Optional.ofNullable(barActions.get(bar.name()))
            .ifPresent(action -> action.accept(bar));

---

类似的方法是使用提供实现handleXxxLogic或存储对适当方法的引用的枚举：

enum FooActions {
    Alex(MyClass::handleAlexFooLogic),
    Michael(MyClass::handleMichaelFooLogic);
    
    private Consumer<Foo> action;
    
    private FooActions(Consumer<Foo> action) {
        this.action = action;
    }
    
    public Consumer<Foo> getAction() {
        return this.action;
    }

    // use this instead of valueOf which may throw exceptions
    public static FooActions byName(String name) {
        try {
            for (FooActions val : FooActions.values()) {
                if (val.name().equalsIgnoreCase(name)) {
                    return val;
                }
            }
        } catch (Exception ex) {}

        return null;
    }
}

然后可以按如下方式使用：

if(myInterface instanceof Foo) {
    Foo foo = (Foo) myInterface;
    Optional.ofNullable(FooActions.byName(foo.name()))
            .map(FooActions::getAction)
            .ifPresentOrElse(
                action -> action.accept(foo),
                ()-> System.out.println(foo.name() + " incorrect!")
            );
}