扔掉okhttp、httpClient，来试试这款轻量级HTTP客户端神器？

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

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

/**
 * 错误解码器。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);
}
}

@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);
}
}

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

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

@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;
}

@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;
        }
}
}

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

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

 * 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);

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

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