基于SSH框架的超市进销存与数据分析管理系统 - 源码深度解析

JavaJavaScriptSSH框架HTMLCSSMySQLJSP+Servlet
2026-02-235 浏览

文章摘要

本系统基于经典的SSH（Struts2 + Spring + Hibernate）框架技术栈构建，专为中小型超市及零售门店设计，旨在实现商品从采购、入库、销售到库存盘点全生命周期的数字化管理，并通过对经营数据的深度分析，为管理者提供科学的决策支持。其核心业务价值在于解决了传统手工或半自动化管理模式下...

在零售行业数字化浪潮中，传统超市面临着库存不准、数据孤岛、决策滞后等核心挑战。针对这些痛点，我们设计并实现了一套基于SSH（Struts2 + Spring + Hibernate）技术栈的智能超市管理系统。该系统将商品采购、库存管理、销售处理与数据分析深度融合，构建了一个完整的业务闭环解决方案。

系统采用经典的三层架构设计，表现层使用Struts2框架处理用户请求和页面跳转，业务逻辑层通过Spring框架实现组件管理和事务控制，数据持久层则基于Hibernate实现对象关系映射。这种架构确保了系统的高内聚、低耦合特性，同时提供了良好的可扩展性和维护性。

数据库架构设计

系统数据库包含6个核心表，每个表都经过精心设计以满足复杂的业务需求。其中商品表（product）和销售记录表（sale_record）的设计尤为关键。

商品表采用层次化分类设计，通过category字段实现商品的多级分类管理：

CREATE TABLE product (
    id INT PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(100) NOT NULL,
    barcode VARCHAR(50) UNIQUE,
    category VARCHAR(50),
    purchase_price DECIMAL(10,2),
    sale_price DECIMAL(10,2),
    stock_quantity INT DEFAULT 0,
    min_stock INT DEFAULT 10,
    supplier_id INT,
    created_time DATETIME DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY (supplier_id) REFERENCES supplier(id)
);

销售记录表的设计充分考虑了数据分析的需求，包含完整的交易信息和关联关系：

CREATE TABLE sale_record (
    id INT PRIMARY KEY AUTO_INCREMENT,
    product_id INT NOT NULL,
    quantity INT NOT NULL,
    unit_price DECIMAL(10,2) NOT NULL,
    total_amount DECIMAL(10,2) NOT NULL,
    sale_time DATETIME DEFAULT CURRENT_TIMESTAMP,
    salesperson_id INT NOT NULL,
    payment_method ENUM('CASH', 'CARD', 'MOBILE'),
    FOREIGN KEY (product_id) REFERENCES product(id),
    FOREIGN KEY (salesperson_id) REFERENCES salesperson(id)
);

库存管理表采用实时更新机制，确保库存数据的准确性：

CREATE TABLE inventory (
    id INT PRIMARY KEY AUTO_INCREMENT,
    product_id INT NOT NULL UNIQUE,
    current_stock INT NOT NULL,
    last_updated DATETIME DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY (product_id) REFERENCES product(id)
);

核心业务功能实现

商品管理模块

商品管理作为系统的基础模块，实现了商品的增删改查、库存预警和条码管理。通过Struts2的Action类处理前端请求，Spring Service层实现业务逻辑，Hibernate负责数据持久化。

商品查询功能的Action实现：

public class ProductAction extends ActionSupport {
    private List<Product> productList;
    private ProductService productService;
    
    public String listProducts() {
        try {
            productList = productService.getAllProducts();
            return SUCCESS;
        } catch (Exception e) {
            addActionError("查询商品列表失败");
            return ERROR;
        }
    }
    
    // Getter和Setter方法
    public List<Product> getProductList() { return productList; }
    public void setProductService(ProductService productService) {
        this.productService = productService;
    }
}

Spring Service层的商品管理实现：

@Service
@Transactional
public class ProductServiceImpl implements ProductService {
    
    @Autowired
    private ProductDAO productDAO;
    
    @Override
    public List<Product> getAllProducts() {
        return productDAO.findAll();
    }
    
    @Override
    @Transactional(readOnly = true)
    public Product getProductById(Integer id) {
        return productDAO.findById(id);
    }
    
    @Override
    public void updateProductStock(Integer productId, Integer quantity) {
        Product product = productDAO.findById(productId);
        if (product != null) {
            int newStock = product.getStockQuantity() + quantity;
            product.setStockQuantity(newStock);
            productDAO.update(product);
        }
    }
}

商品管理界面

销售处理系统

销售模块采用事务性设计，确保销售记录和库存更新的原子性。系统支持多种支付方式，并实时更新库存数据。

销售处理的业务逻辑实现：

@Service
@Transactional
public class SaleServiceImpl implements SaleService {
    
    @Autowired
    private SaleRecordDAO saleRecordDAO;
    
    @Autowired
    private ProductDAO productDAO;
    
    @Override
    @Transactional(rollbackFor = Exception.class)
    public SaleRecord processSale(SaleDTO saleDTO) throws InsufficientStockException {
        // 检查库存
        Product product = productDAO.findById(saleDTO.getProductId());
        if (product.getStockQuantity() < saleDTO.getQuantity()) {
            throw new InsufficientStockException("库存不足");
        }
        
        // 创建销售记录
        SaleRecord record = new SaleRecord();
        record.setProduct(product);
        record.setQuantity(saleDTO.getQuantity());
        record.setUnitPrice(product.getSalePrice());
        record.setTotalAmount(product.getSalePrice() * saleDTO.getQuantity());
        record.setSalesperson(saleDTO.getSalesperson());
        record.setPaymentMethod(saleDTO.getPaymentMethod());
        
        // 更新库存
        product.setStockQuantity(product.getStockQuantity() - saleDTO.getQuantity());
        productDAO.update(product);
        
        return saleRecordDAO.save(record);
    }
}

Hibernate实体映射配置：

<hibernate-mapping>
    <class name="com.supermarket.entity.SaleRecord" table="sale_record">
        <id name="id" column="id">
            <generator class="identity"/>
        </id>
        <many-to-one name="product" column="product_id" 
                     class="com.supermarket.entity.Product" not-null="true"/>
        <property name="quantity" column="quantity" not-null="true"/>
        <property name="unitPrice" column="unit_price" not-null="true"/>
        <property name="totalAmount" column="total_amount" not-null="true"/>
        <property name="saleTime" column="sale_time" type="timestamp"/>
        <many-to-one name="salesperson" column="salesperson_id" 
                     class="com.supermarket.entity.Salesperson" not-null="true"/>
        <property name="paymentMethod" column="payment_method" type="string"/>
    </class>
</hibernate-mapping>

销售记录管理

采购管理功能

采购模块实现供应商管理、采购订单处理和入库流程的完整闭环。系统自动更新库存并记录采购历史。

采购入库的Service层实现：

@Service
@Transactional
public class ProcurementServiceImpl implements ProcurementService {
    
    @Autowired
    private ProcurementDAO procurementDAO;
    
    @Autowired
    private ProductDAO productDAO;
    
    @Override
    @Transactional(rollbackFor = Exception.class)
    public ProcurementOrder createProcurementOrder(ProcurementDTO procurementDTO) {
        ProcurementOrder order = new ProcurementOrder();
        order.setProduct(productDAO.findById(procurementDTO.getProductId()));
        order.setQuantity(procurementDTO.getQuantity());
        order.setUnitPrice(procurementDTO.getUnitPrice());
        order.setTotalAmount(procurementDTO.getQuantity() * procurementDTO.getUnitPrice());
        order.setSupplier(procurementDTO.getSupplier());
        order.setOrderTime(new Date());
        order.setStatus(OrderStatus.PENDING);
        
        return procurementDAO.save(order);
    }
    
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void confirmReceipt(Integer orderId) {
        ProcurementOrder order = procurementDAO.findById(orderId);
        if (order != null && order.getStatus() == OrderStatus.PENDING) {
            // 更新库存
            Product product = order.getProduct();
            product.setStockQuantity(product.getStockQuantity() + order.getQuantity());
            productDAO.update(product);
            
            // 更新订单状态
            order.setStatus(OrderStatus.COMPLETED);
            order.setReceiptTime(new Date());
            procurementDAO.update(order);
        }
    }
}

采购管理界面

数据分析与报表系统

数据分析模块通过复杂的HQL查询实现多维度统计分析，为管理者提供决策支持。

销售统计的数据访问层实现：

@Repository
public class ReportDAOImpl extends HibernateDaoSupport implements ReportDAO {
    
    @Autowired
    public ReportDAOImpl(SessionFactory sessionFactory) {
        setSessionFactory(sessionFactory);
    }
    
    @Override
    @Transactional(readOnly = true)
    public List<SalesSummary> getDailySalesSummary(Date startDate, Date endDate) {
        String hql = "SELECT new com.supermarket.dto.SalesSummary(" +
                    "p.category, SUM(sr.quantity), SUM(sr.totalAmount)) " +
                    "FROM SaleRecord sr JOIN sr.product p " +
                    "WHERE sr.saleTime BETWEEN :startDate AND :endDate " +
                    "GROUP BY p.category " +
                    "ORDER BY SUM(sr.totalAmount) DESC";
        
        Query query = getSession().createQuery(hql);
        query.setParameter("startDate", startDate);
        query.setParameter("endDate", endDate);
        
        return query.list();
    }
    
    @Override
    @Transactional(readOnly = true)
    public List<ProductSalesRanking> getProductSalesRanking(Date startDate, Date endDate) {
        String hql = "SELECT new com.supermarket.dto.ProductSalesRanking(" +
                    "p.name, p.category, SUM(sr.quantity), SUM(sr.totalAmount)) " +
                    "FROM SaleRecord sr JOIN sr.product p " +
                    "WHERE sr.saleTime BETWEEN :startDate AND :endDate " +
                    "GROUP BY p.id, p.name, p.category " +
                    "ORDER BY SUM(sr.quantity) DESC";
        
        Query query = getSession().createQuery(hql);
        query.setParameter("startDate", startDate);
        query.setParameter("endDate", endDate);
        query.setMaxResults(10); // 获取前10名
        
        return query.list();
    }
}

收入报表统计

实体模型设计

系统的实体模型采用面向对象的设计理念，通过Hibernate注解实现对象关系映射：

@Entity
@Table(name = "product")
public class Product {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    
    @Column(name = "name", nullable = false, length = 100)
    private String name;
    
    @Column(name = "barcode", unique = true, length = 50)
    private String barcode;
    
    @Column(name = "category", length = 50)
    private String category;
    
    @Column(name = "purchase_price", precision = 10, scale = 2)
    private BigDecimal purchasePrice;
    
    @Column(name = "sale_price", precision = 10, scale = 2)
    private BigDecimal salePrice;
    
    @Column(name = "stock_quantity")
    private Integer stockQuantity;
    
    @Column(name = "min_stock")
    private Integer minStock;
    
    @ManyToOne
    @JoinColumn(name = "supplier_id")
    private Supplier supplier;
    
    @OneToMany(mappedBy = "product", cascade = CascadeType.ALL)
    private Set<SaleRecord> saleRecords = new HashSet<>();
    
    // Getter和Setter方法
    public Integer getId() { return id; }
    public void setId(Integer id) { this.id = id; }
    // ... 其他getter和setter方法
}

库存预警功能的实现：

@Service
@Transactional
public class InventoryAlertService {
    
    @Autowired
    private ProductDAO productDAO;
    
    @Override
    @Transactional(readOnly = true)
    public List<Product> getLowStockProducts() {
        String hql = "FROM Product p WHERE p.stockQuantity <= p.minStock " +
                    "ORDER BY p.stockQuantity ASC";
        return productDAO.findByHQL(hql);
    }
    
    @Override
    @Scheduled(cron = "0 0 9 * * ?") // 每天上午9点执行
    public void sendLowStockAlert() {
        List<Product> lowStockProducts = getLowStockProducts();
        if (!lowStockProducts.isEmpty()) {
            // 发送预警邮件或系统通知
            sendAlertNotification(lowStockProducts);
        }
    }
}

库存管理界面

系统配置与集成

Spring的配置文件实现了各层组件的依赖注入和事务管理：

<!-- applicationContext.xml -->
<beans xmlns="http://www.springframework.org/schema/beans">
    <!-- 数据源配置 -->
    <bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/supermarket_db"/>
        <property name="username" value="root"/>
        <property name="password" value="password"/>
    </bean>
    
    <!-- Hibernate SessionFactory -->
    <bean id="sessionFactory" 
          class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
                <prop key="hibernate.show_sql">true</prop>
                <prop key="hibernate.format_sql">true</prop>
            </props>
        </property>
        <property name="annotatedClasses">
            <list>
                <value>com.supermarket.entity.Product</value>
                <value>com.supermarket.entity.SaleRecord</value>
                <!-- 其他实体类 -->
            </list>
        </property>
    </bean>
    
    <!-- 事务管理 -->
    <bean id="transactionManager"
          class="org.springframework.orm.hibernate5.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>
    
    <tx:annotation-driven transaction-manager="transactionManager"/>
</beans>

技术优化与扩展方向

  1. 性能优化：引入Redis缓存层，对商品信息、销售排行等热点数据进行缓存，减少数据库访问压力。实现二级缓存配置，提升系统响应速度。

  2. 微服务架构改造：将单体应用拆分为商品服务、订单服务、库存服务、报表服务等微服务，通过Spring Cloud实现服务治理，提高系统可扩展性。

  3. 实时数据分析：集成Apache Kafka实现销售数据的实时流处理，结合Elasticsearch提供更快速的数据检索和分析能力。

  4. 移动端支持：开发基于React Native的移动应用，支持库存盘点、销售查询等移动办公场景，提升操作便捷性。

  5. 智能预测功能：引入机器学习算法，基于历史销售数据实现商品需求预测、库存优化建议等智能功能，为采购决策提供数据支持。

  6. 多门店支持：扩展系统架构支持多门店管理，实现总部与各分店之间的数据同步和统一管理，满足连锁超市的业务需求。

该系统通过SSH框架的成熟技术组合，为中小型超市提供了稳定可靠的数字化管理解决方案。其模块化设计和清晰的架构层次为后续的功能扩展和技术升级奠定了坚实基础，能够有效支撑超市业务的持续发展和技术演进。

本文关键词
SSH框架超市进销存数据分析管理系统源码解析库存管理

上下篇

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