互联网架构开发：在不确定的流量海洋中，构建确定性的系统边界

# application.yml —— 网关的"保命配置"
spring:
  cloud:
    gateway:
      routes:
        - id: order_service
          uri: lb://order-service
          predicates:
            - Path=/order/**
          filters:
            - name: CircuitBreaker
              args:
                name: orderBreaker
                fallbackUri: forward:/fallback/order
            - name: RequestRateLimiter
              args:
                redis-rate-limiter.replenishRate: 100   # 每秒允许100个请求
                redis-rate-limiter.burstCapacity: 200   # 突发容量200

@RestController
public class FallbackController {
    
    @GetMapping("/fallback/order")
    public Result<String> orderFallback() {
        // 返回"有损"但可接受的响应
        return Result.error("当前订单服务繁忙，请稍后重试或联系客服");
    }
    
    @GetMapping("/fallback/user")
    public Result<String> userFallback() {
        // 降级到本地缓存，而非直接报错
        String cachedUser = localCache.get("default_user_info");
        return Result.success(cachedUser != null ? cachedUser : "系统维护中");
    }
}

@Component
public class CacheGuard {
    
    @Autowired
    private StringRedisTemplate redisTemplate;
    
    public String getWithMutex(String key, int expireSeconds, Supplier<String> dbLoader) {
        // 1. 先查缓存
        String cached = redisTemplate.opsForValue().get(key);
        if (cached != null) return cached;
        
        // 2. 缓存失效，尝试获取"重建锁"
        String lockKey = "LOCK:" + key;
        Boolean locked = redisTemplate.opsForValue()
                .setIfAbsent(lockKey, "1", Duration.ofSeconds(3));
        
        if (Boolean.TRUE.equals(locked)) {
            try {
                // 3. 只有拿到锁的线程去DB查询
                String freshData = dbLoader.get();
                redisTemplate.opsForValue().set(key, freshData, expireSeconds, TimeUnit.SECONDS);
                return freshData;
            } finally {
                redisTemplate.delete(lockKey);
            }
        } else {
            // 4. 没拿到锁，等待100ms后重试（递归，需设重试上限）
            try { Thread.sleep(100); } catch (InterruptedException ignored) {}
            return getWithMutex(key, expireSeconds, dbLoader);
        }
    }
}

@Configuration
@EnableAsync
public class AsyncConfig {
    
    @Bean
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(20);
        executor.setQueueCapacity(500);
        executor.setThreadNamePrefix("async-");
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        executor.initialize();
        return executor;
    }
}

@Service
public class UserService {
    
    @Async  // 此方法将异步执行，不阻塞主线程
    public void sendWelcomeSms(String phone, String username) {
        try {
            smsClient.send(phone, "欢迎注册，" + username + "！");
        } catch (Exception e) {
            log.error("短信发送失败，手机号：{}", phone, e);
            // 失败后写入重试队列，不吞掉错误
            retryQueue.push(phone, username);
        }
    }
    
    public Result register(UserRegisterDTO dto) {
        // 主流程只做：校验 + 入库
        userDao.save(dto);
        // 异步发短信，不等待结果
        sendWelcomeSms(dto.getPhone(), dto.getUsername());
        return Result.success("注册成功");
    }
}

@Service
public class OrderService {
    
    @Autowired
    private RocketMQTemplate mqTemplate;
    
    @Transactional
    public void createOrder(OrderDTO order) {
        // 1. 本地事务：生成订单（状态为"待确认"）
        order.setStatus(OrderStatus.PENDING);
        orderDao.save(order);
        
        // 2. 发送半事务消息（RocketMQ的事务消息）
        TransactionSendResult sendResult = mqTemplate.sendMessageInTransaction(
            "order-topic",
            new Message("扣减库存", order.getProductId(), order.getQuantity()),
            order.getOrderId()
        );
        
        if (sendResult.getLocalTransactionState() != LocalTransactionState.COMMIT_MESSAGE) {
            throw new BizException("库存扣减失败，订单回滚");
        }
        
        // 3. 本地事务提交后，将订单状态改为"已确认"
        order.setStatus(OrderStatus.CONFIRMED);
        orderDao.update(order);
    }
}