11 Consuming REST endpoints

Modern backend systems often need one service to call another service’s REST endpoint, and this chapter explains the main Spring options for doing that clearly and correctly. It uses a simple payments example to show how a backend app can send a request with headers and a body, receive the response, and pass it back to the original caller. The goal is not just to make the call work, but to understand which approach fits a given application and why.

The chapter first presents a straightforward solution with RestClient, which is favored for its simple, readable API and works well for common synchronous calls in regular Spring web applications. It then introduces OpenFeign, which reduces boilerplate by letting you define a REST contract as an interface and having Spring generate the implementation. The discussion also contrasts this with the older RestTemplate, showing why it is now considered legacy and less suitable for newer applications.

Finally, the chapter explains WebClient and the reactive style behind it, emphasizing that it is best suited for reactive applications rather than ordinary blocking ones. It shows how reactive programming treats work as connected tasks rather than one thread doing everything in sequence, which can improve efficiency when multiple I/O calls are involved. Across all three approaches, the chapter reinforces good practices such as keeping URLs in properties, using the right client for the architecture, and giving AI tools enough context to generate consistent REST client code.

Often, a backend app needs to act as a client for another backend app and calls exposed REST endpoints to work with specific data.

A client sends a request to the backend app, which in turn needs to call another backend service. The backend app will use clients such as RestClient or OpenFeign to properly send the HTTP requests to the other backend component.

The payment service exposes an endpoint that requires an HTTP request body. The app uses RestClient, OpenFeign, or WebClient to send requests to the endpoint that the payment service exposes.

A backend app needs to send HTTP requests to another backend service. We use RestClient to implement the functionality that consumes the REST endpoint.

With OpenFeign, you only need to define an interface (a contract) and tell OpenFeign where to find this contract to implement it. OpenFeign implements the interface and provides the implementation as a bean in the Spring context based on configurations you define with annotations. You can inject the bean from the Spring context anywhere you need it in your app.

A functionality scenario for demonstrating the usefulness of a reactive approach. A banking app needs to call several other apps to calculate the total debt of a user. Due to these calls, the thread executing the request is blocked several times while waiting for I/O operations to finish.

The execution of the scenario functionality from the thread point of view. The arrow represents the timeline of the thread. Some of the steps cause details to block the thread, which needs to wait for the task to finish before proceeding.

An analogy of the way a reactive app works. A thread doesn’t take a request’s tasks in order and wait when it’s blocked. Instead, all tasks from all requests are on a backlog. Any available thread can work on tasks from any request. This way, independent tasks can be solved in parallel, and the threads don’t stay idle.

In a reactive app, the steps become tasks. Each task marks its dependencies on other tasks and allows other tasks to depend on them. Threads are free to execute any task.

The tasks chain in a reactive app. When building a reactive web app, we define the tasks and the dependencies between them. The WebFlux functionality, initiating the HTTP request, subscribes to the task we create through the producer the controller’s action returns. In our case, this producer is the one we get by sending the HTTP request with WebClient. For WebClient to make the request, it subscribes to another task that provides the request body.

• In a real-world backend solution, you often find cases when a backend app needs to call endpoints exposed by another backend app.
• Spring offers multiple solutions for implementing the client side of a REST service. Three of the most relevant solutions are as follows:
• RestClient—A simple tool used to call REST endpoints in Spring apps
• OpenFeign—A solution offered by the Spring Cloud project that successfully simplifies the code you need to write to call a REST endpoint and adds several features relevant to how we implement services today
• WebClient—A reactive solution for calling REST endpoints in a Spring app
• You shouldn’t use RestTemplate in new implementations. You can choose between RestClient or OpenFeign for non-reactive apps, and WebClient for reactive apps to call REST endpoints.
• For an app following a standard (nonreactive) approach, the best choice is using RestClient or OpenFeign.
• WebClient is an excellent tool for an app designed on a reactive approach. But before using it, you should deeply understand the reactive approach and how to implement a reactive app with Spring.

FAQ