基于SSH框架的洗衣店业务管理系统 - 源码深度解析

JavaJavaScriptSSH框架HTMLCSSMySQLJSP+Servlet
2026-03-162 浏览

文章摘要

本项目是基于SSH（Struts2 + Spring + Hibernate）框架技术栈构建的洗衣店业务管理系统，旨在为中小型洗衣店提供一体化的运营管理解决方案。系统通过整合洗衣管理和库存管理两大核心功能，有效解决了传统洗衣店手工记录订单易出错、库存盘点效率低、业务数据难以追溯等经营痛点，帮助店主实...

在传统洗衣行业向数字化管理转型的背景下，一套高效稳定的业务管理系统成为提升运营效率的关键。洗衣管家系统采用经典的SSH（Struts2+Spring+Hibernate）技术栈构建，为中小型洗衣店提供全方位的数字化解决方案。系统通过模块化设计实现了洗衣服务流程管理、库存控制、财务统计和多角色协同作业等核心功能。

系统架构与技术栈选型

系统采用典型的三层架构模式，各层之间通过接口松散耦合。表现层使用Struts2框架处理用户请求和页面跳转，通过配置struts.xml文件定义Action映射关系。业务逻辑层由Spring框架管理，通过IoC容器实现依赖注入，使用声明式事务管理保证数据一致性。持久层基于Hibernate实现ORM映射，通过HQL语言和Criteria API完成数据访问操作。

Spring配置文件中定义了数据源和事务管理器的Bean配置：

<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3306/laundry_db"/>
    <property name="username" value="root"/>
    <property name="password" value="123456"/>
</bean>

<bean id="transactionManager" 
      class="org.springframework.orm.hibernate3.HibernateTransactionManager">
    <property name="sessionFactory" ref="sessionFactory"/>
</bean>

<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <tx:attributes>
        <tx:method name="save*" propagation="REQUIRED"/>
        <tx:method name="update*" propagation="REQUIRED"/>
        <tx:method name="delete*" propagation="REQUIRED"/>
    </tx:attributes>
</tx:advice>

数据库设计解析

系统数据库包含10个核心表，采用InnoDB存储引擎确保事务完整性。订单表(laundry_order)的设计体现了业务核心逻辑：

CREATE TABLE laundry_order (
    order_id VARCHAR(32) PRIMARY KEY,
    customer_id INT NOT NULL,
    employee_id INT,
    product_type_id INT NOT NULL,
    order_status ENUM('pending','washing','drying','finished') DEFAULT 'pending',
    total_amount DECIMAL(10,2),
    create_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    expected_finish_time TIMESTAMP,
    actual_finish_time TIMESTAMP,
    FOREIGN KEY (customer_id) REFERENCES customer(customer_id),
    FOREIGN KEY (employee_id) REFERENCES employee(employee_id),
    FOREIGN KEY (product_type_id) REFERENCES product_type(type_id),
    INDEX idx_status (order_status),
    INDEX idx_customer (customer_id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

库存表(inventory)的设计支持实时库存追踪和预警机制：

CREATE TABLE inventory (
    inventory_id INT AUTO_INCREMENT PRIMARY KEY,
    product_type_id INT NOT NULL,
    current_stock INT DEFAULT 0,
    min_stock_level INT DEFAULT 10,
    last_restock_date DATE,
    FOREIGN KEY (product_type_id) REFERENCES product_type(type_id),
    INDEX idx_product (product_type_id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

核心功能模块实现

1. 多角色权限管理系统

系统采用基于角色的访问控制(RBAC)模型，通过用户表(user)、角色表(role)和权限表(permission)的三元关系实现细粒度权限控制。用户登录时，系统通过Spring Security进行身份认证和授权：

public class UserAction extends ActionSupport {
    private UserService userService;
    private String username;
    private String password;
    
    public String login() {
        User user = userService.authenticate(username, password);
        if (user != null) {
            Map<String, Object> session = ActionContext.getContext().getSession();
            session.put("currentUser", user);
            session.put("userRole", user.getRole().getRoleName());
            return SUCCESS;
        }
        addActionError("用户名或密码错误");
        return ERROR;
    }
    
    // Getter和Setter方法
    public void setUserService(UserService userService) {
        this.userService = userService;
    }
}

权限管理

2. 洗衣订单全生命周期管理

订单管理模块实现了从接单、洗涤、烘干到完成的完整流程跟踪。OrderService类封装了核心业务逻辑：

@Service
@Transactional
public class OrderService {
    @Autowired
    private OrderDAO orderDAO;
    @Autowired
    private InventoryService inventoryService;
    
    public String createOrder(OrderDTO orderDTO) {
        // 检查库存可用性
        if (!inventoryService.checkStockSufficient(orderDTO.getProductTypeId(), 
                                                  orderDTO.getQuantity())) {
            throw new InsufficientStockException("库存不足");
        }
        
        LaundryOrder order = new LaundryOrder();
        BeanUtils.copyProperties(orderDTO, order);
        order.setOrderId(generateOrderId());
        order.setCreateTime(new Date());
        order.setOrderStatus(OrderStatus.PENDING);
        
        // 扣减库存
        inventoryService.deductStock(orderDTO.getProductTypeId(), 
                                   orderDTO.getQuantity());
        
        return orderDAO.save(order);
    }
    
    public void updateOrderStatus(String orderId, OrderStatus newStatus) {
        LaundryOrder order = orderDAO.findById(orderId);
        order.setOrderStatus(newStatus);
        
        if (newStatus == OrderStatus.FINISHED) {
            order.setActualFinishTime(new Date());
        }
        orderDAO.update(order);
    }
}

订单管理

3. 智能库存预警与补货系统

库存管理模块通过实时监控库存水平，自动触发补货预警。InventoryDAO使用Hibernate实现复杂的库存查询：

@Repository
public class InventoryDAOImpl extends HibernateDaoSupport implements InventoryDAO {
    
    public List<Inventory> findLowStockItems() {
        String hql = "FROM Inventory i WHERE i.currentStock < i.minStockLevel";
        return getHibernateTemplate().find(hql);
    }
    
    public void updateStock(Integer productTypeId, Integer quantity) {
        String hql = "UPDATE Inventory SET currentStock = currentStock + ? " +
                    "WHERE productTypeId = ?";
        getHibernateTemplate().bulkUpdate(hql, quantity, productTypeId);
    }
    
    @Transactional
    public boolean deductStock(Integer productTypeId, Integer quantity) {
        Inventory inventory = findById(productTypeId);
        if (inventory.getCurrentStock() >= quantity) {
            inventory.setCurrentStock(inventory.getCurrentStock() - quantity);
            getHibernateTemplate().update(inventory);
            return true;
        }
        return false;
    }
}

库存管理

4. 财务统计与报表生成

财务模块通过Hibernate的投影查询和聚合函数实现数据统计：

public class FinanceService {
    public FinancialReport generateDailyReport(Date reportDate) {
        String hql = "SELECT new FinancialReport(SUM(o.totalAmount), COUNT(o.orderId), " +
                    "AVG(o.totalAmount)) FROM LaundryOrder o " +
                    "WHERE DATE(o.createTime) = DATE(:reportDate) " +
                    "AND o.orderStatus = 'FINISHED'";
        
        Query query = getSession().createQuery(hql);
        query.setParameter("reportDate", reportDate);
        
        return (FinancialReport) query.uniqueResult();
    }
    
    public List<RevenueTrend> getRevenueTrend(Date startDate, Date endDate) {
        String hql = "SELECT new RevenueTrend(DATE(o.createTime), SUM(o.totalAmount)) " +
                    "FROM LaundryOrder o " +
                    "WHERE o.createTime BETWEEN :startDate AND :endDate " +
                    "GROUP BY DATE(o.createTime) " +
                    "ORDER BY DATE(o.createTime)";
        
        Query query = getSession().createQuery(hql);
        query.setParameter("startDate", startDate);
        query.setParameter("endDate", endDate);
        
        return query.list();
    }
}

财务统计

实体模型设计

系统实体模型采用贫血模型设计，每个实体类对应数据库中的一张表。LaundryOrder实体类展示了Hibernate注解的运用：

@Entity
@Table(name = "laundry_order")
public class LaundryOrder implements Serializable {
    @Id
    @GeneratedValue(generator = "uuid")
    @GenericGenerator(name = "uuid", strategy = "uuid")
    @Column(name = "order_id", length = 32)
    private String orderId;
    
    @ManyToOne
    @JoinColumn(name = "customer_id", nullable = false)
    private Customer customer;
    
    @ManyToOne
    @JoinColumn(name = "employee_id")
    private Employee employee;
    
    @ManyToOne
    @JoinColumn(name = "product_type_id", nullable = false)
    private ProductType productType;
    
    @Enumerated(EnumType.STRING)
    @Column(name = "order_status", length = 20)
    private OrderStatus orderStatus;
    
    @Column(name = "total_amount", precision = 10, scale = 2)
    private BigDecimal totalAmount;
    
    @Temporal(TemporalType.TIMESTAMP)
    @Column(name = "create_time")
    private Date createTime;
    
    @Temporal(TemporalType.TIMESTAMP)
    @Column(name = "expected_finish_time")
    private Date expectedFinishTime;
    
    // Getter和Setter方法
    public String getOrderId() { return orderId; }
    public void setOrderId(String orderId) { this.orderId = orderId; }
    
    public OrderStatus getOrderStatus() { return orderStatus; }
    public void setOrderStatus(OrderStatus orderStatus) { 
        this.orderStatus = orderStatus; 
    }
}

性能优化策略

系统在数据访问层实现了二级缓存机制，通过Ehcache提升查询性能：

<bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
    <property name="hibernateProperties">
        <props>
            <prop key="hibernate.cache.use_second_level_cache">true</prop>
            <prop key="hibernate.cache.use_query_cache">true</prop>
            <prop key="hibernate.cache.region.factory_class">
                org.hibernate.cache.ehcache.EhCacheRegionFactory
            </prop>
        </props>
    </property>
</bean>

对于高频查询操作，使用Hibernate的查询缓存：

@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
public class ProductType implements Serializable {
    // 实体类定义
}

public List<ProductType> getAllProductTypes() {
    String hql = "FROM ProductType";
    Query query = getSession().createQuery(hql);
    query.setCacheable(true);
    return query.list();
}

系统安全机制

系统通过Struts2拦截器实现访问控制，确保只有授权用户才能访问相应功能：

public class AuthorizationInterceptor extends AbstractInterceptor {
    @Override
    public String intercept(ActionInvocation invocation) throws Exception {
        Map<String, Object> session = invocation.getInvocationContext().getSession();
        User currentUser = (User) session.get("currentUser");
        
        if (currentUser == null) {
            return "login";
        }
        
        // 检查用户权限
        String actionName = invocation.getProxy().getActionName();
        if (!hasPermission(currentUser, actionName)) {
            return "unauthorized";
        }
        
        return invocation.invoke();
    }
    
    private boolean hasPermission(User user, String actionName) {
        // 实现权限检查逻辑
        return user.getRole().getPermissions()
                  .stream()
                  .anyMatch(p -> p.getActionName().equals(actionName));
    }
}

未来优化方向

  1. 移动端支持：开发基于React Native的跨平台移动应用，实现订单进度推送和在线支付功能。通过RESTful API与现有系统集成，使用JWT令牌进行身份认证。

  2. 物联网集成：对接智能洗衣设备，实时获取设备运行状态和能耗数据。通过MQTT协议实现设备数据采集，建立设备预测性维护模型。

  3. 大数据分析：引入Apache Spark进行客户行为分析和业务预测。建立RFM客户价值模型，实现个性化营销推荐。

  4. 微服务架构改造：将单体应用拆分为订单服务、库存服务、用户服务等微服务。使用Spring Cloud实现服务注册发现和配置管理。

  5. 自动化工作流：集成Activiti工作流引擎，实现洗衣流程的自动化调度和异常处理。建立智能排班系统优化人力资源分配。

系统通过严谨的架构设计和细致的功能实现，为洗衣行业提供了完整的数字化解决方案。SSH框架的稳定性和成熟度保证了系统的可靠运行，而模块化的设计为后续功能扩展奠定了良好基础。

本文关键词
SSH框架洗衣店管理系统业务管理源码解析数字化管理

上下篇

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