Spring Boot 4 Microservices & REST APIs · 课时

服务间通信基础

探索微服务之间使用 REST 调用等同步通信模式。

第 2 / 3 课11 个步骤

服务间通信基础 是 CoddyKit 上的免费 Spring Boot 4 Microservices & REST APIs 课时。这是第 2 节课，共 3 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 Spring Boot 4 Microservices & REST APIs 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Spring Boot 4 Microservices & REST APIs 课程共包含 3 节课。

本课时的部分内容尚未翻译，以英文显示。

Talking Between Services

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.

Sync or Async?

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.

RESTful Service Calls

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.

How Services Connect

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.

Our Target Service Example

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.

package com.example.productservice;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import java.util.Map;

@SpringBootApplication
@RestController
public class ProductServiceApplication {

    public static void main(String[] args) {
        SpringApplication.run(ProductServiceApplication.class, args);
    }

    @GetMapping("/products/{id}")
    public String getProductInfo(@PathVariable String id) {
        return "Product " + id + " Details (from Product Service)";
    }

    @PostMapping("/products")
    public String createProduct(@RequestBody Map<String, String> productData) {
        String name = productData.getOrDefault("name", "Unknown");
        String price = productData.getOrDefault("price", "0.00");
        return "Created Product: " + name + " with price " + price + " (via Product Service)";
    }
}

Calling with RestTemplate (GET)

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:

package com.example.orderservice;

import org.springframework.web.client.RestTemplate;

public class OrderServiceCaller {

    public static void main(String[] args) {
        RestTemplate restTemplate = new RestTemplate();
        String productId = "123";
        String url = "http://localhost:8081/products/" + productId; // Product Service URL

        System.out.println("Calling Product Service for ID: " + productId);
        try {
            String result = restTemplate.getForObject(url, String.class);
            System.out.println("Received: " + result);
        } catch (Exception e) {
            System.out.println("Error calling Product Service: " + e.getMessage());
        }
    }
}

Processing the Response

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.

Sending Data with POST

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:

package com.example.orderservice;

import org.springframework.web.client.RestTemplate;
import java.util.HashMap;
import java.util.Map;

public class OrderServicePostCaller {

    public static void main(String[] args) {
        RestTemplate restTemplate = new RestTemplate();
        String url = "http://localhost:8081/products"; // Product Service POST URL

        // Data to send in the request body
        Map<String, String> productData = new HashMap<>();
        productData.put("name", "New Gadget");
        productData.put("price", "99.99");

        System.out.println("Calling Product Service to create product...");
        try {
            // postForObject sends data and expects a response object
            String result = restTemplate.postForObject(url, productData, String.class);
            System.out.println("Received: " + result);
        } catch (Exception e) {
            System.out.println("Error calling Product Service POST: " + e.getMessage());
        }
    }
}

Handling Communication Errors

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.

Quick Check: Communication

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

在交互式课程中回答

Recap: Inter-Service Talk

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!

免费开始

用 AI 导师学习 Java — 免费

在浏览器中编写并运行真实代码，获得全天候 AI 导师的即时帮助，并在网页或应用中继续学习。

课程: 24
课程: 93

免费开始学习查看完整课程

常见问题解答

「服务间通信基础」课时是免费的吗？

是的 — 「服务间通信基础」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Spring Boot 4 Microservices & REST APIs 课程的其余内容，请升级到 CoddyKit PRO。 Spring Boot 4 Microservices & REST APIs 课程共包含 3 节课。

「服务间通信基础」这节课中我会学到什么？

探索微服务之间使用 REST 调用等同步通信模式。你通过在浏览器中直接运行的动手代码来练习 Spring Boot 4 Microservices & REST APIs，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Spring Boot 4 Microservices & REST APIs 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Spring Boot 4 Microservices & REST APIs 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 2 节课，共 3 节。

「服务间通信基础」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Spring Boot 4 Microservices & REST APIs 课中编写并运行代码吗？

能。每节 Spring Boot 4 Microservices & REST APIs 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

← 返回 Spring Boot 4 Microservices & REST APIs