使用 AI 辅助开发 Java 电商系统核心模块实战

在电商系统开发中，商品管理、订单流程和购物车计算通常是核心且复杂的模块。借助 AI 编程助手，可以显著提升开发效率，减少重复代码编写。

本文将介绍如何利用 AI 工具快速开发电商系统的三大核心模块：商品管理（上架/搜索/库存）、购物车（加购/改数量/算总价）、订单系统（下单/改状态/查明细）。

一、AI 开发工具的优势

传统开发流程中，编写商品列表接口需要设计表结构、写实体类、Mapper、Service、Controller，耗时较长。使用 AI 编程助手后，只需描述需求，即可生成全套代码，大幅缩短开发周期。

主要优势包括：

懂业务：能理解如'跨设备同步'、'防止重复提交'等业务逻辑并自动实现。
代码规范：生成的代码自带注释、异常处理和日志记录。
可修改：支持根据需求调整实体类、表结构和接口逻辑。

二、环境准备

确保基础环境就绪：

JDK 8+
IDEA 编辑器
MySQL 8.0
Redis 6.x
Spring Boot 2.7.x + MyBatis Plus 3.5.x

安装 AI 插件或配置好本地 AI 服务，登录后可开启智能引导模式。

三、需求分析与表结构设计

向 AI 描述具体需求，例如：'我要开发电商系统的 3 个核心模块，包含商品新增、列表查询、购物车操作、订单创建等'。AI 会拆解需求并生成数据库表结构。

以下是生成的核心表 SQL：

-- 1. 商品表（product）
CREATE TABLE product (
 id BIGINT PRIMARY KEY AUTO_INCREMENT COMMENT '商品 ID',
 product_name VARCHAR(255) NOT NULL COMMENT '商品名称',
 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 '订单编号',
 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_no VARCHAR(64) NOT NULL COMMENT '关联订单编号',
 product_id BIGINT NOT NULL COMMENT '商品 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='订单项表';

四、接口设计与代码生成

表结构确认后，AI 可自动生成 Controller、Service、Mapper 层代码。

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;

@RestController
@RequestMapping("/api/product")
@Slf4j
public class ProductController {
    @Resource
    private ProductService productService;

    /**
     * 新增商品
     */
    @PostMapping("/add")
    public Result<?> addProduct(@RequestBody Product product) {
        if (product.getPrice().compareTo(java.math.BigDecimal.ZERO) < 0) {
            return Result.fail("商品价格不能为负");
        }
        if (product.getStock() < 0) {
            return Result.fail("商品库存不能为负");
        }
        product.setStatus(1);
        boolean success = productService.save(product);
        if (success) {
            log.info("新增商品成功，商品 ID：{}", product.getId());
            return Result.success("新增商品成功", product.getId());
        }
        return Result.fail("新增商品失败");
    }

    /**
     * 商品列表查询
     */
    @GetMapping("/list")
     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 存储）

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;
import java.util.Map;

@RestController
@RequestMapping("/api/cart")
@Slf4j
public class CartController {
    @Resource
    private CartService cartService;

    /**
     * 添加商品到购物车
     */
    @PostMapping("/add")
    public Result<?> addToCart(@RequestParam Long userId, @RequestParam Long productId, @RequestParam Integer buyNum) {
        String checkMsg = cartService.checkBeforeAdd(userId, productId, buyNum);
        if (checkMsg != null) {
            return Result.fail(checkMsg);
        }
        boolean success = cartService.addCart(userId, productId, buyNum);
        if (success) {
            log.info("添加购物车成功，用户 ID：{}，商品 ID：{}", userId, productId);
            return Result.success("添加购物车成功");
        }
        return Result.fail("添加购物车失败");
    }

    /**
     * 查询用户购物车列表
     */
    @GetMapping("/list")
     Result<?> getCartList( Long userId) {
        List<CartVO> cartVOList = cartService.getCartList(userId);
           cartVOList.stream()
                .map(CartVO::getSubtotal)
                .reduce(BigDecimal.ZERO, BigDecimal::add);
        Map<String, Object> data =  <>();
        data.put(, cartVOList);
        data.put(, totalAmount);
         Result.success(, data);
    }

    
    
     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;

@RestController
@RequestMapping("/api/order")
@Slf4j
public class OrderController {
    @Resource
    private OrderService orderService;

    /**
     * 创建订单
     */
    @PostMapping("/create")
    public Result<?> createOrder(@RequestParam Long userId, @RequestParam String productIds) {
        String requestId = userId + "_" + System.currentTimeMillis();
        boolean isRepeat = orderService.checkRepeatRequest(requestId);
        if (isRepeat) {
            return Result.fail("请勿重复提交订单");
        }
        try {
            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());
        }
    }

    
    
     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 自动处理了事务管理、库存扣减和订单编号生成。

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.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;

@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) {
        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() + );
            }
                ();
            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 验证接口。例如调用 POST /api/cart/add，传入 userId, productId, buyNum。若参数异常，AI 生成的异常处理逻辑会返回明确提示。

2. 常见优化方向

通过 AI 分析，可进一步提出以下优化建议：

库存预热：高并发场景下，将热门商品库存缓存至 Redis。
订单超时取消：使用定时任务扫描未支付订单，自动取消并恢复库存。
接口限流：对创建订单接口增加限流保护，防止恶意请求。

六、总结

利用 AI 辅助开发，可将原本需要数天的工作压缩至几小时内完成。开发者只需专注于需求梳理和结果验证，AI 负责生成规范的代码、处理边界条件和提供优化建议。这种模式不仅提升了效率，也降低了技术门槛，适合快速构建电商系统等复杂业务场景。

使用 AI 辅助开发 Java 电商系统核心模块实战