在高并发场景下，送你这三根“救命毫毛”

import org.springframework.cloud.gateway.route.RouteLocator;
import org.springframework.cloud.gateway.route.builder.RouteLocatorBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.cloud.gateway.filter.ratelimit.RedisRateLimiter;


@Configuration
public class GatewayConfig {
  // 定义路由规则，指向商品详情服务
  @Bean
  public RouteLocator customRouteLocator(RouteLocatorBuilder builder){
        return builder.routes()
                .route("product_detail_route", r -> r.path("/product/details/**")
                     .filters(f -> f.requestRateLimiter().configure(c -> c.setRateLimiter(redisRateLimiter())))
                        .uri("lb://PRODUCT-SERVICE"))
                .build();
    }


    // 应用限流过滤器，使用Redis实现
    @Bean
    RedisRateLimiter redisRateLimiter() {
        // 创建RedisRateLimiter实例
        // 参数分别是允许用户每秒进行5次请求，突发流量大小为10个令牌
        return new RedisRateLimiter(5, 10);
    }
}

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
    <version>2.2.6.RELEASE</version>
</dependency>

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

@Service
public class CommentService {


    @HystrixCommand(fallbackMethod = "getDefaultComments")
    public String getComments(String productId) {
        // 模拟从评论服务获取评论的操作，可能会因为服务发生故障而抛出异常
        if (new Random().nextInt(10) < 8) { // 假设有80%的概率服务会失败
            throw new RuntimeException("评论服务异常");
        }
        return "正常获取评论数据";
    }
     // 定义熔断时的备用方法
    public String getDefaultComments(String productId) {
        return "评论服务当前不可用，请稍后再试";
    }
}

const Hystrix = require('hystrix-js');


// 创建一个熔断器，设置错误率阈值为50%
const paymentHystrix = new Hystrix({
    metrics: {
        healthPercentThresholds: [50]
    }
});


// 包装支付服务的调用
function makePaymentRequest() {
    return paymentHystrix.wrap(((resolve, reject) => {
        // 假设的支付服务调用
        payService支付((err, result) => {
            if (err) {
                reject(err); // 支付失败，触发熔断器
            } else {
                resolve(result); // 支付成功
            }
        });
    })).then(() => {
        // 处理支付成功
    }).catch(err => {
        // 处理支付失败，可能触发熔断器
        console.error('支付失败:', err);
    });
}

public class ProductService {
    private CacheManager cacheManager;


    public ProductService(CacheManager cacheManager) {
        this.cacheManager = cacheManager;
    }


    // 获取商品详情
    public ProductDetail getProductDetail(String productId) {
        try {
          // 尝试从数据库中获取最新的商品详情页
            ProductDetail productDetail = fetchProductDetailFromDB(productId);
            return productDetail;
        } catch (Exception e) {
            // 如果数据库访问出错或超时，则使用缓存数据
            ProductDetail cachedDetail = cacheManager.getCachedProductDetail(productId);
            if (cachedDetail != null) {
                return cachedDetail; // 返回缓存的商品详情页信息
            }
            // 如果没有缓存，则返回简化的商品信息
            return new ProductDetail(productId, "暂无详细描述，请稍后再试。");
        }
    }


    // 模拟从数据库中获取商品详情页
    private ProductDetail fetchProductDetailFromDB(String productId) throws Exception {
        // 模拟数据库操作可能的延迟
        Thread.sleep(200); // 假设有200ms的延迟
        return new ProductDetail(productId, "完整的商品描述。");
    }
}

public class RecommendationService {
    // 标志位，用于标识推荐服务是否可用
    private static volatile boolean isServiceEnabled = true;


    // 设置服务状态的方法，可以被外部调用来开启或关闭服务
    public static void setServiceStatus(boolean status) {
        isServiceEnabled = status;
    }


    // 推荐商品的方法
    public List<Product> recommendProducts(User user) {
        // 检查推荐服务是否被降级（即关闭）
        if (!isServiceEnabled) {
            // 在推荐服务被关闭时，返回一个空列表或者预设的简单推荐列表
            return Collections.emptyList(); // 这里为了简化，直接返回空列表
        }
        // 正常情况下的推荐逻辑
        // 假设有一个复杂的逻辑，根据用户的浏览历史、购买历史等信息生成推荐列表
        // ……
        return new ArrayList<>(); // 在实际业务中应有复杂逻辑返回推荐商品
    }
}

// 假设这是一个商品详情页的前端代码片段
function fetchProductDetails(productId) {
    fetch(`/api/product/${productId}`)
        .then(response => {
            if (!response.ok) {
                // 如果请求失败，则返回降级内容
                return getDegradedProductDetails(productId);
            }
            return response.json();
        })
        .then(details => renderProductDetails(details))
        .catch(error => {
            // 如果请求失败，则返回降级内容
           getDegradedProductDetails(productId).then(degradedDetails =>{
                renderDegradedProductDetails(degradedDetails);
           });
        });
}


function getDegradedProductDetails(productId) {
    // 这里可以从本地缓存中获取，或者是更简单的数据
    return new Promise(resolve => {
        resolve({
            name: '商品名称',
            description: '商品描述',
            price: '商品价格'
        });
    });
}


function renderDegradedProductDetails(degradedDetails) {
 // 使用简化的模板或布局渲染降级内容
    const container = document.getElementById('product-details');
    container.innerHTML = '
        <h1>${degradedDetails.name}</h1>
        <p>${degradedDetails.description}</p>
        <p>价格：$${degradedDetails.price}</p>
    ';
}