脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → SpringBoot服务可用性保障技术

SpringBoot中5种服务可用性保障技术分享

 更新时间：2025年05月06日 08:52:58   作者：风象南  
服务可用性已成为系统设计的核心关注点,SpringBoot作为Java生态系统中流行的应用开发框架,提供了丰富的工具和库来保障服务的高可用性,本文将介绍SpringBoot中5种关键的服务可用性保障技术,需要的朋友可以参考下

1. 熔断器模式（Circuit Breaker）

基本原理

熔断器模式借鉴了电路熔断器的概念，当检测到系统中某个服务或组件频繁失败时，自动"断开"对该服务的调用，防止级联故障，同时为故障服务提供恢复时间。熔断器有三种状态：

  • 关闭状态：正常执行操作，同时监控失败率
  • 开启状态：拒绝访问，直接返回错误或执行降级逻辑
  • 半开状态：尝试恢复，允许有限的请求通过以测试服务是否恢复

SpringBoot实现与集成

在SpringBoot中，我们可以使用Resilience4j实现熔断器模式，它是Hystrix的轻量级替代方案，专为Java 8和函数式编程设计。

首先添加依赖：

<dependency>
    <groupId>io.github.resilience4j</groupId>
    <artifactId>resilience4j-spring-boot2</artifactId>
    <version>1.7.0</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

然后在application.yml中配置熔断器参数：

resilience4j:
  circuitbreaker:
    instances:
      orderService:
        registerHealthIndicator: true
        slidingWindowSize: 10
        minimumNumberOfCalls: 5
        permittedNumberOfCallsInHalfOpenState: 3
        automaticTransitionFromOpenToHalfOpenEnabled: true
        waitDurationInOpenState: 5s
        failureRateThreshold: 50
        eventConsumerBufferSize: 10

使用熔断器的示例代码：

@Service
public class OrderService {
    
    private final PaymentServiceClient paymentServiceClient;
    
    public OrderService(PaymentServiceClient paymentServiceClient) {
        this.paymentServiceClient = paymentServiceClient;
    }
    
    @CircuitBreaker(name = "orderService", fallbackMethod = "processOrderFallback")
    public OrderResponse processOrder(OrderRequest orderRequest) {
        // 正常的订单处理逻辑，包括调用支付服务
        PaymentResponse paymentResponse = paymentServiceClient.processPayment(orderRequest.getPaymentDetails());
        return new OrderResponse(orderRequest.getOrderId(), "PROCESSED", paymentResponse.getTransactionId());
    }
    
    // 降级方法，在熔断器触发时执行
    public OrderResponse processOrderFallback(OrderRequest orderRequest, Exception e) {
        log.error("Circuit breaker triggered for order: {}. Error: {}", orderRequest.getOrderId(), e.getMessage());
        // 返回降级响应，可能是从本地缓存获取，或使用默认值
        return new OrderResponse(orderRequest.getOrderId(), "PENDING", null);
    }
}

最佳实践

  • 适当的窗口大小：设置合理的slidingWindowSize，太小可能导致熔断器过于敏感，太大则反应迟钝。
  • 合理的阈值：根据业务需求设置failureRateThreshold，一般建议在50%-60%之间。
  • 监控熔断器状态：集成Spring Boot Actuator监控熔断器状态：
management:
  endpoints:
    web:
      exposure:
        include: health,circuitbreakers
  health:
    circuitbreakers:
      enabled: true
  • 细粒度熔断：为不同的服务依赖配置不同的熔断器实例，避免一个服务故障影响多个业务流程。
  • 测试熔断行为：通过混沌测试验证熔断器在故障情况下的行为是否符合预期。

2. 限流技术（Rate Limiting）

基本原理

限流用于控制系统的请求处理速率，防止系统过载。常见的限流算法包括：

  • 令牌桶：以固定速率向桶中添加令牌，请求需要消耗令牌才能被处理。
  • 漏桶：请求以固定速率处理，超出部分排队或拒绝。
  • 计数器：在固定时间窗口内限制请求数量。

SpringBoot实现与集成

在SpringBoot中，我们可以使用Bucket4j实现API限流，这是一个基于令牌桶算法的Java限流库。

添加依赖：

<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中实现限流：

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);
        };
    }
}

最佳实践

  • 分级限流：基于不同用户类型或API重要性设置不同的限流阈值。
  • 应用多级限流：例如，同时应用用户级、IP级和全局级限流。
  • 限流响应：在限流触发时返回合适的HTTP状态码（通常是429）和明确的错误信息，包括重试建议。
  • 监控限流指标：收集限流指标，用于分析和调整限流策略。
  • 优雅降级：当达到限流阈值时，考虑提供降级服务而非完全拒绝。

3. 服务降级与容错处理

基本原理

服务降级是一种在系统高负载或部分服务不可用时，通过提供有限但可接受的服务来维持系统整体可用性的策略。容错处理则是指系统能够检测并处理错误，同时继续正常运行的能力。

SpringBoot实现与集成

在SpringBoot中，服务降级可以通过多种方式实现，包括与熔断器结合、使用异步回退，以及实现超时控制。

使用Resilience4j的Fallback实现服务降级：

@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();
        
        // 检查系统健康状态
        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));
    }
    
    // 其他响应处理方法...
}

最佳实践

  • 分级降级策略：针对不同的故障场景和服务重要性制定分级降级策略。
  • 静态降级：预先准备好静态资源或缓存数据，在服务不可用时使用。
  • 功能降级：暂时关闭非核心功能，保证核心业务正常。
  • 特定用户群体降级：在高负载情况下，优先保证VIP用户的体验。
  • 服务隔离：使用Bulkhead模式隔离不同服务的资源，防止一个服务的问题影响其他服务。
  • 超时控制：设置合理的超时时间，防止长时间等待影响用户体验。

4. 重试机制（Retry）

基本原理

重试机制用于处理暂时性故障，通过自动重新尝试失败的操作来提高系统的弹性。对于网络抖动、数据库临时不可用等场景尤其有效。

SpringBoot实现与集成

SpringBoot中可以使用Spring Retry库实现重试功能。

添加依赖：

<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());
        // 返回缓存数据或默认响应
        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 -> {
            // 获取当前重试次数
            int retryCount = context.getRetryCount();
            log.info("Processing payment attempt {} for order {}", 
                     retryCount + 1, paymentRequest.getOrderId());
            
            try {
                // 执行支付处理
                return paymentGateway.submitPayment(paymentRequest);
            } catch (PaymentGatewayException e) {
                // 分析异常并决定是否重试
                if (e.isRetryable()) {
                    log.warn("Retryable payment error: {}. Will retry.", e.getMessage());
                    throw e; // 抛出异常以触发重试
                } 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());
            // 返回失败结果并记录需要后续处理
            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的重试功能：

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");
    }
}

最佳实践

  • 区分暂时性和永久性故障：只对暂时性故障进行重试，对永久性故障立即失败。
  • 指数退避：使用指数退避策略，避免重试风暴。
  • 合理的重试次数：设置适当的最大重试次数，通常3-5次。
  • 重试后监控：记录重试次数和结果，帮助识别问题服务。
  • 幂等操作：确保被重试的操作是幂等的，以避免重复处理导致的问题。
  • 设置超时：每次重试都应该有合理的超时时间。
  • 与熔断器结合：将重试机制与熔断器结合使用，当故障持续存在时快速失败。

5. 健康检查与监控（Health Checks and Monitoring）

基本原理

健康检查和监控是保障服务可用性的基础设施，用于实时了解系统状态，及早发现并解决问题。通过系统指标收集、健康状态检查和警报机制，可以提前预防或快速解决服务故障。

SpringBoot实现与集成

SpringBoot Actuator提供了丰富的监控和管理功能，可以轻松集成到应用中。

添加依赖：

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

配置Actuator端点：

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 {
            // 检查外部服务健康状态
            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();
    }
}

集成Grafana和Prometheus监控：

# 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']

最佳实践

  • 多层次健康检查：实现浅层和深层健康检查，前者快速响应，后者全面检查。
  • 关键业务指标监控：监控关键业务指标，如订单数量、转化率等。
  • 系统资源监控：监控CPU、内存、磁盘、网络等系统资源。
  • 设置合理的警报阈值：基于业务重要性和系统特性设置警报阈值。
  • 关联分析：将不同服务的指标关联起来，便于问题根因分析。
  • 日志与指标结合：将日志和指标结合起来，提供更完整的系统视图。
  • 预测性监控：使用趋势分析预测潜在问题，如磁盘空间预测用尽时间。

总结

本文介绍了SpringBoot中5种核心的服务可用性保障技术：熔断器模式、限流技术、服务降级与容错处理、重试机制以及健康检查与监控。这些技术不是孤立的，而是相互配合、协同工作，共同构建起应用的防御体系。

以上就是SpringBoot中5种服务可用性保障技术分享的详细内容，更多关于SpringBoot服务可用性保障技术的资料请关注脚本之家其它相关文章！

您可能感兴趣的文章:

相关文章

  • java实现根据ip地址获取地理位置

    java实现根据ip地址获取地理位置

    本文给大家汇总介绍了2种分别使用新浪和淘宝接口，实现根据IP地址获取详细的地理位置的代码，非常的实用，有需要的小伙伴可以参考下。
    2016-03-03
  • Java线程中的ThreadLocal类解读

    Java线程中的ThreadLocal类解读

    这篇文章主要介绍了Java线程中的ThreadLocal类解读,ThreadLocal是一个泛型类,作用是实现线程隔离,ThreadLocal类型的变量,在每个线程中都会对应一个具体对象,对象类型需要在声明ThreadLocal变量时指定,需要的朋友可以参考下
    2023-11-11
  • SpringBoot事件发布与监听超详细讲解

    SpringBoot事件发布与监听超详细讲解

    今天去官网查看spring boot资料时，在特性中看见了系统的事件及监听章节,所以下面这篇文章主要给大家介绍了关于SpringBoot事件发布和监听的相关资料,文中通过实例代码介绍的非常详细,需要的朋友可以参考下
    2022-11-11
  • Java SE使用数组实现高速数字转换功能

    Java SE使用数组实现高速数字转换功能

    随着大数据时代的到来,数字转换功能变得越来越重要,在Java开发中,数字转换功能也是经常用到的,下面我们就来学习一下如何使用Java SE数组实现高速的数字转换功能吧
    2023-11-11
  • 浅析Mysql中的视图

    浅析Mysql中的视图

    这篇文章主要介绍了浅析Mysql中的视图,视图是从一个或者多个表中导出的表，视图的行为与表非常相似，在视图中用户可以使用SELECT语句查询数据，以及使用INSERT、UPDATE和DELETE修改记录,需要的朋友可以参考下
    2023-05-05
  • 深入讲解SpringBoot Actuator是什么

    深入讲解SpringBoot Actuator是什么

    Spring Boot Actuator提供了生产上经常用到的功能（如健康检查，审计，指标收集，HTTP跟踪等），帮助我们监控和管理Spring Boot应用程序。这些功能都可以通过JMX或HTTP端点访问
    2023-01-01
  • Java通过notify和wait实现线程间的通信功能

    Java通过notify和wait实现线程间的通信功能

    在软件开发中,线程是实现并发执行的重要手段,然而,线程之间的协作与通信却是开发者必须重点考虑的挑战之一,Java作为一种广泛应用于多线程编程的语言,本文将深入探讨Java中通过notify和wait实现线程间通信的机制,需要的朋友可以参考下
    2024-06-06
  • 基于Java创建XML（无中文乱码）过程解析

    基于Java创建XML（无中文乱码）过程解析

    这篇文章主要介绍了基于Java创建XML（无中文乱码）过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
    2019-10-10
  • Java日常练习题,每天进步一点点(3)

    Java日常练习题,每天进步一点点(3)

    下面小编就为大家带来一篇Java基础的几道练习题(分享)。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧，希望可以帮到你
    2021-07-07
  • SpringBoot使用Thymeleaf自定义标签的实例代码

    SpringBoot使用Thymeleaf自定义标签的实例代码

    这篇文章主要介绍了SpringBoot使用Thymeleaf自定义标签的实例代码，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
    2020-09-09

最新评论