基于SSM框架的图书销售与库存管理系统 - 源码深度解析

JavaJavaScriptMavenHTMLCSSSSM框架MySQL
2026-02-214 浏览

文章摘要

本项目是一款基于SSM（Spring + Spring MVC + MyBatis）框架构建的图书销售与库存管理系统，旨在为中小型书店或图书经销商提供一体化的业务管理解决方案。系统核心解决了传统人工记录图书库存和销售数据效率低下、易出错、信息更新不及时的业务痛点。通过数字化管理，实现了库存状态的实时...

在图书行业数字化转型的浪潮中，传统的人工记录和纸质台账管理方式已成为制约中小型书店运营效率提升的主要瓶颈。库存数据更新滞后、销售统计耗时费力、采购决策缺乏数据支撑等问题普遍存在。针对这一市场痛点，我们设计并实现了一套基于SSM（Spring + Spring MVC + MyBatis）技术栈的智能图书仓储与销售管理平台，该系统通过全流程的数字化管理，为图书经销商提供了高效、精准的业务操作体验。

系统采用经典的三层架构设计，实现了表现层、业务逻辑层和数据持久层的清晰分离。Spring Framework作为项目的核心容器，通过控制反转（IoC）和依赖注入（DI）机制管理Bean的生命周期，其声明式事务管理确保了图书销售、库存更新等核心业务操作的原子性和数据一致性。Spring MVC框架负责Web请求的调度与处理，通过配置DispatcherServlet作为前端控制器，实现了请求路径到具体Controller方法的精准映射。数据持久层选用MyBatis框架，利用其灵活的SQL映射能力，开发者可以编写高度优化的SQL语句，并通过动态SQL特性应对复杂的多条件查询场景。

用户登录界面

数据库设计是系统稳定性的基石。系统共包含11张核心数据表，构建了完整的业务数据模型。其中，book表作为核心实体，其设计体现了对图书业务属性的深度理解。

CREATE TABLE `book` (
  `book_id` int(11) NOT NULL AUTO_INCREMENT,
  `isbn` varchar(20) NOT NULL UNIQUE COMMENT '国际标准书号',
  `title` varchar(200) NOT NULL COMMENT '图书名称',
  `author` varchar(100) NOT NULL COMMENT '作者',
  `publisher` varchar(100) NOT NULL COMMENT '出版社',
  `publish_date` date NOT NULL COMMENT '出版日期',
  `category_id` int(11) NOT NULL COMMENT '分类ID',
  `price` decimal(10,2) NOT NULL COMMENT '定价',
  `cost_price` decimal(10,2) NOT NULL COMMENT '成本价',
  `description` text COMMENT '图书简介',
  `create_time` datetime DEFAULT CURRENT_TIMESTAMP,
  `update_time` datetime DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (`book_id`),
  KEY `idx_isbn` (`isbn`),
  KEY `idx_category` (`category_id`),
  KEY `idx_title` (`title`),
  CONSTRAINT `fk_book_category` FOREIGN KEY (`category_id`) REFERENCES `category` (`category_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='图书基本信息表';

该表结构设计有多个亮点：首先，通过isbn字段的唯一索引确保了图书标识的准确性，避免了重复录入；其次，price和cost_price字段使用DECIMAL(10,2)类型精确存储金额，避免了浮点数计算带来的精度问题；第三，创建了复合索引idx_title和idx_category，显著提升了按书名和分类查询的性能；最后，通过create_time和update_time两个时间戳字段，实现了数据的版本追踪，为后续的数据分析提供支持。

另一个关键表是inventory，它记录了图书的实时库存信息，是保证业务数据准确性的核心。

CREATE TABLE `inventory` (
  `inventory_id` int(11) NOT NULL AUTO_INCREMENT,
  `book_id` int(11) NOT NULL COMMENT '图书ID',
  `warehouse_id` int(11) NOT NULL COMMENT '仓库ID',
  `quantity` int(11) NOT NULL DEFAULT '0' COMMENT '库存数量',
  `safe_stock` int(11) NOT NULL DEFAULT '0' COMMENT '安全库存',
  `locked_quantity` int(11) NOT NULL DEFAULT '0' COMMENT '锁定数量（用于预占库存）',
  `create_time` datetime DEFAULT CURRENT_TIMESTAMP,
  `update_time` datetime DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (`inventory_id`),
  UNIQUE KEY `uk_book_warehouse` (`book_id`,`warehouse_id`),
  KEY `idx_warehouse` (`warehouse_id`),
  CONSTRAINT `fk_inventory_book` FOREIGN KEY (`book_id`) REFERENCES `book` (`book_id`),
  CONSTRAINT `fk_inventory_warehouse` FOREIGN KEY (`warehouse_id`) REFERENCES `warehouse` (`warehouse_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='图书库存表';

该设计的创新之处在于引入了locked_quantity字段，实现了库存预占机制。当用户下单但未完成支付时，系统会锁定相应数量的库存，防止超卖。safe_stock字段则设置了库存警戒线，当quantity低于此值时系统会自动生成采购预警，实现了智能库存监控。

图书信息管理界面

系统的核心业务逻辑通过精心设计的Java实体类和Service层实现。Book实体类与数据库表严格映射，包含了完整的业务属性。

public class Book {
    private Integer bookId;
    private String isbn;
    private String title;
    private String author;
    private String publisher;
    private Date publishDate;
    private Integer categoryId;
    private BigDecimal price;
    private BigDecimal costPrice;
    private String description;
    private Date createTime;
    private Date updateTime;
    
    // 构造函数、getter和setter方法
    public Book() {}
    
    public Book(String isbn, String title, String author, String publisher, 
                Date publishDate, Integer categoryId, BigDecimal price, 
                BigDecimal costPrice, String description) {
        this.isbn = isbn;
        this.title = title;
        this.author = author;
        this.publisher = publisher;
        this.publishDate = publishDate;
        this.categoryId = categoryId;
        this.price = price;
        this.costPrice = costPrice;
        this.description = description;
    }
    
    // 省略getter和setter方法...
}

库存管理模块的核心服务类InventoryService包含了复杂的业务逻辑，如库存检查、库存扣减和库存锁定等操作。

@Service
@Transactional
public class InventoryService {
    
    @Autowired
    private InventoryMapper inventoryMapper;
    
    /**
     * 检查并预占库存
     */
    public boolean lockInventory(Integer bookId, Integer warehouseId, Integer quantity) {
        Inventory inventory = inventoryMapper.selectByBookAndWarehouse(bookId, warehouseId);
        if (inventory == null || inventory.getAvailableQuantity() < quantity) {
            throw new InventoryShortageException("库存不足，图书ID: " + bookId);
        }
        
        // 使用乐观锁更新库存
        int affectedRows = inventoryMapper.lockQuantity(
            inventory.getInventoryId(), quantity, inventory.getUpdateTime());
        
        return affectedRows > 0;
    }
    
    /**
     * 扣减库存（用于确认销售）
     */
    public boolean deductInventory(Integer bookId, Integer warehouseId, Integer quantity) {
        int affectedRows = inventoryMapper.deductQuantity(bookId, warehouseId, quantity);
        if (affectedRows == 0) {
            throw new InventoryOperationException("库存扣减失败，可能数据已被修改");
        }
        return true;
    }
    
    /**
     * 获取可用库存量
     */
    public Integer getAvailableQuantity(Integer bookId, Integer warehouseId) {
        Inventory inventory = inventoryMapper.selectByBookAndWarehouse(bookId, warehouseId);
        return inventory != null ? inventory.getAvailableQuantity() : 0;
    }
}

对应的MyBatis映射文件InventoryMapper.xml包含了复杂的SQL逻辑，充分利用了MyBatis的动态SQL特性。

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" 
    "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.bookstore.mapper.InventoryMapper">
    
    <resultMap id="InventoryResultMap" type="com.bookstore.entity.Inventory">
        <id property="inventoryId" column="inventory_id"/>
        <result property="bookId" column="book_id"/>
        <result property="warehouseId" column="warehouse_id"/>
        <result property="quantity" column="quantity"/>
        <result property="safeStock" column="safe_stock"/>
        <result property="lockedQuantity" column="locked_quantity"/>
        <result property="createTime" column="create_time"/>
        <result property="updateTime" column="update_time"/>
    </resultMap>
    
    <select id="selectByBookAndWarehouse" resultMap="InventoryResultMap">
        SELECT * FROM inventory 
        WHERE book_id = #{bookId} AND warehouse_id = #{warehouseId}
    </select>
    
    <update id="lockQuantity">
        UPDATE inventory 
        SET locked_quantity = locked_quantity + #{quantity},
            update_time = NOW()
        WHERE inventory_id = #{inventoryId} 
          AND update_time = #{oldUpdateTime}
          AND (quantity - locked_quantity) >= #{quantity}
    </update>
    
    <update id="deductQuantity">
        UPDATE inventory 
        SET quantity = quantity - #{quantity},
            locked_quantity = locked_quantity - #{quantity},
            update_time = NOW()
        WHERE book_id = #{bookId} 
          AND warehouse_id = #{warehouseId}
          AND locked_quantity >= #{quantity}
    </update>
    
    <!-- 动态条件查询库存 -->
    <select id="selectByCondition" resultMap="InventoryResultMap" 
            parameterType="com.bookstore.dto.InventoryQueryDTO">
        SELECT i.*, b.title, b.isbn, w.warehouse_name
        FROM inventory i
        LEFT JOIN book b ON i.book_id = b.book_id
        LEFT JOIN warehouse w ON i.warehouse_id = w.warehouse_id
        <where>
            <if test="bookTitle != null and bookTitle != ''">
                AND b.title LIKE CONCAT('%', #{bookTitle}, '%')
            </if>
            <if test="isbn != null and isbn != ''">
                AND b.isbn = #{isbn}
            </if>
            <if test="warehouseId != null">
                AND i.warehouse_id = #{warehouseId}
            </if>
            <if test="lowStock != null and lowStock">
                AND i.quantity &lt;= i.safe_stock
            </if>
        </where>
        ORDER BY i.update_time DESC
    </select>
</mapper>

销售管理模块通过SalesController处理前端请求，实现了完整的销售业务流程。

@Controller
@RequestMapping("/sales")
public class SalesController {
    
    @Autowired
    private SalesService salesService;
    
    @Autowired
    private InventoryService inventoryService;
    
    /**
     * 创建销售订单
     */
    @PostMapping("/create")
    @ResponseBody
    public ResponseEntity<Map<String, Object>> createSalesOrder(
            @RequestBody SalesOrderDTO salesOrderDTO) {
        
        Map<String, Object> result = new HashMap<>();
        try {
            // 验证并锁定库存
            for (SalesItemDTO item : salesOrderDTO.getItems()) {
                boolean locked = inventoryService.lockInventory(
                    item.getBookId(), salesOrderDTO.getWarehouseId(), item.getQuantity());
                if (!locked) {
                    throw new InventoryShortageException("图书库存不足: " + item.getBookId());
                }
            }
            
            // 创建销售订单
            SalesOrder order = salesService.createSalesOrder(salesOrderDTO);
            result.put("success", true);
            result.put("orderId", order.getOrderId());
            result.put("message", "销售订单创建成功");
            
        } catch (InventoryShortageException e) {
            result.put("success", false);
            result.put("message", e.getMessage());
        }
        
        return ResponseEntity.ok(result);
    }
    
    /**
     * 分页查询销售记录
     */
    @GetMapping("/list")
    public String getSalesList(
            @RequestParam(defaultValue = "1") Integer page,
            @RequestParam(defaultValue = "10") Integer size,
            @RequestParam(required = false) String startDate,
            @RequestParam(required = false) String endDate,
            Model model) {
        
        PageHelper.startPage(page, size);
        List<SalesOrder> orders = salesService.getSalesOrders(startDate, endDate);
        PageInfo<SalesOrder> pageInfo = new PageInfo<>(orders);
        
        model.addAttribute("pageInfo", pageInfo);
        model.addAttribute("orders", orders);
        return "sales/list";
    }
}

销售管理界面

采购管理模块通过PurchaseOrder实体和相关的服务类，实现了从供应商选择到库存入库的完整流程。

@Entity
@Table(name = "purchase_order")
public class PurchaseOrder {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer orderId;
    
    private String orderNumber;
    private Integer supplierId;
    private Integer warehouseId;
    
    @Enumerated(EnumType.STRING)
    private OrderStatus status;
    
    private BigDecimal totalAmount;
    private Date orderDate;
    private Date expectedDate;
    private Date actualDate;
    
    @OneToMany(mappedBy = "purchaseOrder", cascade = CascadeType.ALL)
    private List<PurchaseItem> items;
    
    // 枚举定义采购订单状态
    public enum OrderStatus {
        PENDING,    // 待处理
        APPROVED,   // 已审核
        DELIVERED,  // 已发货
        RECEIVED,   // 已收货
        COMPLETED,  // 已完成
        CANCELLED   // 已取消
    }
}

库存管理界面

系统在用户体验方面进行了深度优化。前端页面采用响应式设计，通过Ajax技术实现数据的异步加载和局部刷新，提升了操作流畅度。关键操作如库存查询、销售录入等都实现了实时验证和反馈机制。

// 前端库存查询的JavaScript代码
function searchInventory() {
    const queryParams = {
        bookTitle: $('#bookTitle').val(),
        isbn: $('#isbn').val(),
        warehouseId: $('#warehouseSelect').val(),
        lowStock: $('#lowStockCheckbox').is(':checked')
    };
    
    $.ajax({
        url: '/inventory/search',
        type: 'GET',
        data: queryParams,
        success: function(data) {
            renderInventoryTable(data);
            updateStatistics(data.statistics);
        },
        error: function(xhr) {
            showError('查询失败: ' + xhr.responseText);
        }
    });
}

// 实时库存监控
function startInventoryMonitor() {
    setInterval(() => {
        $.get('/inventory/alert', function(alerts) {
            if (alerts.length > 0) {
                showInventoryAlerts(alerts);
            }
        });
    }, 300000); // 每5分钟检查一次
}

系统配置方面，通过Spring的Java Config方式进行了现代化配置，替代了传统的XML配置方式。

@Configuration
@EnableWebMvc
@ComponentScan("com.bookstore")
@EnableTransactionManagement
@PropertySource("classpath:application.properties")
public class AppConfig implements WebMvcConfigurer {
    
    @Bean
    public DataSource dataSource() {
        HikariDataSource dataSource = new HikariDataSource();
        dataSource.setDriverClassName(env.getProperty("jdbc.driverClassName"));
        dataSource.setJdbcUrl(env.getProperty("jdbc.url"));
        dataSource.setUsername(env.getProperty("jdbc.username"));
        dataSource.setPassword(env.getProperty("jdbc.password"));
        dataSource.setMaximumPoolSize(20);
        dataSource.setMinimumIdle(5);
        return dataSource;
    }
    
    @Bean
    public SqlSessionFactoryBean sqlSessionFactory() throws Exception {
        SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
        sessionFactory.setDataSource(dataSource());
        sessionFactory.setMapperLocations(
            new PathMatchingResourcePatternResolver()
                .getResources("classpath:mapper/*.xml"));
        
        // 配置MyBatis插件
        org.apache.ibatis.session.Configuration configuration = 
            new org.apache.ibatis.session.Configuration();
        configuration.setMapUnderscoreToCamelCase(true);
        configuration.setCacheEnabled(true);
        sessionFactory.setConfiguration(configuration);
        
        return sessionFactory;
    }
    
    @Bean
    public PlatformTransactionManager transactionManager() {
        return new DataSourceTransactionManager(dataSource());
    }
}

在系统安全方面，实现了基于角色的访问控制（RBAC），不同角色的用户拥有不同的操作权限。

@Service
public class CustomUserDetailsService implements UserDetailsService {
    
    @Autowired
    private UserMapper userMapper;
    
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        User user = userMapper.findByUsername(username);
        if (user == null) {
            throw new UsernameNotFoundException("用户不存在: " + username);
        }
        
        // 获取用户角色和权限
        List<SimpleGrantedAuthority> authorities = userMapper.findUserAuthorities(user.getUserId());
        
        return new org.springframework.security.core.userdetails.User(
            user.getUsername(), 
            user.getPassword(), 
            authorities);
    }
}

系统在数据统计分析方面提供了强大的支持，通过复杂的SQL查询和Java业务逻辑，生成了多维度的业务报表。

-- 销售统计查询SQL
SELECT 
    b.category_id,
    c.category_name,
    COUNT(so.order_id) as order_count,
    SUM(so.total_amount) as total_sales,
    SUM(so.total_amount - (si.quantity * b.cost_price)) as total_profit,
    AVG(so.total_amount) as avg_order_value
FROM sales_order so
INNER JOIN sales_item si ON so.order_id = si.order_id
INNER JOIN book b ON si.book_id = b.book_id
INNER JOIN category c ON b.category_id = c.category_id
WHERE so.order_date BETWEEN #{startDate} AND #{endDate}
  AND so.status = 'COMPLETED'
GROUP BY b.category_id, c.category_name
ORDER BY total_sales DESC;

未来优化方向包括：第一，引入Redis缓存层，将热点数据如图书信息、库存状态

本文关键词
SSM框架图书销售库存管理源码解析系统设计

上下篇

上一篇
没有更多文章
下一篇
没有更多文章