3

我正在尝试编写一个客户端库，HttpClient用于向/从 Web 服务器发送和接收信息。这个库的核心是一个WebClient类：

public class WebClient {
    public String send(String apiUrl) {
        // Use HttpClient to send a message to 'apiUrl', such as:
        // http://example.com?a=1&response=xml
        //
        // Wait for a response, and extract the HTTP response's body out
        // as raw text string. Return the body as a string.
    }
}

再说一次，这是我正在编写的库mylib.jar（ ）。一个由各种不同服务组成的库，其中每个服务都有 1+ 方法，API 开发人员可以使用这些方法将数据读/写到服务器。所以服务如下：

WidgetService
    getAllWidgets
    getMostExpensiveWidget
    getLastWidgetUpdated
    etc...
FizzService
    getFizzById
    getFizziestFizz
    etc...
BuzzService
    etc...
...

每个服务方法将采用 1+ Java 原语或 1+ 模型实例（实体、值对象等）。每个服务方法都会返回一个这样的模型对象。例如：

public class FizzService {
    public Fizz getFizzById(Long fizzId) {
        // ...
    }

    public Fizz getFizzByBuzz(Buzz buzz) {
        // ...
    }
}

这一点很重要，因为这意味着WebClient#send()最终需要将接收到的 HTTP 响应正文映射回 Java 对象。

从 API 开发人员的角度来看，我只希望开发人员实例化每个服务实例，将其传递给WebClient后台使用，然后让服务完成参数和 api url 之间以及 HTTP 响应主体和模型/实体之间的所有映射。

例如：

public class FizzService {
    private WebClient webClient;
    private FizzApiBuilder fizzApiBuilder;

    // Getters & setters for all properties...

    public Fizz getFizzByBuzz(Buzz buzz) {
        // apiCall == "http://example.com/fizz-service/getFizzByBuzz?buzz_id=93ud94i49&response=json"
        String apiCall = fizzApiBuilder.build(buzz).toString();

        // We asked API to send back a Fizz as JSON, so responseBody is a JSON String representing
        // the correct Fizz.
        String responseBody = webClient.send(apiCall);

        if(apiCall.contains("json"))
            return JsonFizzMapper.toFizz(reponseBody);
        else
            return XmlFizzMapper.toFizz(responseBody);
    }
}

// What the API developer writes:
WebClient webClient = WebClientFactory.newWebClient();
FizzService fizzSvc = new FizzService(webClient);

Buzz b = getBuzz();

Fizz f = fizzSvc.getFizzByBuzz(b);

到目前为止，我喜欢这个设置。但是，对于所有服务中的每个服务方法，我都需要相同的“样板”代码：

String apiCall = someBuilder.build(...)
String responseBody = webClient.send(apiCall)
if(apiCall.contains("json"))
    return JsonMapper.toSomething(responseBody)
else
    return XmlMapper.toSomething(responseBody)

这开始闻起来像是抽象的主要用例。理想情况下，我希望将所有这些样板代码放在一个 中AbstractService，并让每个服务扩展该抽象类。只有一个问题：

public abstract class AbstractService {
    private WebClient webClient;
    private ServiceApiBuilder apiBuilder;

    // Getters & setters for all properties...

    public Object invoke(Object... params) {
        // apiCall == "http://example.com/fizz-service/getFizzByBuzz?buzz_id=93ud94i49&response=json"
        // The injected apiBuilder knows how to validate params and use them to build the api url.
        String apiCall = apiBuilder.build(params).toString();

        String responseBody = webClient.send(apiCall);

        if(apiCall.contains("json"))
            return jsonMapper.to???(reponseBody);
        else
            return xmlMapper.to???(responseBody);
    }
}

public class FizzService extends AbstractService { ... }

问题是，将功能抽象为一个使构建 API 调用的AbstractService事情变得尴尬（但并非不可能），但更糟糕的是，我完全不知道如何创建和注入一组 JSON/XML 映射器，这些映射器将知道什么模型/要映射到的实体responseBody。

这一切都开始发臭了。当我的代码发臭时，我会寻找解决方案，如果找不到，我会来这里。所以我问：我是否采取了根本错误的方法，如果是，我的方法应该是什么？如果我很接近，那么我如何注入正确的映射器并让这段代码闻起来更好？请记住我的代码片段显示了我希望 API 开发人员如何实际使用模型/服务 - 这是这里的最终目标。提前致谢。

4

1 回答 1

2

正如评论中提到的，我们在编译时知道我们想要发出的请求类型和响应类型，所以我不会让代码在运行时简单地处理这些事情，以便可以将其提取到一个基类。您必须为其编写额外的代码才能做出这些决定，这只会为细微的错误留下空间。此外，让 API 构建器仅根据参数计算出要进行的调用将使您陷入困境；例如getMostExpensiveWidget，getLastWidgetUpdated两者听起来都像无参数方法，那么 API 构建器类如何知道要做什么？

因此，假设我们将为 API 构建器类提供用于不同 API 调用的单独方法。还假设映射器类上的方法不是静态的。然后该getFizzByBuzz方法可能如下所示：

public Fizz getFizzByBuzz(Buzz buzz) {
    String apiCall = fizzApiBuilder.buildForBuzz(buzz).toString();
    String responseBody = webClient.send(apiCall);
    return jsonFizzMapper.toFizz(reponseBody);
}

同样，该getFizzById方法可能如下所示：

public Fizz getFizzById(Long fizzId) {
    String apiCall = fizzApiBuilder.buildForId(fizzId).toString();
    String responseBody = webClient.send(apiCall);
    return xmlFizzMapper.toFizz(reponseBody);
}

这两种方法都遵循相同的模式，并且它们的不同之处在于特定的 API 构建器方法（例如buildForBuzzvs buildForId）和特定的响应映射器（jsonFizzMappervs xmlFizzMapper），因为我们不想在运行时做出这些决定。因此，唯一真正的冗余是对 Web 客户端的调用。假设JsonFizzMapper并XmlFizzMapper实现一些FizzMapper接口，我的下一步是在FizzService类中创建以下私有方法：

private Fizz sendRequest(String apiCall, FizzMapper responseMapper) {
    String responseBody = webClient.send(apiCall);
    return responseMapper.toFizz(reponseBody);
}

getFizzByBuzz现在getFizzById看起来像这样：

public Fizz getFizzByBuzz(Buzz buzz) {
    String apiCall = fizzApiBuilder.buildForBuzz(buzz).toString();
    return sendRequest(apiCall, jsonFizzMapper);
}

public Fizz getFizzById(Long fizzId) {
    String apiCall = fizzApiBuilder.buildForId(fizzId).toString();
    return sendRequest(apiCall, xmlFizzMapper);
}

我认为这是纯粹和实用主义之间的一个很好的平衡。理想情况下，您只需将 sendRequest 方法传递给构建器方法（例如buildForBuzz），但是您必须跳过接口和匿名类方面的障碍似乎并不值得。

如果您想更进一步，您可以使 sendRequest 方法通用，然后将其放入抽象基类中（或者最好支持组合而不是继承并将其放入完全独立的类中），然后您需要使您的映射器接口通用. 但是，由于该类仅包含一个两行方法，因此在我看来，这可能不值得。因此，我认为为每个服务类创建相应的私有方法应该没问题，但是如果您认为它可能会变得更复杂，请在其他地方提取功能。

于 2012-12-18T17:22:20.127 回答