พื้นฐานการสื่อสารระหว่างบริการ

Microservices are small, independent services. For them to work together, they need to communicate! Imagine an Order Service needing product details from a Product Service.

This lesson explores how services talk to each other. We'll focus on synchronous communication, where one service waits for a reply from another.

Communication between services can be:

• Synchronous: The calling service sends a request and waits for a response before continuing its own task. Think of a phone call.
• Asynchronous: The calling service sends a request and doesn't wait for an immediate response. It continues its work. Think of sending an email.

Today, we'll dive into synchronous communication, often done using REST APIs.

REST (Representational State Transfer) is a popular architectural style for web services. It's also perfect for microservices to communicate.

Services expose endpoints, and others consume them using standard HTTP methods like GET, POST, PUT, and DELETE.

It's like one service acting as a client and another as a server, just like your browser talks to a website.

When Service A needs data from Service B, Service A acts as an HTTP client. It constructs an HTTP request (method, URL, headers, body) and sends it to Service B.

Service B, acting as an HTTP server, processes the request and sends back an HTTP response (status code, headers, body).

This is a fundamental pattern in microservice architectures.

To demonstrate, let's imagine a simple "Product Service" that our "Order Service" will call. This service will have both GET and POST endpoints.

This code snippet shows a basic Spring Boot controller for our Product Service, running on port 8081. It simulates product retrieval and creation.

Spring's RestTemplate is a synchronous client for making HTTP requests. It's a classic way to call other REST services.

Here's how our "Order Service" could use RestTemplate to get product info from our Product Service:

When RestTemplate makes a call, it expects a response. The getForObject() method automatically converts the response body into the specified Java type (here, String.class).

For more control, you can use getForEntity() which returns a ResponseEntity object. This gives you access to:

• Status Code: E.g., 200 OK, 404 Not Found.
• Headers: E.g., Content-Type.
• Body: The actual data.

Often, services need to send data to each other, not just request it. This is where POST requests come in.

RestTemplate provides methods like postForObject() or postForEntity() to send data in the request body.

Let's see how our "Order Service" could create a new product:

What happens if the target service is down, or sends an error?

RestTemplate will throw exceptions for certain HTTP status codes (e.g., 4xx client errors, 5xx server errors) or connection issues.

It's crucial to wrap your service calls in try-catch blocks to gracefully handle these failures. You might log the error, return a default value, or inform the user.

Later lessons will cover more advanced resilience patterns like Circuit Breakers.

Consider a microservice architecture where an OrderService needs to fetch real-time stock availability from a WarehouseService before confirming an order.

In this lesson, we explored the basics of synchronous inter-service communication in a microservices architecture.

• We learned that services often communicate using REST APIs and standard HTTP methods.
• RestTemplate is a powerful Spring Boot tool for making these synchronous calls.
• It's important to handle responses and errors gracefully.

Next, we'll look at more advanced communication patterns!