乐趣区

关于java:推荐一个适用于SpringBoot项目的轻量级HTTP客户端框架快来试试它

jiezi

在 SpringBoot 我的项目间接应用 okhttp、httpClient 或者 RestTemplate 发动 HTTP 申请，既繁琐又不不便对立治理。因而，在这里举荐一个实用于 SpringBoot 我的项目的轻量级 HTTP 客户端框架 retrofit-spring-boot-starter，应用非常简单不便，同时又提供诸多性能加强。目前我的项目曾经更新至 2.2.2 版本，并且会继续进行迭代优化。

我的项目地址：https://github.com/LianjiaTech/retrofit-spring-boot-starter

前言

Retrofit是实用于 Android 和Java且类型平安的 HTTP 客户端，其最大的个性的是 反对通过 接口 的形式发动 HTTP 申请 。而spring-boot 是应用最宽泛的 Java 开发框架，然而 Retrofit 官网没有反对与 spring-boot 框架疾速整合，因而咱们开发了retrofit-spring-boot-starter。

retrofit-spring-boot-starter实现了 Retrofit 与spring-boot框架疾速整合，并且反对了诸多性能加强，极大简化开发。

???? 我的项目继续优化迭代，欢送大家提 ISSUE 和 PR！麻烦大家能给一颗 star✨，您的 star 是咱们继续更新的能源！

性能个性

  • [x] 自定义注入 OkHttpClient
  • [x] 注解式拦截器
  • [x] 连接池治理
  • [x] 日志打印
  • [x] 申请重试
  • [x] 谬误解码器
  • [x] 全局拦截器
  • [x] 熔断降级
  • [x] 微服务之间的 HTTP 调用
  • [x] 调用适配器
  • [x] 数据转换器

疾速应用

引入依赖

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

定义 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 步：

  1. 继承 BasePathMatchInterceptor 编写拦挡处理器；
  2. 接口上应用 @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 步：

  1. 自定义拦挡注解
  2. 继承 BasePathMatchInterceptor 编写拦挡处理器
  3. 接口上应用自定义拦挡注解；

例如咱们须要 在申请头外面动静退出 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 点须要留神：

  1. 自定义拦挡注解 必须应用 @InterceptMark 标记。
  2. 注解中必须包含 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 的连接池，代码实现如下：

  1. 配置连接池。

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

  2. 通过 @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 种日志打印策略含意如下：

  1. NONE：No logs.
  2. BASIC：Logs request and response lines.
  3. HEADERS：Logs request and response lines and their respective headers.
  4. 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 配置。重试规定反对三种配置：

  1. RESPONSE_STATUS_NOT_2XX：响应状态码不是 2xx 时执行重试；
  2. OCCUR_IO_EXCEPTION：产生 IO 异样时执行重试；
  3. 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 实现：

  1. BodyCallAdapterFactory

    • 默认启用，可通过配置 retrofit.enable-body-call-adapter=false 敞开
    • 同步执行 http 申请，将响应体内容适配成接口办法的返回值类型实例。
    • 除了 Retrofit.Call<T>、Retrofit.Response<T>、java.util.concurrent.CompletableFuture<T> 之外，其它返回类型都能够应用该适配器。

  2. 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 客户端框架，已在线上稳固运行一年多，并且曾经有多个内部公司也接入应用。有趣味的敌人能够尝试一下，如有任何问题，欢送提 issue 或者加 QQ 群（806714302）反馈，极速响应反对。

原创不易，感觉文章写得不错的小伙伴，点个赞???? 激励一下吧~

退出移动版