我有一个基于管道的应用程序，它分析不同语言（比如，英语和中文）的文本。我的目标是拥有一个可以以透明的方式在两种语言中工作的系统。注意：这个问题很长，因为它有许多简单的代码片段。
管道由三个组件组成（我们将它们称为A、B和C），我以下面的方式创建了它们，以便这些组件不会紧密耦合：

public class Pipeline {
    private A componentA;
    private B componentB;
    private C componentC;

    // I really just need the language attribute of Locale,
    // but I use it because it's useful to load language specific ResourceBundles.
    public Pipeline(Locale locale) {
        componentA = new A();
        componentB = new B();
        componentC = new C();
    }

    public Output runPipeline(Input) {
        Language lang = LanguageIdentifier.identify(Input);
        //
        ResultOfA resultA = componentA.doSomething(Input);
        ResultOfB resultB = componentB.doSomethingElse(resultA); // uses result of A
        return componentC.doFinal(resultA, resultB); // uses result of A and B
    }
}

现在，管道的每个组件都有一些特定于语言的东西，例如，为了分析中文文本，我需要一个库，而为了分析英语文本，我需要另一个不同的库。
此外，有些任务可以用一种语言完成，而不能用另一种语言完成。解决这个问题的一个方法是使每个管道组件抽象（实现一些公共方法），然后有一个具体的特定于语言的实现。以组件A为例，我会有以下内容：

public abstract class A {
    private CommonClass x;  // common to all languages
    private AnotherCommonClass y; // common to all languages

    abstract SomeTemporaryResult getTemp(input); // language specific
    abstract AnotherTemporaryResult getAnotherTemp(input); // language specific

    public ResultOfA doSomething(input) {
          // template method
          SomeTemporaryResult t = getTemp(input); // language specific
          AnotherTemporaryResult tt = getAnotherTemp(input); // language specific
          return ResultOfA(t, tt, x.get(), y.get());
    }
}

public class EnglishA extends A {
    private EnglishSpecificClass something;
    // implementation of the abstract methods ... 
}

此外，由于每个管道组件都非常繁重，而且我需要重用它们，因此我考虑创建一个工厂来缓存组件以备将来使用，使用一个以语言为关键字的Map，如下所示（其他组件将以相同的方式工作）：

public Enum AFactory {
    SINGLETON;
    
    private Map<String, A> cache; // this map will only have one or two keys, is there anything more efficient that I can use, instead of HashMap?
    
    public A getA(Locale locale) {
        // lookup by locale.language, and insert if it doesn't exist, et cetera
        return cache.get(locale.getLanguage());
    }
}

所以我的问题是你觉得这个设计怎么样？如何改进它？我需要“透明性”，因为语言可以根据所分析的文本动态更改。正如你从runPipeline方法中看到的，我首先识别Input的语言，然后，基于此，我需要将管道组件更改为所识别的语言。所以，与其直接调用组件，也许我应该从工厂获取它们，如下所示：

public Output runPipeline(Input) {
    Language lang = LanguageIdentifier.identify(Input);
    ResultOfA resultA = AFactory.getA(lang).doSomething(Input);
    ResultOfB resultB = BFactory.getB(lang).doSomethingElse(resultA);
    return CFactory.getC(lang).doFinal(resultA, resultB);
}

谢谢你阅读到这里。我非常感谢你就这个问题提出的每一个建议。