HttpClient is Outdated, OkHttp is Losing Ground! This Tool is the New King!

HttpClient is Outdated, OkHttp is Losing Ground! This Tool is the New King! We are dedicated to exploring, sharing, and recommending the latest practical technology stacks, open-source projects, frameworks, and useful tools. Fresh open-source information awaits your discovery every day!

Using SpringBoot directly with OkHttp, HttpClient, or RestTemplate to initiate HTTP requests is cumbersome and inconvenient for unified management. Therefore, we recommend a lightweight HTTP client framework suitable for SpringBoot projects: retrofit-spring-boot-starter, which is very simple and convenient to use while providing many functional enhancements. The project has been updated to version 2.2.2 and will continue to be iterated and optimized.

Introduction

Retrofit is a type-safe HTTP client for Android and Java, with its biggest feature being support for initiating HTTP requests via interfaces. Meanwhile, spring-boot is the most widely used Java development framework, but the official Retrofit does not support quick integration with the spring-boot framework, which is why we developed retrofit-spring-boot-starter.

retrofit-spring-boot-starter achieves quick integration of Retrofit with the spring-boot framework and supports many functional enhancements, greatly simplifying development.

Features

Custom injection of OkHttpClient
Annotation-based interceptors
Connection pool management
Logging
Request retries
Error decoders
Global interceptors
Circuit breaker and degradation
HTTP calls between microservices
Call adapters
Data converters

Quick Start

Include Dependency

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

Define HTTP Interface

The interface must be marked with the@RetrofitClient annotation! HTTP-related annotations can refer to the official documentation: Retrofit official documentation.

@RetrofitClient(baseUrl = "${test.baseUrl}")
public interface HttpApi {
    @GET("person")
    Result<Person> getPerson(@Query("id") Long id);
}

Inject and Use

Simply inject the interface into other services to use!

@Service
public class TestService {
    @Autowired
    private HttpApi httpApi;
    public void test() {
        // Initiate HTTP request through httpApi
    }
}

HTTP Request Related Annotations

HTTP request-related annotations all use the retrofit native annotations. For detailed information, refer to the official documentation: Retrofit official documentation, below is a simple explanation.

Annotation Category	Supported Annotations
Request Methods	@GET @HEAD @POST @PUT @DELETE @OPTIONS
Request Headers	@Header @HeaderMap @Headers
Query Parameters	@Query @QueryMap @QueryName
Path Parameters	@Path
Form-encoded Parameters	@Field @FieldMap @FormUrlEncoded
File Upload	@Multipart @Part @PartMap
URL Parameters	@Url

Configuration Item Description

retrofit-spring-boot-starter supports multiple configurable properties to handle different business scenarios. You can modify them as needed, specific descriptions are as follows:

If you are preparing for an interview or job change, it is recommended to practice online at ddkk.com, covering over 10,000 Java interview questions, almost all mainstream technical interview questions, and the most comprehensive technical resources available on the market, along with high-quality tutorial series, provided for free.

Configuration	Default Value	Description
enable-log	true	Enable logging
logging-interceptor	DefaultLoggingInterceptor	Logging interceptor
pool	Connection pool configuration
disable-void-return-type	false	Disable java.lang.Void return type
retry-interceptor	DefaultRetryInterceptor	Request retry interceptor
global-converter-factories	JacksonConverterFactory	Global converter factory
global-call-adapter-factories	BodyCallAdapterFactory, ResponseCallAdapterFactory	Global call adapter factory
enable-degrade	false	Whether to enable circuit breaker degradation
degrade-type	sentinel	Circuit breaker degradation implementation method (currently only supports Sentinel)
resource-name-parser	DefaultResourceNameParser	Circuit breaker resource name parser, used to parse resource names

yml configuration method:

retrofit:
  enable-response-call-adapter: true
  # Enable logging
  enable-log: true
  # Connection pool configuration
  pool:
    test1:
      max-idle-connections: 3
      keep-alive-second: 100
    test2:
      max-idle-connections: 5
      keep-alive-second: 50
  # Disable void return type
  disable-void-return-type: false
  # Logging interceptor
  logging-interceptor: com.github.lianjiatech.retrofit.spring.boot.interceptor.DefaultLoggingInterceptor
  # Request retry interceptor
  retry-interceptor: com.github.lianjiatech.retrofit.spring.boot.retry.DefaultRetryInterceptor
  # Global converter factory
  global-converter-factories:
    - retrofit2.converter.jackson.JacksonConverterFactory
  # Global call adapter factory
  global-call-adapter-factories:
    - com.github.lianjiatech.retrofit.spring.boot.core.BodyCallAdapterFactory
    - com.github.lianjiatech.retrofit.spring.boot.core.ResponseCallAdapterFactory
  # Whether to enable circuit breaker degradation
  enable-degrade: true
  # Circuit breaker degradation implementation method
  degrade-type: sentinel
  # Circuit breaker resource name parser
  resource-name-parser: com.github.lianjiatech.retrofit.spring.boot.degrade.DefaultResourceNameParser

Advanced Features

Custom Injection of OkHttpClient

In most cases, dynamically creating the OkHttpClient object through the properties of the @RetrofitClient annotation can meet most usage scenarios. However, in some cases, users may need to customize the OkHttpClient, at which point, you can define a static method returning type OkHttpClient.Builder on the interface to achieve this. The code example is as follows:

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

The method must be marked with the @OkHttpClientBuilder annotation!

Annotation-based Interceptors

Many times, we want certain HTTP requests under a specific interface to execute unified interception logic. To support this functionality, retrofit-spring-boot-starter provides annotation-based interceptors, achieving URL path-based matching interception. The steps to use it are mainly divided into 2 steps:

1. Inherit BasePathMatchInterceptor to write the interceptor;2. Use @Intercept to annotate the interface. If you need to configure multiple interceptors, simply annotate multiple @Intercept annotations on the interface!

Below is an example of how to use annotation-based interceptors to append a timestamp to a specified request URL.

Inherit`BasePathMatchInterceptor` to Write the Interceptor

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

Use`@Intercept` to Annotate the Interface

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

The above @Intercept configuration indicates: intercept requests under the HttpApi interface at the /api/** path (excluding /api/test/savePerson), using the TimeStampInterceptor interceptor.

Extend Annotation-based Interceptors

Sometimes, we need to dynamically pass some parameters into the intercept annotation, and then use these parameters during interception. In such cases, we can extend to implement custom intercept annotations.Custom intercept annotations must be marked with @InterceptMark, and the annotation must include include(), exclude(), handler() attribute information. The steps to use are mainly divided into 3 steps:

1. Custom Intercept Annotation 2. Inherit BasePathMatchInterceptor to write the interceptor3. Use the custom intercept annotation on the interface;

For example, if we need to dynamically add accessKeyId, accessKeySecret signature information in the request header to initiate HTTP requests normally, we can define a signing interceptor annotation @Sign to achieve this. Below is an example of the custom @Sign intercept annotation.

Custom`@Sign` Annotation

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@InterceptMark
public @interface Sign {
    /**
     * Secret key
     * Supports placeholder configuration.
     *
     * @return
     */
    String accessKeyId();
    /**
     * Secret
     * Supports placeholder configuration.
     *
     * @return
     */
    String accessKeySecret();
    /**
     * Interceptor matching path
     *
     * @return
     */
    String[] include() default {"/**"};
    /**
     * Interceptor exclusion matching, exclude specified path interception
     *
     * @return
     */
    String[] exclude() default {};
    /**
     * Interceptor class that handles this annotation
     * Priority is given to obtaining the corresponding Bean from the spring container, if not found, it will be created using reflection!
     *
     * @return
     */
    Class<? extends BasePathMatchInterceptor> handler() default SignInterceptor.class;
}

There are two points to note about extending custom intercept annotations:

1. Custom intercept annotations must be marked with @InterceptMark.

2. The annotation must include include(), exclude(), handler() attribute information.

Implement`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);
    }
}

The above accessKeyId and accessKeySecret field values will be automatically injected based on the @Sign annotation’s accessKeyId() and accessKeySecret() values. If the @Sign specifies a placeholder string, the configuration property value will be used for injection. Additionally, the accessKeyId and accessKeySecret fields must provide setter<code> methods.

Use on the Interface`@Sign`

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

This way, signature information will be automatically added to requests at the specified URL.

Connection Pool Management

By default, all HTTP requests sent through Retrofit will use the default connection pool with max-idle-connections=5 keep-alive-second=300. Of course, we can also configure multiple custom connection pools in the configuration file and specify which one to use through the @RetrofitClient’s poolName property. For example, if we want all requests under a certain interface to use the poolName=test1 connection pool, the code implementation is as follows:

1. Configure the Connection Pool.

retrofit:
        # Connection pool configuration
        pool:
            test1:
            max-idle-connections: 3
            keep-alive-second: 100
            test2:
            max-idle-connections: 5
            keep-alive-second: 50

2. Specify the Connection Pool to Use via @RetrofitClient’s poolName property.

@RetrofitClient(baseUrl = "${test.baseUrl}", poolName="test1")
    public interface HttpApi {
        @GET("person")
        Result<Person> getPerson(@Query("id") Long id);
    }

Logging

In many cases, we want to log HTTP request details. The logging can be globally controlled by the retrofit.enableLog configuration. For each interface, you can control whether logging is enabled through the @RetrofitClient’s enableLog property, and specify the logging level and strategy for each interface through logLevel and logStrategy.

retrofit-spring-boot-starter supports 5 logging levels (ERROR, WARN, INFO, DEBUG, TRACE), with the default being INFO; it supports 4 logging strategies (NONE, BASIC, HEADERS, BODY), with the default being BASIC. The meanings of the 4 logging strategies are as follows:

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 uses DefaultLoggingInterceptor to perform the actual logging function, which is based on okhttp’s native HttpLoggingInterceptor. Of course, you can also implement your own logging interceptor by inheriting from BaseLoggingInterceptor (for specific implementation, refer to DefaultLoggingInterceptor’s implementation), and then configure it in the configuration file.

retrofit:
  # Logging interceptor
  logging-interceptor: com.github.lianjiatech.retrofit.spring.boot.interceptor.DefaultLoggingInterceptor

Request Retries

retrofit-spring-boot-starter supports request retry functionality, simply add the @Retry annotation to the interface or method. @Retry supports retry countmaxRetries, retry intervalintervalMs, and retry rulesretryRules configuration. The retry rules support three configurations:

1. RESPONSE_STATUS_NOT_2XX: Retry when the response status code is not 2xx.2. OCCUR_IO_EXCEPTION: Retry when an IO exception occurs.3. OCCUR_EXCEPTION: Retry when any exception occurs.

By default, retries are automatically performed when the response status code is not 2xx or when an IO exception occurs. If needed, you can also inherit from BaseRetryInterceptor to implement your own request retry interceptor and configure it.

retrofit:
  # Request retry interceptor
  retry-interceptor: com.github.lianjiatech.retrofit.spring.boot.retry.DefaultRetryInterceptor

Error Decoders

When an HTTP request error occurs (including exceptions or response data not meeting expectations), the error decoder can decode the HTTP-related information into a custom exception. You can specify the current interface’s error decoder in the @RetrofitClient annotation’s errorDecoder() method; custom error decoders need to implement the <code>ErrorDecoder interface:

/**
 * Error decoder. ErrorDecoder.
 * 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 {
    /**
     * 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;
    }
    /**
     * 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);
    }
    /**
     * 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);
    }
}

Global Interceptors

Global Application Interceptors

If we need to perform unified interception processing on all HTTP requests in the system, we can customize and implement a global interceptor BaseGlobalInterceptor, and configure it as a bean in the spring container! For example, if we want all HTTP requests initiated in the system to carry source information.

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

Global Network Interceptors

Simply implement the NetworkInterceptor interface and configure it as a bean in the spring container to support automatic weaving of global network interceptors.

Circuit Breaker and Degradation

In a distributed service architecture, performing circuit breaker degradation on unstable external services is one of the important measures to ensure high service availability. Since the stability of external services cannot be guaranteed, when external services are unstable, response times will increase. Consequently, the response time for the caller will also increase, threads will pile up, and eventually, it may exhaust the caller’s thread pool, leading to the entire service becoming unavailable. Therefore, we need to perform circuit breaker degradation on unstable weak dependency service calls to temporarily cut off unstable calls, preventing local instability from causing an overall service avalanche.

retrofit-spring-boot-starter supports circuit breaker degradation functionality, based on Sentinel. Specifically, it supports circuit breaker resource self-discovery and annotation-based degradation rule configuration. To use circuit breaker degradation, simply perform the following operations:

1. Enable Circuit Breaker Degradation Functionality

By default, the circuit breaker degradation functionality is disabled, and you need to set the corresponding configuration items to enable it:

retrofit:
  # Whether to enable circuit breaker degradation
  enable-degrade: true
  # Circuit breaker degradation implementation method (currently only supports Sentinel)
  degrade-type: sentinel
  # Resource name parser
  resource-name-parser: com.github.lianjiatech.retrofit.spring.boot.degrade.DefaultResourceNameParser

The resource name parser is used to implement user-defined resource names, the default configuration is DefaultResourceNameParser, corresponding to the resource name format HTTP_OUT:GET:http://localhost:8080/api/degrade/test. Users can inherit from the BaseResourceNameParser class to implement their own resource name parser.

Additionally, since the circuit breaker degradation functionality is optional, enabling it requires users to manually introduce the Sentinel dependency:

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

2. Configure Degradation Rules (Optional)

retrofit-spring-boot-starter supports annotation-based configuration of degradation rules, configured through the @Degrade annotation. The @Degrade annotation can be configured on interfaces or methods, with higher priority when configured on methods.

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

If the application project already supports configuring degradation rules through a configuration center, the annotation-based configuration method can be ignored.

3. Set Fallback or FallbackFactory in @RetrofitClient (Optional)

If @RetrofitClient does not set fallback or fallbackFactory, when a circuit breaker is triggered, it will directly throw a RetrofitBlockException exception. Users can customize the return value of the method when the circuit breaker is triggered by setting fallback or fallbackFactory. The fallback class must be an implementation of the current interface, and the fallbackFactory must be an implementation of FallbackFactory<T>, with the generic parameter type being the current interface type. Additionally, the fallback and fallbackFactory instances must be configured as Spring container Bean instances.

fallbackFactory differs from fallback mainly in that it can perceive the cause of each circuit breaker (cause). Below is a reference example:

@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 an instance that implements the retrofit interface.
     */
    @Override
    public HttpDegradeApi create(Throwable cause) {
        log.error("Circuit breaker triggered! ", 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 Calls Between Microservices

To enable microservice calls, the following configuration is required:

Configure`ServiceInstanceChooser` as a `Spring` Container `Bean`

Users can implement the ServiceInstanceChooser interface to complete the service instance selection logic and configure it as a Spring container Bean. For Spring Cloud applications, retrofit-spring-boot-starter provides the SpringCloudServiceInstanceChooser implementation, and users only need to configure it as a Spring Bean.

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

Using`@Retrofit`’s `serviceId` and `path` Properties, HTTP Calls Between Microservices Can Be Achieved

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

Call Adapters and Data Converters

Call Adapters

Retrofit can adapt Call<T> objects to the return value types of interface methods through call adapters CallAdapterFactory. retrofit-spring-boot-starter extends two CallAdapterFactory implementations:

1. BodyCallAdapterFactory

 *  Enabled by default, can be disabled by configuring `retrofit.enable-body-call-adapter=false`
 *  Synchronously executes HTTP requests, adapting the response body content to the return value type instance of the interface method.
 *  Besides `Retrofit.Call<T>`, `Retrofit.Response<T>`, `java.util.concurrent.CompletableFuture<T>`, other return types can use this adapter.

2. ResponseCallAdapterFactory

 *  Enabled by default, can be disabled by configuring `retrofit.enable-response-call-adapter=false`
 *  Synchronously executes HTTP requests, adapting the response body content to return `Retrofit.Response<T>`.
 *  If the method's return type is `Retrofit.Response<T>`, this adapter can be used.

Retrofit automatically selects the corresponding CallAdapterFactory based on the method return value type for adaptation! In addition to the default CallAdapterFactory, it supports various forms of method return value types:

Call<T>

: No adaptation processing, directly returns the Call<T> object
CompletableFuture<T>

: Adapts the response body content to return a CompletableFuture<T> object
Void

: Can use Void if the return type is not a concern. If the HTTP status code is not 2xx, it throws an error!
Response<T>

: Adapts the response content to return a Response<T> object
Any other Java type: Adapts the response body content to return a corresponding Java type object, if the HTTP status code is not 2xx, it throws an error!

/**
     * Call<T>
     * No adaptation processing, directly returns Call<T> object
     * @param id
     * @return
     */
    @GET("person")
    Call<Result<Person>> getPersonCall(@Query("id") Long id);
    /**
     *  CompletableFuture<T>
     *  Adapts the response body content to return a CompletableFuture<T> object
     * @param id
     * @return
     */
    @GET("person")
    CompletableFuture<Result<Person>> getPersonCompletableFuture(@Query("id") Long id);
    /**
     * Void
     * Can use Void if the return type is not a concern. If the HTTP status code is not 2xx, it throws an error!
     * @param id
     * @return
     */
    @GET("person")
    Void getPersonVoid(@Query("id") Long id);
    /**
     *  Response<T>
     *  Adapts the response content to return a Response<T> object
     * @param id
     * @return
     */
    @GET("person")
    Response<Result<Person>> getPersonResponse(@Query("id") Long id);
    /**
     * Any other Java type
     * Adapts the response body content to return a corresponding Java type object, if the HTTP status code is not 2xx, it throws an error!
     * @param id
     * @return
     */
    @GET("person")
    Result<Person> getPerson(@Query("id") Long id);

We can also extend and implement our own CallAdapter by inheriting from CallAdapter.Factory!

retrofit-spring-boot-starter supports configuring global call adapter factories through retrofit.global-call-adapter-factories, the factory instance is prioritized to be obtained from the Spring container, and if not obtained, it will be created using reflection. The default global call adapter factories are [BodyCallAdapterFactory, ResponseCallAdapterFactory]!

retrofit:
  # Global call adapter factory
  global-call-adapter-factories:
    - com.github.lianjiatech.retrofit.spring.boot.core.BodyCallAdapterFactory
    - com.github.lianjiatech.retrofit.spring.boot.core.ResponseCallAdapterFactory

For each Java interface, you can also specify the CallAdapter.Factory used by the current interface through the @RetrofitClient annotation’s callAdapterFactories(), the specified factory instance is still prioritized to be obtained from the Spring container.

Note: If the CallAdapter.Factory does not have a public no-argument constructor, please manually configure it as a Spring container Bean object!

Data Converters

Retrofit uses Converter to convert objects annotated with @Body into request bodies and to convert response body data into a Java object. The following converters can be selected:

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 supports configuring global data converter factories through retrofit.global-converter-factories, the converter factory instance is prioritized to be obtained from the Spring container, and if not obtained, it will be created using reflection. The default global data converter factory is retrofit2.converter.jackson.JacksonConverterFactory, and you can directly configure spring.jackson.* to set Jackson serialization rules, refer to Customize the Jackson ObjectMapper for configuration!

retrofit:
  # Global converter factory
  global-converter-factories:
    - retrofit2.converter.jackson.JacksonConverterFactory

For each Java interface, you can also specify the Converter.Factory used by the current interface through the @RetrofitClient annotation’s converterFactories(), the specified converter factory instance is still prioritized to be obtained from the Spring container.

Note: If the Converter.Factory does not have a public no-argument constructor, please manually configure it as a Spring container Bean object.

—END—This account has collected some learning materials, welcome to obtain: reply 888 to get learning e-books! reply 666 to get video learning resources!Exciting RecommendationsA powerful intelligent operation and maintenance platform open-sourced by Tencent!A tool for taking private jobs, the fastest website building framework in the world! (79.8k stars)36.6k stars, a powerful low-code platform[Zero-code development] Magic-Boot open-source engine: Play enterprise-level development in IDE, efficiency skyrockets![Gitee Hot List] Deep analysis of the open-source low-code tool Jeecg-Boot: Build an enterprise-level system in 3 days!45.4k stars, build an enterprise-level management system in 3 minutes47.8k stars, a tool for taking private jobs, complete enterprise-level authentication in 10 minutes!11.4k stars, a low-intrusion operation and maintenance tool! One-click realization of automated deployment + monitoring!Development scaffolding recommendation, an enterprise-level rapid development platform!Development scaffolding recommendation, no more reinventing the wheel, let Java be “sweet”!Low-code tool, zero-code to build data dashboards and visual reports

HttpClient is Outdated, OkHttp is Losing Ground! This Tool is the New King!

Introduction

Features

Quick Start

Include Dependency

Define HTTP Interface

Inject and Use

HTTP Request Related Annotations

Configuration Item Description

Advanced Features

Custom Injection of OkHttpClient

Annotation-based Interceptors

Inherit`<strong><span>BasePathMatchInterceptor</span></strong>` to Write the Interceptor

Use`<strong><span>@Intercept</span></strong>` to Annotate the Interface

Extend Annotation-based Interceptors

Custom`<strong><span>@Sign</span></strong>` Annotation

Implement`<strong><span>SignInterceptor</span></strong>`

Use on the Interface`<strong><span>@Sign</span></strong>`

Connection Pool Management

Logging

Request Retries

Error Decoders

Global Interceptors

Global Application Interceptors

Global Network Interceptors

Circuit Breaker and Degradation

1. Enable Circuit Breaker Degradation Functionality

2. Configure Degradation Rules (Optional)

3. Set Fallback or FallbackFactory in @RetrofitClient (Optional)

HTTP Calls Between Microservices

Configure`<strong><span>ServiceInstanceChooser</span></strong>` as a `<strong><span>Spring</span></strong>` Container `<strong><span>Bean</span></strong>`

Using`<strong><span>@Retrofit</span></strong>`’s `<strong><span>serviceId</span></strong>` and `<strong><span>path</span></strong>` Properties, HTTP Calls Between Microservices Can Be Achieved

Call Adapters and Data Converters

Call Adapters

Data Converters

Leave a Comment Cancel reply

Introduction

Features

Quick Start

Include Dependency

Define HTTP Interface

Inject and Use

HTTP Request Related Annotations

Configuration Item Description

Advanced Features

Custom Injection of OkHttpClient

Annotation-based Interceptors

Inherit<strong><span>BasePathMatchInterceptor</span></strong> to Write the Interceptor

Use<strong><span>@Intercept</span></strong> to Annotate the Interface

Extend Annotation-based Interceptors

Custom<strong><span>@Sign</span></strong> Annotation

Implement<strong><span>SignInterceptor</span></strong>

Use on the Interface<strong><span>@Sign</span></strong>

Connection Pool Management

Logging

Request Retries

Error Decoders

Global Interceptors

Global Application Interceptors

Global Network Interceptors

Circuit Breaker and Degradation

1. Enable Circuit Breaker Degradation Functionality

2. Configure Degradation Rules (Optional)

3. Set Fallback or FallbackFactory in @RetrofitClient (Optional)

HTTP Calls Between Microservices

Configure<strong><span>ServiceInstanceChooser</span></strong> as a <strong><span>Spring</span></strong> Container <strong><span>Bean</span></strong>

Using<strong><span>@Retrofit</span></strong>’s <strong><span>serviceId</span></strong> and <strong><span>path</span></strong> Properties, HTTP Calls Between Microservices Can Be Achieved

Call Adapters and Data Converters

Call Adapters

Data Converters

Related posts

Leave a Comment Cancel reply

Inherit`<strong><span>BasePathMatchInterceptor</span></strong>` to Write the Interceptor

Use`<strong><span>@Intercept</span></strong>` to Annotate the Interface

Custom`<strong><span>@Sign</span></strong>` Annotation

Implement`<strong><span>SignInterceptor</span></strong>`

Use on the Interface`<strong><span>@Sign</span></strong>`

Configure`<strong><span>ServiceInstanceChooser</span></strong>` as a `<strong><span>Spring</span></strong>` Container `<strong><span>Bean</span></strong>`

Using`<strong><span>@Retrofit</span></strong>`’s `<strong><span>serviceId</span></strong>` and `<strong><span>path</span></strong>` Properties, HTTP Calls Between Microservices Can Be Achieved