Spring Cloud 详解

Spring Cloud是构建分布式系统和微服务架构的完整解决方案，它基于Spring Boot提供了服务注册发现、配置管理、负载均衡、熔断降级等微服务核心功能。

本文内容概览

1. Spring Cloud基础概念
- 1.1 什么是微服务？
- 1.2 Spring Cloud组件
2. 服务注册与发现
3. 服务网关
4. 负载均衡
5. 熔断降级
- 5.1 Hystrix配置
- 5.2 Sentinel配置
6. 配置管理
7. 分布式链路追踪
- 7.1 Sleuth配置
- 7.2 Zipkin配置
8. 面试题精选
9. Spring Cloud Alibaba
10. 微服务架构设计模式
11. 微服务监控与运维
- 11.1 监控体系
- 11.2 日志管理
12. 面试题精选（全面版）

核心价值

Spring Cloud = 微服务架构 + 服务治理 + 配置管理 + 负载均衡 + 熔断降级

🔍 服务治理：服务注册发现、API网关
⚖️ 负载均衡：智能路由、客户端负载均衡
🛡️ 熔断降级：服务容错、失败隔离
⚙️ 配置管理：集中配置、动态刷新
📊 链路追踪：分布式系统监控、调用链分析

1. Spring Cloud基础概念

1.1 什么是微服务？

微服务是一种软件架构风格，将应用程序拆分为一组小型、独立的服务，每个服务运行在自己的进程中，通过轻量级机制进行通信。

微服务架构特点

特点	说明	优势
服务拆分	按业务功能拆分服务	职责单一，易于维护
独立部署	每个服务可独立部署	快速迭代，降低风险
技术异构	不同服务可使用不同技术栈	技术选型灵活
数据隔离	每个服务管理自己的数据	数据一致性可控
故障隔离	单个服务故障不影响整体	提高系统可用性

1.2 Spring Cloud组件

Spring Cloud提供了一套完整的微服务解决方案，包含多个组件共同构建分布式系统。

Spring Cloud依赖配置

Spring Cloud依赖

xml

1<dependencyManagement>
2    <dependencies>
3        <dependency>
4            <groupId>org.springframework.cloud</groupId>
5            <artifactId>spring-cloud-dependencies</artifactId>
6            <version>2021.0.8</version>
7            <type>pom</type>
8            <scope>import</scope>
9        </dependency>
10    </dependencies>
11</dependencyManagement>

2. 服务注册与发现

服务注册与发现是微服务架构的基础设施，用于管理和定位服务实例。

2.1 Eureka Server

Java配置
YAML配置
集群配置

Eureka Server配置

java

1@SpringBootApplication
2@EnableEurekaServer
3public class EurekaServerApplication {
4    public static void main(String[] args) {
5        SpringApplication.run(EurekaServerApplication.class, args);
6    }
7}

Eureka Server配置

yaml

1server:
2  port: 8761
3
4spring:
5  application:
6    name: eureka-server
7
8eureka:
9  instance:
10    hostname: localhost
11  client:
12    register-with-eureka: false
13    fetch-registry: false
14    service-url:
15      defaultZone: http://localhost:8761/eureka/
16  server:
17    enable-self-preservation: false
18    eviction-interval-timer-in-ms: 1000

Eureka Server集群配置

yaml

1# eureka-server-1 配置
2server:
3  port: 8761
4
5spring:
6  application:
7    name: eureka-server
8
9eureka:
10  instance:
11    hostname: eureka1
12  client:
13    register-with-eureka: true
14    fetch-registry: true
15    service-url:
16      defaultZone: http://eureka2:8762/eureka/,http://eureka3:8763/eureka/
17      
18# eureka-server-2 配置
19server:
20  port: 8762
21
22spring:
23  application:
24    name: eureka-server
25
26eureka:
27  instance:
28    hostname: eureka2
29  client:
30    register-with-eureka: true
31    fetch-registry: true
32    service-url:
33      defaultZone: http://eureka1:8761/eureka/,http://eureka3:8763/eureka/

2.2 Eureka Client

Java配置
YAML配置

Eureka Client配置

java

1@SpringBootApplication
2@EnableEurekaClient
3public class UserServiceApplication {
4    public static void main(String[] args) {
5        SpringApplication.run(UserServiceApplication.class, args);
6    }
7}

Eureka Client配置

yaml

1spring:
2  application:
3    name: user-service
4
5eureka:
6  client:
7    service-url:
8      defaultZone: http://localhost:8761/eureka/
9    register-with-eureka: true
10    fetch-registry: true
11  instance:
12    prefer-ip-address: true
13    instance-id: ${spring.application.name}:${server.port}
14    lease-renewal-interval-in-seconds: 30
15    lease-expiration-duration-in-seconds: 90

配置项	说明	默认值	推荐设置
register-with-eureka	是否注册到Eureka	true	生产环境保持true
fetch-registry	是否从Eureka获取注册信息	true	生产环境保持true
prefer-ip-address	是否使用IP地址注册	false	建议设为true
lease-renewal-interval	心跳间隔时间(秒)	30	根据负载调整
lease-expiration-duration	失效时间(秒)	90	通常为心跳间隔的3倍

2.3 服务注册示例

服务注册示例

java

1@RestController
2@RequestMapping("/users")
3public class UserController {
4    
5    @Autowired
6    private UserService userService;
7    
8    @GetMapping("/{id}")
9    public ResponseEntity<User> getUser(@PathVariable Long id) {
10        User user = userService.findById(id);
11        return ResponseEntity.ok(user);
12    }
13    
14    @PostMapping
15    public ResponseEntity<User> createUser(@RequestBody User user) {
16        User savedUser = userService.save(user);
17        return ResponseEntity.status(HttpStatus.CREATED).body(savedUser);
18    }
19}

3. 服务网关

3.1 Gateway配置

Spring Cloud Gateway是API网关服务，提供了路由、过滤、限流等功能。

Java配置
YAML配置

Gateway配置

java

1@SpringBootApplication
2@EnableDiscoveryClient
3public class GatewayApplication {
4    public static void main(String[] args) {
5        SpringApplication.run(GatewayApplication.class, args);
6    }
7}

Gateway路由配置

yaml

1spring:
2  cloud:
3    gateway:
4      discovery:
5        locator:
6          enabled: true
7          lower-case-service-id: true
8      routes:
9        - id: user-service
10          uri: lb://user-service
11          predicates:
12            - Path=/api/users/**
13          filters:
14            - StripPrefix=1
15            - name: RequestRateLimiter
16              args:
17                redis-rate-limiter.replenishRate: 10
18                redis-rate-limiter.burstCapacity: 20
19        
20        - id: order-service
21          uri: lb://order-service
22          predicates:
23            - Path=/api/orders/**
24          filters:
25            - StripPrefix=1
26            - name: CircuitBreaker
27              args:
28                name: orderCircuitBreaker
29                fallbackUri: forward:/fallback/order

3.2 自定义过滤器

自定义过滤器

java

1@Component
2public class AuthFilter implements GlobalFilter, Ordered {
3    
4    @Override
5    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
6        ServerHttpRequest request = exchange.getRequest();
7        String token = request.getHeaders().getFirst("Authorization");
8        
9        if (token == null || !isValidToken(token)) {
10            ServerHttpResponse response = exchange.getResponse();
11            response.setStatusCode(HttpStatus.UNAUTHORIZED);
12            return response.setComplete();
13        }
14        
15        return chain.filter(exchange);
16    }
17    
18    @Override
19    public int getOrder() {
20        return -100;
21    }
22    
23    private boolean isValidToken(String token) {
24        // 验证token逻辑
25        return token != null && token.startsWith("Bearer ");
26    }
27}

3.3 限流配置

代码配置
Redis限流器

限流配置

java

1@Configuration
2public class RateLimiterConfig {
3    
4    @Bean
5    public KeyResolver userKeyResolver() {
6        return exchange -> Mono.just(
7            exchange.getRequest().getHeaders().getFirst("X-User-Id")
8        );
9    }
10    
11    @Bean
12    public KeyResolver ipKeyResolver() {
13        return exchange -> Mono.just(
14            exchange.getRequest().getRemoteAddress().getAddress().getHostAddress()
15        );
16    }
17}

Redis限流配置

yaml

1spring:
2  cloud:
3    gateway:
4      routes:
5        - id: user-service
6          uri: lb://user-service
7          predicates:
8            - Path=/api/users/**
9          filters:
10            - name: RequestRateLimiter
11              args:
12                redis-rate-limiter.replenishRate: 10  # 令牌桶每秒填充速率
13                redis-rate-limiter.burstCapacity: 20  # 令牌桶总容量
14                key-resolver: "#{@ipKeyResolver}"     # 限流键解析器

4. 负载均衡

Spring Cloud提供了客户端负载均衡功能，主要通过Ribbon和LoadBalancer组件实现。

4.1 Ribbon配置

基础配置
YAML配置

Ribbon配置

java

1@Configuration
2public class RibbonConfig {
3    
4    @Bean
5    @LoadBalanced
6    public RestTemplate restTemplate() {
7        return new RestTemplate();
8    }
9    
10    @Bean
11    public IRule ribbonRule() {
12        return new RoundRobinRule(); // 轮询策略
13    }
14    
15    @Bean
16    public IPing ribbonPing() {
17        return new PingUrl();
18    }
19}

Ribbon配置

yaml

1ribbon:
2  ReadTimeout: 5000
3  ConnectTimeout: 2000
4  MaxAutoRetries: 1
5  MaxAutoRetriesNextServer: 2
6  # 特定服务的配置
7  user-service:
8    ReadTimeout: 10000
9    ConnectTimeout: 5000

4.2 负载均衡策略

负载均衡策略

java

1@Service
2public class UserService {
3    
4    @Autowired
5    @LoadBalanced
6    private RestTemplate restTemplate;
7    
8    public User getUserById(Long id) {
9        // 使用服务名进行负载均衡调用
10        return restTemplate.getForObject(
11            "http://user-service/users/" + id, 
12            User.class
13        );
14    }
15    
16    public List<User> getAllUsers() {
17        return restTemplate.getForObject(
18            "http://user-service/users", 
19            List.class
20        );
21    }
22}

4.3 自定义负载均衡

自定义规则
配置自定义规则

自定义负载均衡

java

1@Component
2public class CustomLoadBalancerRule extends AbstractLoadBalancerRule {
3    
4    @Override
5    public Server choose(Object key) {
6        ILoadBalancer lb = getLoadBalancer();
7        
8        List<Server> reachableServers = lb.getReachableServers();
9        List<Server> allServers = lb.getAllServers();
10        
11        if (reachableServers.isEmpty()) {
12            return null;
13        }
14        
15        // 自定义负载均衡逻辑
16        return reachableServers.get(new Random().nextInt(reachableServers.size()));
17    }
18    
19    @Override
20    public void initWithNiwsConfig(IClientConfig clientConfig) {
21        // 初始化配置
22    }
23}

配置自定义规则

java

1@Configuration
2public class RibbonClientConfig {
3    
4    @Bean
5    public IRule ribbonRule() {
6        return new CustomLoadBalancerRule();
7    }
8}
9
10// 针对特定服务的配置
11@Configuration
12@RibbonClient(name = "user-service", configuration = UserServiceRibbonConfig.class)
13public class UserServiceRibbonConfig {
14    
15    @Bean
16    public IRule ribbonRule() {
17        return new WeightedResponseTimeRule();
18    }
19    
20    @Bean
21    public IPing ribbonPing() {
22        return new PingUrl();
23    }
24}

5. 熔断降级

熔断器设计模式用于保护系统免受级联故障影响，当服务调用失败达到阈值时，触发熔断，并提供后备响应。

5.1 Hystrix配置

应用配置
服务配置
关键属性

Hystrix配置

java

1@SpringBootApplication
2@EnableCircuitBreaker
3public class UserServiceApplication {
4    public static void main(String[] args) {
5        SpringApplication.run(UserServiceApplication.class, args);
6    }
7}

Hystrix使用示例

java

1@Service
2public class UserService {
3    
4    @Autowired
5    private RestTemplate restTemplate;
6    
7    @HystrixCommand(
8        fallbackMethod = "getUserFallback",
9        commandProperties = {
10            @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "2000"),
11            @HystrixProperty(name = "circuitBreaker.requestVolumeThreshold", value = "10"),
12            @HystrixProperty(name = "circuitBreaker.errorThresholdPercentage", value = "50"),
13            @HystrixProperty(name = "circuitBreaker.sleepWindowInMilliseconds", value = "5000")
14        }
15    )
16    public User getUserById(Long id) {
17        return restTemplate.getForObject(
18            "http://user-service/users/" + id, 
19            User.class
20        );
21    }
22    
23    public User getUserFallback(Long id, Throwable e) {
24        // 降级逻辑
25        User fallbackUser = new User();
26        fallbackUser.setId(id);
27        fallbackUser.setName("默认用户");
28        fallbackUser.setEmail("default@example.com");
29        return fallbackUser;
30    }
31}

属性	说明	默认值	推荐值
execution.isolation.thread.timeoutInMilliseconds	执行超时时间	1000ms	根据接口调整
circuitBreaker.requestVolumeThreshold	熔断触发最小请求数	20	生产环境调大
circuitBreaker.errorThresholdPercentage	错误率阈值	50%	根据容错率调整
circuitBreaker.sleepWindowInMilliseconds	熔断恢复时间窗口	5000ms	根据服务恢复时间调整

5.2 Sentinel配置

Sentinel是阿里巴巴开源的流量控制组件，提供了熔断降级、系统负载保护、实时监控等功能。

Sentinel配置

java

1@Configuration
2public class SentinelConfig {
3    
4    @PostConstruct
5    public void init() {
6        // 配置限流规则
7        List<FlowRule> rules = new ArrayList<>();
8        FlowRule rule = new FlowRule();
9        rule.setResource("getUser");
10        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
11        rule.setCount(10);
12        rules.add(rule);
13        FlowRuleManager.loadRules(rules);
14    }
15}

服务使用
规则配置

Sentinel使用示例

java

1@Service
2public class UserService {
3    
4    @SentinelResource(
5        value = "getUser",
6        blockHandler = "getUserBlockHandler",
7        fallback = "getUserFallback"
8    )
9    public User getUserById(Long id) {
10        return userRepository.findById(id).orElse(null);
11    }
12    
13    public User getUserBlockHandler(Long id, BlockException ex) {
14        // 限流处理
15        return new User();
16    }
17    
18    public User getUserFallback(Long id, Throwable e) {
19        // 降级处理
20        return new User();
21    }
22}

Sentinel规则配置

java

1// 流控规则
2private void initFlowRules() {
3    List<FlowRule> rules = new ArrayList<>();
4    FlowRule rule = new FlowRule();
5    rule.setResource("getUser");
6    rule.setGrade(RuleConstant.FLOW_GRADE_QPS);  // QPS模式
7    rule.setCount(20);  // 每秒允许20次调用
8    
9    // 流控效果
10    rule.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_WARM_UP); // 预热方式
11    rule.setWarmUpPeriodSec(10); // 预热时间10秒
12    
13    rules.add(rule);
14    FlowRuleManager.loadRules(rules);
15}
16
17// 降级规则
18private void initDegradeRules() {
19    List<DegradeRule> rules = new ArrayList<>();
20    DegradeRule rule = new DegradeRule();
21    rule.setResource("getUser");
22    rule.setGrade(RuleConstant.DEGRADE_GRADE_EXCEPTION_RATIO); // 异常比例
23    rule.setCount(0.5); // 异常比例阈值50%
24    rule.setTimeWindow(10); // 熔断时间10秒
25    
26    rules.add(rule);
27    DegradeRuleManager.loadRules(rules);
28}

6. 配置管理

Spring Cloud Config提供了集中化的配置管理，支持动态刷新和版本管理。

6.1 Config Server

服务配置
YAML配置
本地配置

Config Server配置

java

1@SpringBootApplication
2@EnableConfigServer
3public class ConfigServerApplication {
4    public static void main(String[] args) {
5        SpringApplication.run(ConfigServerApplication.class, args);
6    }
7}

Config Server配置

yaml

1server:
2  port: 8888
3
4spring:
5  application:
6    name: config-server
7  cloud:
8    config:
9      server:
10        git:
11          uri: https://github.com/example/config-repo
12          default-label: main
13          search-paths: config
14          username: ${GIT_USERNAME}
15          password: ${GIT_PASSWORD}

本地配置模式

yaml

1spring:
2  cloud:
3    config:
4      server:
5        native:
6          search-locations: classpath:/config,file:./config
7  profiles:
8    active: native

6.2 Config Client

Config Client配置

java

1@SpringBootApplication
2@EnableDiscoveryClient
3@RefreshScope
4public class UserServiceApplication {
5    public static void main(String[] args) {
6        SpringApplication.run(UserServiceApplication.class, args);
7    }
8}

YAML配置
Bootstrap配置
配置使用

Config Client配置

yaml

1spring:
2  application:
3    name: user-service
4  cloud:
5    config:
6      uri: http://localhost:8888
7      fail-fast: true
8      retry:
9        initial-interval: 1000
10        max-interval: 2000
11        max-attempts: 6

bootstrap.yml

yaml

1spring:
2  application:
3    name: user-service
4  cloud:
5    config:
6      uri: http://localhost:8888
7      fail-fast: true
8  profiles:
9    active: dev

配置使用示例

java

1@RestController
2@RefreshScope
3public class ConfigController {
4    
5    @Value("${app.feature.enabled:false}")
6    private boolean featureEnabled;
7    
8    @Value("${app.max.users:100}")
9    private int maxUsers;
10    
11    @GetMapping("/config")
12    public Map<String, Object> getConfig() {
13        Map<String, Object> config = new HashMap<>();
14        config.put("featureEnabled", featureEnabled);
15        config.put("maxUsers", maxUsers);
16        return config;
17    }
18}

6.3 动态刷新配置

手动刷新
消息总线自动刷新

shell

1# 单个服务手动刷新
2curl -X POST http://localhost:8080/actuator/refresh
3
4# 添加actuator依赖和配置
5# pom.xml
6<dependency>
7    <groupId>org.springframework.boot</groupId>
8    <artifactId>spring-boot-starter-actuator</artifactId>
9</dependency>
10
11# application.yml
12management:
13  endpoints:
14    web:
15      exposure:
16        include: refresh,health,info

yaml

1# 添加依赖
2# pom.xml
3<dependency>
4    <groupId>org.springframework.cloud</groupId>
5    <artifactId>spring-cloud-starter-bus-amqp</artifactId>
6</dependency>
7
8# application.yml
9spring:
10  rabbitmq:
11    host: localhost
12    port: 5672
13    username: guest
14    password: guest
15  cloud:
16    bus:
17      enabled: true
18      trace:
19        enabled: true
20        
21# 刷新所有服务配置
22curl -X POST http://localhost:8888/actuator/busrefresh
23
24# 刷新指定服务配置
25curl -X POST http://localhost:8888/actuator/busrefresh/user-service:8080

7. 分布式链路追踪

分布式链路追踪用于跟踪和可视化微服务调用链路，帮助开发人员理解系统行为和排查问题。

7.1 Sleuth配置

依赖配置
YAML配置
使用示例

Sleuth依赖

xml

1<dependency>
2    <groupId>org.springframework.cloud</groupId>
3    <artifactId>spring-cloud-starter-sleuth</artifactId>
4</dependency>

Sleuth配置

yaml

1spring:
2  sleuth:
3    sampler:
4      probability: 1.0
5    web:
6      client:
7        enabled: true
8    messaging:
9      enabled: true

Sleuth使用示例

java

1@Service
2public class UserService {
3    
4    private static final Logger logger = LoggerFactory.getLogger(UserService.class);
5    
6    @Autowired
7    private RestTemplate restTemplate;
8    
9    public User getUserById(Long id) {
10        logger.info("开始获取用户信息，用户ID: {}", id);
11        
12        User user = restTemplate.getForObject(
13            "http://user-service/users/" + id, 
14            User.class
15        );
16        
17        logger.info("获取用户信息成功，用户: {}", user);
18        return user;
19    }
20}

7.2 Zipkin配置

Zipkin配置

yaml

1spring:
2  application:
3    name: zipkin-server
4  sleuth:
5    zipkin:
6      base-url: http://localhost:9411

Zipkin依赖
Zipkin服务器

xml

1<!-- Zipkin依赖 -->
2<dependency>
3    <groupId>org.springframework.cloud</groupId>
4    <artifactId>spring-cloud-starter-zipkin</artifactId>
5</dependency>

Zipkin服务器启动

java

1// 现代版本推荐使用Docker方式启动Zipkin服务器
2// docker run -d -p 9411:9411 openzipkin/zipkin
3
4// 或者使用Java命令
5// java -jar zipkin-server.jar
6
7// Spring Boot 2.0后不再推荐自建Zipkin服务器
8@SpringBootApplication
9@EnableZipkinServer // 已弃用
10public class ZipkinServerApplication {
11    public static void main(String[] args) {
12        SpringApplication.run(ZipkinServerApplication.class, args);
13    }
14}

8. 面试题精选

8.1 基础概念题

微服务架构
核心组件

A: 微服务架构是一种将应用程序拆分为小型、独立服务的架构风格。

优势包括：

服务拆分：按业务功能拆分，职责单一
独立部署：每个服务可独立部署和扩展
技术异构：不同服务可使用不同技术栈
故障隔离：单个服务故障不影响整体

挑战包括：

分布式复杂性：网络通信、数据一致性等
服务治理：服务发现、负载均衡、熔断降级
数据管理：分布式事务、数据一致性
运维复杂度：监控、日志、部署等

8.2 实践题

服务注册发现
API网关

A: 实现服务注册与发现的步骤：

配置Eureka Server：

java

1@SpringBootApplication
2@EnableEurekaServer
3public class EurekaServerApplication {
4  public static void main(String[] args) {
5      SpringApplication.run(EurekaServerApplication.class, args);
6  }
7}

配置Eureka Client：

java

1@SpringBootApplication
2@EnableEurekaClient
3public class ServiceApplication {
4  public static void main(String[] args) {
5      SpringApplication.run(ServiceApplication.class, args);
6  }
7}

服务调用：使用@LoadBalanced注解的RestTemplate或Feign客户端
负载均衡：通过Ribbon实现，可自定义负载均衡策略

A: 实现API网关的方法：

配置Gateway：

yaml

1spring:
2cloud:
3  gateway:
4    routes:
5      - id: user-service
6        uri: lb://user-service
7        predicates:
8          - Path=/api/users/**
9        filters:
10          - StripPrefix=1

过滤器链：实现GlobalFilter接口，可处理认证、限流、日志等
服务发现：结合Eureka，实现动态路由
负载均衡：使用lb://前缀进行负载均衡

8.3 高级题

分布式事务
熔断降级

A: 实现分布式事务的方法：

2PC/3PC：两阶段/三阶段提交协议，强一致性但性能较差
TCC模式：Try-Confirm-Cancel模式，补偿事务

java

1// Try阶段
2@Transactional
3public void tryCreate(Order order) {
4  orderMapper.insert(order);  // 创建订单
5  accountService.tryDeduct(order.getUserId(), order.getAmount());  // 尝试扣减余额
6}
7
8// Confirm阶段
9@Transactional
10public void confirmCreate(Order order) {
11  order.setStatus("CONFIRMED");
12  orderMapper.updateStatus(order);  // 确认订单
13  accountService.confirmDeduct(order.getUserId(), order.getAmount());  // 确认扣减
14}
15
16// Cancel阶段
17@Transactional
18public void cancelCreate(Order order) {
19  order.setStatus("CANCELED");
20  orderMapper.updateStatus(order);  // 取消订单
21  accountService.cancelDeduct(order.getUserId(), order.getAmount());  // 取消扣减
22}

Saga模式：长事务的补偿模式，每步都有对应的补偿操作
消息事务：基于消息的最终一致性，通过消息表+定时任务实现
Seata：阿里开源的分布式事务框架，支持AT、TCC、Saga和XA模式

A: 实现服务熔断降级的方法：

Hystrix：

java

1@HystrixCommand(
2  fallbackMethod = "fallbackMethod",
3  commandProperties = {
4      @HystrixProperty(name = "circuitBreaker.requestVolumeThreshold", value = "10"),
5      @HystrixProperty(name = "circuitBreaker.errorThresholdPercentage", value = "50"),
6      @HystrixProperty(name = "circuitBreaker.sleepWindowInMilliseconds", value = "5000")
7  }
8)
9public String serviceMethod() {
10  // 业务逻辑
11}
12
13public String fallbackMethod() {
14  return "降级响应";
15}

Sentinel：

java

1@SentinelResource(
2  value = "resourceName",
3  blockHandler = "blockHandler",
4  fallback = "fallbackMethod"
5)
6public String serviceMethod() {
7  // 业务逻辑
8}
9
10public String blockHandler(BlockException ex) {
11  return "限流响应";
12}
13
14public String fallbackMethod(Throwable t) {
15  return "降级响应";
16}

Resilience4j：新一代熔断器，可替代Hystrix

Spring Cloud学习要点

理解微服务架构：掌握微服务的设计原则和最佳实践
熟悉核心组件：了解Eureka、Gateway、Ribbon等组件
掌握服务治理：学会服务注册发现、负载均衡、熔断降级
学会配置管理：掌握分布式配置和配置中心
了解监控追踪：学会分布式链路追踪和监控

通过本章的学习，你应该已经掌握了Spring Cloud的核心概念、组件使用和微服务架构设计。Spring Cloud是构建分布式系统的重要框架，掌握Spring Cloud对于构建高可用、可扩展的微服务应用至关重要。

9. Spring Cloud Alibaba

Spring Cloud Alibaba是阿里巴巴开源的微服务框架，提供了丰富的微服务组件，与Spring Cloud生态完美集成。

9.1 Nacos服务注册与发现

Nacos是阿里巴巴开源的服务注册与发现组件，支持服务注册、配置管理、服务发现等功能。

Nacos Server配置
Nacos Client配置

Nacos Server配置

yaml

1spring:
2  application:
3    name: nacos-server
4  cloud:
5    nacos:
6      discovery:
7        server-addr: localhost:8848
8        namespace: public
9        group: DEFAULT_GROUP
10      config:
11        server-addr: localhost:8848
12        namespace: public
13        group: DEFAULT_GROUP
14        file-extension: yaml

Nacos Client配置

yaml

1spring:
2  application:
3    name: user-service
4  cloud:
5    nacos:
6      discovery:
7        server-addr: localhost:8848
8        namespace: public
9        group: DEFAULT_GROUP
10        cluster-name: DEFAULT
11        metadata:
12          version: 1.0.0
13          zone: zone-a
14      config:
15        server-addr: localhost:8848
16        namespace: public
17        group: DEFAULT_GROUP
18        file-extension: yaml
19        refresh-enabled: true

9.2 Sentinel流量控制

Sentinel是阿里巴巴开源的流量控制组件，提供了丰富的流量控制、熔断降级、系统负载保护等功能。

Sentinel配置
Sentinel规则配置

Sentinel配置

yaml

1spring:
2  cloud:
3    sentinel:
4      transport:
5        dashboard: localhost:8080
6        port: 8719
7      datasource:
8        ds:
9          nacos:
10            server-addr: localhost:8848
11            dataId: sentinel-rules
12            groupId: DEFAULT_GROUP
13            rule-type: flow

Sentinel规则配置

java

1@Configuration
2public class SentinelConfig {
3    
4    @PostConstruct
5    public void init() {
6        // 流控规则
7        initFlowRules();
8        // 降级规则
9        initDegradeRules();
10        // 系统规则
11        initSystemRules();
12    }
13    
14    private void initFlowRules() {
15        List<FlowRule> rules = new ArrayList<>();
16        FlowRule rule = new FlowRule();
17        rule.setResource("getUser");
18        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
19        rule.setCount(20);
20        rule.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_WARM_UP);
21        rule.setWarmUpPeriodSec(10);
22        rules.add(rule);
23        FlowRuleManager.loadRules(rules);
24    }
25    
26    private void initDegradeRules() {
27        List<DegradeRule> rules = new ArrayList<>();
28        DegradeRule rule = new DegradeRule();
29        rule.setResource("getUser");
30        rule.setGrade(RuleConstant.DEGRADE_GRADE_EXCEPTION_RATIO);
31        rule.setCount(0.5);
32        rule.setTimeWindow(10);
33        rules.add(rule);
34        DegradeRuleManager.loadRules(rules);
35    }
36    
37    private void initSystemRules() {
38        List<SystemRule> rules = new ArrayList<>();
39        SystemRule rule = new SystemRule();
40        rule.setHighestSystemLoad(0.8);
41        rule.setMaxThread(1000);
42        rule.setQps(100);
43        rules.add(rule);
44        SystemRuleManager.loadRules(rules);
45    }
46}

9.3 Seata分布式事务

Seata是阿里巴巴开源的分布式事务框架，支持AT、TCC、Saga和XA四种事务模式。

Seata配置
Seata使用示例

Seata配置

yaml

1seata:
2  tx-service-group: my_test_tx_group
3  service:
4    vgroup-mapping:
5      my_test_tx_group: default
6  registry:
7    type: nacos
8    nacos:
9      server-addr: localhost:8848
10      namespace: public
11      group: SEATA_GROUP
12  config:
13    type: nacos
14    nacos:
15      server-addr: localhost:8848
16      namespace: public
17      group: SEATA_GROUP
18      data-id: seataServer.properties

Seata使用示例

java

1@Service
2public class OrderService {
3    
4    @Autowired
5    private OrderMapper orderMapper;
6    
7    @Autowired
8    private AccountService accountService;
9    
10    @GlobalTransactional
11    public void createOrder(Order order) {
12        // 创建订单
13        orderMapper.insert(order);
14        
15        // 扣减账户余额
16        accountService.deduct(order.getUserId(), order.getAmount());
17        
18        // 如果这里抛出异常，整个事务会回滚
19        if (order.getAmount() > 1000) {
20            throw new RuntimeException("订单金额过大");
21        }
22    }
23}

9.4 RocketMQ消息队列

RocketMQ是阿里巴巴开源的消息队列，支持分布式事务消息、顺序消息、延时消息等特性。

RocketMQ配置
RocketMQ使用示例

RocketMQ配置

yaml

1rocketmq:
2  name-server: localhost:9876
3  producer:
4    group: my-producer-group
5    send-message-timeout: 3000
6    retry-times-when-send-failed: 2
7  consumer:
8    group: my-consumer-group
9    consume-timeout: 15
10    max-reconsume-times: 3

RocketMQ使用示例

java

1@Service
2public class MessageService {
3    
4    @Autowired
5    private RocketMQTemplate rocketMQTemplate;
6    
7    public void sendMessage(String topic, String message) {
8        rocketMQTemplate.convertAndSend(topic, message);
9    }
10    
11    public void sendOrderedMessage(String topic, String message, String hashKey) {
12        rocketMQTemplate.syncSendOrderly(topic, message, hashKey);
13    }
14    
15    @RocketMQMessageListener(
16        topic = "order-topic",
17        consumerGroup = "order-consumer-group"
18    )
19    public class OrderMessageListener implements RocketMQListener<String> {
20        
21        @Override
22        public void onMessage(String message) {
23            // 处理订单消息
24            System.out.println("收到订单消息: " + message);
25        }
26    }
27}

10. 微服务架构设计模式

10.1 服务拆分模式

10.2 服务通信模式

同步通信
异步通信

10.3 数据一致性模式

11. 微服务监控与运维

11.1 监控体系

11.2 日志管理

ELK架构
Logback配置

Logback配置

xml

1<configuration>
2    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
3        <encoder>
4            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
5        </encoder>
6    </appender>
7    
8    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
9        <file>logs/application.log</file>
10        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
11            <fileNamePattern>logs/application.%d{yyyy-MM-dd}.log</fileNamePattern>
12            <maxHistory>30</maxHistory>
13        </rollingPolicy>
14        <encoder>
15            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
16        </encoder>
17    </appender>
18    
19    <root level="INFO">
20        <appender-ref ref="STDOUT" />
21        <appender-ref ref="FILE" />
22    </root>
23</configuration>

12. 面试题精选（全面版）

12.1 Spring Cloud基础题

微服务架构
核心组件

A: 微服务架构是一种将应用程序拆分为小型、独立服务的架构风格。

优势包括：

服务拆分：按业务功能拆分，职责单一
独立部署：每个服务可独立部署和扩展
技术异构：不同服务可使用不同技术栈
故障隔离：单个服务故障不影响整体
团队自治：不同团队可独立开发维护

挑战包括：

分布式复杂性：网络通信、数据一致性等
服务治理：服务发现、负载均衡、熔断降级
数据管理：分布式事务、数据一致性
运维复杂度：监控、日志、部署等
测试复杂性：集成测试、端到端测试

12.2 Spring Cloud Alibaba题

Nacos
Sentinel

A: Nacos相比Eureka的优势：

功能更全面：不仅支持服务注册发现，还支持配置管理
支持多数据中心：支持多环境、多命名空间
配置动态刷新：支持配置的实时推送和动态刷新
支持多种协议：支持HTTP、gRPC等多种协议
更好的可用性：支持集群部署，提供更好的高可用性
支持服务标签：支持服务分组、标签等高级功能
支持权重路由：支持基于权重的负载均衡

12.3 分布式系统题

分布式事务
服务治理

A: 实现分布式事务的方法：

2PC/3PC：两阶段/三阶段提交协议，强一致性但性能较差
TCC模式：Try-Confirm-Cancel模式，补偿事务
Saga模式：长事务的补偿模式，每步都有对应的补偿操作
消息事务：基于消息的最终一致性，通过消息表+定时任务实现
Seata：阿里开源的分布式事务框架，支持AT、TCC、Saga和XA模式
本地消息表：本地事务+消息表的方式
事务消息：基于消息队列的事务消息

12.4 高级架构题

高可用设计
性能优化

A: 高可用微服务架构设计要点：

服务冗余：关键服务部署多个实例，避免单点故障
负载均衡：使用负载均衡器分发请求
熔断降级：实现熔断器模式，快速失败
超时重试：设置合理的超时时间和重试策略
异步处理：使用消息队列异步处理，提高响应速度
缓存策略：使用多级缓存提高性能
监控告警：实时监控系统状态，及时发现问题
灾备方案：多机房部署，数据备份

12.5 实战应用题

架构设计
问题排查

A: 电商微服务架构设计要点：

服务拆分：用户服务、商品服务、订单服务、库存服务、支付服务、物流服务
数据一致性：订单创建涉及库存扣减、支付等，需要分布式事务
高并发处理：秒杀场景需要限流、缓存、异步处理
服务治理：服务注册发现、负载均衡、熔断降级
监控告警：业务监控、性能监控、异常监控
安全防护：用户认证、权限控制、防刷
缓存策略：商品信息缓存、用户信息缓存
消息队列：订单异步处理、库存异步更新

Spring Cloud学习路径

🚀 Spring Cloud学习建议：

基础阶段：掌握Spring Boot、微服务架构概念
组件学习：学习Eureka、Gateway、Ribbon等核心组件
高级特性：深入理解熔断降级、配置管理、链路追踪
Alibaba生态：学习Nacos、Sentinel、Seata等组件
架构设计：掌握微服务拆分、服务治理、高可用设计
实战应用：通过项目实践巩固理论知识
运维监控：学习监控、日志、部署等运维知识

通过本章的全面学习，你应该已经掌握了Spring Cloud和Spring Cloud Alibaba的核心概念、组件使用、架构设计和最佳实践。这些知识将帮助你构建高可用、可扩展、易维护的微服务应用。记住，微服务架构不仅仅是技术选型，更是一种架构思维和设计理念。

1. Spring Cloud基础概念​

1.1 什么是微服务？​

微服务架构特点​

1.2 Spring Cloud组件​

2. 服务注册与发现​

2.1 Eureka Server​

2.2 Eureka Client​

Eureka Client核心配置说明

2.3 服务注册示例​

3. 服务网关​

3.1 Gateway配置​

3.2 自定义过滤器​

3.3 限流配置​

4. 负载均衡​

4.1 Ribbon配置​

4.2 负载均衡策略​

4.3 自定义负载均衡​

5. 熔断降级​

5.1 Hystrix配置​

Hystrix关键属性

5.2 Sentinel配置​

6. 配置管理​

6.1 Config Server​

6.2 Config Client​

6.3 动态刷新配置​

7. 分布式链路追踪​

7.1 Sleuth配置​

7.2 Zipkin配置​

8. 面试题精选​

8.1 基础概念题​

Q: 什么是微服务架构？它的优势和挑战是什么？

Q: Spring Cloud的核心组件有哪些？

8.2 实践题​

Q: 如何实现服务注册与发现？

Q: 如何实现API网关？

8.3 高级题​

Q: 如何实现分布式事务？

Q: 如何实现服务熔断降级？

9. Spring Cloud Alibaba​

9.1 Nacos服务注册与发现​

9.2 Sentinel流量控制​

9.3 Seata分布式事务​

9.4 RocketMQ消息队列​

10. 微服务架构设计模式​

10.1 服务拆分模式​

10.2 服务通信模式​

10.3 数据一致性模式​

11. 微服务监控与运维​

11.1 监控体系​

11.2 日志管理​

12. 面试题精选（全面版）​

12.1 Spring Cloud基础题​

Q: 什么是微服务架构？它的优势和挑战是什么？

Q: Spring Cloud的核心组件有哪些？

12.2 Spring Cloud Alibaba题​

Q: Nacos相比Eureka有什么优势？

Q: Sentinel的流量控制策略有哪些？

12.3 分布式系统题​

Q: 如何实现分布式事务？

Q: 微服务治理包括哪些方面？

12.4 高级架构题​

Q: 如何设计高可用的微服务架构？

Q: 微服务架构如何做性能优化？

12.5 实战应用题​

Q: 设计一个电商微服务架构，需要考虑哪些方面？

Q: 微服务架构中常见的问题如何排查？

评论

1. Spring Cloud基础概念

1.1 什么是微服务？

微服务架构特点

1.2 Spring Cloud组件

2. 服务注册与发现

2.1 Eureka Server

2.2 Eureka Client

2.3 服务注册示例

3. 服务网关

3.1 Gateway配置

3.2 自定义过滤器

3.3 限流配置

4. 负载均衡

4.1 Ribbon配置

4.2 负载均衡策略

4.3 自定义负载均衡

5. 熔断降级

5.1 Hystrix配置

5.2 Sentinel配置

6. 配置管理

6.1 Config Server

6.2 Config Client

6.3 动态刷新配置

7. 分布式链路追踪

7.1 Sleuth配置

7.2 Zipkin配置

8. 面试题精选

8.1 基础概念题

8.2 实践题

8.3 高级题

9. Spring Cloud Alibaba

9.1 Nacos服务注册与发现

9.2 Sentinel流量控制

9.3 Seata分布式事务

9.4 RocketMQ消息队列

10. 微服务架构设计模式

10.1 服务拆分模式

10.2 服务通信模式

10.3 数据一致性模式

11. 微服务监控与运维

11.1 监控体系

11.2 日志管理

12. 面试题精选（全面版）

12.1 Spring Cloud基础题

12.2 Spring Cloud Alibaba题

12.3 分布式系统题

12.4 高级架构题

12.5 实战应用题