对于这种类对的情况，是否有一个设计模式？

Question

这个问题在我的项目中经常出现。作为一个例子，假设我有两个接口，一个从API检索信息，另一个解析这些信息。

public interface APIClient {...}

public interface APIParser {...}

现在，我可能需要有不同的API，因此我将有许多APIClient的实现，但每个实现都需要自己的APIParser。

public class APIClientA implements APIClient {...}
public class APIParserA implements APIParser {...}

public class APIClientB implements APIClient {...}
public class APIParserB implements APIParser {...}

...
...

这看起来与Bridge设计模式所建议的非常相似，但是该模式允许任何APIClient使用任何APIParser（我说的对吗？）

那么，有没有更好的解决方案呢？或者也许这很好，不需要重构它。

另外，也许parse不是正确的词，对不起，我的英语，但我想说的是分析一个JSON/XML响应，以便从中获得具体的信息。我分析每个响应的方式取决于每个API提供的结构，所以这就是为什么我将需要不同的“解析器”

我将把这个想法扩展一点。有一个client类使用一个APIClient发出请求，并带有给定类型的参数。一旦请求得到JSON响应，客户机就会使用相应的APIParser来获取关于响应的特定信息。

public class ClientClass {

  ...
  json = APIClientTypeA.makeRequest(city, day, ...);
  temperature = APIParserTypeA.getTemperature(json);
  ...

}

这里的问题是客户端需要确保使用APIClient和APIParser的正确实现（它们必须匹配）

Answer 1

您的需求似乎与抽象工厂GoF模式非常匹配，因为一旦您创建了一个具体工厂，并且您的代码仅通过该工厂实例化客户端和解析器，就不可能错误地获得一组不匹配的客户端/解析器实例。

abstractFactory是客户端用于实例化客户端/解析器对的对象：

interface AbstractFactory {
    APIParser createAPIParser();
    APIClient createAPIClient();    
}

interface APIParser {} 
interface APIClient {}

具体工厂可以提供匹配对（您可能可以重用产品实例，但我保持简单）：

class ConcreteFactoryA implements AbstractFactory {

    public APIParser createAPIParser() { return new APIParserA(); }
    public APIClient createAPIClient() { return new APIClientA(); }
}

class ConcreteFactoryB implements AbstractFactory {

    public APIParser createAPIParser() { return new APIParserB(); }
    public APIClient createAPIClient() { return new APIClientB(); }
}

class APIParserA implements APIParser {}
class APIParserB implements APIParser {}
class APIClientA implements APIClient {}
class APIClientB implements APIClient {}

客户端代码示例：

AbstractFactory factory = new ConcreteFactoryA();
APIClient client = factory.createAPIClient();
APIParser parser = factory.createAPIParser();