你知道的越多，不知道的就越多，业余的像一棵小草！

你来，咱们一块儿精进！你不来，我和你的竞争对手一块儿精进！
java

编辑：业余草

juejin.cn/post/6898485806587969544

推荐：https://www.xttblog.com/?p=5120

在SpringBoot项目直接使用okhttp、httpClient或者RestTemplate发起HTTP请求，既繁琐又不方便统一管理。所以，在这里推荐一个适用于SpringBoot项目的轻量级HTTP客户端框架retrofit-spring-boot-starter，使用很是简单方便，同时又提供诸多功能加强。目前项目已经更新至2.2.2版本，而且会持续进行迭代优化。
git

前言

Retrofit是适用于Android和Java且类型安全的HTTP客户端，其最大的特性的是支持经过接口的方式发起HTTP请求 。而spring-boot是使用最普遍的Java开发框架，可是Retrofit官方没有支持与spring-boot框架快速整合，所以咱们开发了retrofit-spring-boot-starter。github

retrofit-spring-boot-starter实现了Retrofit与spring-boot框架快速整合，而且支持了诸多功能加强，极大简化开发 。web

🚀项目持续优化迭代。spring

功能特性

自定义注入OkHttpClient
注解式拦截器
链接池管理
日志打印
请求重试
错误解码器
全局拦截器
熔断降级
微服务之间的HTTP调用
调用适配器
数据转换器

快速使用

引入依赖

<dependency>
    <groupId>com.github.lianjiatech</groupId>
    <artifactId>retrofit-spring-boot-starter</artifactId>
    <version>2.2.2</version>
</dependency>
api

定义http接口

接口必须使用@RetrofitClient注解标记 ！http相关注解可参考官方文档：retrofit官方文档。安全

@RetrofitClient(baseUrl = "${test.baseUrl}")
public interface HttpApi {

    @GET("person")
    Result<Person> getPerson(@Query("id") Long id);
}
微信

注入使用

将接口注入到其它Service中便可使用！网络

@Service
public class TestService {

    @Autowired
    private HttpApi httpApi;

    public void test() {
        // 经过httpApi发起http请求
    }
}
架构

HTTP请求相关注解

HTTP请求相关注解，所有使用了retrofit原生注解。详细信息可参考官方文档：retrofit官方文档 ，如下是一个简单说明。

注解分类

支持的注解


请求方式	`@GET` `@HEAD` `@POST` `@PUT` `@DELETE` `@OPTIONS`
请求头	`@Header` `@HeaderMap` `@Headers`
Query参数	`@Query` `@QueryMap` `@QueryName`
path参数	`@Path`
form-encoded参数	`@Field` `@FieldMap` `@FormUrlEncoded`
文件上传	`@Multipart` `@Part` `@PartMap`
url参数	`@Url`

配置项说明

retrofit-spring-boot-starter支持了多个可配置的属性，用来应对不一样的业务场景。您能够视状况进行修改，具体说明以下：

配置默认值说明


enable-log	true	启用日志打印
logging-interceptor	DefaultLoggingInterceptor	日志打印拦截器
pool		链接池配置
disable-void-return-type	false	禁用java.lang.Void返回类型
retry-interceptor	DefaultRetryInterceptor	请求重试拦截器
global-converter-factories	JacksonConverterFactory	全局转换器工厂
global-call-adapter-factories	BodyCallAdapterFactory,ResponseCallAdapterFactory	全局调用适配器工厂
enable-degrade	false	是否启用熔断降级
degrade-type	sentinel	熔断降级实现方式(目前仅支持Sentinel)
resource-name-parser	DefaultResourceNameParser	熔断资源名称解析器，用于解析资源名称

yml配置方式：

retrofit:
  enable-response-call-adapter: true
  # 启用日志打印
  enable-log: true
  # 链接池配置
  pool:
    test1:
      max-idle-connections: 3
      keep-alive-second: 100
    test2:
      max-idle-connections: 5
      keep-alive-second: 50
  # 禁用void返回值类型
  disable-void-return-type: false
  # 日志打印拦截器
  logging-interceptor: com.github.lianjiatech.retrofit.spring.boot.interceptor.DefaultLoggingInterceptor
  # 请求重试拦截器
  retry-interceptor: com.github.lianjiatech.retrofit.spring.boot.retry.DefaultRetryInterceptor
  # 全局转换器工厂
  global-converter-factories:
    - retrofit2.converter.jackson.JacksonConverterFactory
  # 全局调用适配器工厂
  global-call-adapter-factories:
    - com.github.lianjiatech.retrofit.spring.boot.core.BodyCallAdapterFactory
    - com.github.lianjiatech.retrofit.spring.boot.core.ResponseCallAdapterFactory
  # 是否启用熔断降级
  enable-degrade: true
  # 熔断降级实现方式
  degrade-type: sentinel
  # 熔断资源名称解析器
  resource-name-parser: com.github.lianjiatech.retrofit.spring.boot.degrade.DefaultResourceNameParser

高级功能

自定义注入OkHttpClient

一般状况下，经过@RetrofitClient注解属性动态建立OkHttpClient对象可以知足大部分使用场景。可是在某些状况下，用户可能须要自定义OkHttpClient，这个时候，能够在接口上定义返回类型是OkHttpClient.Builder的静态方法来实现。代码示例以下：

@RetrofitClient(baseUrl = "http://ke.com")
public interface HttpApi3 {

    @OkHttpClientBuilder
    static OkHttpClient.Builder okhttpClientBuilder() {
        return new OkHttpClient.Builder()
                .connectTimeout(1, TimeUnit.SECONDS)
                .readTimeout(1, TimeUnit.SECONDS)
                .writeTimeout(1, TimeUnit.SECONDS);

    }

    @GET
    Result<Person> getPerson(@Url String url, @Query("id") Long id);
}

方法必须使用@OkHttpClientBuilder注解标记！

注解式拦截器

不少时候，咱们但愿某个接口下的某些http请求执行统一的拦截处理逻辑。为了支持这个功能，retrofit-spring-boot-starter提供了注解式拦截器 ，作到了基于url路径的匹配拦截 。使用的步骤主要分为2步：

继承 BasePathMatchInterceptor编写拦截处理器；
接口上使用 @Intercept进行标注。如需配置多个拦截器，在接口上标注多个 @Intercept注解便可！

下面以给指定请求的url后面拼接timestamp时间戳为例，介绍下如何使用注解式拦截器。

继承`BasePathMatchInterceptor`编写拦截处理器

@Component
public class TimeStampInterceptor extends BasePathMatchInterceptor {

    @Override
    public Response doIntercept(Chain chain) throws IOException {
        Request request = chain.request();
        HttpUrl url = request.url();
        long timestamp = System.currentTimeMillis();
        HttpUrl newUrl = url.newBuilder()
                .addQueryParameter("timestamp", String.valueOf(timestamp))
                .build();
        Request newRequest = request.newBuilder()
                .url(newUrl)
                .build();
        return chain.proceed(newRequest);
    }
}

接口上使用`@Intercept`进行标注

@RetrofitClient(baseUrl = "${test.baseUrl}")
@Intercept(handler = TimeStampInterceptor.class, include = {"/api/**"}, exclude = "/api/test/savePerson")
public interface HttpApi {

    @GET("person")
    Result<Person> getPerson(@Query("id") Long id);

    @POST("savePerson")
    Result<Person> savePerson(@Body Person person);
}

上面的@Intercept配置表示：拦截HttpApi接口下/api/**路径下（排除/api/test/savePerson）的请求，拦截处理器使用TimeStampInterceptor。

扩展注解式拦截器

有的时候，咱们须要在拦截注解 动态传入一些参数，而后再执行拦截的时候须要使用这个参数。这种时候，咱们能够扩展实现自定义拦截注解 。自定义拦截注解必须使用@InterceptMark标记，而且注解中必须包括include()、exclude()、handler()属性信息 。使用的步骤主要分为3步：

自定义拦截注解
继承 BasePathMatchInterceptor编写拦截处理器
接口上使用自定义拦截注解；

例如咱们须要在请求头里面动态加入accessKeyId、accessKeySecret签名信息才能正常发起http请求 ，这个时候能够自定义一个加签拦截器注解@Sign来实现 。下面以自定义@Sign拦截注解为例进行说明。

自定义`@Sign`注解

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@InterceptMark
public @interface Sign {
    /**
     * 密钥key
     * 支持占位符形式配置。
     *
     * @return
     */
    String accessKeyId();

    /**
     * 密钥
     * 支持占位符形式配置。
     *
     * @return
     */
    String accessKeySecret();

    /**
     * 拦截器匹配路径
     *
     * @return
     */
    String[] include() default {"/**"};

    /**
     * 拦截器排除匹配，排除指定路径拦截
     *
     * @return
     */
    String[] exclude() default {};

    /**
     * 处理该注解的拦截器类
     * 优先从spring容器获取对应的Bean，若是获取不到，则使用反射建立一个！
     *
     * @return
     */
    Class<? extends BasePathMatchInterceptor> handler() default SignInterceptor.class;
}

扩展自定义拦截注解有如下2点须要注意：

自定义拦截注解必须使用 @InterceptMark标记。
注解中必须包括 include()、exclude()、handler()属性信息。

实现`SignInterceptor`

@Component
public class SignInterceptor extends BasePathMatchInterceptor {

    private String accessKeyId;

    private String accessKeySecret;

    public void setAccessKeyId(String accessKeyId) {
        this.accessKeyId = accessKeyId;
    }

    public void setAccessKeySecret(String accessKeySecret) {
        this.accessKeySecret = accessKeySecret;
    }

    @Override
    public Response doIntercept(Chain chain) throws IOException {
        Request request = chain.request();
        Request newReq = request.newBuilder()
                .addHeader("accessKeyId", accessKeyId)
                .addHeader("accessKeySecret", accessKeySecret)
                .build();
        return chain.proceed(newReq);
    }
}

上述accessKeyId和accessKeySecret字段值会依据@Sign注解的accessKeyId()和accessKeySecret()值自动注入，若是@Sign指定的是占位符形式的字符串，则会取配置属性值进行注入。另外，accessKeyId和accessKeySecret字段必须提供setter方法 。

接口上使用`@Sign`

@RetrofitClient(baseUrl = "${test.baseUrl}")
@Sign(accessKeyId = "${test.accessKeyId}", accessKeySecret = "${test.accessKeySecret}", exclude = {"/api/test/person"})
public interface HttpApi {

    @GET("person")
    Result<Person> getPerson(@Query("id") Long id);

    @POST("savePerson")
    Result<Person> savePerson(@Body Person person);
}

这样就能在指定url的请求上，自动加上签名信息了。

链接池管理

默认状况下，全部经过Retrofit发送的http请求都会使用max-idle-connections=5 keep-alive-second=300的默认链接池。固然，咱们也能够在配置文件中配置多个自定义的链接池，而后经过@RetrofitClient的poolName属性来指定使用。好比咱们要让某个接口下的请求所有使用poolName=test1的链接池，代码实现以下：

一、配置链接池。

   retrofit:
       # 链接池配置
       pool:
           test1:
           max-idle-connections: 3
           keep-alive-second: 100
           test2:
           max-idle-connections: 5
           keep-alive-second: 50

一、经过@RetrofitClient的poolName属性来指定使用的链接池。

   @RetrofitClient(baseUrl = "${test.baseUrl}", poolName="test1")
   public interface HttpApi {

       @GET("person")
       Result<Person> getPerson(@Query("id") Long id);
   }

日志打印

不少状况下，咱们但愿将http请求日志记录下来。经过retrofit.enableLog配置能够全局控制日志是否开启。针对每一个接口，能够经过@RetrofitClient的enableLog控制是否开启，经过logLevel和logStrategy，能够指定每一个接口的日志打印级别以及日志打印策略。retrofit-spring-boot-starter支持了5种日志打印级别(ERROR, WARN, INFO, DEBUG, TRACE)，默认INFO；支持了4种日志打印策略（NONE, BASIC, HEADERS, BODY），默认BASIC。4种日志打印策略含义以下：

NONE：No logs.
BASIC：Logs request and response lines.
HEADERS：Logs request and response lines and their respective headers.
BODY：Logs request and response lines and their respective headers and bodies (if present).

retrofit-spring-boot-starter默认使用了DefaultLoggingInterceptor执行真正的日志打印功能，其底层就是okhttp原生的HttpLoggingInterceptor。固然，你也能够自定义实现本身的日志打印拦截器，只须要继承BaseLoggingInterceptor（具体能够参考DefaultLoggingInterceptor的实现），而后在配置文件中进行相关配置便可。

retrofit:
# 日志打印拦截器
logging-interceptor: com.github.lianjiatech.retrofit.spring.boot.interceptor.DefaultLoggingInterceptor

请求重试

retrofit-spring-boot-starter支持请求重试功能，只须要在接口或者方法上加上@Retry注解便可。@Retry支持重试次数maxRetries、重试时间间隔intervalMs以及重试规则retryRules配置 。重试规则支持三种配置：

RESPONSE_STATUS_NOT_2XX：响应状态码不是 2xx时执行重试；
OCCUR_IO_EXCEPTION：发生IO异常时执行重试；
OCCUR_EXCEPTION：发生任意异常时执行重试；

默认响应状态码不是2xx或者发生IO异常时自动进行重试。须要的话，你也能够继承BaseRetryInterceptor实现本身的请求重试拦截器，而后将其配置上去。

retrofit:
# 请求重试拦截器
retry-interceptor: com.github.lianjiatech.retrofit.spring.boot.retry.DefaultRetryInterceptor

错误解码器

在HTTP发生请求错误(包括发生异常或者响应数据不符合预期)的时候，错误解码器可将HTTP相关信息解码到自定义异常中。你能够在@RetrofitClient注解的errorDecoder()指定当前接口的错误解码器，自定义错误解码器须要实现ErrorDecoder接口：

/**
* 错误解码器。ErrorDecoder.
* 当请求发生异常或者收到无效响应结果的时候，将HTTP相关信息解码到异常中，无效响应由业务本身判断
*
* When an exception occurs in the request or an invalid response result is received, the HTTP related information is decoded into the exception,
* and the invalid response is determined by the business itself.
*
* @author 陈添明
*/
public interface ErrorDecoder {

    /**
     * 当无效响应的时候，将HTTP信息解码到异常中，无效响应由业务自行判断。
     * When the response is invalid, decode the HTTP information into the exception, invalid response is determined by business.业余草，公众号
     *
     * @param request  request
     * @param response response
     * @return If it returns null, the processing is ignored and the processing continues with the original response.
     */
    default RuntimeException invalidRespDecode(Request request, Response response) {
        if (!response.isSuccessful()) {
            throw RetrofitException.errorStatus(request, response);
        }
        return null;
    }

    /**
     * 当请求发生IO异常时，将HTTP信息解码到异常中。
     * When an IO exception occurs in the request, the HTTP information is decoded into the exception.
     *
     * @param request request
     * @param cause   IOException
     * @return RuntimeException
     */
    default RuntimeException ioExceptionDecode(Request request, IOException cause) {
        return RetrofitException.errorExecuting(request, cause);
    }

    /**
     * 当请求发生除IO异常以外的其它异常时，将HTTP信息解码到异常中。
     * When the request has an exception other than the IO exception, the HTTP information is decoded into the exception.
     *
     * @param request request
     * @param cause   Exception
     * @return RuntimeException
     */
    default RuntimeException exceptionDecode(Request request, Exception cause) {
        return RetrofitException.errorUnknown(request, cause);
    }

}

全局拦截器

全局应用拦截器

若是咱们须要对整个系统的的http请求执行统一的拦截处理，能够自定义实现全局拦截器BaseGlobalInterceptor, 并配置成spring容器中的bean！例如咱们须要在整个系统发起的http请求，都带上来源信息。

@Component
public class SourceInterceptor extends BaseGlobalInterceptor {
    @Override
    public Response doIntercept(Chain chain) throws IOException {
        Request request = chain.request();
        Request newReq = request.newBuilder()
                .addHeader("source", "test")
                .build();
        return chain.proceed(newReq);
    }
}

全局网络拦截器

只须要实现NetworkInterceptor接口并配置成spring容器中的bean就支持自动织入全局网络拦截器。

熔断降级

在分布式服务架构中，对不稳定的外部服务进行熔断降级是保证服务高可用的重要措施之一。因为外部服务的稳定性是不能保证的，当外部服务不稳定时，响应时间会变长。相应地，调用方的响应时间也会变长，线程会产生堆积，最终可能耗尽调用方的线程池，致使整个服务不可用。所以咱们须要对不稳定的弱依赖服务调用进行熔断降级，暂时切断不稳定调用，避免局部不稳定致使总体服务雪崩。

retrofit-spring-boot-starter支持熔断降级功能，底层基于Sentinel实现。具体来讲，支持了熔断资源自发现 和注解式降级规则配置 。如需使用熔断降级，只须要进行如下操做便可：

1. 开启熔断降级功能

默认状况下，熔断降级功能是关闭的，须要设置相应的配置项来开启熔断降级功能 ：

retrofit:
  # 是否启用熔断降级
  enable-degrade: true
  # 熔断降级实现方式(目前仅支持Sentinel)
  degrade-type: sentinel
  # 资源名称解析器
  resource-name-parser: com.github.lianjiatech.retrofit.spring.boot.degrade.DefaultResourceNameParser

资源名称解析器用于实现用户自定义资源名称，默认配置是DefaultResourceNameParser，对应的资源名称格式为HTTP_OUT:GET:http://localhost:8080/api/degrade/test。用户能够继承BaseResourceNameParser类实现本身的资源名称解析器。

另外，因为熔断降级功能是可选的，所以启用熔断降级须要用户自行引入Sentinel依赖 ：

<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-core</artifactId>
    <version>1.6.3</version>
</dependency>

2. 配置降级规则（可选）

retrofit-spring-boot-starter支持注解式配置降级规则，经过@Degrade注解来配置降级规则 。@Degrade注解能够配置在接口或者方法上，配置在方法上的优先级更高。

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD, ElementType.TYPE})
@Documented
public @interface Degrade {

    /**
     * RT threshold or exception ratio threshold count.
     */
    double count();

    /**
     * Degrade recover timeout (in seconds) when degradation occurs.
     */
    int timeWindow() default 5;

    /**
     * Degrade strategy (0: average RT, 1: exception ratio).
     */
    DegradeStrategy degradeStrategy() default DegradeStrategy.AVERAGE_RT;
}

若是应用项目已支持经过配置中心配置降级规则，可忽略注解式配置方式 。

3. @RetrofitClient设置fallback或者fallbackFactory (可选)

若是@RetrofitClient不设置fallback或者fallbackFactory，当触发熔断时，会直接抛出RetrofitBlockException异常。用户能够经过设置fallback或者fallbackFactory来定制熔断时的方法返回值 。fallback类必须是当前接口的实现类，fallbackFactory必须是FallbackFactory<T>实现类，泛型参数类型为当前接口类型。另外，fallback和fallbackFactory实例必须配置成Spring容器的Bean。

fallbackFactory相对于fallback，主要差异在于可以感知每次熔断的异常缘由(cause) 。参考示例以下：

@Slf4j
@Service
public class HttpDegradeFallback implements HttpDegradeApi {

    @Override
    public Result<Integer> test() {
        Result<Integer> fallback = new Result<>();
        fallback.setCode(100)
                .setMsg("fallback")
                .setBody(1000000);
        return fallback;
    }
}

@Slf4j
@Service
public class HttpDegradeFallbackFactory implements FallbackFactory<HttpDegradeApi> {

    /**
     * Returns an instance of the fallback appropriate for the given cause
     *
     * @param cause fallback cause 业余草，公众号
     * @return 实现了retrofit接口的实例。an instance that implements the retrofit interface.
     */
    @Override
    public HttpDegradeApi create(Throwable cause) {
        log.error("触发熔断了! ", cause.getMessage(), cause);
        return new HttpDegradeApi() {
            @Override
            public Result<Integer> test() {
                Result<Integer> fallback = new Result<>();
                fallback.setCode(100)
                        .setMsg("fallback")
                        .setBody(1000000);
                return fallback;
            }
    }
}

微服务之间的HTTP调用

为了可以使用微服务调用，须要进行以下配置：

配置`ServiceInstanceChooser`为`Spring`容器`Bean`

用户能够自行实现ServiceInstanceChooser接口，完成服务实例的选取逻辑，并将其配置成Spring容器的Bean。对于Spring Cloud应用，retrofit-spring-boot-starter提供了SpringCloudServiceInstanceChooser实现，用户只需将其配置成Spring的Bean便可。

@Bean
@Autowired
public ServiceInstanceChooser serviceInstanceChooser(LoadBalancerClient loadBalancerClient) {
    return new SpringCloudServiceInstanceChooser(loadBalancerClient);
}

使用`@Retrofit`的`serviceId`和`path`属性，能够实现微服务之间的HTTP调用

@RetrofitClient(serviceId = "${jy-helicarrier-api.serviceId}", path = "/m/count", errorDecoder = HelicarrierErrorDecoder.class)
@Retry
public interface ApiCountService {

}

调用适配器和数据转码器

调用适配器

Retrofit能够经过调用适配器CallAdapterFactory将Call<T>对象适配成接口方法的返回值类型。retrofit-spring-boot-starter扩展2种CallAdapterFactory实现：

BodyCallAdapterFactory

默认启用，可经过配置 retrofit.enable-body-call-adapter=false关闭
同步执行http请求，将响应体内容适配成接口方法的返回值类型实例。
除了 Retrofit.Call<T>、 Retrofit.Response<T>、 java.util.concurrent.CompletableFuture<T>以外，其它返回类型均可以使用该适配器。

ResponseCallAdapterFactory

默认启用，可经过配置 retrofit.enable-response-call-adapter=false关闭
同步执行http请求，将响应体内容适配成 Retrofit.Response<T>返回。
若是方法的返回值类型为 Retrofit.Response<T>，则可使用该适配器。

Retrofit自动根据方法返回值类型选用对应的CallAdapterFactory执行适配处理！加上Retrofit默认的CallAdapterFactory，可支持多种形式的方法返回值类型：

Call<T>: 不执行适配处理，直接返回 Call<T>对象
CompletableFuture<T>: 将响应体内容适配成 CompletableFuture<T>对象返回
Void: 不关注返回类型可使用 Void。若是http状态码不是2xx，直接抛错！
Response<T>: 将响应内容适配成 Response<T>对象返回
其余任意Java类型：将响应体内容适配成一个对应的Java类型对象返回，若是http状态码不是2xx，直接抛错！

    /**
     * Call<T>
     * 不执行适配处理，直接返回Call<T>对象
     * @param id
     * @return
     */
    @GET("person")
    Call<Result<Person>> getPersonCall(@Query("id") Long id);

    /**
     *  CompletableFuture<T>
     *  将响应体内容适配成CompletableFuture<T>对象返回
     * @param id
     * @return
     */
    @GET("person")
    CompletableFuture<Result<Person>> getPersonCompletableFuture(@Query("id") Long id);

    /**
     * Void
     * 不关注返回类型可使用Void。若是http状态码不是2xx，直接抛错！
     * @param id
     * @return
     */
    @GET("person")
    Void getPersonVoid(@Query("id") Long id);

    /**
     *  Response<T>
     *  将响应内容适配成Response<T>对象返回
     * @param id
     * @return
     */
    @GET("person")
    Response<Result<Person>> getPersonResponse(@Query("id") Long id);

    /**
     * 其余任意Java类型
     * 将响应体内容适配成一个对应的Java类型对象返回，若是http状态码不是2xx，直接抛错！
     * @param id
     * @return
     */
    @GET("person")
    Result<Person> getPerson(@Query("id") Long id);

咱们也能够经过继承CallAdapter.Factory扩展实现本身的CallAdapter ！

retrofit-spring-boot-starter支持经过retrofit.global-call-adapter-factories配置全局调用适配器工厂，工厂实例优先从Spring容器获取，若是没有获取到，则反射建立。默认的全局调用适配器工厂是[BodyCallAdapterFactory, ResponseCallAdapterFactory]！

retrofit:
  # 全局调用适配器工厂
  global-call-adapter-factories:
    - com.github.lianjiatech.retrofit.spring.boot.core.BodyCallAdapterFactory
    - com.github.lianjiatech.retrofit.spring.boot.core.ResponseCallAdapterFactory

针对每一个Java接口，还能够经过@RetrofitClient注解的callAdapterFactories()指定当前接口采用的CallAdapter.Factory，指定的工厂实例依然优先从Spring容器获取。

注意：若是CallAdapter.Factory没有public的无参构造器，请手动将其配置成Spring容器的Bean对象 ！

数据转码器

Retrofit使用Converter将@Body注解标注的对象转换成请求体，将响应体数据转换成一个Java对象，能够选用如下几种Converter：

Gson: com.squareup.Retrofit:converter-gson
Jackson: com.squareup.Retrofit:converter-jackson
Moshi: com.squareup.Retrofit:converter-moshi
Protobuf: com.squareup.Retrofit:converter-protobuf
Wire: com.squareup.Retrofit:converter-wire
Simple XML: com.squareup.Retrofit:converter-simplexml
JAXB: com.squareup.retrofit2:converter-jaxb

retrofit-spring-boot-starter支持经过retrofit.global-converter-factories配置全局数据转换器工厂，转换器工厂实例优先从Spring容器获取，若是没有获取到，则反射建立。默认的全局数据转换器工厂是retrofit2.converter.jackson.JacksonConverterFactory，你能够直接经过spring.jackson.*配置jackson序列化规则，配置可参考Customize the Jackson ObjectMapper！

retrofit:
  # 全局转换器工厂
  global-converter-factories:
    - retrofit2.converter.jackson.JacksonConverterFactory

针对每一个Java接口，还能够经过@RetrofitClient注解的converterFactories()指定当前接口采用的Converter.Factory，指定的转换器工厂实例依然优先从Spring容器获取。

注意：若是Converter.Factory没有public的无参构造器，请手动将其配置成Spring容器的Bean对象 ！

总结

retrofit-spring-boot-starter一个适用于SpringBoot项目的轻量级HTTP客户端框架，已在线上稳定运行一年多，而且已经有多个外部公司也接入使用。

本文分享自微信公众号 - 业余草（yyucao）。
若有侵权，请联系 support@oschina.cn 删除。
本文参与“OSC源创计划”，欢迎正在阅读的你也加入，一块儿分享。

为何我决定要放弃 okhttp、httpClient？