Location>code7788 >text

Refit principle analysis: From the beginning to the practice

Popularity：59 ℃/2025-02-28 17:14:19

HTTP API calls are an integral part of modern distributed systems and microservice architectures. To simplify the construction and parsing of HTTP requests, we can useRefitThis powerful library. Refit makes calling remote services very simple and intuitive by abstracting the HTTP API into an interface.

1. First meet Refit

Refit is a type-safe REST client library for .NET. It allows you to describe the HTTP API by defining an interface and automatically generate implementation code. The core idea of ​​Refit is to abstract HTTP API calls into interface methods. Developers only need to define interfaces. Refit will automatically handle the construction, sending and resolution of HTTP requests.

Define a simple API interface

public interface IUserRefitApi
{
    [Get("/users/{id}")]
    Task<User> GetUserAsync(int id);
}

In this example,IUserRefitApiThe interface describes an API that obtains user information. Refit will automatically generate HTTP request codes based on interface definitions.

2. The role of Refit

The main function of Refit isSimplify calls to HTTP APIs. Specifically, Refit can help developers:

  1. 1. Reduce boilerplate code: No manual creation is requiredHttpClient, build request, parse response.
  2. 2. Improve code readability: Defining API through interfaces makes the code clearer and easier to understand.
  3. 3. Enhanced type safety: The compiler will check the interface definition and return value types to reduce runtime errors.
  4. 4. Support asynchronous operation: All methods are supportedasync/await, suitable for modern asynchronous programming mode.
  5. 5. Flexible configuration: Supports custom serialization, adding request headers, handling errors, etc.

3. The principle of Refit

The working principle of Refit can be divided into the following steps:

3.1 Interface resolution

Refit extracts HTTP methods through reflection parsing interface definition (such as[Get]、[Post]), path, parameters and other information.

  • • HTTP Methods: By annotation (such as[Get]、[Post]) Specified.
  • • path: The path in the annotation can contain placeholders (such as{username}), these placeholders are replaced by the method's parameters.
  • • parameter: The parameters of the method can be bound to paths, query strings, request bodies, etc.

3.2 Request to build

Refit builds HTTP requests based on interface definitions. It will bind the parameters of the method to the request path, query string, request body, etc.

  • • Path parameters: Replaced by placeholder.
  • • Query parameters:pass[Query]Annotation specification.
  • • Request body:pass[Body]Annotation specification.

3.3 Request to send

Refit UseHttpClientSend an HTTP request. It sends the built request to the specified API endpoint.

3.4 Response Analysis

Refit receives an HTTP response and deserializes it to the return type of the method. By default, Refit usesPerform deserialization.

3.5 Exception handling

If the HTTP request fails (such as returning a 4xx or 5xx status code), Refit will throwApiException, developers can catch and handle these exceptions.

4. Refit usage scenarios

Refit is suitable for the following scenarios:

  1. 1. Calling the RESTful API：
    • • Refit simplifies the construction and parsing of HTTP requests when you need to communicate with external services such as third-party APIs.
  2. 2. Microservice architecture：
    • • In a microservice architecture, services usually communicate over HTTP. Refit can help you quickly create type-safe clients and reduce the effort to manually write HTTP request code.
  3. 3. Mobile applications and backend communications：
    • • In mobile applications, Refit can be used to communicate with backend services, simplifying the logic of network requests.
  4. 4. Rapid development：
    • • When you need to quickly test or integrate an API, Refit allows you to write API call code in minutes.
  5. 5. Scenarios that require strong type support：
    • • Refit provides strongly typed API calls, avoiding the hassle of manually parsing JSON or processing strings.

5. Project Practice

5.1 Install Refit

Install the NuGet package for Refit:

dotnet add package 

What we installed here isBag,Refitandare two different parts of the Refit library, and their functions and usage scenarios are different.

RefitandThe roughly differentiates are as follows:

characteristic Refit core library
rely Direct dependencyHttpClient relyHttpClientFactory
Lifecycle Management Need to be managed manuallyHttpClient
life cycle Depend onHttpClientFactoryAutomatic management
Dependency injection support Direct dependency injection is not supported Supports dependency injection
Applicable scenarios Simple console application or manual management
HttpClient Core or other dependency injection applications
Configuration flexibility Need to manually configureHttpClient Can be passedHttpClientFactoryConfiguration

Use Refit in Core, it is recommended to usebecause it hasHttpClientFactoryBetter integration, more flexible configuration and managementHttpClient。

5.2 Defining API Interfaces

Define an interface in the project to describe the external API you want to call. We will use/usersRelated endpoints.

using ;
 using ;
 using Refit;

 public interface IUserRefitApi
 {
 //Acquiring all users
 [Get("/users")]
 Task<List<User>> GetUsersAsync();

 //Acquiring a single user
 [Get("/users/{id}")]
 Task<User> GetUserAsync(int id);

 // Create a new user
 [Post("/users")]
 Task<User> CreateUserAsync([Body] User user);

 //Update users
 [Put("/users/{id}")]
 Task<User> UpdateUserAsync(int id, [Body] User user);

 // Delete the user
 [Delete("/users/{id}")]
 Task DeleteUserAsync(int id);
 }

5.3 Register the Refit Client

existRegister the Refit client in Refit. You can useHttpClientFactoryCome to manageHttpClientlife cycle.

using ;
 using Refit;

 var builder = (args);

 // Add Refit client
 <IUserRefitApi>()
 ConfigureHttpClient(c => = new Uri("https://******"));

 var app = ();

 // Configure middleware and routing
 ();

 ();

5.4 Using Refit Client in Controller

Inject the Refit client into the controller of the Web API and call the external API.

using ;
 using ;

 [ApiController]
 [Route("api/[controller]")]
 public class UsersController : ControllerBase
 {
 private readonly IUserRefitApi _userRefitApi;

 public UsersController(IUserRefitApi userRefitApi)
     {
 _userRefitApi = userRefitApi;
     }

 //Acquiring all users
 [HttpGet]
 public async Task<IActionResult> GetUsers()
     {
 var users = await _userRefitApi.GetUsersAsync();
 return Ok(users);
     }

 //Acquiring a single user
 [HttpGet("{id}")]
 public async Task<IActionResult> GetUser(int id)
     {
 var user = await _userRefitApi.GetUserAsync(id);
 return Ok(user);
     }

 // Create a new user
 [HttpPost]
 public async Task<IActionResult> CreateUser([FromBody] User user)
     {
 var createdUser = await _userRefitApi.CreateUserAsync(user);
 return Ok(createdUser);
     }

 //Update users
 [HttpPut("{id}")]
 public async Task<IActionResult> UpdateUser(int id, [FromBody] User user)
     {
 var updatedUser = await _userRefitApi.UpdateUserAsync(id, user);
 return Ok(updatedUser);
     }

 // Delete the user
 [HttpDelete("{id}")]
 public async Task<IActionResult> DeleteUser(int id)
     {
 await _userRefitApi.DeleteUserAsync(id);
 return NoContent();
     }
 }

6. Extended functions

6.1 Adding a request header

Can be passed[Headers]Annotation adds request headers for interfaces or methods:

[Headers("Authorization: Bearer TOKEN")]
public interface IUserRefitApi
{
   [Get("/users")]
   Task<List<User>> GetUsersAsync();
}

6.2 Custom serialization

Can be passedRefitSettingsCustom serialization behavior:

<IUserRefitApi>(new RefitSettings
{
    ContentSerializer = new NewtonsoftJsonContentSerializer()
    })
    .ConfigureHttpClient(c =>  = new Uri("https://******"));

6.3 File upload

Refit supports file upload. Available[Multipart]annotation:

public interface IFileApi
{
    [Multipart]
    [Post("/upload")]
    Task UploadFileAsync([AliasAs("file")] StreamPart file);
}

7. Summary

Using Refit in the .NET Core Web API can greatly simplify calls to external HTTP APIs. By defining interfaces and annotations, Refit can automatically generate HTTP request codes and passHttpClientFactorymanageHttpClientlife cycle. Whether it is calling third-party APIs or implementing microservice communication, Refit is a very practical tool.

.preview-wrapper pre::before { position: absolute; top: 0; right: 0; color: #ccc; text-align: center; font-size: 0.8em; padding: 5px 10px 0; line-height: 15px; height: 15px; font-weight: 600; } .hljs.code__pre > .mac-sign { display: flex; } .code__pre { padding: 0 !important; } .hljs.code__pre code { display: -webkit-box; padding: 0.5em 1em 1em; overflow-x: auto; text-indent: 0; }

<Previous Next>