利用 AI 工具快速构建电商系统核心模块（商品、购物车、订单）

连"CHECK 约束（价格/库存不能为负）''冗余字段（订单项存商品名称）'这种细节都考虑到了。

第二步：接口设计 + 代码生成

表结构搞定后，AI 会自动生成接口方案和全套代码（实体类、Mapper、Service、Controller）。我挑几个核心接口给大家展示，代码都是 AI 生成的，我只改了点注释：

1. 商品管理核心接口（Controller 层）

package com.example.ecommerce.controller;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.example.ecommerce.common.Result;
import com.example.ecommerce.entity.Product;
import com.example.ecommerce.service.ProductService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import java.util.List;

/**
 * 商品管理接口
 * 由 AI 自动生成，可根据需求调整
 */
@RestController
@RequestMapping("/api/product")
@Slf4j
public class ProductController {
    @Resource
    private ProductService productService;

    /**
     * 新增商品
     * @param product 商品信息（含 name、price、stock 等）
     */
    @PostMapping("/add")
    public Result<?> addProduct(@RequestBody Product product) {
        // AI 自动生成的参数校验逻辑
        if (product.getPrice().compareTo(BigDecimal.ZERO) < 0) {
            return Result.fail("商品价格不能为负");
        }
        if (product.getStock() < 0) {
            return Result.fail("商品库存不能为负");
        }
        // 默认为上架状态（status=1）
        product.setStatus(1);
        boolean success = productService.save(product);
        if (success) {
            log.info("新增商品成功，商品 ID：{}", product.getId());
            return Result.success("新增商品成功", product.getId());
        }
        return Result.fail("新增商品失败");
    }

    /**
     * 商品列表查询（支持模糊查 + 排序 + 分页）
     * @param productName 商品名称（模糊匹配，可为空）
     * @param pageNum 页码（默认 1）
     * @param pageSize 每页条数（默认 10）
     * @param sortField 排序字段（默认 id）
     * @param sortType 排序类型（asc=升序，desc=降序，默认 desc）
     */
    @GetMapping("/list")
    public Result<?> getProductList(@RequestParam(required = false) String productName,
                                    @RequestParam(defaultValue = "1") Integer pageNum,
                                    @RequestParam(defaultValue = "10") Integer pageSize,
                                    @RequestParam(defaultValue = "id") String sortField,
                                    @RequestParam(defaultValue = "desc") String sortType) {
        // AI 自动生成的分页查询逻辑
        Page<Product> page = new Page<>(pageNum, pageSize);
        List<Product> productList = productService.getProductList(page, productName, sortField, sortType);
        page.setRecords(productList);
        log.info("查询商品列表成功，页码：{}，条数：{}", pageNum, productList.size());
        return Result.success("查询成功", page);
    }

    /**
     * 商品上下架
     * @param productId 商品 ID
     * @param status 目标状态（1=上架，0=下架）
     */
    @PutMapping("/status")
    public Result<?> updateProductStatus(@RequestParam Long productId, @RequestParam Integer status) {
        if (!status.equals(0) && !status.equals(1)) {
            return Result.fail("状态只能是 0（下架）或 1（上架）");
        }
        Product product = new Product();
        product.setId(productId);
        product.setStatus(status);
        boolean success = productService.updateById(product);
        if (success) {
            String msg = status == 1 ? "商品上架成功" : "商品下架成功";
            log.info(msg + "，商品 ID：{}", productId);
            return Result.success(msg);
        }
        return Result.fail("修改商品状态失败，商品不存在");
    }
}

2. 购物车核心接口（用 Redis 存储，AI 自动生成 Redis 操作逻辑）

package com.example.ecommerce.controller;

import com.example.ecommerce.common.Result;
import com.example.ecommerce.entity.vo.CartVO;
import com.example.ecommerce.service.CartService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.HashMap;
import java.util.List;

/**
 * 购物车接口（Redis 存储）
 * 由 AI 自动生成，可根据需求调整
 */
@RestController
@RequestMapping("/api/cart")
@Slf4j
public class CartController {
    @Resource
    private CartService cartService;

    /**
     * 添加商品到购物车
     * @param userId 用户 ID
     * @param productId 商品 ID
     * @param buyNum 购买数量
     */
    @PostMapping("/add")
    public Result<?> addToCart(@RequestParam Long userId, @RequestParam Long productId, @RequestParam Integer buyNum) {
        // AI 自动生成的业务校验：商品是否存在 + 上架 + 库存足够
        String checkMsg = cartService.checkBeforeAdd(userId, productId, buyNum);
        if (checkMsg != null) {
            return Result.fail(checkMsg);
        }
        // 添加到 Redis 购物车
        boolean success = cartService.addCart(userId, productId, buyNum);
        if (success) {
            log.info("添加商品到购物车成功，用户 ID：{}，商品 ID：{}", userId, productId);
            return Result.success("添加购物车成功");
        }
        return Result.fail("添加购物车失败");
    }

    /**
     * 查询用户购物车列表（含小计 + 总价）
     * @param userId 用户 ID
     */
    @GetMapping("/list")
    public Result<?> getCartList(@RequestParam Long userId) {
        List<CartVO> cartVOList = cartService.getCartList(userId);
        // 计算购物车总价
        BigDecimal totalAmount = cartVOList.stream().map(CartVO::getSubtotal).reduce(BigDecimal.ZERO, BigDecimal::add);
        // 封装返回结果（列表 + 总价）
        HashMap<String, Object> resultData = new HashMap<>();
        resultData.put("cartList", cartVOList);
        resultData.put("totalAmount", totalAmount);
        return Result.success("查询购物车成功", resultData);
    }

    /**
     * 修改购物车商品数量
     * @param userId 用户 ID
     * @param productId 商品 ID
     * @param newNum 新数量
     */
    @PutMapping("/num")
    public Result<?> updateCartNum(@RequestParam Long userId, @RequestParam Long productId, @RequestParam Integer newNum) {
        if (newNum <= 0) {
            return Result.fail("数量不能小于等于 0");
        }
        // 校验库存是否足够
        String checkMsg = cartService.checkStock(productId, newNum);
        if (checkMsg != null) {
            return Result.fail(checkMsg);
        }
        boolean success = cartService.updateCartNum(userId, productId, newNum);
        if (success) {
            log.info("修改购物车数量成功，用户 ID：{}，商品 ID：{}，新数量：{}", userId, productId, newNum);
            return Result.success("修改数量成功");
        }
        return Result.fail("修改数量失败，商品不在购物车中");
    }
}

3. 订单核心接口（含库存扣减 + 幂等校验）

package com.example.ecommerce.controller;

import com.example.ecommerce.common.Result;
import com.example.ecommerce.entity.OrderInfo;
import com.example.ecommerce.entity.vo.OrderDetailVO;
import com.example.ecommerce.service.OrderService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import java.util.List;

/**
 * 订单接口
 * 由 AI 自动生成，可根据需求调整
 */
@RestController
@RequestMapping("/api/order")
@Slf4j
public class OrderController {
    @Resource
    private OrderService orderService;

    /**
     * 创建订单（从购物车选商品生成）
     * @param userId 用户 ID
     * @param productIds 选中的商品 ID 列表（逗号分隔，如"1,2,3"）
     */
    @PostMapping("/create")
    public Result<?> createOrder(@RequestParam Long userId, @RequestParam String productIds) {
        // 防重复提交：生成请求唯一标识（实际项目可存在 Redis，设置 5 分钟过期）
        String requestId = userId + "_" + System.currentTimeMillis();
        boolean isRepeat = orderService.checkRepeatRequest(requestId);
        if (isRepeat) {
            return Result.fail("请勿重复提交订单");
        }
        try {
            // AI 自动生成的订单创建逻辑：查购物车→算总价→扣库存→生成订单→清购物车
            String orderNo = orderService.createOrder(userId, productIds);
            log.info("创建订单成功，用户 ID：{}，订单编号：{}", userId, orderNo);
            return Result.success("创建订单成功", orderNo);
        } catch (Exception e) {
            log.error("创建订单失败，用户 ID：{}，错误信息：{}", userId, e.getMessage());
            return Result.fail("创建订单失败：" + e.getMessage());
        }
    }

    /**
     * 查询订单列表
     * @param userId 用户 ID
     * @param pageNum 页码（默认 1）
     * @param pageSize 每页条数（默认 10）
     */
    @GetMapping("/list")
    public Result<?> getOrderList(@RequestParam Long userId, @RequestParam(defaultValue = "1") Integer pageNum, @RequestParam(defaultValue = "10") Integer pageSize) {
        List<OrderInfo> orderList = orderService.getOrderList(userId, pageNum, pageSize);
        log.info("查询订单列表成功，用户 ID：{}，订单数量：{}", userId, orderList.size());
        return Result.success("查询订单列表成功", orderList);
    }

    /**
     * 查询订单明细
     * @param orderNo 订单编号
     * @param userId 用户 ID（校验订单归属，防止查别人的订单）
     */
    @GetMapping("/detail")
    public Result<?> getOrderDetail(@RequestParam String orderNo, @RequestParam Long userId) {
        OrderDetailVO orderDetail = orderService.getOrderDetail(orderNo, userId);
        if (orderDetail == null) {
            return Result.fail("订单不存在或无权限查看");
        }
        return Result.success("查询订单明细成功", orderDetail);
    }

    /**
     * 修改订单支付状态
     * @param orderNo 订单编号
     * @param userId 用户 ID
     * @param payStatus 目标支付状态（1=已支付，2=已取消）
     */
    @PutMapping("/payStatus")
    public Result<?> updatePayStatus(@RequestParam String orderNo, @RequestParam Long userId, @RequestParam Integer payStatus) {
        // 校验支付状态合法性
        if (!payStatus.equals(1) && !payStatus.equals(2)) {
            return Result.fail("支付状态只能是 1（已支付）或 2（已取消）");
        }
        // 校验订单归属 + 当前状态（待付款才能改）
        String checkMsg = orderService.checkOrderBeforeUpdate(orderNo, userId);
        if (checkMsg != null) {
            return Result.fail(checkMsg);
        }
        boolean success = orderService.updatePayStatus(orderNo, payStatus);
        if (success) {
            String msg = payStatus == 1 ? "订单支付成功" : "订单取消成功";
            log.info("{}，订单编号：{}，用户 ID：{}", msg, orderNo, userId);
            return Result.success(msg);
        }
        return Result.fail("修改支付状态失败");
    }
}

4. 核心 Service 层代码（AI 生成，含业务逻辑）

以订单创建为例，AI 自动处理了'库存扣减''事务管理''订单编号生成'等关键逻辑：

package com.example.ecommerce.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.example.ecommerce.entity.*;
import com.example.ecommerce.entity.vo.CartVO;
import com.example.ecommerce.entity.vo.OrderDetailVO;
import com.example.ecommerce.mapper.*;
import com.example.ecommerce.service.CartService;
import com.example.ecommerce.service.OrderService;
import com.example.ecommerce.service.ProductService;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.List;
import java.util.Random;
import java.util.concurrent.TimeUnit;

/**
 * 订单服务实现类
 * 由 AI 自动生成，可根据需求调整
 */
@Service
public class OrderServiceImpl implements OrderService {
    @Resource
    private OrderInfoMapper orderInfoMapper;
    @Resource
    private OrderItemMapper orderItemMapper;
    @Resource
    private ProductMapper productMapper;
    @Resource
    private CartService cartService;
    @Resource
    private RedisTemplate<String, Object> redisTemplate;

    /**
     * 创建订单（事务保证：扣库存 + 生成订单 + 清购物车要么全成，要么全失败）
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public String createOrder(Long userId, String productIds) {
        // 1. 查询用户购物车中选中的商品
        List<CartVO> cartVOList = cartService.getCheckedCartList(userId, productIds);
        if (cartVOList.isEmpty()) {
            throw new RuntimeException("购物车中无选中商品");
        }
        // 2. 计算订单总金额
        BigDecimal totalAmount = cartVOList.stream()
                .map(CartVO::getSubtotal)
                .reduce(BigDecimal.ZERO, BigDecimal::add);
        // 3. 生成唯一订单编号（格式：YYYYMMDDHHMMSS+6 位随机数）
        String orderNo = generateOrderNo();
        // 4. 扣减商品库存（加行锁防止超卖：SELECT ... FOR UPDATE）
        for (CartVO cartVO : cartVOList) {
            Long productId = cartVO.getProductId();
            Integer buyNum = cartVO.getBuyNum();
            // 查询商品并加锁
            Product product = productMapper.selectByIdForUpdate(productId);
            if (product == null || product.getStatus() == 0) {
                throw new RuntimeException("商品" + cartVO.getProductName() + "已下架或不存在");
            }
            if (product.getStock() < buyNum) {
                throw new RuntimeException("商品" + cartVO.getProductName() + "库存不足，当前库存：" + product.getStock());
            }
            // 扣减库存
            Product updateProduct = new Product();
            updateProduct.setId(productId);
            updateProduct.setStock(product.getStock() - buyNum);
            productMapper.updateById(updateProduct);
        }
        // 5. 插入订单表
        OrderInfo orderInfo = new OrderInfo();
        orderInfo.setOrderNo(orderNo);
        orderInfo.setUserId(userId);
        orderInfo.setTotalAmount(totalAmount);
        orderInfo.setPayStatus(0); // 0=待付款
        orderInfo.setOrderStatus(0); // 0=待发货
        orderInfo.setCreateTime(LocalDateTime.now());
        orderInfoMapper.insert(orderInfo);
        // 6. 插入订单项表
        for (CartVO cartVO : cartVOList) {
            OrderItem orderItem = new OrderItem();
            orderItem.setOrderId(orderInfo.getId());
            orderItem.setOrderNo(orderNo);
            orderItem.setProductId(cartVO.getProductId());
            orderItem.setProductName(cartVO.getProductName());
            orderItem.setProductPrice(cartVO.getProductPrice());
            orderItem.setBuyNum(cartVO.getBuyNum());
            orderItem.setCreateTime(LocalDateTime.now());
            orderItemMapper.insert(orderItem);
        }
        // 7. 清空购物车中已下单的商品
        cartService.clearCheckedCart(userId, productIds);
        return orderNo;
    }

    /**
     * 生成唯一订单编号
     */
    private String generateOrderNo() {
        // 时间戳部分：YYYYMMDDHHMMSS
        String timeStr = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMddHHmmss"));
        // 随机数部分：6 位随机数
        String randomStr = String.format("%06d", new Random().nextInt(1000000));
        return timeStr + randomStr;
    }

    /**
     * 防重复提交校验
     */
    @Override
    public boolean checkRepeatRequest(String requestId) {
        String redisKey = "order:repeat:" + requestId;
        // 如果 Redis 中已存在，说明是重复请求
        if (Boolean.TRUE.equals(redisTemplate.hasKey(redisKey))) {
            return true;
        }
        // 不存在则存入 Redis，设置 5 分钟过期
        redisTemplate.opsForValue().set(redisKey, "1", 5, TimeUnit.MINUTES);
        return false;
    }
    // 其他方法（getOrderList、getOrderDetail、updatePayStatus 等）省略，AI 会自动生成完整实现
}

第三步：系统测试 + 优化

1. 接口测试（用 Postman 快速验证）

AI 生成代码后，我们只需要启动项目，用 Postman 调用接口测试即可。以'添加商品到购物车'为例：

• 请求地址：http://localhost:8080/api/cart/add
• 请求方式：POST
• 请求参数：userId=1&productId=1&buyNum=2
• 成功响应：

{
  "code": 200,
  "msg": "添加购物车成功",
  "data": null
}

如果参数有误（比如 buyNum=100，而商品库存只有 10），AI 生成的异常处理会返回明确提示：

{
  "code": 500,
  "msg": "添加购物车失败：商品 iPhone 15 Pro 库存不足，当前库存：10",
  "data": null
}

2. AI 自动提优化建议

测试过程中，我在 AI 工具里问了句'这个电商系统还有哪些可以优化的地方？'，AI 立马给出了 3 个实用建议：

1. 库存预热：高并发场景下，可把热门商品库存缓存到 Redis，减少数据库访问（附 Redis 缓存库存的代码示例）。
2. 订单超时取消：用定时任务（如 Quartz）扫描超过 30 分钟未支付的订单，自动改为'已取消'并恢复库存（附定时任务代码）。
3. 接口限流：给'创建订单'接口加限流（如每个用户每分钟最多创建 5 个订单），防止恶意请求（附 Redis 限流代码）。

比如 AI 生成的'订单超时取消'定时任务代码：

package com.example.ecommerce.task;

import com.example.ecommerce.entity.OrderInfo;
import com.example.ecommerce.mapper.OrderInfoMapper;
import com.example.ecommerce.mapper.ProductMapper;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
import java.time.LocalDateTime;
import java.util.List;

/**
 * 订单超时取消定时任务
 * 由 AI 自动生成（优化建议配套代码）
 */
@Component
public class OrderTimeoutTask {
    @Resource
    private OrderInfoMapper orderInfoMapper;
    @Resource
    private ProductMapper productMapper;

    /**
     * 每 5 分钟执行一次：查询超过 30 分钟未支付的订单，改为已取消并恢复库存
     */
    @Scheduled(cron = "0 0/5 * * * ?")
    @Transactional(rollbackFor = Exception.class)
    public void cancelTimeoutOrder() {
        // 查询条件：待付款（payStatus=0）+ 创建时间超过 30 分钟
        LocalDateTime timeoutTime = LocalDateTime.now().minusMinutes(30);
        List<OrderInfo> timeoutOrders = orderInfoMapper.selectTimeoutOrders(0, timeoutTime);
        for (OrderInfo order : timeoutOrders) {
            // 1. 修改订单状态为已取消
            order.setPayStatus(2);
            order.setUpdateTime(LocalDateTime.now());
            orderInfoMapper.updateById(order);
            // 2. 恢复商品库存（从订单项表查购买数量）
            List<OrderItem> orderItems = orderItemMapper.selectByOrderId(order.getId());
            for (OrderItem item : orderItems) {
                Product product = productMapper.selectById(item.getProductId());
                product.setStock(product.getStock() + item.getBuyNum());
                productMapper.updateById(product);
            }
            System.out.println("取消超时订单，订单编号：" + order.getOrderNo());
        }
    }
}

四、总结

回顾整个开发过程，我只做了 3 件事：

1. 跟 AI'唠嗑'，把需求说清楚（10 分钟）；
2. 复制 AI 生成的 SQL 建表（5 分钟）；
3. 用 Postman 测试接口，改了 2 处注释（15 分钟）。

剩下的 90% 工作（表结构设计、代码编写、异常处理、优化建议）全是 AI 搞定的，前后加起来不到 3 小时 —— 要是搁以前，我至少得熬 3 个晚上，还得担心库存超卖、重复下单这些 bug。

现在的开发早就不是'比谁代码写得快'，而是'比谁能用好工具'。AI 这种工具就像给你配了个'全能开发助手'，让你不用再死磕重复代码，把精力放在更有价值的业务设计上。