java-microservices

Compare original and translation side by side

🇺🇸

Original

English

🇨🇳

Translation

Chinese

Java Microservices Skill

Java微服务技能

Build production microservices with Spring Cloud and distributed system patterns.

使用Spring Cloud和分布式系统模式构建生产级微服务。

Overview

概述

This skill covers microservices architecture with Spring Cloud including service discovery, API gateway, circuit breakers, event-driven communication, and distributed tracing.

本技能涵盖基于Spring Cloud的微服务架构，包括服务发现、API网关、断路器、事件驱动通信和分布式追踪。

When to Use This Skill

何时使用本技能

Use when you need to:

Design microservices architecture
Implement service-to-service communication
Configure resilience patterns
Set up event-driven messaging
Add distributed tracing

当你需要以下操作时使用本技能：

设计微服务架构
实现服务间通信
配置弹性模式
搭建事件驱动消息系统
添加分布式追踪

Topics Covered

涵盖主题

Spring Cloud Components

Spring Cloud组件

Config Server (centralized config)
Service Discovery (Eureka, Consul)
API Gateway (Spring Cloud Gateway)
Load Balancing (Spring Cloud LoadBalancer)

Config Server（集中式配置）
服务发现（Eureka、Consul）
API网关（Spring Cloud Gateway）
负载均衡（Spring Cloud LoadBalancer）

Resilience Patterns

弹性模式

Circuit Breaker (Resilience4j)
Retry with backoff
Bulkhead isolation
Rate limiting

断路器（Resilience4j）
带退避的重试
舱壁隔离
限流

Event-Driven Architecture

事件驱动架构

Apache Kafka integration
Spring Cloud Stream
Saga pattern
Event sourcing basics

Apache Kafka集成
Spring Cloud Stream
Saga模式
事件溯源基础

Observability

可观测性

Distributed tracing (Micrometer)
Metrics (Prometheus)
Log correlation

分布式追踪（Micrometer）
指标监控（Prometheus）
日志关联

Quick Reference

快速参考

java

// Saga with Choreography
@Component
public class OrderSagaListener {

    @KafkaListener(topics = "order.created")
    public void handleOrderCreated(OrderCreatedEvent event) {
        inventoryService.reserve(event.getItems());
    }

    @KafkaListener(topics = "payment.failed")
    public void handlePaymentFailed(PaymentFailedEvent event) {
        // Compensating transaction
        inventoryService.release(event.getOrderId());
        orderService.cancel(event.getOrderId());
    }
}

// Circuit Breaker Configuration
@Configuration
public class ResilienceConfig {

    @Bean
    public Customizer<Resilience4JCircuitBreakerFactory> cbCustomizer() {
        return factory -> factory.configureDefault(id ->
            new Resilience4JConfigBuilder(id)
                .circuitBreakerConfig(CircuitBreakerConfig.custom()
                    .failureRateThreshold(50)
                    .waitDurationInOpenState(Duration.ofSeconds(30))
                    .slidingWindowSize(10)
                    .build())
                .build());
    }
}

// API Gateway Routes
@Configuration
public class GatewayConfig {

    @Bean
    public RouteLocator routes(RouteLocatorBuilder builder) {
        return builder.routes()
            .route("orders", r -> r
                .path("/api/orders/**")
                .filters(f -> f
                    .stripPrefix(1)
                    .circuitBreaker(c -> c.setName("order-cb"))
                    .retry(retry -> retry.setRetries(3)))
                .uri("lb://order-service"))
            .build();
    }
}

java

// Saga with Choreography
@Component
public class OrderSagaListener {

    @KafkaListener(topics = "order.created")
    public void handleOrderCreated(OrderCreatedEvent event) {
        inventoryService.reserve(event.getItems());
    }

    @KafkaListener(topics = "payment.failed")
    public void handlePaymentFailed(PaymentFailedEvent event) {
        // Compensating transaction
        inventoryService.release(event.getOrderId());
        orderService.cancel(event.getOrderId());
    }
}

// Circuit Breaker Configuration
@Configuration
public class ResilienceConfig {

    @Bean
    public Customizer<Resilience4JCircuitBreakerFactory> cbCustomizer() {
        return factory -> factory.configureDefault(id ->
            new Resilience4JConfigBuilder(id)
                .circuitBreakerConfig(CircuitBreakerConfig.custom()
                    .failureRateThreshold(50)
                    .waitDurationInOpenState(Duration.ofSeconds(30))
                    .slidingWindowSize(10)
                    .build())
                .build());
    }
}

// API Gateway Routes
@Configuration
public class GatewayConfig {

    @Bean
    public RouteLocator routes(RouteLocatorBuilder builder) {
        return builder.routes()
            .route("orders", r -> r
                .path("/api/orders/**")
                .filters(f -> f
                    .stripPrefix(1)
                    .circuitBreaker(c -> c.setName("order-cb"))
                    .retry(retry -> retry.setRetries(3)))
                .uri("lb://order-service"))
            .build();
    }
}

Observability Configuration

可观测性配置

yaml

management:
  tracing:
    sampling:
      probability: 1.0
  endpoints:
    web:
      exposure:
        include: health,info,metrics,prometheus

logging:
  pattern:
    level: "%5p [${spring.application.name:},%X{traceId:-},%X{spanId:-}]"

yaml

management:
  tracing:
    sampling:
      probability: 1.0
  endpoints:
    web:
      exposure:
        include: health,info,metrics,prometheus

logging:
  pattern:
    level: "%5p [${spring.application.name:},%X{traceId:-},%X{spanId:-}]"

Common Patterns

常见模式

Saga Pattern

Saga模式

Order → Inventory → Payment → (Success | Compensate)

Order → Inventory → Payment → (Success | Compensate)

Circuit Breaker States

断路器状态

CLOSED → (failures exceed threshold) → OPEN
OPEN → (wait duration) → HALF_OPEN
HALF_OPEN → (success) → CLOSED
HALF_OPEN → (failure) → OPEN

CLOSED → (failures exceed threshold) → OPEN
OPEN → (wait duration) → HALF_OPEN
HALF_OPEN → (success) → CLOSED
HALF_OPEN → (failure) → OPEN

Troubleshooting

故障排查

Common Issues

常见问题

Problem	Cause	Solution
Cascade failure	No circuit breaker	Add Resilience4j
Message lost	No ack	Enable manual ack
Inconsistent data	No compensation	Implement saga
Service not found	Discovery delay	Tune heartbeat

问题	原因	解决方案
级联故障	未配置断路器	添加Resilience4j
消息丢失	未启用确认机制	启用手动确认
数据不一致	无补偿机制	实现Saga模式
服务未找到	服务发现延迟	调整心跳参数

Debug Checklist

调试检查清单

□ Trace request (traceId)
□ Check circuit breaker state
□ Verify Kafka consumer lag
□ Review gateway routes
□ Monitor retry counts

□ Trace request (traceId)
□ Check circuit breaker state
□ Verify Kafka consumer lag
□ Review gateway routes
□ Monitor retry counts

Usage

使用方法

Skill("java-microservices")

Skill("java-microservices")