飞算 JavaAI 驱动电商系统核心模块高效开发实战

实体类与 DTO

// 商品实体类
@Data
@TableName("product")
public class Product {
    @TableId(type = IdType.AUTO)
    private Long id;
    
    @NotBlank(message = "商品名称不能为空")
    private String productName;
    
    @NotNull(message = "分类 ID 不能为空")
    private Long categoryId;
    
    @DecimalMin(value = "0.01", message = "商品价格必须大于 0")
    private BigDecimal price;
    
    @Min(value = 0, message = "库存数量不能为负数")
    private Integer stock;
    
    private Integer status;
    
    @TableField(fill = FieldFill.INSERT)
    private LocalDateTime createTime;
}

Service 层核心逻辑

这里需要注意并发场景下的库存处理。AI 生成的代码通常会集成分布式锁或乐观锁机制。

@Service
@RequiredArgsConstructor
public class ProductServiceImpl extends ServiceImpl<ProductMapper, Product> implements ProductService {
    private final ProductMapper productMapper;
    private final RedissonClient redissonClient;

    /**
     * 新增商品
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean addProduct(ProductAddDTO dto) {
        // 使用 Redis 分布式锁防止并发问题
        RLock lock = redissonClient.getLock("product:name:lock:" + dto.getProductName());
        lock.lock(5, TimeUnit.SECONDS);
        try {
            LambdaQueryWrapper<Product> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(Product::getProductName, dto.getProductName());
            if (baseMapper.exists(queryWrapper)) {
                throw new BusinessException("商品名称已存在");
            }
            Product product = new Product();
            BeanUtils.copyProperties(dto, product);
            product.setStatus(1);
            return save(product);
        } finally {
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }

    /**
     * 库存扣减
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean deductStock(Long productId, Integer quantity) {
        Product product = getById(productId);
        if (product == null) {
            throw new BusinessException("商品不存在");
        }
        if (product.getStock() < quantity) {
            throw new BusinessException("库存不足");
        }
        Product updateProduct = new Product();
        updateProduct.setId(productId);
        updateProduct.setStock(product.getStock() - quantity);
        // 乐观锁版本控制
        updateProduct.setVersion(product.getVersion());
        int rows = baseMapper.updateById(updateProduct);
        if (rows == 0) {
            throw new RetryException("库存扣减冲突，请重试");
        }
        return true;
    }
}

Controller 层 API

@RestController
@RequestMapping("/api/v1/product")
@RequiredArgsConstructor
public class ProductController {
    private final ProductService productService;

    @PostMapping("/add")
    public Result<Boolean> addProduct(@Valid @RequestBody ProductAddDTO dto) {
        return Result.success(productService.addProduct(dto));
    }

    @PostMapping("/deduct-stock")
    public Result<Boolean> deductStock(@RequestParam Long productId, @RequestParam Integer quantity) {
        return Result.success(productService.deductStock(productId, quantity));
    }
}

三、订单管理模块开发

订单模块涉及高并发场景，需关注状态流转、超时关闭及事务一致性。

3.1 核心设计

• 状态机：待付款 → 已付款 → 已发货 → 已完成 → 已取消
• 分布式事务：使用 Seata 保证订单与库存的一致性
• 超时处理：基于 RocketMQ 延迟队列实现订单自动关闭

3.2 核心代码实现

Service 层逻辑

@Service
@RequiredArgsConstructor
public class OrderServiceImpl extends ServiceImpl<OrderMapper, Order> implements OrderService {
    private final ProductService productService;
    private final RocketMQTemplate rocketMQTemplate;

    /**
     * 创建订单
     */
    @Override
    @GlobalTransactional(rollbackFor = Exception.class)
    public OrderVO createOrder(OrderCreateDTO dto) {
        String orderNo = idGenerator.nextIdStr();
        boolean deductResult = productService.deductStock(dto.getProductId(), dto.getQuantity());
        if (!deductResult) {
            throw new BusinessException("库存扣减失败");
        }
        Order order = new Order();
        order.setOrderNo(orderNo);
        order.setUserId(dto.getUserId());
        order.setTotalAmount(product.getPrice().multiply(new BigDecimal(dto.getQuantity())));
        order.setOrderStatus(1); // 待付款
        save(order);
        sendOrderTimeoutMsg(orderNo);
        return convertToVO(order);
    }

    /**
     * 发送订单超时消息
     */
    private void sendOrderTimeoutMsg(String orderNo) {
        OrderTimeoutMsg msg = new OrderTimeoutMsg();
        msg.setOrderNo(orderNo);
        // 延迟级别 18 代表 30 分钟
        rocketMQTemplate.syncSend("order-timeout-topic", MessageBuilder.withPayload(msg).build(), 3000, 18);
    }

    /**
     * 订单超时关闭
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void closeOrderTimeout(String orderNo) {
        Order order = getOne(new LambdaQueryWrapper<Order>()
            .eq(Order::getOrderNo, orderNo)
            .eq(Order::getOrderStatus, 1));
        if (order != null) {
            order.setOrderStatus(5); // 已取消
            order.setCancelTime(LocalDateTime.now());
            updateById(order);
            // 恢复库存
            productService.recoverStock(order.getProductId(), orderItem.getQuantity());
            log.info("订单超时关闭，库存已恢复：{}", orderNo);
        }
    }
}

四、支付集成模块开发

支付模块需保障安全合规，支持多渠道接入及异步通知处理。

4.1 支付流程

1. 发起支付：生成支付参数（链接或二维码）
2. 回调处理：验证签名并更新订单状态
3. 主动查询：处理异步通知丢失场景
4. 退款处理：支持全额或部分退款

4.2 核心代码实现

配置类

@Configuration
@ConfigurationProperties(prefix = "pay")
@Data
public class PayConfig {
    private AlipayConfig alipay;
    private WxPayConfig wxpay;

    @Data
    public static class AlipayConfig {
        private String appId;
        private String privateKey;
        private String publicKey;
        private String notifyUrl;
        private String returnUrl;
    }
}

Service 层逻辑

@Service
@RequiredArgsConstructor
public class PayServiceImpl implements PayService {
    private final PayConfig payConfig;
    private final OrderService orderService;

    /**
     * 发起支付
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public PayVO createPay(PayCreateDTO dto) {
        Order order = orderService.getOne(new LambdaQueryWrapper<Order>()
            .eq(Order::getOrderNo, dto.getOrderNo())
            .eq(Order::getOrderStatus, 1));
        if (order == null) {
            throw new BusinessException("订单不存在或状态不允许支付");
        }
        if (dto.getPayType() == 1) {
            return createAlipay(dto, order);
        } else if (dto.getPayType() == 2) {
            return createWxPay(dto, order);
        }
        throw new BusinessException("不支持的支付方式");
    }

    /**
     * 支付宝支付参数生成
     */
    private PayVO createAlipay(PayCreateDTO dto, Order order) {
        AlipayTradePagePayRequest request = new AlipayTradePagePayRequest();
        request.setReturnUrl(payConfig.getAlipay().getReturnUrl());
        request.setNotifyUrl(payConfig.getAlipay().getNotifyUrl());
        JSONObject bizContent = new JSONObject();
        bizContent.put("out_trade_no", generatePayNo());
        bizContent.put("total_amount", order.getPayAmount().toString());
        bizContent.put("subject", "订单支付-" + order.getOrderNo());
        request.setBizContent(bizContent.toString());
        AlipayTradePagePayResponse response = alipayClient.pageExecute(request);
        if (response.isSuccess()) {
            PayVO payVO = new PayVO();
            payVO.setPayUrl(response.getBody());
            return payVO;
        }
        throw new BusinessException("支付宝支付参数生成失败");
    }

    /**
     * 支付回调处理
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public String handlePayNotify(Integer payType, Map<String, String> params) {
        boolean signValid = false;
        if (payType == 1) {
            signValid = AlipaySignature.rsaCheckV1(params, payConfig.getAlipay().getPublicKey(), "UTF-8", "RSA2");
        } else if (payType == 2) {
            signValid = wxPayService.verifyNotifySign(params);
        }
        if (!signValid) {
            log.warn("支付回调签名验证失败");
            return "fail";
        }
        String tradeNo = params.get("trade_no");
        String tradeStatus = params.get("trade_status");
        boolean paySuccess = "TRADE_SUCCESS".equals(tradeStatus);
        if (paySuccess) {
            payRecord.setPayStatus(1);
            payRecord.setTradeNo(tradeNo);
            payRecordService.updateById(payRecord);
            orderService.updateOrderStatus(payRecord.getOrderNo(), 2);
            log.info("支付成功，已更新订单状态：{}", payRecord.getOrderNo());
        }
        return payType == 1 ? "success" : "<xml><return_code><![CDATA[SUCCESS]]></return_code></xml>";
    }
}

五、总结

通过商品、订单、支付三大模块的实战开发，可以看到 AI 辅助工具在电商系统构建中的价值。它不仅提升了开发效率，还通过内置的最佳实践保障了高并发场景下的数据一致性与安全性。开发者可将更多精力聚焦于业务创新，而非重复性编码工作。