management:
  endpoints:
    web:
      exposure:
        include: health,circuitbreakers
  health:
    circuitbreakers:
      enabled: true

<dependency>
    <groupId>com.github.vladimir-bukhtoyarov</groupId>
    <artifactId>bucket4j-core</artifactId>
    <version>4.10.0</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
</dependency>

@Configuration
public class RateLimitingConfig {

    @Bean
    public CacheManager cacheManager() {
        CaffeineCacheManager cacheManager = new CaffeineCacheManager("rateLimit");
        cacheManager.setCaffeine(Caffeine.newBuilder()
                .expireAfterWrite(1, TimeUnit.HOURS)
                .maximumSize(1000));
        return cacheManager;
    }
    
    @Bean
    public Bucket4jCacheConfiguration bucket4jCacheConfiguration() {
        return new Bucket4jCacheConfiguration(cacheManager(), "rateLimit");
    }
}

@Component
public class RateLimitingInterceptor implements HandlerInterceptor {

    private final Cache<String, Bucket> cache;
    
    public RateLimitingInterceptor() {
        this.cache = Caffeine.newBuilder()
                .expireAfterWrite(1, TimeUnit.HOURS)
                .maximumSize(1000)
                .build();
    }
    
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String apiKey = request.getHeader("X-API-KEY");
        if (apiKey == null || apiKey.isEmpty()) {
            response.sendError(HttpStatus.BAD_REQUEST.value(), "Missing API key");
            return false;
        }
        
        Bucket bucket = cache.get(apiKey, key -> createNewBucket());
        ConsumptionProbe probe = bucket.tryConsumeAndReturnRemaining(1);
        
        if (probe.isConsumed()) {
            response.addHeader("X-Rate-Limit-Remaining", String.valueOf(probe.getRemainingTokens()));
            return true;
        } else {
            long waitForRefill = probe.getNanosToWaitForRefill() / 1_000_000_000;
            response.addHeader("X-Rate-Limit-Retry-After-Seconds", String.valueOf(waitForRefill));
            response.sendError(HttpStatus.TOO_MANY_REQUESTS.value(), "Rate limit exceeded");
            return false;
        }
    }
    
    private Bucket createNewBucket() {
        BucketConfiguration config = Bucket4j.configurationBuilder()
                .addLimit(Bandwidth.classic(100, Refill.intervally(100, Duration.ofMinutes(1))))
                .addLimit(Bandwidth.classic(1000, Refill.intervally(1000, Duration.ofHours(1))))
                .build();
        return Bucket4j.builder().withConfiguration(config).build();
    }
}

@Configuration
public class WebMvcConfig implements WebMvcConfigurer {

    @Autowired
    private RateLimitingInterceptor rateLimitingInterceptor;
    
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(rateLimitingInterceptor)
                .addPathPatterns("/api/**");
    }
}

spring:
  cloud:
    gateway:
      routes:
        - id: order-service
          uri: lb://order-service
          predicates:
            - Path=/orders/**
          filters:
            - name: RequestRateLimiter
              args:
                redis-rate-limiter.replenishRate: 10
                redis-rate-limiter.burstCapacity: 20
                redis-rate-limiter.requestedTokens: 1
                key-resolver: "#{@userKeyResolver}"

@Configuration
public class GatewayConfig {
    
    @Bean
    public KeyResolver userKeyResolver() {
        return exchange -> {
            String userId = exchange.getRequest().getHeaders().getFirst("User-Id");
            if (userId == null) {
                userId = "anonymous";
            }
            return Mono.just(userId);
        };
    }
}

@Service
public class ProductService {
    
    private final ProductRepository productRepository;
    private final ProductCacheService productCacheService;
    
    @Autowired
    public ProductService(ProductRepository productRepository, ProductCacheService productCacheService) {
        this.productRepository = productRepository;
        this.productCacheService = productCacheService;
    }
    
    @CircuitBreaker(name = "productService", fallbackMethod = "getProductDetailsFallback")
    @Bulkhead(name = "productService", fallbackMethod = "getProductDetailsFallback")
    @TimeLimiter(name = "productService", fallbackMethod = "getProductDetailsFallback")
    public CompletableFuture<ProductDetails> getProductDetails(String productId) {
        return CompletableFuture.supplyAsync(() -> {
            // 正常的產品詳情獲取邏輯
            Product product = productRepository.findById(productId)
                    .orElseThrow(() -> new ProductNotFoundException(productId));
            
            // 獲取實時庫存和價格信息
            InventoryInfo inventory = inventoryService.getInventory(productId);
            PricingInfo pricing = pricingService.getCurrentPrice(productId);
            
            return new ProductDetails(product, inventory, pricing);
        });
    }
    
    // 降級方法，提供基本產品信息和緩存的庫存和價格
    public CompletableFuture<ProductDetails> getProductDetailsFallback(String productId, Exception e) {
        log.warn("Fallback for product {}. Reason: {}", productId, e.getMessage());
        return CompletableFuture.supplyAsync(() -> {
            // 從緩存獲取基本產品信息
            Product product = productCacheService.getProductFromCache(productId)
                    .orElse(new Product(productId, "Unknown Product", "No details available"));
            
            // 使用默認的庫存和價格信息
            InventoryInfo inventory = new InventoryInfo(productId, 0, false);
            PricingInfo pricing = new PricingInfo(productId, 0.0, false);
            
            return new ProductDetails(product, inventory, pricing, true);
        });
    }
}

resilience4j:
  timelimiter:
    instances:
      productService:
        timeoutDuration: 2s
        cancelRunningFuture: true
  bulkhead:
    instances:
      productService:
        maxConcurrentCalls: 20
        maxWaitDuration: 500ms

@Component
public class GracefulDegradationFilter extends OncePerRequestFilter {
    
    private final HealthCheckService healthCheckService;
    
    @Autowired
    public GracefulDegradationFilter(HealthCheckService healthCheckService) {
        this.healthCheckService = healthCheckService;
    }
    
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, 
                                  FilterChain filterChain) throws ServletException, IOException {
        
        String path = request.getRequestURI();
        
        // 檢查系統(tǒng)健康狀態(tài)
        SystemHealth health = healthCheckService.getCurrentHealth();
        
        if (health.isHighLoad() && isNonCriticalPath(path)) {
            // 在高負載下降級非關鍵路徑請求
            sendDegradedResponse(response, "Service temporarily operating at reduced capacity");
            return;
        } else if (health.isInMaintenance() && !isAdminPath(path)) {
            // 在維護模式下只允許管理請求
            sendMaintenanceResponse(response);
            return;
        } else if (health.hasFailedDependencies() && dependsOnFailedServices(path, health.getFailedServices())) {
            // 如果請求依賴的服務不可用，返回降級響應
            sendDependencyFailureResponse(response, health.getFailedServices());
            return;
        }
        
        // 正常處理請求
        filterChain.doFilter(request, response);
    }
    
    private boolean isNonCriticalPath(String path) {
        // 判斷請求是否是非關鍵路徑
        return path.startsWith("/api/recommendations") || 
               path.startsWith("/api/analytics") ||
               path.startsWith("/api/marketing");
    }
    
    private boolean isAdminPath(String path) {
        return path.startsWith("/admin") || path.startsWith("/management");
    }
    
    private boolean dependsOnFailedServices(String path, List<String> failedServices) {
        // 檢查請求是否依賴失敗的服務
        Map<String, List<String>> serviceDependencies = new HashMap<>();
        serviceDependencies.put("/api/orders", Arrays.asList("payment-service", "inventory-service"));
        serviceDependencies.put("/api/payments", Arrays.asList("payment-service"));
        // ... 其他路徑與服務的依賴關系
        
        String matchingPath = findMatchingPath(path, serviceDependencies.keySet());
        if (matchingPath != null) {
            List<String> dependencies = serviceDependencies.get(matchingPath);
            return dependencies.stream().anyMatch(failedServices::contains);
        }
        return false;
    }
    
    private String findMatchingPath(String requestPath, Set<String> configuredPaths) {
        // 查找請求路徑匹配的配置路徑
        return configuredPaths.stream()
                .filter(requestPath::startsWith)
                .findFirst()
                .orElse(null);
    }
    
    private void sendDegradedResponse(HttpServletResponse response, String message) throws IOException {
        response.setStatus(HttpStatus.SERVICE_UNAVAILABLE.value());
        response.setContentType(MediaType.APPLICATION_JSON_VALUE);
        
        Map<String, Object> responseBody = new HashMap<>();
        responseBody.put("status", "degraded");
        responseBody.put("message", message);
        responseBody.put("retry_after", 30); // 建議30秒后重試
        
        response.getWriter().write(new ObjectMapper().writeValueAsString(responseBody));
    }
    
    // 其他響應處理方法...
}

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

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

@Service
public class RemoteServiceClient {
    
    private final RestTemplate restTemplate;
    
    @Autowired
    public RemoteServiceClient(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }
    
    @Retryable(
        value = {ResourceAccessException.class, HttpServerErrorException.class},
        maxAttempts = 3,
        backoff = @Backoff(delay = 1000, multiplier = 2)
    )
    public ResponseEntity<OrderData> getOrderDetails(String orderId) {
        log.info("Attempting to fetch order details for {}", orderId);
        return restTemplate.getForEntity("/api/orders/" + orderId, OrderData.class);
    }
    
    @Recover
    public ResponseEntity<OrderData> recoverGetOrderDetails(Exception e, String orderId) {
        log.error("All retries failed for order {}. Last error: {}", orderId, e.getMessage());
        // 返回緩存數(shù)據或默認響應
        return ResponseEntity.ok(new OrderData(orderId, "UNKNOWN", new Date(), Collections.emptyList()));
    }
}

@Service
public class PaymentService {
    
    private final RetryTemplate retryTemplate;
    
    @Autowired
    public PaymentService(RetryTemplate retryTemplate) {
        this.retryTemplate = retryTemplate;
    }
    
    public PaymentResult processPayment(PaymentRequest paymentRequest) {
        return retryTemplate.execute(context -> {
            // 獲取當前重試次數(shù)
            int retryCount = context.getRetryCount();
            log.info("Processing payment attempt {} for order {}", 
                     retryCount + 1, paymentRequest.getOrderId());
            
            try {
                // 執(zhí)行支付處理
                return paymentGateway.submitPayment(paymentRequest);
            } catch (PaymentGatewayException e) {
                // 分析異常并決定是否重試
                if (e.isRetryable()) {
                    log.warn("Retryable payment error: {}. Will retry.", e.getMessage());
                    throw e; // 拋出異常以觸發(fā)重試
                } else {
                    log.error("Non-retryable payment error: {}", e.getMessage());
                    throw new NonRetryableException("Payment failed with non-retryable error", e);
                }
            }
        }, context -> {
            // 恢復策略
            log.error("All payment retries failed for order {}", paymentRequest.getOrderId());
            // 返回失敗結果并記錄需要后續(xù)處理
            return PaymentResult.failed(paymentRequest.getOrderId(), "Maximum retries exceeded");
        });
    }
}

@Configuration
public class RetryConfig {
    
    @Bean
    public RetryTemplate retryTemplate() {
        RetryTemplate retryTemplate = new RetryTemplate();
        
        // 設置重試策略
        SimpleRetryPolicy retryPolicy = new SimpleRetryPolicy();
        retryPolicy.setMaxAttempts(3);
        
        // 設置退避策略
        ExponentialBackOffPolicy backOffPolicy = new ExponentialBackOffPolicy();
        backOffPolicy.setInitialInterval(1000); // 1秒
        backOffPolicy.setMultiplier(2.0);       // 每次失敗后等待時間翻倍
        backOffPolicy.setMaxInterval(10000);    // 最長等待10秒
        
        retryTemplate.setRetryPolicy(retryPolicy);
        retryTemplate.setBackOffPolicy(backOffPolicy);
        
        return retryTemplate;
    }
}

resilience4j.retry:
  instances:
    paymentService:
      maxRetryAttempts: 3
      waitDuration: 1s
      enableExponentialBackoff: true
      exponentialBackoffMultiplier: 2
      retryExceptions:
        - org.springframework.web.client.ResourceAccessException
        - com.example.service.exception.TemporaryServiceException

@Service
public class PaymentServiceWithResilience4j {
    
    private final PaymentGateway paymentGateway;
    
    @Autowired
    public PaymentServiceWithResilience4j(PaymentGateway paymentGateway) {
        this.paymentGateway = paymentGateway;
    }
    
    @Retry(name = "paymentService", fallbackMethod = "processPaymentFallback")
    public PaymentResult processPayment(PaymentRequest request) {
        return paymentGateway.submitPayment(request);
    }
    
    public PaymentResult processPaymentFallback(PaymentRequest request, Exception e) {
        log.error("Payment processing failed after retries for order: {}", request.getOrderId());
        return PaymentResult.failed(request.getOrderId(), "Payment processing temporarily unavailable");
    }
}

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-registry-prometheus</artifactId>
</dependency>

management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics,prometheus,loggers,env
  endpoint:
    health:
      show-details: always
      group:
        readiness:
          include: db,redis,rabbit,diskSpace
  health:
    circuitbreakers:
      enabled: true
    ratelimiters:
      enabled: true
  metrics:
    export:
      prometheus:
        enabled: true
    enable:
      jvm: true
      system: true
      process: true
      http: true

@Component
public class ExternalServiceHealthIndicator implements HealthIndicator {
    
    private final RestTemplate restTemplate;
    
    @Autowired
    public ExternalServiceHealthIndicator(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }
    
    @Override
    public Health health() {
        try {
            // 檢查外部服務健康狀態(tài)
            ResponseEntity<Map> response = restTemplate.getForEntity("https://api.external-service.com/health", Map.class);
            
            if (response.getStatusCode().is2xxSuccessful()) {
                return Health.up()
                        .withDetail("status", response.getBody().get("status"))
                        .withDetail("version", response.getBody().get("version"))
                        .build();
            } else {
                return Health.down()
                        .withDetail("statusCode", response.getStatusCodeValue())
                        .withDetail("reason", "Unexpected status code")
                        .build();
            }
        } catch (Exception e) {
            return Health.down()
                    .withDetail("error", e.getMessage())
                    .build();
        }
    }
}

@Configuration
public class HealthCheckConfig {
    
    @Bean
    public HealthContributorRegistry healthContributorRegistry(
            ApplicationAvailabilityBean availabilityBean) {
        
        HealthContributorRegistry registry = new DefaultHealthContributorRegistry();
        
        // 添加應用啟動完成的就緒檢查
        registry.registerContributor("readiness", new ApplicationAvailabilityHealthIndicator(
                availabilityBean, ApplicationAvailabilityBean.LivenessState.CORRECT));
        
        // 添加應用正在運行的活性檢查
        registry.registerContributor("liveness", new ApplicationAvailabilityHealthIndicator(
                availabilityBean, ApplicationAvailabilityBean.ReadinessState.ACCEPTING_TRAFFIC));
        
        return registry;
    }
}

@Component
public class OrderMetrics {
    
    private final MeterRegistry meterRegistry;
    private final Counter orderCounter;
    private final DistributionSummary orderAmountSummary;
    private final Timer orderProcessingTimer;
    
    public OrderMetrics(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
        
        this.orderCounter = Counter.builder("orders.created")
                .description("Number of orders created")
                .tag("application", "order-service")
                .register(meterRegistry);
        
        this.orderAmountSummary = DistributionSummary.builder("orders.amount")
                .description("Order amount distribution")
                .tag("application", "order-service")
                .publishPercentiles(0.5, 0.95, 0.99)
                .register(meterRegistry);
        
        this.orderProcessingTimer = Timer.builder("orders.processing.time")
                .description("Order processing time")
                .tag("application", "order-service")
                .publishPercentiles(0.5, 0.95, 0.99)
                .register(meterRegistry);
    }
    
    public void recordOrderCreated(String orderType) {
        orderCounter.increment();
        meterRegistry.counter("orders.created.by.type", "type", orderType).increment();
    }
    
    public void recordOrderAmount(double amount) {
        orderAmountSummary.record(amount);
    }
    
    public Timer.Sample startOrderProcessing() {
        return Timer.start(meterRegistry);
    }
    
    public void endOrderProcessing(Timer.Sample sample) {
        sample.stop(orderProcessingTimer);
    }
}

@Service
public class OrderServiceWithMetrics {
    
    private final OrderRepository orderRepository;
    private final OrderMetrics orderMetrics;
    
    @Autowired
    public OrderServiceWithMetrics(OrderRepository orderRepository, OrderMetrics orderMetrics) {
        this.orderRepository = orderRepository;
        this.orderMetrics = orderMetrics;
    }
    
    public Order createOrder(OrderRequest request) {
        Timer.Sample timer = orderMetrics.startOrderProcessing();
        
        try {
            Order order = new Order();
            // 處理訂單
            order.setItems(request.getItems());
            order.setTotalAmount(calculateTotalAmount(request.getItems()));
            order.setType(request.getType());
            
            Order savedOrder = orderRepository.save(order);
            
            // 記錄指標
            orderMetrics.recordOrderCreated(order.getType());
            orderMetrics.recordOrderAmount(order.getTotalAmount());
            
            return savedOrder;
        } finally {
            orderMetrics.endOrderProcessing(timer);
        }
    }
    
    private double calculateTotalAmount(List<OrderItem> items) {
        // 計算總金額
        return items.stream()
                .mapToDouble(item -> item.getPrice() * item.getQuantity())
                .sum();
    }
}

# docker-compose.yml
version: '3.8'
services:
  app:
    image: my-spring-boot-app:latest
    ports:
      - "8080:8080"
    
  prometheus:
    image: prom/prometheus:latest
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
    ports:
      - "9090:9090"
    
  grafana:
    image: grafana/grafana:latest
    depends_on:
      - prometheus
    ports:
      - "3000:3000"
    volumes:
      - grafana-storage:/var/lib/grafana
    
volumes:
  grafana-storage:

# prometheus.yml
global:
  scrape_interval: 15s

scrape_configs:
  - job_name: 'spring-boot-app'
    metrics_path: '/actuator/prometheus'
    static_configs:
      - targets: ['app:8080']