```mermaid theme={null}
sequenceDiagram
participant Client as Order Service
participant Eureka as Eureka Server
participant User1 as User Service (IP: 10.1)
participant User2 as User Service (IP: 10.2)
Client->>Eureka: 1. "Give me IPs for USER-SERVICE"
Eureka-->>Client: 2. Returns [10.1, 10.2]
Client->>Client: 3. Pick one (Round Robin) -> 10.1
Client->>User1: 4. HTTP GET /users/1
User1-->>Client: 5. Response
```
### RestTemplate (Deprecated/Legacy)
```java theme={null}
@LoadBalanced // Magic annotation!
@Bean
public RestTemplate restTemplate() {
return new RestTemplate();
}
// In Service
String url = "http://USER-SERVICE/users/" + userId;
UserDto user = restTemplate.getForObject(url, UserDto.class);
```
Spring intercepts the request, looks up `USER-SERVICE` in Eureka, gets a list of IPs, and uses **Round Robin** load balancing to pick one.
### WebClient (Reactive & Modern)
The recommended way in modern Spring.
```java theme={null}
@Bean
@LoadBalanced
public WebClient.Builder webClientBuilder() {
return WebClient.builder();
}
// In Service
UserDto user = webClientBuilder.build()
.get()
.uri("http://USER-SERVICE/users/{id}", userId)
.retrieve()
.bodyToMono(UserDto.class)
.block(); // Blocking for sync code
```
### Feign Client (Declarative)
The cleanest way. It looks like a JPA Repository but for HTTP calls.
1. Dependency: `spring-cloud-starter-openfeign`.
2. Annotation: `@EnableFeignClients`.
```java theme={null}
@FeignClient(name = "USER-SERVICE")
public interface UserClient {
@GetMapping("/users/{id}")
UserDto getUser(@PathVariable("id") Long id);
}
```
Now just autowire `UserClient` and call `getUser(id)`. Spring handles the lookup, load balancing, and HTTP serialization!
***
## Interview Deep-Dive