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

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 {...}

...
...

所以，一般来说，这意味着每次我想添加一种新类型的API时，我都必须为同一类型创建几个类，并确保它们只相互通信而不是与其他类的实现相互通信。 API的类型。

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

那么，有更好的解决方案吗？ 或许这很好，没有必要重构它。

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

编辑：

我会稍微扩展这个想法。 有一个客户端类使用API​​Client发出请求，具有给定类型的参数。 一旦请求得到JSON响应，客户端就会使用相应的APIParser获取有关响应的特定信息。

public class ClientClass {

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

}

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

Answer 1

您的要求似乎与Abstract Factory 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();

Answer 2

你可以做的是为你的类添加一个类型参数。

// wrapper for your json
public class APIResult<T extends APIClient<T>> {

    private final String json;

    public APIResult(String json) {
        this.json = json;
    }

    public String getJson() {
        return this.json;
    }
}

// client always returns a result with itself as a type
public interface APIClient<T extends APIClient<T>> {

    APIResult<T> makeRequest();
}

// parser only handles the implementation specific results of one client
public interface APIParser<T extends APIClient<T>> {

    String getTemperature(APIResult<T> result);
}

public class APIClientA implements APIClient<APIClientA> {

    public APIResult<APIClientA> makeRequest() {
        // must return a result with this type
    }
}

public class APIParserA implements APIParser<APIClientA> {

    public String getTemperature(APIResult<APIClientA> result) {
        // only accepts results from one specific client
    }
}