Spring Cloud：小白也能看懂的分布式系统问题终极指南

Netflix Eureka: 一个基于REST的服务，用于定位服务，以实现云端中间层服务发现和故障转移。

Alibaba Nacos: 不仅能做服务注册发现，还能做配置管理，功能更强大。

Consul: HashiCorp公司推出的，功能也很全面。

// 在启动类上添加注解，表明我是一个Eureka客户端，需要去注册中心注册
@SpringBootApplication
@EnableEurekaClient // 或者 @EnableDiscoveryClient 更通用
public class OrderServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrderServiceApplication.class, args);
    }
}

spring:
  application:
    name: order-service # 我的服务名叫订单服务
eureka:
  client:
    service-url:
      defaultZone: http://eureka-server-ip:8761/eureka/ # 注册中心地址
  instance:
    prefer-ip-address: true # 优先使用IP地址注册

Ribbon

Spring Cloud LoadBalancer

Netflix Ribbon

Spring Cloud LoadBalancer

@Configuration
public class RestTemplateConfig {
    @Bean
    @LoadBalanced // 开启负载均衡能力
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

// 在服务A中调用服务B (order-service)
@Service
public class UserService {
    @Autowired
    private RestTemplate restTemplate;

    public String createOrder() {
        // 注意这里用的是服务名，而不是具体的IP和端口
        // Spring Cloud LoadBalancer会自动从Eureka中找到order-service的实例列表，并选择一个进行调用
        String result = restTemplate.getForObject("http://order-service/create", String.class);
        return "User created order: " + result;
    }
}

@SpringBootApplication
@EnableDiscoveryClient
@EnableFeignClients // 开启Feign功能
public class UserServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(UserServiceApplication.class, args);
    }
}

// 假设我们要调用 "product-service" 这个服务
@FeignClient(name = "product-service") // 指定服务名
public interface ProductServiceClient {

    @GetMapping("/product/{id}") // 对应product-service中的API路径
    String getProductById(@PathVariable("id") Long id);

    // 也可以定义POST请求等
    // @PostMapping("/product/create")
    // String createProduct(@RequestBody ProductDto productDto);
}

@Service
public class OrderService {
    @Autowired
    private ProductServiceClient productServiceClient;

    public String getProductDetailsForOrder(Long productId) {
        // 直接调用接口方法，就像调用本地方法一样
        String productInfo = productServiceClient.getProductById(productId);
        return "Product for order: " + productInfo;
    }
}

// 定义输出通道（发消息）
public interface MySource {
    String OUTPUT = "myOutputChannel"; // 通道名称
    @Output(MySource.OUTPUT)
    MessageChannel output();
}

// 定义输入通道（收消息）
public interface MySink {
    String INPUT = "myInputChannel"; // 通道名称
    @Input(MySink.INPUT)
    SubscribableChannel input();
}

@SpringBootApplication
@EnableBinding({MySource.class, MySink.class}) // 绑定我们定义的通道
public class NotificationServiceApplication {
    // ...
}

@Service
public class EmailService {
    @Autowired
    private MySource mySource;

    public void sendWelcomeEmail(String emailAddress) {
        String message = "Welcome, " + emailAddress + "!";
        mySource.output().send(MessageBuilder.withPayload(message).build());
        System.out.println("Sent welcome email message to MQ.");
    }
}

@Service
public class SmsService {
    @StreamListener(MySink.INPUT) // 监听指定的输入通道
    public void handleWelcomeMessage(String message) {
        System.out.println("Received message for SMS: " + message + ". Sending SMS now...");
        // 实际发送短信的逻辑
    }
}

spring:
  cloud:
    stream:
      bindings:
        myOutputChannel: # 对应MySource.OUTPUT
          destination: welcome-topic # MQ中的topic或exchange
          content-type: text/plain
        myInputChannel: # 对应MySink.INPUT
          destination: welcome-topic
          group: sms-consumer-group # 消费者组，用于消息只被一个消费者处理
          content-type: text/plain
      # 根据使用的MQ（如RabbitMQ或Kafka）进行具体配置
      rabbit: # 或 kafka
        binder:
          # brokers: localhost:9092 (kafka)
          # addresses: localhost:5672 (rabbitmq)
          # ...

spring:
  application:
    name: order-service # 我的服务名，配置中心会根据这个名字找我的配置
  cloud:
    config:
      uri: http://config-server-ip:8888 # 配置中心的地址
      # profile: dev # 可以指定环境（dev, prod, test）
      # label: main # 如果用Git，可以指定分支

import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.context.config.annotation.RefreshScope; // 非常重要，实现动态刷新
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RefreshScope // 允许这个Bean在配置变更时被重新创建，从而获取新配置
public class ConfigTestController {

    @Value("${my.custom.property:Default Value}") // 从配置中心读取my.custom.property的值
    private String customProperty;

    @Value("${common.config.value:Common Default}")
    private String commonValue;

    @GetMapping("/config-test")
    public String testConfig() {
        return "Custom Property: " + customProperty + "<br/>Common Value: " + commonValue;
    }
}

my:
  custom:
    property: "Hello from Config Server for Order Service!"
common:
  config:
    value: "This is a common value for all services."
# 也可以有 application.yml 作为所有服务的通用配置

Netflix Hystrix

Resilience4j

Alibaba Sentinel

resilience4j:
  circuitbreaker:
    instances:
      # "productService" 是一个自定义的标识，可以和FeignClient的name或contextId关联
      productServiceCB: # 这个名字要和 fallback 方法中的 circuitBreaker 属性对应
        registerHealthIndicator: true
        slidingWindowType: COUNT_BASED
        slidingWindowSize: 10 # 最近10次请求
        failureRateThreshold: 50 # 失败率达到50%则跳闸
        waitDurationInOpenState: 10000 # 跳闸后10秒进入半开状态
        permittedNumberOfCallsInHalfOpenState: 2 # 半开状态允许2次请求尝试
        # slowCallRateThreshold: 100
        # slowCallDurationThreshold: 2000 # 慢调用阈值，超过2秒算慢调用
  # 也可以配置TimeLimiter等
  # timelimiter:
  #   instances:
  #     productServiceTL:
  #       timeoutDuration: 2s # 调用超时时间
​```

定义Feign客户端和Fallback类：

​```java
// ProductServiceClient.java
@FeignClient(name = "product-service", fallback = ProductServiceFallback.class)
public interface ProductServiceClient {
    @GetMapping("/product/{id}")
    String getProductById(@PathVariable("id") Long id);
}

// ProductServiceFallback.java
// 需要实现Feign客户端接口，并标记为@Component
@Component
public class ProductServiceFallback implements ProductServiceClient {
    @Override
    public String getProductById(Long id) {
        // 这里是降级逻辑
        return "哎呀，产品服务太忙了，请稍后再试！(Fallback for product: " + id + ")";
    }
}

// 在某个Service类中
import io.github.resilience4j.circuitbreaker.annotation.CircuitBreaker;
// import io.github.resilience4j.timelimiter.annotation.TimeLimiter; // 可选，配合超时
import org.springframework.stereotype.Service;

@Service
public class ProductIntegrationService {

    private final ProductServiceClient productServiceClient; // 假设注入了上面的FeignClient

    public ProductIntegrationService(ProductServiceClient productServiceClient) {
        this.productServiceClient = productServiceClient;
    }

    // "productServiceCB" 对应了yml中配置的实例名
    @CircuitBreaker(name = "productServiceCB", fallbackMethod = "getProductByIdFallback")
    // @TimeLimiter(name = "productServiceTL") // 可选，如果需要超时控制
    public String fetchProductDetails(Long id) {
        // 模拟一个可能很慢或失败的调用
        return productServiceClient.getProductById(id);
    }

    // Fallback方法的签名需要和原方法一致，最后一个参数可以是Throwable
    public String getProductByIdFallback(Long id, Throwable t) {
        // t 参数可以获取到触发fallback的异常信息
        System.err.println("Error calling product service for id " + id + ": " + t.getMessage());
        return "（熔断/降级）获取产品信息失败，ID：" + id + "。请稍后重试。";
    }
}

Spring Cloud Gateway

Netflix Zuul 1.x

spring:
  application:
    name: api-gateway
  cloud:
    gateway:
      discovery:
        locator:
          enabled: true # 开启从注册中心自动发现服务并创建路由的功能
          lower-case-service-id: true # 将服务名转为小写作为路径的一部分，如/order-service/**
      routes:
        # 自定义路由规则1: 访问 /myusers/** 的请求会被转发到 user-service 服务
        - id: user_service_route # 路由的唯一ID
          uri: lb://user-service # lb代表从注册中心负载均衡地选择一个user-service实例
          predicates: # 断言，即满足什么条件才应用此路由
            - Path=/myusers/** # 当请求路径匹配 /myusers/**
          filters: # 过滤器，可以在请求转发前后做一些处理
            - StripPrefix=1 # 转发前去掉路径的第一部分（即去掉/myusers）
                            # 例如 /myusers/info -> 转发到 user-service 的 /info

        # 自定义路由规则2: 访问 /myorders/** 的请求会被转发到 order-service 服务
        - id: order_service_route
          uri: lb://order-service
          predicates:
            - Path=/myorders/**
          filters:
            - StripPrefix=1
            # 可以添加其他过滤器，如请求头、请求参数、限流等
            # - AddRequestHeader=X-Request-Source, gateway
            # - RewritePath=/oldpath/(?<segment>.*), /newpath/${segment}

        # 也可以直接使用服务名作为路径前缀 (如果开启了discovery.locator.enabled=true)
        # 比如访问 /order-service/api/v1/orders 会自动路由到 order-service 服务的 /api/v1/orders
        # 这个优先级低于上面自定义的routes
# 需要Eureka客户端配置，让网关自己也注册并能发现其他服务
eureka:
  client:
    service-url:
      defaultZone: http://eureka-server-ip:8761/eureka/
  instance:
    prefer-ip-address: true