SpringCloud一览

发表于 更新于 分类于
本文字数： 5.8k 阅读时长 ≈ 21 分钟

Spring Cloud 是一个基于 Spring Boot 的微服务架构工具集，旨在简化分布式系统的开发和管理。其核心工作原理围绕解决微服务架构中的共性问题（如服务治理、配置管理、容错、负载均衡等），通过一系列子项目模块化地提供解决方案。以下是其核心工作原理的总结：

服务治理为何选择 Spring Cloud

一、 架构演进：从单体到微服务

微服务架构的出现是为了解决单体架构在大型项目中的痛点，但也带来了新的复杂性。

1. 单体架构的局限

  • 扩展难：无法针对特定高负载模块进行水平扩展。
  • 部署慢：任何微小改动都需重新发布整个应用，影响交付效率。
  • 高耦合：代码相互依赖严重，局部故障可能引发整体崩溃。

2. 微服务的优势

  • 松耦合：服务间通过轻量级协议（REST/RPC）通信，独立开发与部署。
  • 技术多样性：不同服务可根据需求选择最适合的语言或数据库。
  • 按需扩展：支持对流量核心服务进行精准扩容。

二、 服务治理的核心内涵

服务治理是确保微服务系统稳定、可靠运行的一系列技术手段。

  • 服务注册与发现：动态管理服务地址，解决“去哪儿找服务”的问题。
  • 负载均衡：在多个实例间合理分配流量，提高吞吐量。
  • 熔断与容错：防止局部故障引发的“雪崩效应”。
  • 配置管理：统一管理海量服务的配置信息，支持热更新。
  • 分布式追踪：记录请求在服务间的流转轨迹，方便排查性能瓶颈。

三、 为何 Spring Cloud 是首选？

  1. 一站式解决方案：它不是单一框架，而是整合了 Netflix、Consul、Zookeeper 等优秀开源项目的“全家桶”，覆盖了治理的所有环节。
  2. 基于 Spring Boot：继承了“约定优于配置”的理念，开发成本极低，配置简单。
  3. 生态与社区：拥有极其庞大的用户群体和完善的文档支持，遇到问题极易找到解决方案。
  4. 云原生友好：天然适配 Docker、Kubernetes 等容器化技术，是云原生时代的标配。

四、 核心组件及其职责对照表

核心组件 治理能力 作用描述
Eureka / Consul / Nacos 服务注册与发现 类似“通讯录”，管理所有服务实例的在线状态。
Ribbon / LoadBalancer 负载均衡 实现客户端侧的请求分发策略（如轮询、随机）。
Hystrix / Sentinel 熔断与降级 设置阈值，当服务异常时快速切断调用并执行 Fallback 逻辑。
Spring Cloud Config / Nacos 分布式配置管理 将配置中心化存储，支持不重启应用即可更新参数。
Spring Cloud Gateway API 网关 系统的唯一入口，处理鉴权、限流、路径路由等。
Sleuth / Zipkin 分布式追踪 生成 Trace ID 追踪请求全路径，实现监控可视化。

五、 核心价值总结

Spring Cloud 的本质是屏蔽分布式系统的复杂性。它将复杂的治理逻辑封装为可插拔的组件，让开发者能够像使用普通 Spring 插件一样来实现高级治理功能，从而将精力集中在核心业务逻辑的实现上。

总结

spring cloud整体

服务治理 - Eureka 核心解析

一、 Eureka 的核心角色

Eureka 采用了 C/S (Client/Server) 架构，主要由两部分组成：

  • Eureka Server：注册中心服务端。存储服务实例清单，维护实例状态。
  • Eureka Client：服务实例客户端。包括服务提供者（Provider）和消费者（Consumer）。

二、 服务治理的关键生命周期

  1. 服务注册：客户端启动后，将自身元数据（IP、Port、ID）发送至 Server。
  2. 心跳续约：客户端默认每 30s 发送一次心跳；若 Server 连续 90s 未收到心跳则剔除该实例。
  3. 服务发现：客户端从 Server 拉取服务清单并缓存到本地，避免每次调用都请求 Server。
  4. 服务下线：客户端正常关闭时发送 shutdown 信号，Server 立即删除其记录。

三、 自我保护模式 (Self-Preservation)

  • 背景：在分布式环境下，网络分区故障可能导致 Server 收不到心跳。
  • 机制：当 Server 检测到心跳失败率过高时，会进入保护状态，停止剔除服务。
  • 目的：保证集群的可用性（AP 原则），防止健康的实例因为网络抖动被误杀。
  • 生产建议：除非是在本地开发测试环境，否则严禁关闭自我保护模式。

四、 Eureka 与 Zookeeper 的区别 (CAP 理论)

特性 Eureka Zookeeper
一致性 (C) 弱一致性 强一致性 (Leader 选举期间不可用)
可用性 (A) 高可用 (即使 Server 挂了 Client 还能互调) 较弱 (Master 挂了会触发重新选举)
设计原则 AP CP
适用场景 强调服务可用性的微服务环境 强调数据一致性的分布式协调

五、 核心价值

Eureka 屏蔽了服务实例动态变化的复杂性，通过本地缓存 + 自我保护的策略，确保了即使在网络不稳定的环境下，微服务系统依然具备强大的生命力和可用性。

Spring Cloud一些核心概念

1. 核心设计思想

  • 模块化：每个功能（如服务发现、配置中心）由独立组件实现，开发者按需引入。
  • 与 Spring Boot 集成：基于 Spring Boot 的自动配置和约定优于配置原则，简化开发。
  • 标准化抽象：提供通用接口（如 DiscoveryClient、LoadBalancerClient），支持不同实现（如 Eureka、Consul、Nacos）。

2. 核心组件与工作原理

1) 服务注册与发现

  • 组件：Eureka、Consul、Nacos 等。
  • 原理：
    • 服务提供者启动时向注册中心注册自身信息（IP、端口、服务名）。
    • 服务消费者通过注册中心查询服务实例列表，动态发现可用服务。
    • 结合客户端负载均衡（如 Ribbon/Spring Cloud LoadBalancer）实现请求分发。

2) 客户端负载均衡

  • 组件：Ribbon（旧）、Spring Cloud LoadBalancer（新）。
  • 原理：
    • 服务消费者从注册中心获取服务实例列表。
    • 通过负载均衡算法（轮询、随机、权重等）选择目标实例，避免单点压力。

3) 服务调用

  • 组件：OpenFeign（基于接口的声明式 HTTP 客户端）。
  • 原理：
    • 定义接口并注解 @FeignClient，声明服务名和 API 路径。
    • Feign 动态生成实现类，结合 Ribbon/LoadBalancer 实现负载均衡调用。

4) 熔断与容错

  • 组件：Hystrix（旧）、Resilience4j、Spring Cloud Circuit Breaker。
  • 原理：
    • 通过熔断器模式监控服务调用失败率，达到阈值时熔断请求，避免雪崩效应。
    • 支持降级逻辑（Fallback），在服务不可用时返回默认响应。

5) 统一配置管理

  • 组件：Spring Cloud Config、Nacos Config。
  • 原理：
    • 配置文件集中存储在远程仓库（Git、数据库等）。
    • 服务启动时从配置服务器拉取配置，支持动态刷新（通过 Spring Cloud Bus 或 Webhook）。

6) API 网关

  • 组件：Spring Cloud Gateway、Zuul（旧）。
  • 原理：
    • 作为所有请求的入口，负责路由转发、权限校验、限流、日志等。
    • 通过谓词（Predicate）和过滤器（Filter）链实现灵活的路由规则。

7) 分布式链路追踪

  • 组件：Sleuth + Zipkin、SkyWalking。
  • 原理：
    • Sleuth 为每个请求生成唯一 Trace ID 和 Span ID，记录调用链。
    • 数据上报至 Zipkin 等工具，可视化展示服务间调用关系和耗时。

3. 协同工作流程示例

  1. 服务启动：服务提供者向 Eureka 注册，配置中心拉取远程配置。
  2. 服务调用：消费者通过 Feign 调用服务，由 Ribbon 选择实例，Hystrix 监控熔断。
  3. 网关路由：外部请求经过 Gateway，验证后路由至具体服务。
  4. 链路追踪：Sleuth 记录调用链，Zipkin 分析性能瓶颈。
  5. 动态更新：通过 Config Server 和 Bus 实现配置热更新。

4. 优势与特点

  • 开箱即用：通过 Starter 依赖快速集成功能。
  • 标准化与灵活性：抽象接口支持多种实现（如注册中心可选 Eureka/Nacos）。
  • 云原生友好：兼容 Spring Cloud Kubernetes，适应容器化部署。

其它知识点总结

一、Spring Cloud 基础概念

  1. Spring Cloud 与 Spring Boot 的关系是什么？

    • Spring Boot 是快速开发微服务的框架，Spring Cloud 是基于 Spring Boot 的微服务治理工具集（如服务发现、配置中心、熔断器等）。

  2. Spring Cloud 的核心功能有哪些？

    • 服务注册与发现、配置中心、服务网关、负载均衡、熔断器、分布式链路追踪等。

  3. 什么是微服务架构？Spring Cloud 如何支持微服务架构？

    • 微服务架构将单体应用拆分为独立的小服务，通过轻量级通信协同工作。Spring Cloud 提供 Netflix/Alibaba 等组件解决分布式系统问题（如服务治理、容错）。

二、服务注册与发现

  1. Eureka 的工作原理是什么？与 Zookeeper 的区别？

    • Eureka 采用 AP 模型（高可用、最终一致性），服务启动时注册到 Eureka Server，客户端通过心跳检测服务状态。
    • Zookeeper 是 CP 模型（强一致性），适用于需要强一致性的场景（如分布式锁）。

  2. Eureka 如何实现服务发现的高可用？

    • 多个 Eureka Server 相互注册组成集群，服务提供者和消费者向所有 Server 注册并拉取服务列表。

  3. Nacos 与 Eureka 的区别？

    • Nacos 支持服务发现与配置中心，提供 CP/AP 模式切换；Eureka 仅支持 AP 模式。

三、服务调用与负载均衡

  1. Ribbon 的负载均衡策略有哪些？如何自定义策略？

    • 轮询、随机、权重、最小响应时间等。通过 IRule 接口实现自定义策略。

  2. Feign 与 RestTemplate 的区别？

    • Feign 是声明式的 HTTP 客户端，通过接口和注解简化调用；RestTemplate 需要手动拼接 URL 和参数。

  3. 如何实现服务调用的超时控制？

    • Ribbon：ribbon.ReadTimeout；Feign：feign.client.config.default.readTimeout；Hystrix：hystrix.command.default.execution.isolation.thread.timeoutInMilliseconds。

四、服务熔断与降级

  1. Hystrix 的熔断机制是如何工作的？

    • 当失败率超过阈值，熔断器打开，后续请求快速失败；熔断器半开状态允许部分请求尝试恢复。

  2. Sentinel 与 Hystrix 的区别？

    • Sentinel 支持流量控制、熔断降级、系统保护，配置更灵活；Hystrix 侧重熔断和线程隔离。

  3. 什么是服务雪崩？如何避免？

    • 服务雪崩指一个服务故障引发连锁故障。解决方案：熔断、降级、限流、异步调用。

五、服务网关

  1. Zuul 和 Spring Cloud Gateway 的区别？

    • Zuul 1.x 基于 Servlet 阻塞模型，Gateway 基于 Reactor 非阻塞模型，支持更灵活的路由配置（如 Predicate、Filter）。

  2. 如何在网关中实现鉴权？

    • 通过自定义全局过滤器（如 GlobalFilter）验证 Token 或权限。

  3. 网关如何实现限流？

    • 使用 Sentinel 或 Redis + Lua 脚本实现令牌桶/漏桶算法。

六、配置中心

  1. Spring Cloud Config 的工作原理？

    • 将配置文件存储在 Git/SVN 等仓库，客户端启动时从 Config Server 拉取配置。

  2. 如何实现配置的热更新？

    • 结合 Spring Cloud Bus 和消息队列（如 RabbitMQ），通过 /actuator/refresh 或 @RefreshScope 刷新配置。

  3. Nacos 作为配置中心的优势？

    • 支持动态配置、版本管理、监听机制，且与注册中心集成。

七、分布式链路追踪

  1. Sleuth + Zipkin 的作用是什么？

    • Sleuth 生成请求链路 ID（Trace ID、Span ID），Zipkin 收集并可视化链路数据，用于性能分析和故障排查。

  2. 如何自定义 Sleuth 的采样率？

    • 配置 spring.sleuth.sampler.probability 控制采样比例（如 1.0 表示全采样）。

八、分布式事务

  1. Seata 的 AT 模式原理是什么？

    • 通过全局事务 ID 协调分支事务，执行 SQL 解析生成前后镜像，实现回滚（基于 undo_log 表）。

  2. 如何避免分布式事务？

    • 最终一致性方案：消息队列（如 RocketMQ 事务消息）、补偿机制（TCC）、Saga 模式。

九、Spring Cloud Alibaba

  1. Nacos 的核心功能？

    • 服务注册发现、动态配置管理、命名服务。

  2. Sentinel 如何实现熔断和限流？

    • 熔断：基于异常比例/响应时间；限流：QPS/线程数控制，支持预热、排队等待。

十、综合场景

  1. 如何设计一个高可用的微服务架构？

    • 服务注册集群、熔断降级、冗余部署、分布式配置、监控告警、自动化运维。

  2. Spring Cloud 如何与 Docker/K8s 集成？

    • 将服务打包为 Docker 镜像，通过 K8s 进行服务发现、负载均衡、自动扩缩容。

附：常见组件对比表

组件 作用 替代方案
Eureka 服务注册与发现 Nacos, Consul
Ribbon 客户端负载均衡 Spring Cloud LoadBalancer
Hystrix 熔断降级 Sentinel
Zuul 服务网关 Spring Cloud Gateway
Config 配置中心 Nacos, Apollo

关于Eureka

Eureka 是 Netflix 开源的服务发现组件，主要用于实现微服务架构中的服务注册与发现功能。它是 Spring Cloud 生态中的核心组件之一，帮助服务提供者和消费者动态感知彼此的存在。以下是 Eureka 的工作原理总结：

1. 核心角色

  1. Eureka Server：

    • 服务注册中心，负责管理所有服务的注册信息。
    • 提供服务发现的能力，供客户端查询可用服务实例。

  2. Eureka Client：

    • 服务提供者（Provider）：将自身注册到 Eureka Server。
    • 服务消费者（Consumer）：从 Eureka Server 获取服务实例列表，用于调用。

2. 核心工作原理

1) 服务注册

  • 服务提供者启动时，会向 Eureka Server 发送注册请求，包含以下信息：
    • 服务名称（Service Name）
    • IP 地址
    • 端口号
    • 健康检查 URL
    • 元数据（Metadata）
  • Eureka Server 将这些信息存储在注册表中，供其他服务查询。

2) 服务续约（心跳机制）

  • 服务提供者默认每 30 秒向 Eureka Server 发送一次心跳，证明自己仍然存活。
  • 如果 Eureka Server 在 90 秒内未收到心跳，则认为该服务实例不可用，将其从注册表中移除。

3) 服务发现

  • 服务消费者启动时，会从 Eureka Server 拉取服务注册表，缓存到本地。
  • 消费者通过服务名称查询可用实例列表，结合客户端负载均衡（如 Ribbon）选择目标实例进行调用。

4) 服务下线

  • 服务提供者正常关闭时，会向 Eureka Server 发送下线请求，从注册表中移除自己。
  • 如果服务异常终止（如崩溃），Eureka Server 会通过心跳机制检测并移除该实例。

5) 自我保护机制

  • Eureka Server 在短时间内丢失大量客户端心跳时（如网络分区故障），会进入自我保护模式。
  • 在该模式下，Eureka Server 不会移除未续约的服务实例，避免因网络问题导致服务列表被清空。
  • 网络恢复后，Eureka Server 会自动退出自我保护模式。

3. 数据存储与同步

  • Eureka Server 使用双层缓存机制提高性能：
    • 一级缓存：ReadOnlyCacheMap，定时从 ReadWriteCacheMap 同步数据，默认每 30 秒同步一次。
    • 二级缓存：ReadWriteCacheMap，直接存储注册表数据。
  • 客户端默认每 30 秒从 Eureka Server 拉取一次注册表更新。

4. 高可用架构

  • Eureka Server 支持集群部署，多个 Eureka Server 之间通过互相注册实现数据同步。
  • 客户端配置多个 Eureka Server 地址，实现故障转移。

5. 核心特点

  1. AP 模型：
    • Eureka 遵循 CAP 理论中的 AP（可用性和分区容错性），在网络分区时优先保证服务可用性。
  2. 客户端缓存：
    • 客户端本地缓存注册表，即使 Eureka Server 宕机，仍能继续调用服务。
  3. 简单易用：
    • 与 Spring Cloud 无缝集成，通过注解和配置即可快速使用。

6. 工作流程示例

  1. 服务启动：
    • 服务提供者向 Eureka Server 注册。
    • 服务消费者启动时拉取注册表。
  2. 服务调用：
    • 消费者通过服务名称查询实例列表，选择目标实例调用。
  3. 服务下线：
    • 提供者正常关闭时主动下线，异常终止时由 Eureka Server 检测移除。

总结

Eureka 通过服务注册、心跳续约、服务发现等机制，实现了微服务架构中的动态服务治理。其核心优势在于简单易用、高可用性强，适合中小规模的微服务场景。但随着云原生技术的发展，Eureka 逐渐被更强大的服务发现工具（如 Nacos、Consul）取代。

Eureka与Nacos的场景区别

一、核心架构与设计理念

  1. CAP 模型支持

    • Eureka：遵循 AP 模型（高可用性 + 分区容错性），在网络分区时优先保证服务可用性，但牺牲一致性。
    • Nacos：支持 AP 和 CP 模式切换。临时实例（默认）使用 AP 模式，非临时实例（需配置 ephemeral=false）使用 CP 模式，基于 Raft 协议保证强一致性。

  2. 实例类型

    • Eureka：仅支持临时实例，依赖心跳机制维持注册状态。
    • Nacos：支持临时实例和非临时实例。非临时实例宕机时不会被剔除，仅标记为不健康，由注册中心主动探测恢复状态。

二、服务发现与健康检查

  1. 服务发现机制

    • Eureka：客户端定时拉取服务列表（默认 30 秒），存在数据延迟。
    • Nacos：支持定时拉取 + 服务端主动推送变更信息，更新更及时。

  2. 健康检查

    • Eureka：仅通过客户端心跳（默认 30 秒）检测健康状态。
    • Nacos：
      • 临时实例：心跳检测（默认 5 秒），15 秒未收到标记不健康，30 秒剔除。
      • 非临时实例：服务端主动探测，异常时保留实例并标记不健康。

三、服务异常处理与自我保护

  1. 服务剔除效率

    • Eureka：极端情况下（心跳丢失 + 清除间隔）需约 3 分钟剔除异常实例。
    • Nacos：最快 30 秒剔除临时实例，效率更高。

  2. 自我保护机制

    • Eureka：全局阈值触发，进入保护模式后停止剔除所有实例。
    • Nacos：针对单个服务设置阈值，允许返回部分不健康实例以保障剩余服务可用。

四、功能扩展与生态集成

  1. 配置管理

    • Eureka：无内置配置中心，需配合 Spring Cloud Config 等组件实现动态配置。
    • Nacos：集成配置中心，支持动态配置推送、版本管理及在线编辑。

  2. 其他功能

    • Nacos 额外支持：
      • 权重管理：调整实例流量负载。
      • 分组与环境隔离：通过 Namespace 和 Group 实现多环境隔离。
      • 长连接通信：基于 Netty 保持长连接，减少网络开销。

五、部署与维护

  1. 数据存储

    • Eureka：内存存储注册表，集群间数据同步依赖复制。
    • Nacos：支持 MySQL 等数据库持久化存储，适合大规模生产环境。

  2. 社区与维护

    • Eureka：2.x 版本闭源，社区活跃度下降。
    • Nacos：阿里巴巴开源，持续更新并集成 Spring Cloud Alibaba 生态。

选型建议

  • 选择 Eureka：适用于简单微服务场景，需快速集成 Spring Cloud 原生组件。
  • 选择 Nacos：
    • 需要统一服务注册、配置管理及动态路由。
    • 期望高可用性 + 强一致性灵活切换。
    • 需云原生支持或长期技术演进。

关于Feign的一些概念

Feign 是一个声明式的 HTTP 客户端，主要用于简化微服务间的调用。其工作原理可总结如下：

  1. 声明式接口：
    • 开发者通过 Java 接口定义 HTTP API，使用注解（如 @RequestMapping）描述请求方法、路径和参数。
  2. 动态代理：
    • Feign 在运行时为接口创建动态代理对象，代理处理接口方法的调用。
  3. 请求构造：
    • 调用接口方法时，代理根据注解信息构造 HTTP 请求，包括 URL、方法、参数和头信息。
  4. 编码与解码：
    • Feign 使用编码器（Encoder）将请求参数转换为 HTTP 请求体，解码器（Decoder）将响应体转换为 Java 对象。
  5. HTTP 请求发送：
    • 通过底层的 HTTP 客户端（如 JDK 的 HttpURLConnection 或 Apache 的 HttpClient）发送请求。
  6. 负载均衡：
    • 与 Ribbon 集成时，Feign 支持客户端负载均衡，自动选择服务实例并发送请求。
  7. 错误处理：
    • 提供错误处理机制，开发者可通过自定义错误解码器处理异常。
  8. 日志记录：
    • 支持日志记录，便于调试和监控。
  9. 集成与扩展：
    • 可与 Spring Cloud 等框架集成，支持 Hystrix 熔断器等扩展功能。

一个简单的使用示例

OpenFeign 是一个声明式的 Web 服务客户端，它使得编写 Web 服务客户端变得更加简单。通过使用 OpenFeign，你可以通过定义接口并添加注解的方式来调用远程服务。以下是一个简单的示例，展示如何使用 OpenFeign 调用远程服务。

1. 添加依赖

首先，你需要在 pom.xml 中添加 OpenFeign 的依赖：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<dependencies>
    <!-- OpenFeign -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-openfeign</artifactId>
    </dependency>

    <!-- Spring Boot Web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!-- Spring Boot Starter -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
</dependencies>

2. 启用 Feign 客户端

在你的 Spring Boot 主类上添加 @EnableFeignClients 注解，以启用 Feign 客户端：

1
2
3
4
5
6
7
8
9
10
11
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.openfeign.EnableFeignClients;

@SpringBootApplication
@EnableFeignClients
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

3. 定义 Feign 客户端接口

接下来，定义一个 Feign 客户端接口，使用 @FeignClient 注解指定要调用的服务名称或 URL：

1
2
3
4
5
6
7
8
9
10
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

@FeignClient(name = "example-service", url = "https://api.example.com")
public interface ExampleServiceClient {

    @GetMapping("/users/{id}")
    User getUserById(@PathVariable("id") Long id);
}

在这个例子中，ExampleServiceClient 是一个 Feign 客户端接口，它定义了一个 getUserById 方法，用于调用远程服务的 /users/{id} 接口。

4. 定义 User 类

定义一个 User 类来表示返回的用户数据：

1
2
3
4
5
6
7
public class User {
    private Long id;
    private String name;
    private String email;

    // Getters and Setters
}

5. 使用 Feign 客户端

最后，在你的服务或控制器中注入 ExampleServiceClient 并使用它来调用远程服务：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {

    @Autowired
    private ExampleServiceClient exampleServiceClient;

    @GetMapping("/users/{id}")
    public User getUser(@PathVariable Long id) {
        return exampleServiceClient.getUserById(id);
    }
}

在这个例子中，UserController 是一个 Spring MVC 控制器，它通过 ExampleServiceClient 调用远程服务并返回用户数据。

6. 运行应用程序

现在你可以运行你的 Spring Boot 应用程序，并通过访问 /users/{id} 端点来获取用户信息。