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

利用 AI 工具快速构建电商系统核心模块

以前听说要做电商系统，光是'商品管理'、'订单流程'、'购物车计算'这几个词，就够啃一周文档。但自从使用了AI 辅助开发工具，我发现开发效率能显著提升：不用死磕 SQL，不用纠结逻辑，甚至不用写重复代码，AI 直接把'半成品'喂到嘴边，我只需要做'选择题'。

今天就带大家手把手用 AI 工具开发电商 3 大核心模块：商品管理（上架/搜索/库存）、购物车（加购/改数量/算总价）、订单系统（下单/改状态/查明细），全程不踩坑，代码复制就能跑。

一、AI 辅助开发的优势

在开始前，先解答大家最关心的问题：AI 到底能帮我们做啥？举个例子：以前写商品列表接口，你得先设计表结构、写实体类、写 Mapper、写 Service、写 Controller，一套下来 2 小时起步；现在用 AI 工具，你只需要说一句'我要商品列表接口，支持按名称模糊查、按价格排序'，AI 直接把全套代码生成好，你改改数据库配置就能用。

这类工具的优势主要有 3 个：

懂业务：你说'电商购物车要支持跨设备同步'，它知道要用 Redis 存；你说'订单要防止重复提交'，它自动加幂等校验。
代码规范：生成的代码自带注释、异常处理、日志记录，比资深开发写的还规整。
可修改：生成的代码不是'死的'，你说'我要给订单加个优惠券字段'，它立马帮你改实体类、表结构、接口逻辑。

二、环境准备

先把基础环境搞定，简单得很：

1. 安装 AI 插件

以 IDEA 插件为例，安装步骤跟装普通插件一样简单：

打开 IDEA → 点击"File"→"Settings"→"Plugins"
在搜索框搜对应 AI 插件 → 点击"Install" → 重启 IDEA
打开插件后注册登录，选'智能引导模式'（新手首选，跟着走不迷路）

2. 明确需求

不用写复杂的 PRD 文档，就像跟朋友吐槽需求一样，把你想要的功能说清楚。我当时是这么跟 AI 说的（直接复制到插件输入框里）：

我要开发电商系统的 3 个核心模块，具体需求如下：
1. 商品管理模块：
   - 功能：商品新增（名称、价格、库存、分类 ID、图片 URL）、商品列表查询（支持按名称模糊查、按价格排序、分页）、商品详情查询（按 ID 查）、商品上下架（改 status 字段）
   - 约束：价格不能为负、库存不能为负、新增商品时 status 默认 1（上架）
2. 购物车模块：
   - 功能：添加商品到购物车（用户 ID、商品 ID、数量）、修改购物车商品数量、删除购物车商品、查询用户购物车列表（显示商品名称、价格、数量、小计）、计算购物车总价
   - 约束：添加时要校验商品是否存在 + 是否上架 + 库存是否足够、修改数量时不能超过商品库存
3. 订单模块：
   - 功能：创建订单（从购物车选商品生成订单，生成唯一订单编号）、查询订单列表（按用户 ID 查，显示订单编号、总金额、支付状态）、查询订单明细（显示每个商品的名称、数量、单价）、修改订单支付状态（待付款→已支付/已取消）
   - 约束：创建订单时要扣减商品库存、防止重复下单（按订单编号幂等）、未支付订单不能改发货状态
技术要求：
   - 后端：Spring Boot 2.7.x + MyBatis Plus 3.5.x + MySQL 8.0 + Redis 6.x（购物车用 Redis 存）
   - 接口：RESTful 风格，返回格式统一（code+msg+data），支持分页（pageNum/pageSize）
   - 其他：异常处理（比如'商品不存在'返回明确提示）、日志记录（用 Slf4j）

写完直接点'提交需求'，AI 会秒回'正在分析需求'。

三、实战：3 步生成电商核心功能

第一步：需求分析 + 表结构设计

提交需求后，AI 会先帮你拆解需求，生成'功能关系图'，然后自动设计数据库表结构。我生成的 3 张核心表 SQL 如下（直接复制到 MySQL 执行，无语法错误）：

-- 1. 商品表（product）
CREATE TABLE product (
  id BIGINT PRIMARY KEY AUTO_INCREMENT COMMENT '商品 ID',
  product_name VARCHAR(255) NOT NULL COMMENT '商品名称（如"iPhone 15 Pro"）',
  price DECIMAL(10,2) NOT NULL CHECK(price >=0) COMMENT '商品价格（单位：元，不能为负）',
  stock INT NOT NULL DEFAULT 0 CHECK(stock >=0) COMMENT '库存数量（不能为负）',
  category_id BIGINT NOT NULL COMMENT '商品分类 ID（关联分类表，此处简化暂不建）',
  product_img VARCHAR(512) COMMENT '商品图片 URL',
  status TINYINT NOT NULL DEFAULT 1 COMMENT '商品状态（1=上架，0=下架）',
  create_time DATETIME DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  update_time DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  INDEX idx_product_name (product_name), -- 名称模糊查索引
  INDEX idx_category_id (category_id) -- 分类查索引
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='商品表';

-- 2. 订单表（order_info）
CREATE TABLE order_info (
  id BIGINT PRIMARY KEY AUTO_INCREMENT COMMENT '订单 ID',
  order_no VARCHAR(64) NOT NULL UNIQUE COMMENT '订单编号（唯一，格式：YYYYMMDDHHMMSS+ 随机 6 位）',
  user_id BIGINT NOT NULL COMMENT '用户 ID',
  total_amount DECIMAL(10,2) NOT NULL COMMENT '订单总金额（单位：元）',
  pay_status TINYINT NOT NULL DEFAULT 0 COMMENT '支付状态（0=待付款，1=已支付，2=已取消）',
  order_status TINYINT NOT NULL DEFAULT 0 COMMENT '订单状态（0=待发货，1=已发货，2=已完成）',
  create_time DATETIME DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  pay_time DATETIME COMMENT '支付时间',
  update_time DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  INDEX idx_user_id (user_id), -- 按用户查订单索引
  INDEX idx_order_no (order_no) -- 按订单号查索引
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='订单表';

-- 3. 订单项表（order_item）—— 存订单里的商品明细
CREATE TABLE order_item (
  id BIGINT PRIMARY KEY AUTO_INCREMENT COMMENT '订单项 ID',
  order_id BIGINT NOT NULL COMMENT '关联订单 ID（关联 order_info.id）',
  order_no VARCHAR(64) NOT NULL COMMENT '关联订单编号（冗余字段，方便查询）',
  product_id BIGINT NOT NULL COMMENT '商品 ID（关联 product.id）',
  product_name VARCHAR(255) NOT NULL COMMENT '商品名称（冗余，避免查商品表）',
  product_price DECIMAL(10,2) NOT NULL COMMENT '商品购买时的价格（冗余，防止价格变动）',
  buy_num INT NOT NULL COMMENT '购买数量',
  create_time DATETIME DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  INDEX idx_order_id (order_id), -- 按订单查明细索引
  INDEX idx_product_id (product_id) -- 按商品查订单索引
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='订单项表';

连"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());
        }
         Result.fail();
    }

    
    
     Result<?> getProductList( String productName,
                                     Integer pageNum,
                                     Integer pageSize,
                                     String sortField,
                                     String sortType) {
        
        Page<Product> page =  <>(pageNum, pageSize);
        List<Product> productList = productService.getProductList(page, productName, sortField, sortType);
        page.setRecords(productList);
        log.info(, pageNum, productList.size());
         Result.success(, page);
    }

    
    
     Result<?> updateProductStatus( Long productId,  Integer status) {
         (!status.equals() && !status.equals()) {
             Result.fail();
        }
            ();
        product.setId(productId);
        product.setStatus(status);
           productService.updateById(product);
         (success) {
               status ==  ?  : ;
            log.info(msg + , productId);
             Result.success(msg);
        }
         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);
             Result.success();
        }
         Result.fail();
    }

    
    
     Result<?> getCartList( Long userId) {
        List<CartVO> cartVOList = cartService.getCartList(userId);
        
           cartVOList.stream().map(CartVO::getSubtotal).reduce(BigDecimal.ZERO, BigDecimal::add);
        
        HashMap<String, Object> resultData =  <>();
        resultData.put(, cartVOList);
        resultData.put(, totalAmount);
         Result.success(, resultData);
    }

    
    
     Result<?> updateCartNum( Long userId,  Long productId,  Integer newNum) {
         (newNum <= ) {
             Result.fail();
        }
        
           cartService.checkStock(productId, newNum);
         (checkMsg != ) {
             Result.fail(checkMsg);
        }
           cartService.updateCartNum(userId, productId, newNum);
         (success) {
            log.info(, userId, productId, newNum);
             Result.success();
        }
         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(, userId, orderNo);
             Result.success(, orderNo);
        }  (Exception e) {
            log.error(, userId, e.getMessage());
             Result.fail( + e.getMessage());
        }
    }

    
    
     Result<?> getOrderList( Long userId,  Integer pageNum,  Integer pageSize) {
        List<OrderInfo> orderList = orderService.getOrderList(userId, pageNum, pageSize);
        log.info(, userId, orderList.size());
         Result.success(, orderList);
    }

    
    
     Result<?> getOrderDetail( String orderNo,  Long userId) {
           orderService.getOrderDetail(orderNo, userId);
         (orderDetail == ) {
             Result.fail();
        }
         Result.success(, orderDetail);
    }

    
    
     Result<?> updatePayStatus( String orderNo,  Long userId,  Integer payStatus) {
        
         (!payStatus.equals() && !payStatus.equals()) {
             Result.fail();
        }
        
           orderService.checkOrderBeforeUpdate(orderNo, userId);
         (checkMsg != ) {
             Result.fail(checkMsg);
        }
           orderService.updatePayStatus(orderNo, payStatus);
         (success) {
               payStatus ==  ?  : ;
            log.info(, msg, orderNo, userId);
             Result.success(msg);
        }
         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)
     String  {
        
        List<CartVO> cartVOList = cartService.getCheckedCartList(userId, productIds);
         (cartVOList.isEmpty()) {
              ();
        }
        
           cartVOList.stream()
                .map(CartVO::getSubtotal)
                .reduce(BigDecimal.ZERO, BigDecimal::add);
        
           generateOrderNo();
        
         (CartVO cartVO : cartVOList) {
               cartVO.getProductId();
               cartVO.getBuyNum();
            
               productMapper.selectByIdForUpdate(productId);
             (product ==  || product.getStatus() == ) {
                  ( + cartVO.getProductName() + );
            }
             (product.getStock() < buyNum) {
                  ( + cartVO.getProductName() +  + product.getStock());
            }
            
                ();
            updateProduct.setId(productId);
            updateProduct.setStock(product.getStock() - buyNum);
            productMapper.updateById(updateProduct);
        }
        
            ();
        orderInfo.setOrderNo(orderNo);
        orderInfo.setUserId(userId);
        orderInfo.setTotalAmount(totalAmount);
        orderInfo.setPayStatus(); 
        orderInfo.setOrderStatus(); 
        orderInfo.setCreateTime(LocalDateTime.now());
        orderInfoMapper.insert(orderInfo);
        
         (CartVO cartVO : cartVOList) {
                ();
            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);
        }
        
        cartService.clearCheckedCart(userId, productIds);
         orderNo;
    }

    
     String  {
        
           LocalDateTime.now().format(DateTimeFormatter.ofPattern());
        
           String.format(,  ().nextInt());
         timeStr + randomStr;
    }

    
    
       {
            + requestId;
        
         (Boolean.TRUE.equals(redisTemplate.hasKey(redisKey))) {
             ;
        }
        
        redisTemplate.opsForValue().set(redisKey, , , TimeUnit.MINUTES);
         ;
    }
    
}

第三步：系统测试 + 优化

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 个实用建议：

库存预热：高并发场景下，可把热门商品库存缓存到 Redis，减少数据库访问（附 Redis 缓存库存的代码示例）。
订单超时取消：用定时任务（如 Quartz）扫描超过 30 分钟未支付的订单，自动改为'已取消'并恢复库存（附定时任务代码）。
接口限流：给'创建订单'接口加限流（如每个用户每分钟最多创建 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) {
                   productMapper.selectById(item.getProductId());
                product.setStock(product.getStock() + item.getBuyNum());
                productMapper.updateById(product);
            }
            System.out.println( + order.getOrderNo());
        }
    }
}

四、总结

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

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

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

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

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