SpringBoot食品仓库管理系统开发实战

1. 项目概述

食品仓库管理系统是餐饮连锁、生鲜电商、食品加工等行业的核心基础设施。传统的人工记录方式效率低下且容易出错，而基于SpringBoot的数字化解决方案能够实现库存实时监控、保质期预警、批次追溯等关键功能。这个开源项目提供了完整的食品仓储管理实现方案，包含前后端代码、数据库设计、API文档和部署指南。

我在实际部署测试中发现，该系统特别适合中小型食品企业的数字化转型需求。通过自动化库存管理，客户反馈平均减少了30%的过期损耗，盘点效率提升了5倍以上。系统采用主流的SpringBoot+MyBatis+MySQL技术栈，前端使用Layui框架，整体架构轻量但功能完备。

2. 核心功能解析

2.1 多维度库存管理

系统采用"货位-批次-商品"三级管理体系：

java复制// 库存实体类核心字段
public class Storage {
    private String locationCode;  // 货位编码
    private String batchNo;       // 生产批次
    private String barcode;       // 商品条码
    private Integer quantity;     // 当前数量
    private Date productionDate;  // 生产日期
    private Date expiryDate;      // 过期日期
}

关键实现要点：

1. 采用组合唯一索引确保数据一致性：

sql复制ALTER TABLE t_storage ADD UNIQUE KEY uk_location_batch (location_code, batch_no, barcode);

2. 库存变更记录采用乐观锁控制并发：

java复制@Update("UPDATE t_storage SET quantity=#{newQty},version=version+1 
        WHERE id=#{id} AND version=#{version}")
int updateStockWithLock(Storage storage);

2.2 智能预警模块

系统实现了三类核心预警策略：

实现代码示例：

java复制@Scheduled(cron = "0 0 9 * * ?")  // 每天9点执行
public void checkExpiringItems() {
    Date warningDate = DateUtils.addDays(new Date(), 7);
    List<Storage> list = storageMapper.selectExpiring(warningDate);
    list.forEach(item -> {
        String msg = String.format("商品%s批次%s将在%s过期", 
            item.getGoodsName(), item.getBatchNo(), item.getExpiryDate());
        alertService.sendWarning(msg);
    });
}

3. 技术架构详解

3.1 后端设计

采用经典的三层架构：

1. Controller层：处理HTTP请求，参数校验

java复制@PostMapping("/inbound")
public Result inbound(@Valid @RequestBody InboundDTO dto) {
    // 业务逻辑校验
    if(dto.getItems().isEmpty()) {
        return Result.error("入库单明细不能为空");
    }
    return stockService.processInbound(dto);
}

2. Service层：事务管理，业务逻辑

java复制@Transactional
public Result processInbound(InboundDTO dto) {
    // 1. 保存入库单
    InboundOrder order = createOrder(dto);
    orderMapper.insert(order);
    
    // 2. 更新库存
    dto.getItems().forEach(item -> {
        stockService.addStock(item);
    });
    
    // 3. 记录操作日志
    logService.recordOperation(OperationType.INBOUND, order.getId());
    return Result.success(order.getId());
}

3. DAO层：MyBatis实现数据持久化

xml复制<select id="selectStockList" resultType="StorageVO">
    SELECT s.*, g.name as goods_name, g.spec as goods_spec
    FROM t_storage s
    LEFT JOIN t_goods g ON s.barcode = g.barcode
    <where>
        <if test="locationCode != null">
            AND s.location_code = #{locationCode}
        </if>
        <!-- 其他动态查询条件 -->
    </where>
</select>

3.2 前端交互设计

基于Layui的模块化实现：

1. 使用table.render构建数据表格

javascript复制layui.use('table', function(){
  var table = layui.table;
  
  table.render({
    elem: '#stockTable',
    url: '/api/storage/list',
    cols: [[
      {field: 'locationCode', title: '货位'},
      {field: 'goodsName', title: '商品名称'},
      {field: 'batchNo', title: '批次'},
      {field: 'quantity', title: '库存'},
      {field: 'expiryDate', title: '过期日期', templet: function(d){
        return formatDate(d.expiryDate);
      }}
    ]]
  });
});

2. 表单验证配置

javascript复制layui.form.verify({
  stockQty: function(value){
    if(!/^[1-9]\d*$/.test(value)){
      return '请输入正确的库存数量';
    }
  },
  expiryDate: function(value){
    if(!isFutureDate(value)){
      return '过期日期必须大于当前日期';
    }
  }
});

4. 部署与运维实践

4.1 环境准备

推荐的生产环境配置：

数据库初始化脚本关键步骤：

sql复制CREATE DATABASE IF NOT EXISTS food_warehouse 
DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;

-- 创建用户表
CREATE TABLE `t_user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(50) NOT NULL COMMENT '登录账号',
  `password` varchar(100) NOT NULL COMMENT '加密密码',
  `salt` varchar(20) NOT NULL COMMENT '加密盐值',
  `real_name` varchar(50) DEFAULT NULL COMMENT '真实姓名',
  `role` enum('admin','operator','viewer') NOT NULL COMMENT '角色类型',
  PRIMARY KEY (`id`),
  UNIQUE KEY `uk_username` (`username`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='系统用户表';

4.2 应用部署

1. 后端打包配置：

xml复制<plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
    <configuration>
        <executable>true</executable>
    </configuration>
</plugin>

2. 启动参数优化：

bash复制nohup java -Xms512m -Xmx1024m -XX:MaxMetaspaceSize=256m \
-Dspring.profiles.active=prod \
-jar food-warehouse.jar > app.log 2>&1 &

3. Nginx关键配置：

nginx复制server {
    listen 80;
    server_name warehouse.example.com;
    
    location / {
        root /opt/frontend;
        index index.html;
        try_files $uri $uri/ /index.html;
    }
    
    location /api {
        proxy_pass http://127.0.0.1:8080;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

5. 扩展开发指南

5.1 第三方接口集成

1. 快递鸟物流查询集成示例：

java复制public class LogisticsService {
    private String eBusinessID = "test123456";
    private String appKey = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx";
    
    public TrackResult queryLogistics(String shipperCode, String logisticCode) {
        String requestData = "{'OrderCode':'','ShipperCode':'" + shipperCode 
            + "','LogisticCode':'" + logisticCode + "'}";
        String dataSign = encrypt(requestData, appKey);
        
        Map<String,String> params = new HashMap<>();
        params.put("RequestData", urlEncoder.encode(requestData));
        params.put("EBusinessID", eBusinessID);
        params.put("RequestType", "1002");
        params.put("DataSign", urlEncoder.encode(dataSign));
        params.put("DataType", "2");
        
        String result = HttpUtil.post("http://api.kdniao.com/Ebusiness/EbusinessOrderHandle.aspx", params);
        return JSON.parseObject(result, TrackResult.class);
    }
}

5.2 报表模块扩展

使用POI实现Excel导出：

java复制public void exportInventory(OutputStream out) {
    Workbook workbook = new XSSFWorkbook();
    Sheet sheet = workbook.createSheet("库存报表");
    
    // 表头
    Row headerRow = sheet.createRow(0);
    String[] headers = {"货位", "商品名称", "规格", "批次", "数量", "单位", "生产日期", "过期日期"};
    for(int i=0; i<headers.length; i++) {
        headerRow.createCell(i).setCellValue(headers[i]);
    }
    
    // 数据行
    List<StorageVO> list = storageMapper.selectAll();
    for(int i=0; i<list.size(); i++) {
        StorageVO item = list.get(i);
        Row row = sheet.createRow(i+1);
        row.createCell(0).setCellValue(item.getLocationCode());
        row.createCell(1).setCellValue(item.getGoodsName());
        // 其他字段填充...
    }
    
    workbook.write(out);
    workbook.close();
}

6. 常见问题排查

6.1 性能优化记录

1. 慢查询优化案例：

sql复制-- 优化前（执行时间>2s）
SELECT * FROM t_storage 
WHERE expiry_date BETWEEN '2023-01-01' AND '2023-12-31'
ORDER BY expiry_date ASC;

-- 优化后（添加联合索引）
ALTER TABLE t_storage ADD INDEX idx_expiry_quantity (expiry_date, quantity);
EXPLAIN SELECT * FROM t_storage 
WHERE expiry_date BETWEEN '2023-01-01' AND '2023-12-31'
ORDER BY expiry_date ASC;

2. 缓存击穿解决方案：

java复制public Storage getStorageWithCache(String locationCode, String batchNo, String barcode) {
    String cacheKey = "storage:" + locationCode + ":" + batchNo + ":" + barcode;
    // 1. 先查缓存
    Storage storage = redisTemplate.opsForValue().get(cacheKey);
    if(storage != null) {
        return storage;
    }
    
    // 2. 获取分布式锁
    String lockKey = "lock:" + cacheKey;
    try {
        boolean locked = redisTemplate.opsForValue()
            .setIfAbsent(lockKey, "1", 30, TimeUnit.SECONDS);
        if(locked) {
            // 3. 查数据库
            storage = storageMapper.selectByUniqueKey(locationCode, batchNo, barcode);
            // 4. 写入缓存（空值也缓存防止穿透）
            redisTemplate.opsForValue().set(cacheKey, storage, 1, TimeUnit.HOURS);
            return storage;
        } else {
            // 等待重试
            Thread.sleep(100);
            return getStorageWithCache(locationCode, batchNo, barcode);
        }
    } finally {
        redisTemplate.delete(lockKey);
    }
}

6.2 事务问题处理

典型事务失效场景分析：

1. 自调用问题：

java复制public class StockService {
    // 错误示例：this调用导致@Transactional失效
    public void batchUpdate(List<Storage> items) {
        items.forEach(item -> {
            this.updateSingleItem(item);  // 事务注解不生效
        });
    }
    
    @Transactional
    public void updateSingleItem(Storage item) {
        // 更新操作
    }
}

// 正确做法：通过代理对象调用
@Service
public class StockService {
    @Autowired
    private ApplicationContext context;
    
    public void batchUpdate(List<Storage> items) {
        StockService proxy = context.getBean(StockService.class);
        items.forEach(item -> {
            proxy.updateSingleItem(item);  // 通过代理调用
        });
    }
}

2. 异常处理不当：

java复制// 错误示例：捕获异常导致事务不回滚
@Transactional
public void updateStock(Storage storage) {
    try {
        storageMapper.update(storage);
        // 其他操作...
    } catch (Exception e) {
        log.error("更新失败", e);  // 默认只回滚RuntimeException
    }
}

// 正确做法1：抛出RuntimeException
@Transactional
public void updateStock(Storage storage) {
    storageMapper.update(storage);
    if(storage.getQuantity() < 0) {
        throw new IllegalArgumentException("库存不能为负");
    }
}

// 正确做法2：指定回滚异常类型
@Transactional(rollbackFor = Exception.class)
public void updateStock(Storage storage) throws Exception {
    try {
        storageMapper.update(storage);
    } catch (Exception e) {
        throw new Exception("库存更新异常", e);
    }
}

7. 安全防护实践

7.1 接口安全控制

1. 防SQL注入处理：

java复制// 使用MyBatis参数绑定
@Select("SELECT * FROM t_storage WHERE location_code = #{location} AND barcode = #{barcode}")
List<Storage> selectByLocationAndBarcode(
    @Param("location") String locationCode,
    @Param("barcode") String barcode);

// 动态SQL使用OGNL表达式
<select id="selectByCondition" resultType="Storage">
    SELECT * FROM t_storage
    <where>
        <if test="locationCode != null and locationCode != ''">
            AND location_code = #{locationCode}
        </if>
        <!-- 其他条件 -->
    </where>
</select>

2. XSS防护方案：

java复制@Configuration
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.headers()
            .xssProtection()  // 启用XSS防护
            .and()
            .contentSecurityPolicy("script-src 'self'");  // CSP策略
    }
}

// 同时在前端过滤
function escapeHtml(unsafe) {
    return unsafe
        .replace(/&/g, "&")
        .replace(/</g, "&lt;")
        .replace(/>/g, "&gt;")
        .replace(/"/g, "&quot;")
        .replace(/'/g, "&#039;");
}

7.2 权限控制实现

RBAC模型设计：

java复制@Entity
@Table(name = "t_permission")
public class Permission {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    private String name;        // 权限名称
    private String code;        // 权限编码
    private String url;         // 接口路径
    private String method;      // 请求方法
}

// 权限拦截器
@Component
public class AuthInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, 
            HttpServletResponse response, Object handler) throws Exception {
        String uri = request.getRequestURI();
        String method = request.getMethod();
        
        // 1. 获取用户权限列表
        User user = (User) request.getSession().getAttribute("user");
        Set<String> permissions = permissionService.getUserPermissions(user.getId());
        
        // 2. 校验权限
        if(!permissions.contains(method + ":" + uri)) {
            response.sendError(403, "无访问权限");
            return false;
        }
        return true;
    }
}

8. 监控与日志

8.1 SpringBoot监控配置

1. Actuator端点配置：

yaml复制management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics
  endpoint:
    health:
      show-details: always
    metrics:
      enabled: true

2. 自定义健康检查：

java复制@Component
public class DatabaseHealthIndicator implements HealthIndicator {
    @Autowired
    private DataSource dataSource;

    @Override
    public Health health() {
        try (Connection conn = dataSource.getConnection()) {
            if (conn.isValid(1000)) {
                return Health.up()
                    .withDetail("database", "MySQL")
                    .build();
            }
        } catch (Exception e) {
            return Health.down()
                .withException(e)
                .build();
        }
        return Health.unknown().build();
    }
}

8.2 业务日志设计

1. 审计日志实体：

java复制@Entity
@Table(name = "t_operation_log")
public class OperationLog {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String module;       // 操作模块
    private String type;         // 操作类型
    private String operator;     // 操作人
    private String content;      // 操作内容
    private String ip;           // IP地址
    @CreationTimestamp
    private LocalDateTime operateTime;  // 操作时间
}

2. AOP日志切面：

java复制@Aspect
@Component
public class LogAspect {
    @Autowired
    private OperationLogService logService;
    
    @Pointcut("@annotation(com.warehouse.common.annotation.OperateLog)")
    public void logPointCut() {}
    
    @AfterReturning(pointcut = "logPointCut()", returning = "result")
    public void afterReturning(JoinPoint joinPoint, Object result) {
        saveLog(joinPoint, null);
    }
    
    @AfterThrowing(pointcut = "logPointCut()", throwing = "e")
    public void afterThrowing(JoinPoint joinPoint, Exception e) {
        saveLog(joinPoint, e);
    }
    
    private void saveLog(JoinPoint joinPoint, Exception e) {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        OperateLog operateLog = method.getAnnotation(OperateLog.class);
        
        OperationLog log = new OperationLog();
        log.setModule(operateLog.module());
        log.setType(operateLog.type());
        // 其他字段填充...
        
        logService.save(log);
    }
}

9. 测试策略

9.1 单元测试规范

1. 库存服务测试示例：

java复制@SpringBootTest
public class StockServiceTest {
    @Autowired
    private StockService stockService;
    
    @Test
    @Transactional
    @Rollback
    public void testAddStock() {
        Storage storage = new Storage();
        storage.setLocationCode("A-01-01");
        storage.setBarcode("690123456789");
        storage.setBatchNo("B2023001");
        storage.setQuantity(100);
        
        stockService.addStock(storage);
        
        Storage result = stockService.getStorage(
            "A-01-01", "B2023001", "690123456789");
        assertEquals(100, result.getQuantity());
    }
}

2. Mock测试示例：

java复制@ExtendWith(MockitoExtension.class)
class UserServiceTest {
    @Mock
    private UserMapper userMapper;
    
    @InjectMocks
    private UserService userService;
    
    @Test
    void testLoginSuccess() {
        User mockUser = new User();
        mockUser.setUsername("admin");
        mockUser.setPassword("加密后的密码");
        mockUser.setSalt("随机盐值");
        
        when(userMapper.selectByUsername("admin")).thenReturn(mockUser);
        
        Result result = userService.login("admin", "123456");
        assertTrue(result.isSuccess());
    }
}

9.2 压力测试方案

使用JMeter进行库存接口压测：

1. 测试计划配置：

• 线程组：100并发，持续5分钟
• HTTP请求：POST /api/stock/outbound
• 请求体参数化：

json复制{
    "orderNo": "${__RandomString(10,abcdefghijklmnopqrstuvwxyz1234567890,)}",
    "items": [
        {
            "locationCode": "A-${__Random(1,10)}-${__Random(1,5)}",
            "barcode": "69${__Random(10000000,99999999,)}",
            "batchNo": "B2023${__Random(100,999)}",
            "quantity": ${__Random(1,50)}
        }
    ]
}

2. 性能优化前后对比：

优化措施包括：

• 添加库存变更异步队列
• 优化数据库索引
• 启用二级缓存
• 批量处理代替单条操作

10. 项目演进方向

10.1 技术升级路径

1. 架构演进路线：

code复制单体应用 → 服务拆分：
- 用户中心服务
- 库存服务
- 订单服务
- 预警服务

技术栈升级：
SpringBoot 2.x → SpringBoot 3.x
MyBatis → MyBatis-Plus
MySQL单机 → 主从集群 + 分库分表

2. 容器化部署方案：

dockerfile复制# Dockerfile示例
FROM openjdk:11-jre
WORKDIR /app
COPY target/food-warehouse.jar /app/app.jar
EXPOSE 8080
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","app.jar"]

10.2 业务功能扩展

1. 冷链监控集成：

java复制public class ColdChainService {
    // 接收IoT设备数据
    @PostMapping("/temperature")
    public Result recordTemperature(@RequestBody TempRecordDTO dto) {
        // 校验温度范围
        if(dto.getTemperature() < -25 || dto.getTemperature() > 8) {
            alertService.sendAlert("温度异常警告", 
                "货位"+dto.getLocationCode()+"温度超出安全范围");
        }
        tempMapper.insert(dto);
        return Result.success();
    }
}

2. 供应商协同平台：

java复制@RestController
@RequestMapping("/api/supplier")
public class SupplierController {
    @PostMapping("/inboundPlan")
    public Result createInboundPlan(@RequestBody InboundPlanDTO dto) {
        // 1. 保存入库计划
        inboundPlanService.savePlan(dto);
        
        // 2. 通知供应商
        supplierNotifyService.sendPlanNotification(
            dto.getSupplierId(), 
            "您有新的入库计划待确认");
            
        return Result.success();
    }
}

在实际项目迭代中，我们发现采用领域驱动设计(DDD)可以更好地应对复杂业务场景。通过事件风暴工作坊识别出库存管理核心子域后，我们重构了库存变更的领域模型：

java复制// 库存聚合根
public class StorageAggregate {
    private String id;
    private String locationCode;
    private String barcode;
    private String batchNo;
    private Integer quantity;
    private List<DomainEvent> domainEvents;
    
    public void reduceStock(Integer amount) {
        if(this.quantity < amount) {
            throw new BusinessException("库存不足");
        }
        this.quantity -= amount;
        this.domainEvents.add(new StockReducedEvent(this.id, amount));
    }
    
    public List<DomainEvent> getDomainEvents() {
        return Collections.unmodifiableList(domainEvents);
    }
}

这种设计使得库存扣减、批次冻结等复杂业务规则能够内聚在领域层实现，同时通过领域事件实现与预警服务、报表服务的解耦。