使用SpringBoot快速构建Web API

因为我们已经实现了 CurrencyRateService，所以，可以直接将其作为项目依赖的一部分（当然，这样也让我们的 Web API 看起来更像一个适配网关了）。

我们直接使用 SpringMVC 构建对应的 Controller 对外提供 Web API 的访问如下：

1. @Controller
2. public class CurrencyRateQueryController {
3. @Autowired
4. private CurrencyRateService currencyRateService;
5. @RequestMapping(value = "/", method = RequestMethod.GET)
6. @ResponseBody
7. public ExchangeRate quote(String symbol) throws IOException {
8. return currencyRateService.quote(CurrencyPair.from(symbol));
9. }
10. }

spring-boot-starter-web 默认会提供一系列的 HttpMessageConverter 用于对请求参数和响应结果做类型转换。所以，ExchangeRate 类型将通过默认 HttpMessageConverter 序列中的 MappingJackson2HttpMessageConverter 转换成对应的 JSON 响应结果，类似于：

1. { currencyPair: { symbol: “USD/CNY” }, bidPrice: 6.67, askPrice: 6.56}

整个 Web API 的功能流程算是跑通了，但跟我们之前定义的 Web API 规范却没有关系，所以，下一步我们要做的事情就是在此基础上规范 HTTP 响应格式，使其遵循我们之前定义的 Web API 规范，从而任何访问我们提供的 Web API 访问者都可以相同的认知使用这些 Web API，进而也可以打造和沉淀相应的工具或者类库。

我们定义的 Web API 规范并非最优，也并非必要，如果团队成员的认知差不多，那么直接使用 HTTP Status Code 结合直接的值类型响应就可以了，我们给出的 Web API 规范考虑了更多因素后做出的一个折中方案，但任何方案设计是否完美并非最主要的，执行才是。

要开发符合我们的 Web API 规范的 Web API，最少有两种方案可以选择：

• 显式的强类型封装方式（explicit type wrapper）
• 隐式的自动转换方式（implicit conversion）

显式的强类型封装方式的出发点是说，既然 spring-boot-starter-web 已经提供了 MappingJackson2HttpMessageConverter 用于对象类型到 JSON 的类型转换，那么，我们只要提供针对 Web API 规范的 Java 对象类型作为所有 Web API 处理方法的返回值就可以了，比如：

1. public class WebApiResponse {
2. public static final int SUCCESS_CODE = 0;
3. public static final int ERROR_CODE = 1;
4. private int code;
5. private String error;
6. private T data;
7. // getters, setters, toString(), etc.
8. }

然后，所有的 Web API 的处理方法统一定义为返回 WebApiResponse 作为结果类型：

1. @RequestMapping(value = "/", method = RequestMethod.GET)
2. @ResponseBody
3. public WebApiResponse quote(String symbol) throws IOException {
4. WebApiResponse response = new WebApiResponse<>();
5. response.setCode(WebApiResponse.SUCCESS_CODE);
6. response.setData(currencyRateService.quote(CurrencyPair.from(symbol)));
7. return response;
8. }

不过，这种模式过于强调规范的管控，对开发者来说不是太友好，即使我们通过 Builder 模式来简化 WebApiResponse 的构造过程，比如：

1. public class WebApiResponse {
2. public static final int SUCCESS_CODE = 0;
3. public static final int ERROR_CODE = 1;
4. private int code;
5. private String error;
6. private T data;
7. public static WebApiResponse success(T data) {
8. WebApiResponse response = new WebApiResponse<>();
9. response.setCode(SUCCESS_CODE);
10. response.setData(data);
11. return response;
12. }
13. public static WebApiResponse error(String errorMessage) {
14. return WebApiResponse.error(errorMessage, ERROR_CODE);
15. }
16. // ...
17. @RequestMapping(value = "/", method = RequestMethod.GET)
18. @ResponseBody
19. public WebApiResponse quote(String symbol) throws IOException {
20. return WebApiResponse.success(currencyRateService.quote(CurrencyPair.from(symbol)));
21. }
22. }

但从 API 的使用者角度来看，这种设计并非最优，最好的方式其实应该是隐式的自动转换方式。在隐式的自动转换方式下，用户的 Web API 处理方法定义保持不变，直接返回最原始的值类型（比如 ExchangeRate）：

1. @RequestMapping(value = "/", method = RequestMethod.GET)
2. @ResponseBody
3. public ExchangeRate quote(String symbol) throws IOException {
4. return currencyRateService.quote(CurrencyPair.from(symbol));
5. }

通过在框架层面对原始的值类型进行符合规范行为的封装，最终返回给用户的响应结果“自动”的或者说以“不打扰 API 开发者”的形式变成了符合我们 Web API 规范的响应结果形式。

要达到隐式的自动转换方式的效果，最简单粗暴的做法就是完全覆盖 Web 应用的配置，只配置一个自定义处理 JSON 转换的 HttpMessageConverter 实现，比如：

1. public class JsonHttpMessageConverter extends AbstractHttpMessage-Converter