When you create microsers with a spring boot, you have to decide how the services will interact with each other. The basic choices in terms of protocol are messaging and comfort. In this article we will discuss comfortable tools, which is a common protocol for micro services. There are two well -known tolls Open Fine And Web client.
You will learn how they are different in their perspective, use issues and design. You will then have the necessary information to make the appropriate choice.
The table of content
Introduction to Open Fine
The Open Fine is an HTTP client tool that is actually manufactured by Netflix and is now retained as an open source community project. In the spring cloud environmental system, the open -fins allow you to explain the rest of the boiler plate code, using the interpreted Java interface.
A primary Open Fine Client looks like this:
@FeignClient(name = "book-service")
public interface BookClient {
@GetMapping("/books/{id}")
User getBookById(@PathVariable("id") Long id);
}
Then you can inject BookClient Like any spring bean:
@Service
public class BookService {
@Autowired
private BookClient bookClient;
public User getBook(Long id) {
return bookClient.getBookById(id);
}
}
Open Fine Spring Cloud Discovery Service (Euraka), Spring Cloud Config, and Spring Cloud Download Balancer is well connected. This is the best of the spring -based microsurious microsaries in the architecture. It has many important features.
Declaration syntax: It uses interfaces and interpretations to explain HTTP clients, avoiding the implementation of manual application.
Spring Cloud Integration: It is well connected with spring cloud components, such as service discovery (Eurica), Spring Config, and burden with baleson components.
Re -try and fallback mechanism: It can be easily integrated with spring cloud circuit breaker or flexible 4 -j.
Customs Configures: You can customize many aspects, such as headers, interceptors, logging, timeouts, and encoders/decoders.
Introduction to Web Client
Web client is a reaction http client, and it’s part of it Spring Web Floks The module is primarily based on non -blocking non -blocking HTTP communication, but it can also deal with synchronized calls.
Although the Open Fine follows a declaration design, the web client offers an essential, fluent API.
Here is a fundamental example of using a web client with harmony:
WebClient client = WebClient.create("http://book-service");
User user = client.get()
.uri("/books/{id}", 1L)
.retrieve()
.bodyToMono(Book.class)
.block();
Or seriously:
Mono bookMono = client.get()
.uri("/books/{id}", 1L)
.retrieve()
.bodyToMono(Book.class);
Designed designed non -blocking and reaction, the web client performs well with high thruppets, I/O extreme operations. This is especially true if the whole stack is reaction.
Important differences
Programming model
Open Fine: You just have to explain the interface. The framework will provide the implementation of these interfaces.
Web client: Program. You use an essential, fluent API to enforce HTTP calls.
Harmony/Unconscious Calls
Open Fine: Based on harmony calls. You need to extend the customization or third party to put into practice conflicting behavior.
Web client: Unconstitutional and non -blocking. It fits well with a stack -based system.
Integration with a cloud of spring
Open Fine: It is well connected with spring cloud stacks, such as service discovery (Eurica), client side loads, and well connected with circuit breakers.
Web client: It is connected to the spring cloud, but some features require additional extra layout, such as balance in the load.
Boiler plate code
Open Fine: You have to explain only the closing point with the interface, and the rest of the framework is automatically enforced.
Web client: You have a bit more code to write and more obvious setting.
Error in handling
Open Fine: You need to deal with customs error or Fallbacks Hydrox Or Flexibility 4 j.
Web client: It is more flexible to deal with operators such as on -status () and exception maping.
Performance concerns
When high -thropped is not a basic concern, the open fine is a better choice, as it is suitable for traditional, blocking applications where simplicity and developer productivity is more important than input.
When you have a large number of harmony requests, such as hundreds or thousands per second, with open fins, you can face thread fatigue problems unless you increase the size of the thread pool significantly. As a result, memory consumption increases and the CPU’s overhead increases. For a solid application with blocking operations, the open fins are better, as blocking and mixing the non -blocking model is discouraged.
If your application I/O is bound and heavy loads are handled, the web client is more suitable. Its non -blocking, the nature of the reaction is perfect for these scenarios, as it can handle more harmony with low threads. The web client does not block a thread while waiting for a response, it immediately releases it for other tasks to be reused for other tasks. It also provides a reaction feature called the back per person, which is used to control the data flow rate. This is useful when dealing with large data streams or when client data use. This is suitable for applications that need to be managed by thousands of harmony requests. It is more complicated, though, and has strong learning curves.
Use matters
Use Open Fine when:
With the discovery of the service and integration with the Spring Cloudload Blasser, you need to call other services in the spring cloud microscope architecture.
You prefer productivity and simplicity.
You are bound to synchronize, blocking models.
When use web client:
You are using Spring Web Flukes to create an application.
You need full control over application/response handling.
You need high performance, non -blocking communication.
You want more control over mistakes and re -attempting logic.
Conclusion
Your system’s architecture and performance requirements guide the selection between the Open Fine and the Web Client.
Open Fine Spring Cloud Stack is ideal for the rest of the call and helps reduce the boiler plate code. On the other hand, web clients provide their best performance and more flexible for high performance applications.
If you are creating a traditional micro -services system using Spring Boat and Spring Cloud, the open -fins are more likely to be a clear selection. If you are in the context of reaction programming or you have to handle thousands of harmony, the web client will be a better choice.
In order to make the appropriate choice, it is important to understand both tools, their profession and adaptation.