基于 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 层核心逻辑

@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 || 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);

        // 发送延迟消息（30 分钟超时关闭）
        sendOrderTimeoutMsg(orderNo);
        return convertToVO(order);
    }

    /**
     * 订单超时关闭
     */
    @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); // 已取消
            updateById(order);
            productService.recoverStock(order.getId(), order.getQuantity());
        }
    }
}

四、支付集成模块开发

支付模块需保障资金安全与合规，支持多渠道接入。

4.1 配置类

@Configuration
@ConfigurationProperties(prefix = "pay")
@Data
public class PayConfig {
    @Data
    public static class AlipayConfig {
        private String appId;
        private String privateKey;
        private String publicKey;
        private String notifyUrl;
    }
    @Data
    public static class WxPayConfig {
        private String appId;
        private String mchId;
        private String mchKey;
        private String notifyUrl;
    }
    private AlipayConfig alipay;
    private WxPayConfig wxpay;
}

4.2 支付服务逻辑

@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(payRecord, order);
        } else if (dto.getPayType() == 2) {
            return createWxPay(payRecord, order);
        }
        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, ...);
        } else if (payType == 2) {
            signValid = wxPayService.verifyNotifySign(params);
        }
        if (!signValid) return "fail";

        String payNo = params.get("out_trade_no");
        // 更新支付记录与订单状态
        return payType == 1 ? "success" : "<xml><return_code><![CDATA[SUCCESS]]></return_code></xml>";
    }
}

五、技术总结

本次实战涵盖了电商系统的核心链路，关键技术点总结如下：

1. 高并发防护：库存扣减采用 Redis 分布式锁配合 MyBatis-Plus 乐观锁，有效防止超卖。
2. 数据一致性：订单创建与库存扣减通过 Seata 分布式事务保证跨服务数据一致。
3. 可靠性保障：利用 RocketMQ 延迟队列处理订单超时自动关闭，避免死锁或资损。
4. 安全合规：支付回调严格验证签名，敏感数据脱敏，遵循 PCI DSS 规范。

通过合理的架构设计与工具辅助，可显著降低开发成本，提升系统稳定性与可维护性。