陕西互联网违法和不良信息举报电话 029-85582645

// 模块1：高并发场景下的订单服务实现（Spring Cloud Alibaba + Sentinel）
@RestController
@RequestMapping("/orders")
@Slf4j
public class OrderController {

    @Autowired
    private OrderService orderService;

    @Autowired
    private SentinelClient sentinelClient;

    // 限流保护的下单接口
    @PostMapping("/create")
    @SentinelResource(value = "createOrder", blockHandler = "handleFlowQpsException")
    public Result createOrder(@RequestBody OrderRequest request) {
        // 业务参数校验
        ValidationUtils.validate(request);
        
        // 热点参数限流：对用户ID进行限流
        Entry entry = null;
        try {
            entry = SphU.entry("createOrderByUserId", 
                EntryType.OUT, 1, request.getUserId());
            return orderService.createOrder(request);
        } catch (BlockException e) {
            log.error("用户ID被限流: {}", request.getUserId(), e);
            return Result.failed("操作过于频繁，请稍后再试");
        } finally {
            if (entry != null) {
                entry.exit();
            }
        }
    }

    // 熔断降级处理
    public Result handleFlowQpsException(OrderRequest request, BlockException ex) {
        log.error("订单服务被限流或降级: {}", ex.getMessage());
        // 触发服务降级，返回缓存数据或默认值
        return Result.failed("系统繁忙，请稍后重试");
    }

    // 分布式事务示例：Seata全局事务管理
    @GlobalTransactional(name = "order-create-tx", rollbackFor = Exception.class)
    public Result createOrderWithTx(OrderRequest request) {
        // 1. 创建订单
        Order order = orderService.saveOrder(request);
        
        // 2. 扣减库存
        inventoryService.decreaseStock(request.getProductId(), request.getQuantity());
        
        // 3. 扣减用户余额
        accountService.debit(request.getUserId(), request.getAmount());
        
        return Result.success(order);
    }
}

// 模块2：容器化部署脚本（Docker + Kubernetes）
# Dockerfile for Order Service
FROM openjdk:17-alpine
LABEL maintainer="doubao@example.com"

# 设置工作目录
WORKDIR /app

# 复制依赖和应用JAR
COPY target/dependency/ ./
COPY target/*.jar app.jar

# 暴露端口
EXPOSE 8080

# 启动命令
ENTRYPOINT ["java", "-jar", "app.jar"]

# Kubernetes部署配置
apiVersion: apps/v1
kind: Deployment
metadata:
  name: order-service
  namespace: microservice
spec:
  replicas: 3
  selector:
    matchLabels:
      app: order-service
  template:
    metadata:
      labels:
        app: order-service
        version: v1
    spec:
      containers:
      - name: order-service
        image: registry.example.com/order-service:2025.06
        ports:
        - containerPort: 8080
        resources:
          requests:
            memory: "512Mi"
            cpu: "250m"
          limits:
            memory: "1Gi"
            cpu: "500m"
        env:
        - name: SPRING_PROFILES_ACTIVE
          value: "prod"
        - name: NACOS_SERVER_ADDR
          value: "nacos-server:8848"
        readinessProbe:
          httpGet:
            path: /actuator/health
            port: 8080
          initialDelaySeconds: 30
          periodSeconds: 10
          timeoutSeconds: 5
        livenessProbe:
          httpGet:
            path: /actuator/health
            port: 8080
          initialDelaySeconds: 60
          periodSeconds: 10
          timeoutSeconds: 5
          failureThreshold: 3

# 模块3：微服务网关配置（Spring Cloud Gateway + Sentinel）
spring:
  cloud:
    gateway:
      routes:
        - id: order_route
          uri: lb://order-service
          predicates:
            - Path=/api/orders/**
          filters:
            - StripPrefix=2
            - name: RequestRateLimiter
              args:
                redis-rate-limiter.replenishRate: 100  # 令牌桶每秒填充速率
                redis-rate-limiter.burstCapacity: 200  # 令牌桶容量
                key-resolver: "#{@userKeyResolver}"  # 使用用户ID作为限流键
        - id: product_route
          uri: lb://product-service
          predicates:
            - Path=/api/products/**
          filters:
            - StripPrefix=2
            - SentinelGatewayFilter

# Sentinel熔断降级配置
spring:
  cloud:
    sentinel:
      transport:
        dashboard: sentinel-dashboard:8080
        port: 8719
      datasource:
        ds1:
          nacos:
            server-addr: nacos-server:8848
            dataId: ${spring.application.name}-sentinel.json
            groupId: DEFAULT_GROUP
            data-type: json
            rule-type: flow

// 模块4：响应式编程示例（Spring WebFlux + Reactor）
@RestController
@RequestMapping("/api/products")
public class ProductController {

    @Autowired
    private ProductService productService;

    // 响应式查询商品列表
    @GetMapping
    public Flux<Product> getProducts() {
        return productService.getAllProducts()
            .onErrorResume(e -> {
                log.error("获取商品列表失败", e);
                return Flux.empty();
            })
            .timeout(Duration.ofSeconds(3))
            .doOnNext(product -> log.info("返回商品: {}", product.getName()));
    }

    // 响应式创建商品
    @PostMapping
    public Mono<Product> createProduct(@RequestBody Mono<Product> productMono) {
        return productMono
            .flatMap(productService::saveProduct)
            .map(savedProduct -> {
                // 发送事件到消息队列
                eventPublisher.publishProductCreated(savedProduct);
                return savedProduct;
            });
    }

    // WebClient调用示例
    public Mono<Product> getProductById(String productId) {
        WebClient client = WebClient.create("http://product-service");
        return client.get()
            .uri("/api/products/{id}", productId)
            .retrieve()
            .bodyToMono(Product.class)
            .retry(3) // 失败重试3次
            .timeout(Duration.ofSeconds(5));
    }
}

// 模块5：分布式缓存与搜索（Redis + Elasticsearch）
@Service
public class ProductServiceImpl implements ProductService {

    @Autowired
    private RedisTemplate<String, Product> redisTemplate;
    
    @Autowired
    private RestHighLevelClient elasticsearchClient;
    
    @Autowired
    private ProductRepository productRepository;

    // 缓存优先的商品查询
    @Override
    public Mono<Product> getProduct(String id) {
        // 先查Redis缓存
        String key = "product:" + id;
        Product cachedProduct = redisTemplate.opsForValue().get(key);
        
        if (cachedProduct != null) {
            return Mono.just(cachedProduct);
        }
        
        // 缓存未命中，查询数据库
        return productRepository.findById(id)
            .flatMap(product -> {
                // 存入缓存，设置10分钟过期
                redisTemplate.opsForValue().set(key, product, 10, TimeUnit.MINUTES);
                return Mono.just(product);
            })
            .switchIfEmpty(Mono.error(new ProductNotFoundException("商品不存在")));
    }

    // 商品搜索功能
    @Override
    public Flux<Product> searchProducts(String keyword) {
        SearchRequest searchRequest = new SearchRequest("products");
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        
        // 构建多字段搜索查询
        MultiMatchQueryBuilder queryBuilder = QueryBuilders.multiMatchQuery(
            keyword, "name^3", "description", "category"); // name字段权重提高3倍
        
        sourceBuilder.query(queryBuilder);
        sourceBuilder.size(20);
        searchRequest.source(sourceBuilder);
        
        return Mono.fromFuture(elasticsearchClient.searchAsync(searchRequest, RequestOptions.DEFAULT))
            .flatMapMany(response -> {
                SearchHits hits = response.getHits();
                List<Product> products = Arrays.stream(hits.getHits())
                    .map(hit -> {
                        Map<String, Object> source = hit.getSourceAsMap();
                        return Product.builder()
                            .id(hit.getId())
                            .name((String) source.get("name"))
                            .description((String) source.get("description"))
                            .price((Double) source.get("price"))
                            .category((String) source.get("category"))
                            .build();
                    })
                    .collect(Collectors.toList());
                return Flux.fromIterable(products);
            })
            .onErrorResume(e -> {
                log.error("搜索商品失败", e);
                return Flux.empty();
            });
    }
}