Spring Cloud 笔记

约 2670 字大约 9 分钟

2025-08-23

一、Spring Cloud 简介

1.1 什么是 Spring Cloud？

Spring Cloud 是一系列框架的集合，用于快速构建分布式系统和微服务架构。它基于 Spring Boot，提供了一系列工具，使开发者能够轻松地配置、部署和管理分布式系统中的常见模式，如配置管理、服务发现、断路器、智能路由、微代理、控制总线等。

1.2 Spring Cloud 核心特点

约定优于配置：简化分布式系统配置
开箱即用：提供一系列即插即用的组件
云原生支持：天然支持云环境部署
服务治理：提供完整的服务治理解决方案
与 Spring 生态无缝集成：与 Spring Boot、Spring Data 等无缝集成
社区活跃：拥有庞大的开发者社区和丰富的资源

1.3 Spring Cloud 与 Spring Boot 关系

Spring Boot：用于快速创建独立的、生产级的 Spring 应用
Spring Cloud：基于 Spring Boot 构建，用于解决分布式系统中的常见问题

关系图：

Spring Cloud
    │
    ├── 基于
    │
    ▼
Spring Boot
    │
    ├── 基于
    │
    ▼
Spring Framework

二、微服务架构基础

2.1 什么是微服务

微服务是一种架构风格，它将单个应用程序开发为一组小型服务，每个服务运行在自己的进程中，并使用轻量级机制（通常是 HTTP 资源 API）进行通信。这些服务围绕业务能力构建，可通过全自动部署机制独立部署。

2.2 微服务架构的优势

独立开发：团队可以独立开发、测试和部署服务
技术多样性：不同服务可以使用不同的技术栈
弹性扩展：可以针对特定服务进行扩展
故障隔离：一个服务的故障不会影响整个系统
持续交付：更容易实现持续集成和持续部署

2.3 微服务架构的挑战

分布式系统复杂性：网络延迟、服务发现、负载均衡
数据一致性：分布式事务问题
服务治理：服务注册、发现、熔断
监控和日志：分布式追踪、集中式日志
测试复杂性：需要模拟服务依赖

三、服务注册与发现

3.1 Eureka

Eureka 是 Netflix 开源的服务发现组件，也是 Spring Cloud 中最常用的服务注册中心。

服务端配置：

server:
  port: 8761

eureka:
  instance:
    hostname: localhost
  client:
    register-with-eureka: false  # 作为服务端，不向自己注册
    fetch-registry: false         # 作为服务端，不获取注册信息
  server:
    wait-time-in-ms-when-sync-empty: 0

服务端启动类：

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

客户端配置：

spring:
  application:
    name: user-service

eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/

客户端启动类：

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

3.2 Nacos

Nacos 是阿里巴巴开源的服务发现和配置管理平台，是 Spring Cloud Alibaba 的核心组件。

服务端启动：

# 下载并启动 Nacos 服务端
sh bin/start.sh -m standalone

客户端配置：

spring:
  application:
    name: user-service
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848

客户端启动类：

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

四、客户端负载均衡

4.1 Spring Cloud LoadBalancer

Spring Cloud LoadBalancer 是 Spring Cloud 的客户端负载均衡器，替代了已弃用的 Ribbon。

基本使用：

@Configuration
public class LoadBalancerConfig {
    
    @Bean
    public ReactorLoadBalancer<ServiceInstance> randomLoadBalancer(Environment environment,
                                                                LoadBalancerClientFactory loadBalancerClientFactory) {
        String name = environment.getProperty(LoadBalancerClientFactory.PROPERTY_NAME);
        return new RandomLoadBalancer(loadBalancerClientFactory.getLazyProvider(name, ServiceInstanceListSupplier.class), name);
    }
}

使用 RestTemplate 集成负载均衡：

@Bean
@LoadBalanced
public RestTemplate restTemplate() {
    return new RestTemplate();
}

// 使用
String result = restTemplate.getForObject("http://order-service/api/orders", String.class);

4.2 负载均衡策略

策略	说明
Random	随机选择服务实例
RoundRobin	轮询选择服务实例
Weighted	基于权重选择服务实例
ZoneAvoidance	基于区域的负载均衡

五、服务调用

5.1 OpenFeign

OpenFeign 是一个声明式的 Web 服务客户端，简化了服务间调用的代码。

依赖配置：

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

启动类配置：

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

Feign 客户端定义：

@FeignClient(name = "order-service", path = "/api/orders")
public interface OrderClient {
    
    @GetMapping("/{id}")
    Order getOrderById(@PathVariable("id") Long id);
    
    @PostMapping
    Order createOrder(@RequestBody Order order);
}

使用 Feign 客户端：

@RestController
public class UserController {
    
    @Autowired
    private OrderClient orderClient;
    
    @GetMapping("/users/{userId}/orders")
    public List<Order> getUserOrders(@PathVariable Long userId) {
        // 调用 order-service
        return orderClient.getUserOrders(userId);
    }
}

Feign 配置：

feign:
  client:
    config:
      default:  # 全局配置
        connectTimeout: 5000
        readTimeout: 5000
      order-service:  # 针对特定服务的配置
        connectTimeout: 3000
        readTimeout: 3000

5.2 超时与重试配置

# 全局配置
ribbon:
  ConnectTimeout: 1000  # 连接超时（毫秒）
  ReadTimeout: 3000     # 读取超时（毫秒）
  MaxAutoRetries: 1     # 同一实例重试次数
  MaxAutoRetriesNextServer: 2  # 切换实例重试次数

六、API 网关

6.1 Spring Cloud Gateway

Spring Cloud Gateway 是 Spring Cloud 的新一代 API 网关，基于 Reactor 模型，性能优于 Zuul。

依赖配置：

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

基本路由配置：

spring:
  cloud:
    gateway:
      routes:
        - id: user-service
          uri: lb://user-service
          predicates:
            - Path=/api/users/**
          filters:
            - StripPrefix=1  # 去掉前缀
        - id: order-service
          uri: lb://order-service
          predicates:
            - Path=/api/orders/**

通过 Java 配置路由：

@Configuration
public class GatewayConfig {
    
    @Bean
    public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
        return builder.routes()
            .route("user-service", r -> r.path("/api/users/**")
                .filters(f -> f.stripPrefix(1))
                .uri("lb://user-service"))
            .route("order-service", r -> r.path("/api/orders/**")
                .filters(f -> f.stripPrefix(1))
                .uri("lb://order-service"))
            .build();
    }
}

6.2 常用过滤器

过滤器	说明	示例
AddRequestHeader	添加请求头	`AddRequestHeader=X-Request-Id, 12345`
AddResponseHeader	添加响应头	`AddResponseHeader=Access-Control-Allow-Origin, *`
StripPrefix	去掉路径前缀	`StripPrefix=1`
RewritePath	重写路径	`RewritePath=/api/(?<segment>.*), /$\{segment}`
RequestRateLimiter	请求限流	`RequestRateLimiter=redisRateLimiter`

6.3 限流配置

spring:
  cloud:
    gateway:
      routes:
        - id: user-service
          uri: lb://user-service
          predicates:
            - Path=/api/users/**
          filters:
            - name: RequestRateLimiter
              args:
                redis-rate-limiter.replenishRate: 10  # 每秒允许10个请求
                redis-rate-limiter.burstCapacity: 20   # 令牌桶容量
      redis-rate-limiter:
        replenishRate: 10
        burstCapacity: 20

七、熔断与容错

7.1 Resilience4j

Resilience4j 是 Spring Cloud 推荐的熔断器实现，替代了已弃用的 Hystrix。

依赖配置：

<dependency>
    <groupId>io.github.resilience4j</groupId>
    <artifactId>resilience4j-spring-boot2</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-circuitbreaker-resilience4j</artifactId>
</dependency>

基本配置：

resilience4j:
  circuitbreaker:
    instances:
      backendA:
        failure-rate-threshold: 50    # 失败率阈值
        wait-duration-in-open-state: 5000  # 熔断器打开后等待时间
        ring-buffer-size-in-half-open-state: 3  # 半开状态缓冲区大小
        minimum-number-of-calls: 5     # 最小调用次数
        automatic-transition-from-open-to-half-open-enabled: true

使用 CircuitBreaker：

@Service
public class OrderService {
    
    private final CircuitBreakerFactory circuitBreakerFactory;
    
    @Autowired
    public OrderService(CircuitBreakerFactory circuitBreakerFactory) {
        this.circuitBreakerFactory = circuitBreakerFactory;
    }
    
    public Order getOrder(Long id) {
        CircuitBreaker circuitBreaker = circuitBreakerFactory.create("orderService");
        return circuitBreaker.run(() -> {
            // 服务调用
            return restTemplate.getForObject("http://order-service/api/orders/" + id, Order.class);
        }, fallback -> {
            // 熔断后的降级处理
            Order order = new Order();
            order.setId(id);
            order.setStatus("DEGRADED");
            return order;
        });
    }
}

7.2 服务降级

使用 Feign 集成熔断：

@FeignClient(name = "order-service", fallback = OrderServiceFallback.class)
public interface OrderClient {
    @GetMapping("/{id}")
    Order getOrderById(@PathVariable("id") Long id);
}

@Component
public class OrderServiceFallback implements OrderClient {
    @Override
    public Order getOrderById(Long id) {
        Order order = new Order();
        order.setId(id);
        order.setStatus("DEGRADED");
        return order;
    }
}

八、分布式配置管理

8.1 Spring Cloud Config

Spring Cloud Config 为分布式系统提供集中化的外部配置支持。

Config Server 配置：

server:
  port: 8888

spring:
  application:
    name: config-server
  cloud:
    config:
      server:
        git:
          uri: https://github.com/yourname/config-repo
          search-paths: '{application}'
          username: your-username
          password: your-password

Config Server 启动类：

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

Config Client 配置：

spring:
  application:
    name: user-service
  cloud:
    config:
      uri: http://localhost:8888
      profile: dev
      label: master

配置文件命名规则：

{application}-{profile}.yml：如 user-service-dev.yml
{application}-{profile}.properties：如 user-service-dev.properties

8.2 配置刷新

添加配置刷新依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

配置端点：

management:
  endpoints:
    web:
      exposure:
        include: refresh  # 暴露refresh端点

刷新配置：

curl -X POST http://localhost:8080/actuator/refresh

自动刷新配置：

@RestController
@RefreshScope  // 添加此注解实现配置自动刷新
public class UserController {
    
    @Value("${custom.property}")
    private String customProperty;
    
    @GetMapping("/property")
    public String getProperty() {
        return customProperty;
    }
}

九、分布式追踪

9.1 Spring Cloud Sleuth

Spring Cloud Sleuth 为服务提供分布式追踪解决方案，与 Zipkin 集成。

依赖配置：

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

基本配置：

spring:
  application:
    name: user-service
  sleuth:
    sampler:
      probability: 1.0  # 采样率，1.0表示100%采样
  zipkin:
    base-url: http://localhost:9411  # Zipkin 服务器地址

9.2 Zipkin 集成

启动 Zipkin 服务器：

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

追踪信息：

Trace ID：一个分布式系统中完整的请求链路
Span ID：单个服务中的操作
Parent Span ID：父Span ID，形成调用链

日志中查看追踪信息：

2023-08-15 14:30:00.123  INFO [user-service,67c3d5a2d5e6f7a8,67c3d5a2d5e6f7a8,false] 12345 --- [nio-8080-exec-1] c.e.d.controller.UserController : Received request

十、消息驱动

10.1 Spring Cloud Stream

Spring Cloud Stream 是一个用于构建消息驱动微服务的框架。

依赖配置：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-stream</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-stream-binder-rabbit</artifactId>  <!-- 或 kafka -->
</dependency>

消息生产者：

@SpringBootApplication
public class ProducerApplication {
    
    @Autowired
    private Source source;
    
    public static void main(String[] args) {
        SpringApplication.run(ProducerApplication.class, args);
    }
    
    @Bean
    public CommandLineRunner runner() {
        return args -> {
            Message<String> message = MessageBuilder.withPayload("Hello Spring Cloud Stream!")
                    .setHeader("type", "greeting")
                    .build();
            source.output().send(message);
        };
    }
}

消息消费者：

@SpringBootApplication
public class ConsumerApplication {
    
    public static void main(String[] args) {
        SpringApplication.run(ConsumerApplication.class, args);
    }
    
    @StreamListener(Sink.INPUT)
    public void handle(Message<String> message) {
        System.out.println("Received: " + message.getPayload());
        System.out.println("Headers: " + message.getHeaders());
    }
}

配置文件：

spring:
  cloud:
    stream:
      bindings:
        output:
          destination: greetings
        input:
          destination: greetings
      rabbit:
        bindings:
          output:
            producer:
              routing-key-expression: headers.type
          input:
            consumer:
              binding-routing-key: greeting

十一、安全

11.1 Spring Cloud Security

Spring Cloud Security 提供了微服务架构中的安全解决方案。

资源服务器配置：

@Configuration
@EnableResourceServer
public class ResourceServerConfig extends ResourceServerConfigurerAdapter {
    
    @Override
    public void configure(ResourceServerSecurityConfigurer config) {
        config.resourceId("resource-server");
    }
    
    @Override
    public void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
            .antMatchers("/api/public/**").permitAll()
            .anyRequest().authenticated();
    }
}

配置文件：

security:
  oauth2:
    resource:
      user-info-uri: http://auth-server/userinfo
      token-info-uri: http://auth-server/check_token
      client-id: client
      client-secret: secret

11.2 服务间安全调用

使用 OAuth2 保护服务：

@Configuration
@EnableResourceServer
public class ResourceServerConfig extends ResourceServerConfigurerAdapter {
    
    @Override
    public void configure(ResourceServerSecurityConfigurer config) {
        config.resourceId("user-service");
    }
    
    @Override
    public void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
            .anyRequest().authenticated();
    }
}

Feign 客户端集成 OAuth2：

@Bean
public RequestInterceptor oauth2FeignRequestInterceptor() {
    return requestTemplate -> {
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        if (authentication != null && authentication.getCredentials() instanceof String) {
            requestTemplate.header("Authorization", "Bearer " + authentication.getCredentials());
        }
    };
}

十二、最佳实践

12.1 微服务拆分原则

单一职责原则：每个服务只负责一个业务领域
高内聚低耦合：服务内部高度内聚，服务间低耦合
业务边界：基于业务能力进行拆分，而非技术能力
渐进式拆分：从单体应用逐步拆分为微服务
避免分布式事务：使用最终一致性替代强一致性

12.2 配置管理最佳实践

配置与代码分离：所有配置外部化
环境差异化：使用 profile 区分不同环境配置
敏感信息加密：使用 Jasypt 等工具加密敏感配置
配置变更审计：记录配置变更历史
配置版本管理：配置变更也要纳入版本控制

12.3 监控与日志

集中式日志：使用 ELK (Elasticsearch, Logstash, Kibana) 或 Splunk
统一监控：使用 Prometheus + Grafana 监控系统指标
分布式追踪：使用 Zipkin 或 Jaeger 进行请求链路追踪
健康检查：实现 /actuator/health 端点
告警机制：设置合理的告警阈值和通知方式