Service-to-service communication in Spring Boot - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this RestTemplate call?

Consider a Spring Boot service using RestTemplate to call another service endpoint that returns a JSON object {"status":"ok"}. What will be the output of the following code snippet?

Spring Boot

RestTemplate restTemplate = new RestTemplate();
String response = restTemplate.getForObject("http://localhost:8081/api/status", String.class);
System.out.println(response);

A "{\"status\":\"ok\"}"

B RestClientException

C null

D status: ok

💡 Hint

The RestTemplate returns the raw response body as a String when using getForObject with String.class.

The getForObject method returns the response body as a String exactly as received. Since the endpoint returns JSON, the output is the JSON string including quotes and escaped characters.

📝 Syntax

intermediate

Which option correctly declares a Feign client interface?

You want to create a Feign client in Spring Boot to call a remote service at 'http://inventory-service'. Which of the following interface declarations is correct?

A

@FeignClient(url = "http://inventory-service")
public interface InventoryClient {
  @PostMapping("/items")
  List<String> getItems();
}

B

@FeignClient(name = "inventory-service")
public class InventoryClient {
  @GetMapping("/items")
  List<String> getItems();
}

C

@FeignClient(name = "inventory-service", url = "http://inventory-service")
public interface InventoryClient {
  @GetMapping("/items")
  List<String> getItems();
}

D

@FeignClient(name = "inventory-service")
public interface InventoryClient {
  @GetMapping("items")
  List<String> getItems();
}

💡 Hint

Feign clients must be interfaces and use correct annotations for HTTP methods and paths.

Option C correctly declares a Feign client interface with name and url, uses @GetMapping with a leading slash, and defines the method signature properly.

🔧 Debug

advanced

Why does this WebClient call fail with a 404 error?

Given this WebClient call to a service endpoint '/api/data', the call returns 404 Not Found. What is the most likely cause?

Spring Boot

WebClient client = WebClient.create("http://localhost:8080");
String result = client.get()
  .uri("api/data")
  .retrieve()
  .bodyToMono(String.class)
  .block();

A The URI path is missing a leading slash, so the request goes to 'http://localhost:8080api/data' which is invalid.

B The WebClient is not configured with a base URL, so it cannot resolve the URI.

C The retrieve() method does not handle 404 errors and throws an exception instead.

D The block() method is called on a Mono which is not allowed in WebClient.

💡 Hint

Check how the URI is constructed when using WebClient with a base URL.

Without a leading slash, the URI is appended directly to the base URL without a separator, causing an invalid URL and 404 error.

❓ state_output

advanced

What is the value of 'response' after this asynchronous WebClient call?

Consider this Spring Boot WebClient code snippet. What will be the value of the 'response' variable after execution?

Spring Boot

WebClient client = WebClient.create("http://localhost:8080");
final String[] response = {null};
client.get()
  .uri("/api/message")
  .retrieve()
  .bodyToMono(String.class)
  .subscribe(body -> {
    response[0] = body;
  });
System.out.println(response[0]);

A A compilation error because response is assigned inside lambda

B The response body string from the service

C An empty string ""

D null

💡 Hint

Remember that subscribe runs asynchronously and the print happens immediately.

The subscribe method runs asynchronously, so the print statement executes before the response is assigned inside the lambda, leaving response null.

🧠 Conceptual

expert

Which statement best describes the difference between RestTemplate and WebClient in Spring Boot?

Choose the most accurate description of how RestTemplate and WebClient differ in service-to-service communication.

A WebClient is only used for SOAP services, while RestTemplate is for REST services.

B RestTemplate is synchronous and blocking, while WebClient supports asynchronous and non-blocking calls.

C Both RestTemplate and WebClient are deprecated and should not be used for service communication.

D RestTemplate supports reactive streams natively, but WebClient only supports traditional blocking calls.

💡 Hint

Think about how each client handles request execution and threading.

RestTemplate executes calls synchronously blocking the thread, whereas WebClient supports reactive programming with asynchronous non-blocking calls.