🔧 后端问题排查实战手册

// ✅ 修复方案：所有需要同时锁 Order 和 Inventory 的地方，统一先锁 Order 再锁 Inventory
// 这样就不会出现 A先锁Order B先锁Inventory 的情况

public void placeOrder(OrderRequest req) {
    synchronized(orderService) { // 先锁 Order
        synchronized(inventoryService) { // 再锁 Inventory
            // 业务逻辑
        }
    }
}

public void cancelOrder(Long orderId) {
    synchronized(orderService) { // 也先锁 Order
        synchronized(inventoryService) { // 再锁 Inventory
            // 业务逻辑
        }
    }
}

// ✅ 1. 给HTTP客户端加超时（防线1：防止无限阻塞）
@Bean
public RestTemplate restTemplate() {
    SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
    factory.setConnectTimeout(3000); // 连接超时 3s
    factory.setReadTimeout(5000); // 读取超时 5s
    return new RestTemplate(factory);
}

// ✅ 2. 正确的支付流程：预下单→返回支付URL→前端跳转→回调确认→创建业务订单
@Service
public class OrderServiceImpl {

    // 第一步：只做预下单，不创建业务订单
    public PrepayResult createPrepay(OrderRequest req) {
        inventoryService.check(req.getProductId()); // 检查库存
        try {
            String payUrl = wechatPayService.prepay(req); // 拿到支付链接
            return PrepayResult.ok(payUrl); // 返回给前端跳转支付
        } catch (ResourceAccessException e) {
            // ⚠️ 超时降级：提示用户稍后重试或走线下支付
            log.warn("微信支付超时，走降级路径", e);
            return PrepayResult.degrade("支付处理中，请稍后在订单列表重试");
        }
    }

    // 第二步：微信支付成功回调，此时才创建业务订单
    @Transactional
    public void onPayCallback(PayCallbackRequest cb) {
        if (cb.isSuccess()) {
            orderMapper.insert(buildOrder(cb)); // ✅ 支付成功才创建订单
        }
    }
}

@Transactional(rollbackFor = Exception.class) // ✅ 所有异常都回滚
public void createOrder(OrderRequest req) {
    inventoryMapper.decrement(req.getProductId(), req.getQuantity());
    try {
        orderMapper.insert(buildOrder(req));
    } catch (DuplicateKeyException e) {
        log.error("订单重复", e);
        throw new BizException("请勿重复下单"); // ✅ 重新抛出！
    }
}

public Product getProduct(Long productId) {
    // 1. 先查缓存
    Product cached = redisTemplate.opsForValue().get("product:" + productId);
    if (cached != null) return cached;

    // 2. 缓存没有，查数据库
    Product product = productMapper.selectById(productId);
    if (product != null) {
        redisTemplate.opsForValue().set("product:" + productId, product, 30, TimeUnit.MINUTES);
    }
    // ⚠️ product == null 时，什么都不做，直接返回null
    return product; // 💥 不存在的商品每次都打到DB！
}

public Product getProduct(Long productId) {
    String key = "product:" + productId;
    Product cached = redisTemplate.opsForValue().get(key);
    if (cached != null) return cached;

    // ✅ 检查空值标记
    if (redisTemplate.hasKey("product:null:" + productId)) {
        return null; // 直接返回，不查DB
    }

    Product product = productMapper.selectById(productId);
    if (product != null) {
        redisTemplate.opsForValue().set(key, product, 30, TimeUnit.MINUTES);
    } else {
        // ✅ 缓存空值，短过期时间
        redisTemplate.opsForValue().set("product:null:" + productId, "", 5, TimeUnit.MINUTES);
    }
    return product;
}

// ✅ 统一序列化配置，兼容新旧数据
@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
    RedisTemplate<String, Object> template = new RedisTemplate<>();
    template.setConnectionFactory(factory);
    // key 用 String 序列化
    template.setKeySerializer(new StringRedisSerializer());
    // value 用 GenericJackson2Json（带@class，兼容旧数据）
    template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
    return template;
}

// ✅ 在 pom.xml 中排除冲突依赖
<dependency>
    <groupId>com.new-tool</groupId>
    <artifactId>some-library</artifactId>
    <version>1.5</version>
    <exclusions>
        <exclusion>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
        </exclusion>
    </exclusions>
</dependency>

// ✅ 获取Token（页面加载时调用）
@GetMapping("/token")
public String getToken() {
    String token = UUID.randomUUID().toString();
    redisTemplate.opsForValue().set("order:token:" + token, "1", 10, TimeUnit.MINUTES);
    return token;
}

// ✅ 下单时验证Token（原子删除）
@PostMapping("/create")
public Result create(@RequestHeader("X-Order-Token") String token, ...) {
    Boolean deleted = redisTemplate.delete("order:token:" + token);
    if (deleted == null || !deleted) {
        return Result.fail("请勿重复提交");
    }
    // 正常下单...
}

// ✅ 修复后的代码：关键节点都有日志
public OrderResult createOrder(OrderRequest req) {
    log.info("收到下单请求: userId={}, productId={}, quantity={}",
        req.getUserId(), req.getProductId(), req.getQuantity());

    try {
        inventoryService.decrement(req.getProductId(), req.getQuantity());
        log.info("库存扣减成功: productId={}", req.getProductId());
        Order order = orderMapper.insert(buildOrder(req));
        log.info("订单创建成功: orderId={}", order.getId());
    } catch (Exception e) {
        log.error("订单创建失败: userId={}, productId={}, error={}",
            req.getUserId(), req.getProductId(), e.getMessage(), e); // ✅ 带上异常堆栈
    }
}

// ✅ 方案1：在 ReportMapper 上加 @Mapper
@Mapper
public interface ReportMapper extends BaseMapper<Report> { ... }

// ✅ 方案2：或者检查 @MapperScan 包路径
@MapperScan("com.milktea.**.mapper") // 用通配符覆盖所有mapper包
@SpringBootApplication
public class MilkTeaApplication { ... }

// ✅ 1. 缩短事务范围（只包裹必要的DB操作）
@Transactional(timeout = 30) // 设置超时30秒
public void createOrder(...) { ... }

// ✅ 2. 适当增加连接池大小
# application.yml
spring.datasource.hikari.maximum-pool-size: 30 # 默认10，改为30
spring.datasource.hikari.leak-detection-threshold: 60000 # 60秒未还报警

@Configuration
@EnableScheduling
public class ScheduleConfig implements SchedulingConfigurer {

    @Override
    public void configureTasks(ScheduledTaskRegistrar registrar) {
        registrar.setScheduler(taskExecutor());
    }

    @Bean(destroyMethod = "shutdown")
    public ScheduledExecutorService taskExecutor() {
        return Executors.newScheduledThreadPool(4); // ✅ 4个线程
    }
}

@PostMapping("/upload")
public Result upload(@RequestParam("file") MultipartFile file) {
    // 💥 直接getBytes() 把整个文件读到内存
    byte[] data = file.getBytes(); // 500MB!
    String path = saveToDisk(data, file.getOriginalFilename());
    return Result.ok(path);
}

@PostMapping("/upload")
public Result upload(@RequestParam("file") MultipartFile file) {
    // ✅ 用流式方式，不一次性加载到内存
    Path target = Paths.get("/data/uploads", file.getOriginalFilename());
    try (InputStream in = file.getInputStream();
         OutputStream out = Files.newOutputStream(target)) {
        byte[] buffer = new byte[8192]; // 8KB 缓冲区
        int len;
        while ((len = in.read(buffer)) != -1) {
            out.write(buffer, 0, len);
        }
    }
    return Result.ok(target.toString());
}

# application.yml 限制文件大小
spring.servlet.multipart.max-file-size: 100MB
spring.servlet.multipart.max-request-size: 100MB

// ✅ Spring Boot + Guava RateLimiter 限流
@RestController
public class OrderController {

    // 每秒允许100个请求
    private final RateLimiter rateLimiter = RateLimiter.create(100);

    @PostMapping("/api/orders")
    public R createOrder(@RequestBody OrderRequest req) {
        // 非阻塞式限流：尝试获取令牌，1秒内拿不到就拒绝
        if (!rateLimiter.tryAcquire(1, TimeUnit.SECONDS)) {
            return R.fail("系统繁忙，请稍后重试");
        }

        // 正常业务逻辑...
        return R.ok(orderService.createOrder(req));
    }
}

// 分布式限流：Redis + Lua 脚本（推荐生产环境）
// 见 Redisson 的 RRateLimiter

# application.yml — 开启优雅停机
server:
  shutdown: graceful          # 等待正在处理的请求完成
spring:
  lifecycle:
    timeout-per-shutdown-phase: 30s  # 最多等30秒

// 自定义清理逻辑
@Component
public class GracefulShutdown {

    @Autowired
    private ExecutorService businessExecutor;

    @PreDestroy
    public void onShutdown() {
        // 1. 停止接收新任务
        businessExecutor.shutdown();
        try {
            // 2. 等待已有任务完成
            if (!businessExecutor.awaitTermination(30, TimeUnit.SECONDS)) {
                // 3. 超时强制关闭
                businessExecutor.shutdownNow();
            }
        } catch (InterruptedException e) {
            businessExecutor.shutdownNow();
        }
    }
}

# Kubernetes 部署时的 Pod 终止流程：
# 1. kubectl delete pod → 发送 SIGTERM
# 2. Spring Boot 收到信号 → 标记为"不接受新请求"
# 3. 等待正在处理的请求完成（最多30秒）
# 4. 超时后强制退出 → 容器终止
# 5. Service 从 Endpoints 移除 → 新请求不再路由到此 Pod