Spring Boot 微服务实战：从零构建云原生应用

1. 教程概览

本教程面向零基础或有 Spring Boot 基础的开发者，带你一步步从单体思维转向微服务架构，最终将应用容器化并部署到 Kubernetes 集群。你将掌握 Spring Cloud 全家桶核心组件的实战用法，理解云原生开发的完整闭环。

学习目标：

• 使用 Spring Boot 2.7+ 与 Spring Cloud 2021.x 构建微服务体系
• 掌握服务注册、配置管理、网关、熔断、链路追踪等核心模式
• 将微服务打包为 Docker 镜像并推送至镜像仓库
• 编写 Kubernetes 部署清单，实现滚动发布与服务发现

技术栈：

• Spring Boot 2.7.18、Spring Cloud 2021.0.9
• Nacos 2.2.3（注册中心 & 配置中心）
• Spring Cloud Gateway、OpenFeign、Resilience4j
• Sleuth + Zipkin（链路追踪）
• Docker、Kubernetes（Minikube 或 Kind）

2. 微服务架构核心概念

2.1 什么是微服务？

微服务是一种软件架构风格，将单一应用程序划分为一组小型的、独立的服务。每个服务运行在自己的进程中，通过轻量级通信机制（如 HTTP/REST 或 gRPC）互相协作。各服务围绕具体业务能力构建，可独立开发、部署和扩展。

2.2 微服务与云原生的关系

云原生追求的是弹性、可观测、自动化。微服务是云原生应用的主流架构，配合容器化与 Kubernetes 编排，可以充分利用云平台的伸缩能力和容错机制。Spring Cloud 为微服务提供了分布式系统开发的通用模式，让开发者无需重复造轮子。

3. 开发环境准备

• JDK：17（推荐 Amazon Corretto 或 OpenJDK）
• 构建工具：Maven 3.8+
• IDE：IntelliJ IDEA、VS Code 或 Eclipse
• Docker：24.0+
• Kubernetes：Minikube、Kind 或 Docker Desktop 内置 K8s
• 辅助工具：curl、Postman、kubectl

验证安装：

java -version
mvn -v
docker --version
kubectl version --client

4. 构建你的第一个微服务

4.1 项目初始化

使用 Spring Initializr 创建两个基础服务：user-service 和 order-service。

• 依赖：Spring Web、Lombok、Spring Boot Actuator
• 父 POM 统一管理 Spring Cloud 版本（后面添加）

父工程 pom.xml：

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.7.18</version>
</parent>

<properties>
    <java.version>17</java.version>
    <spring-cloud.version>2021.0.9</spring-cloud.version>
</properties>

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

4.2 编写 user-service

提供用户查询接口。创建 UserController：

@RestController
@RequestMapping("/users")
public class UserController {
    @GetMapping("/{id}")
    public ResponseEntity<String> getUser(@PathVariable Long id) {
        return ResponseEntity.ok("User-" + id + " info");
    }
}

application.yml：

server:
  port: 8081
spring:
  application:
    name: user-service

4.3 编写 order-service

订单服务会调用用户服务。同样创建简单控制器：

@RestController
@RequestMapping("/orders")
public class OrderController {
    @GetMapping("/{id}")
    public ResponseEntity<String> getOrder(@PathVariable Long id) {
        // 模拟订单详情
        return ResponseEntity.ok("Order-" + id + " and User-1 info");
    }
}

application.yml：

server:
  port: 8082
spring:
  application:
    name: order-service

启动两个服务，浏览器访问 http://localhost:8081/users/1 和 http://localhost:8082/orders/1，确保返回数据。

5. 服务注册与发现 —— Nacos

Nacos 是阿里巴巴开源的动态服务发现、配置和管理平台，完美替代 Eureka，更适合云原生环境。我们用它来实现服务的自动注册与发现。

5.1 启动 Nacos Server

docker run --name nacos -e MODE=standalone \
  -p 8848:8848 -p 9848:9848 \
  -d nacos/nacos-server:v2.2.3

访问 http://localhost:8848/nacos，默认用户名/密码：nacos/nacos。

5.2 微服务接入

在两个服务的 pom.xml 中添加 Nacos Discovery 依赖：

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    <version>2021.0.5.1</version>
</dependency>

application.yml 增加配置：

spring:
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848

启动服务后，在 Nacos 控制台的服务列表中可看到 user-service 和 order-service。

6. 微服务配置中心 —— Nacos Config

将配置集中管理，支持动态刷新，避免重启。

6.1 添加依赖

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-bootstrap</artifactId>
</dependency>

创建 bootstrap.yml：

spring:
  application:
    name: user-service
  cloud:
    nacos:
      config:
        server-addr: 127.0.0.1:8848
        file-extension: yaml

6.2 在 Nacos 中创建配置

控制台进入“配置管理” -> “配置列表”，新建配置：
Data ID：user-service.yaml
Group：DEFAULT_GROUP
配置内容：

config:
  welcome: Hello from Nacos Config Center

在代码中通过 @Value 或 @RefreshScope 注入并验证动态更新。

7. API 网关 —— Spring Cloud Gateway

网关是所有微服务的统一入口，负责路由、限流、鉴权等。

7.1 创建 gateway-service

新建 Spring Boot 模块，依赖：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

application.yml：

server:
  port: 8080
spring:
  application:
    name: gateway-service
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
    gateway:
      discovery:
        locator:
          enabled: true   # 自动根据服务名创建路由
      routes:
        - id: user-route
          uri: lb://user-service   # 负载均衡方式
          predicates:
            - Path=/users/**
        - id: order-route
          uri: lb://order-service
          predicates:
            - Path=/orders/**

启动网关，通过 http://localhost:8080/users/1 和 http://localhost:8080/orders/1 访问，网关成功转发。

8. 服务间通信 —— OpenFeign

替换原始的 RestTemplate，实现声明式 HTTP 客户端调用。

8.1 改造 order-service 调用 user-service

添加依赖：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

主启动类加 @EnableFeignClients。
编写 Feign 接口：

@FeignClient("user-service")
public interface UserFeignClient {
    @GetMapping("/users/{id}")
    String getUser(@PathVariable("id") Long id);
}

在 OrderController 中注入并使用：

@RestController
@RequestMapping("/orders")
public class OrderController {
    @Autowired
    private UserFeignClient userFeignClient;

    @GetMapping("/{id}")
    public ResponseEntity<String> getOrder(@PathVariable Long id) {
        String userInfo = userFeignClient.getUser(1L);
        return ResponseEntity.ok("Order-" + id + " with " + userInfo);
    }
}

重启 order-service，访问网关或直接调用，验证跨服务数据聚合。

9. 熔断与容错 —— Resilience4j

当 user-service 不可用时，order-service 需要快速失败并提供降级响应，防止雪崩。

9.1 引入 Sentinel 或 Resilience4j

推荐使用 Sentinel 作为生产级熔断降级组件，也可用 Resilience4j。以 Sentinel 为例：

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
</dependency>

启动 Sentinel 控制台：

docker run -d -p 8088:8088 --name sentinel \
  bladex/sentinel-dashboard:1.8.6

application.yml 配置：

spring:
  cloud:
    sentinel:
      transport:
        dashboard: 127.0.0.1:8088

在 Feign 接口上添加 fallback 类：

@FeignClient(name = "user-service", fallback = UserFallback.class)
public interface UserFeignClient { ... }

@Component
class UserFallback implements UserFeignClient {
    @Override
    public String getUser(Long id) {
        return "User service fallback";
    }
}

关闭 user-service 后访问订单接口，返回降级内容。

10. 分布式链路追踪 —— Sleuth + Zipkin

在微服务调用链中快速定位性能瓶颈和异常。

10.1 集成 Sleuth

所有服务添加依赖：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-sleuth</artifactId>
</dependency>

日志中会自动增加 [appname,traceId,spanId] 信息。

10.2 集成 Zipkin

启动 Zipkin Server：

docker run -d -p 9411:9411 openzipkin/zipkin

各服务添加依赖：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-sleuth-zipkin</artifactId>
</dependency>

配置采样率：

spring:
  zipkin:
    base-url: http://127.0.0.1:9411
  sleuth:
    sampler:
      probability: 1.0   # 全量采样，生产环境酌情降低

发起几次请求后，访问 Zipkin UI http://localhost:9411 查看调用链路。

11. 容器化部署 —— Docker

将每个微服务打包为 Docker 镜像，方便分发和部署。

11.1 编写 Dockerfile

以 user-service 为例，项目根目录创建 Dockerfile：

FROM openjdk:17-jdk-slim
VOLUME /tmp
ARG JAR_FILE=target/*.jar
COPY ${JAR_FILE} app.jar
ENTRYPOINT ["java","-jar","/app.jar"]

执行构建：

mvn clean package -DskipTests
docker build -t user-service:1.0.0 .
docker images | grep user-service

11.2 运行容器

确保 Nacos 等基础设施可访问（如果在本机 Docker，注意网络模式）。启动容器：

docker run -d -p 8081:8081 --name user-service user-service:1.0.0

同样构建 order-service 和 gateway-service 镜像。

11.3 推送镜像（可选）

若拥有 Docker Hub 或私有仓库，标记并推送：

docker tag user-service:1.0.0 yourrepo/user-service:1.0.0
docker push yourrepo/user-service:1.0.0

12. 云原生部署 —— Kubernetes

使用 Kubernetes 编排容器，实现自动伸缩、滚动更新和服务发现。

12.1 准备 K8s 环境

本教程使用 Minikube：

minikube start --cpus=4 --memory=8192 --driver=docker

确保 kubectl 上下文指向 Minikube。

12.2 编写部署清单

创建 user-service-deploy.yaml：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: user-service
spec:
  replicas: 2
  selector:
    matchLabels:
      app: user-service
  template:
    metadata:
      labels:
        app: user-service
    spec:
      containers:
        - name: user-service
          image: user-service:1.0.0
          imagePullPolicy: IfNotPresent
          ports:
            - containerPort: 8081
          env:
            - name: SPRING_CLOUD_NACOS_DISCOVERY_SERVER-ADDR
              value: "nacos-service:8848"   # 需要先部署 Nacos 到 K8s
---
apiVersion: v1
kind: Service
metadata:
  name: user-service
spec:
  selector:
    app: user-service
  ports:
    - port: 8081
      targetPort: 8081
  type: ClusterIP

类似地创建 order-service、gateway-service 的部署清单。

12.3 部署基础服务（Nacos）

可使用官方提供的 Nacos K8s 部署方案，或简化部署：

kubectl create deployment nacos --image=nacos/nacos-server:v2.2.3
kubectl expose deployment nacos --port=8848 --target-port=8848 --name=nacos-service

12.4 应用微服务

kubectl apply -f user-service-deploy.yaml
kubectl apply -f order-service-deploy.yaml
kubectl apply -f gateway-service-deploy.yaml

查看 pods：

kubectl get pods

12.5 暴露网关

kubectl expose deployment gateway-service --type=NodePort --port=8080
minikube service gateway-service --url

通过输出的 URL 访问微服务，验证整个云原生集群生效。

12.6 滚动更新与回滚

修改代码后重新构建镜像，更新 Deployment 的镜像版本：

kubectl set image deployment/user-service user-service=user-service:1.0.1
kubectl rollout status deployment/user-service
kubectl rollout history deployment/user-service
kubectl rollout undo deployment/user-service

Kubernetes 将执行滚动更新，零停机。

13. 总结与扩展方向

通过本教程，你已从零构建了一套完整的 Spring Boot 微服务应用，覆盖了服务注册发现、配置中心、API 网关、服务调用、熔断、链路追踪、容器化及 Kubernetes 部署。这套架构足够支撑中小型项目上线。

下一步学习建议：

• 引入消息队列（RocketMQ / Kafka）实现异步解耦
• 集成分布式事务（Seata）
• 使用 Prometheus + Grafana 搭建监控体系
• 利用 Helm 打包微服务，实现一键部署
• 探索 Service Mesh（Istio）替代部分 Spring Cloud 功能

本教程所有代码示例保持简单直接，鼓励你动手实践每个步骤。微服务之路，实践出真知。