Explain WebClient in detail
WebClient is a non-blocking, reactive web client that is part of the Spring WebFlux library. It is used for making HTTP requests to communicate with other microservices or external APIs. WebClient offers a more flexible and scalable way of handling HTTP requests and responses compared to the traditional RestTemplate.

Table of Contents
Features of WebClient:
- 1. Non-blocking and Asynchronous: Allows for better resource utilization and scalability.
- 2. Reactive Streams Support: Works well with reactive programming paradigms.
- 3. Fluent API: Provides a fluent, builder-style API for constructing HTTP requests.
How Java Microservices Communicate using WebClient
In this example, we have two microservices: User Service and Order Service. The Order Service communicates with the User Service using WebClient.
User Service
```java
// UserServiceApplication.java
@SpringBootApplication
@RestController
@RequestMapping("/users")
public class UserServiceApplication {
public static void main(String[] args) {
SpringApplication.run(UserServiceApplication.class, args);
}
@GetMapping("/{id}")
public User getUserById(@PathVariable String id) {
return new User(id, "John Doe", "john.doe@example.com");
}
}
// User.java
public class User {
private String id;
private String name;
private String email;
// Constructors, Getters, and Setters
}
```
Order Service
```java
// OrderServiceApplication.java
@SpringBootApplication
@RestController
@RequestMapping("/orders")
public class OrderServiceApplication {
public static void main(String[] args) {
SpringApplication.run(OrderServiceApplication.class, args);
}
@Autowired
private UserServiceClient userServiceClient;
@GetMapping("/{orderId}")
public Mono<Order> getOrderById(@PathVariable String orderId) {
return userServiceClient.getUserById("123")
.map(user -> new Order(orderId, "Product 1", user));
}
}
// Order.java
public class Order {
private String orderId;
private String productName;
private User user;
// Constructors, Getters, and Setters
}
// UserServiceClient.java
@Component
public class UserServiceClient {
private final WebClient webClient;
public UserServiceClient(WebClient.Builder webClientBuilder) {
this.webClient = webClientBuilder.baseUrl("http://localhost:8080").build();
}
public Mono<User> getUserById(String userId) {
return this.webClient.get()
.uri("/users/{id}", userId)
.retrieve()
.bodyToMono(User.class);
}
}
```
Configuration (WebClient Builder Bean)
```java
// WebClientConfig.java
@Configuration
public class WebClientConfig {
@Bean
public WebClient.Builder webClientBuilder() {
return WebClient.builder();
}
}
```
Explanation:
- 1. User Service: Provides an endpoint `/users/{id}` to get user details.
- 2. Order Service:
- Uses `UserServiceClient` to make a non-blocking HTTP GET request to the User Service.
- `UserServiceClient` is a component that uses WebClient to call the User Service.
- The `getOrderById` method in `OrderServiceApplication` calls `getUserById` from `UserServiceClient` and maps the response to create an Order object.
Advantages:
- Non-blocking I/O: Improves scalability and resource utilization.
- Reactive Programming: Seamlessly integrates with reactive streams and Spring WebFlux.
- Fluent API: Makes it easy to construct and manage HTTP requests.