mcpField
S
spring-cloud

spring-cloud

github.com/partme-ai開発716106 回インストール3 週間前に更新
リポジトリ

spring-cloud について

マイクロサービスを開発するエンジニア向けの Spring Cloud ガイドです。サービス検出、設定、ゲートウェイ、負荷分散、サーキットブレーカー、サービス呼び出し、トレースを例とともに扱います。

主な機能

  1. 01サービス登録と検出
  2. 02集中設定管理
  3. 03API ゲートウェイルーティング
  4. 04負荷分散とサーキットブレーカー
  5. 05Feign 呼び出しと分散トレース

活用シーン

  1. 01Eureka によるサービス検出の構築
  2. 02Spring Cloud Config センターの設定
  3. 03Spring Cloud Gateway によるリクエストルーティング
  4. 04Feign 呼び出しとサーキットブレーカーの追加

インストール

コマンドをコピーしてターミナルで実行します。

$npx skills add https://github.com/partme-ai/full-stack-skills --skill spring-cloud

インストール後、Claude Code で/spring-cloudを入力して読み込まれたか確認します。

詳細

プロジェクトの README より

Spring Cloud 微服务开发指南

概述

Spring Cloud 是一套完整的微服务解决方案，提供了服务注册与发现、配置管理、网关、负载均衡、熔断器等组件。

核心组件

1. 服务注册与发现（Eureka）

Eureka Server：

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

application.yml：

server:
  port: 8761

eureka:
  instance:
    hostname: localhost
  client:
    register-with-eureka: false
    fetch-registry: false
    service-url:
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

Eureka Client：

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

application.yml：

spring:
  application:
    name: user-service

eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/
2. 配置中心（Config Server）

Config Server：

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

application.yml：

server:
  port: 8888

spring:
  cloud:
    config:
      server:
        git:
          uri: https://github.com/example/config-repo
          search-paths: '{application}'

Config Client：

spring:
  application:
    name: user-service
  cloud:
    config:
      uri: http://localhost:8888
      name: user-service
      profile: dev
3. API 网关（Gateway）

Gateway 配置：

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

application.yml：

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/**
          filters:
            - StripPrefix=1

路由配置类：

@Configuration
public class GatewayConfig {
    @Bean
    public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
        return builder.routes()
            .route("user-service", r -> r
                .path("/api/users/**")
                .uri("lb://user-service"))
            .route("order-service", r -> r
                .path("/api/orders/**")
                .uri("lb://order-service"))
            .build();
    }
}
4. 负载均衡（LoadBalancer）

使用 RestTemplate：

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

使用 WebClient：

@Configuration
public class WebClientConfig {
    @Bean
    @LoadBalanced
    public WebClient.Builder webClientBuilder() {
        return WebClient.builder();
    }
}

服务调用：

@Service
public class OrderService {
    private final RestTemplate restTemplate;
    
    public OrderService(@LoadBalanced RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }
    
    public User getUser(Long userId) {
        return restTemplate.getForObject(
            "http://user-service/api/users/{id}",
            User.class,
            userId
        );
    }
}
5. 熔断器（Circuit Breaker）

依赖：

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

配置：

resilience4j:
  circuitbreaker:
    instances:
      userService:
        registerHealthIndicator: true
        slidingWindowSize: 10
        failureRateThreshold: 50
        waitDurationInOpenState: 10000

使用：

@Service
public class OrderService {
    private final CircuitBreaker circuitBreaker;
    private final RestTemplate restTemplate;
    
    public OrderService(
        CircuitBreakerRegistry circuitBreakerRegistry,
        RestTemplate restTemplate
    ) {
        this.circuitBreaker = circuitBreakerRegistry.circuitBreaker("userService");
        this.restTemplate = restTemplate;
    }
    
    public User getUser(Long userId) {
        return circuitBreaker.executeSupplier(() ->
            restTemplate.getForObject(
                "http://user-service/api/users/{id}",
                User.class,
                userId
            )
        );
    }
}
6. 服务调用（Feign）

依赖：

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

启用 Feign：

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

定义 Feign Client：

@FeignClient(name = "user-service")
public interface UserServiceClient {
    @GetMapping("/api/users/{id}")
    User getUserById(@PathVariable Long id);
    
    @PostMapping("/api/users")
    User createUser(@RequestBody User user);
}

使用：

@Service
public class OrderService {
    private final UserServiceClient userServiceClient;
    
    public OrderService(UserServiceClient userServiceClient) {
        this.userServiceClient = userServiceClient;
    }
    
    public Order createOrder(Long userId, Order order) {
        User user = userServiceClient.getUserById(userId);
        // 创建订单逻辑
        return order;
    }
}
7. 分布式追踪（Sleuth）

依赖：

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

配置：

spring:
  sleuth:
    sampler:
      probability: 1.0

微服务架构示例

项目结构
microservices/
├── eureka-server/          # 服务注册中心
├── config-server/          # 配置中心
├── gateway/                # API 网关
├── user-service/           # 用户服务
├── order-service/          # 订单服务
└── product-service/        # 商品服务
服务间调用

同步调用（Feign）：

@FeignClient(name = "user-service")
public interface UserServiceClient {
    @GetMapping("/api/users/{id}")
    User getUserById(@PathVariable Long id);
}

异步调用（消息队列）：

@Service
public class OrderService {
    private final RabbitTemplate rabbitTemplate;
    
    public void publishOrderEvent(Order order) {
        rabbitTemplate.convertAndSend("order.exchange", "order.created", order);
    }
}

最佳实践

1. 服务拆分
  • 按业务领域拆分
  • 保持服务独立性
  • 避免服务间强耦合
2. 配置管理
  • 使用配置中心统一管理
  • 区分环境配置
  • 支持动态刷新
3. 服务治理
  • 使用网关统一入口
  • 实现服务熔断和降级
  • 监控服务健康状态
4. 数据管理
  • 每个服务独立数据库
  • 使用 Saga 模式处理分布式事务
  • 避免跨服务直接访问数据库

常用依赖

<!-- Eureka Client -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

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

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

<!-- Circuit Breaker -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-circuitbreaker-resilience4j</artifactId>
</dependency>

示例 Prompt

  • "如何使用 Spring Cloud 构建微服务架构？"
  • "Spring Cloud Gateway 如何配置路由？"
  • "如何在 Spring Cloud 中使用 Feign 进行服务调用？"
  • "Spring Cloud 中如何实现服务熔断？"
  • "如何配置 Spring Cloud Config 配置中心？"

コメント

Markdown 対応