基于SSH框架的网上水果生鲜商城管理系统 - 源码深度解析

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

文章摘要

本系统是基于SSH（Struts2 + Spring + Hibernate）集成框架开发的网上水果生鲜商城后台管理系统，旨在为中小型生鲜零售商提供一体化的电商运营解决方案。其核心业务价值在于打通线上销售与后端库存管理的关键环节，有效解决传统生鲜行业因商品保质期短、库存变动频繁而导致的线上线下数据不...

在生鲜电商行业快速发展的背景下，传统水果零售商面临着库存管理困难、线上线下数据不同步、商品损耗率高等核心挑战。针对这些痛点，我们设计并实现了一套基于SSH（Struts2 + Spring + Hibernate）集成框架的"鲜果优管"电商后台管理系统，为中小型生鲜企业提供全方位的数字化解决方案。

系统采用经典的三层架构设计，各层职责分明。表现层使用Struts2框架处理用户请求和响应，通过拦截器机制实现统一的权限验证和输入校验。业务逻辑层由Spring框架的IoC容器管理，通过依赖注入实现组件解耦，并利用声明式事务管理确保数据一致性。数据持久层采用Hibernate作为ORM工具，通过对象关系映射简化数据库操作，提高开发效率。

数据库架构设计亮点

系统数据库包含15张核心表，采用规范化的设计理念确保数据完整性和查询效率。其中几个关键表的设计体现了对生鲜行业特性的深度理解。

商品信息表（product）的设计充分考虑了生鲜商品的特殊性：

CREATE TABLE product (
    product_id INT PRIMARY KEY AUTO_INCREMENT,
    product_name VARCHAR(100) NOT NULL,
    category_id INT NOT NULL,
    original_price DECIMAL(10,2),
    promote_price DECIMAL(10,2),
    stock_quantity INT DEFAULT 0,
    sales_volume INT DEFAULT 0,
    shelf_status TINYINT DEFAULT 0,
    create_time DATETIME DEFAULT CURRENT_TIMESTAMP,
    update_time DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
    expiry_date DATE,
    weight_unit VARCHAR(10),
    product_description TEXT,
    FOREIGN KEY (category_id) REFERENCES product_category(category_id)
);

该表设计了expiry_date字段记录商品保质期，weight_unit字段支持按重量单位销售，shelf_status字段控制商品上下架状态，充分满足了生鲜商品的业务需求。同时采用双价格字段设计，支持原价和促销价的同时展示。

订单表（order）的设计体现了交易完整性：

CREATE TABLE `order` (
    order_id INT PRIMARY KEY AUTO_INCREMENT,
    order_number VARCHAR(32) UNIQUE NOT NULL,
    user_id INT NOT NULL,
    total_amount DECIMAL(10,2) NOT NULL,
    payment_status TINYINT DEFAULT 0,
    order_status TINYINT DEFAULT 0,
    create_time DATETIME DEFAULT CURRENT_TIMESTAMP,
    pay_time DATETIME,
    delivery_time DATETIME,
    receive_time DATETIME,
    shipping_address TEXT NOT NULL,
    receiver_name VARCHAR(50) NOT NULL,
    receiver_phone VARCHAR(20) NOT NULL,
    FOREIGN KEY (user_id) REFERENCES user(user_id)
);

订单表通过状态字段的精细划分（支付状态、订单状态）实现了订单生命周期的完整追踪，时间戳字段记录了各个关键节点的时间，为数据分析和运营决策提供了有力支持。

核心功能模块深度解析

智能库存管理机制

库存管理是生鲜电商的核心环节，系统通过实时库存追踪和预警机制解决了传统生鲜行业的库存难题。

库存扣减的Service层实现：

@Service("inventoryService")
@Transactional
public class InventoryServiceImpl implements InventoryService {
    
    @Autowired
    private ProductDao productDao;
    
    @Autowired
    private InventoryLogDao inventoryLogDao;
    
    @Override
    public synchronized boolean deductInventory(Integer productId, Integer quantity, String orderNumber) {
        Product product = productDao.findById(productId);
        if (product == null || product.getStockQuantity() < quantity) {
            throw new InventoryShortageException("商品库存不足");
        }
        
        // 扣减库存
        int newStock = product.getStockQuantity() - quantity;
        product.setStockQuantity(newStock);
        productDao.update(product);
        
        // 记录库存变更日志
        InventoryLog log = new InventoryLog();
        log.setProductId(productId);
        log.setChangeType("SALE");
        log.setChangeQuantity(-quantity);
        log.setRemainingQuantity(newStock);
        log.setOrderNumber(orderNumber);
        log.setCreateTime(new Date());
        inventoryLogDao.save(log);
        
        // 触发低库存预警
        if (newStock < product.getSafetyStock()) {
            sendLowStockAlert(product);
        }
        
        return true;
    }
    
    private void sendLowStockAlert(Product product) {
        // 发送低库存预警通知
        System.out.println("商品【" + product.getProductName() + "】库存低于安全库存，请及时补货");
    }
}

该实现通过synchronized关键字确保在高并发场景下的库存数据一致性，避免超卖问题。同时记录详细的库存变更日志，为后续的数据分析和问题排查提供依据。

库存管理界面

订单处理流程优化

订单处理模块采用状态机模式管理订单生命周期，确保订单状态转换的逻辑严谨性。

订单状态管理的Action类实现：

public class OrderAction extends ActionSupport {
    private OrderService orderService;
    private Integer orderId;
    private Integer targetStatus;
    private Order order;
    
    public String updateOrderStatus() {
        try {
            order = orderService.findOrderById(orderId);
            if (order == null) {
                addActionError("订单不存在");
                return ERROR;
            }
            
            if (!OrderStatusValidator.isValidTransition(
                order.getOrderStatus(), targetStatus)) {
                addActionError("非法的订单状态转换");
                return ERROR;
            }
            
            orderService.updateOrderStatus(orderId, targetStatus);
            addActionMessage("订单状态更新成功");
            return SUCCESS;
            
        } catch (Exception e) {
            addActionError("订单状态更新失败: " + e.getMessage());
            return ERROR;
        }
    }
    
    // Getter和Setter方法
    public void setOrderService(OrderService orderService) {
        this.orderService = orderService;
    }
    
    public void setOrderId(Integer orderId) {
        this.orderId = orderId;
    }
    
    public void setTargetStatus(Integer targetStatus) {
        this.targetStatus = targetStatus;
    }
    
    public Order getOrder() {
        return order;
    }
}

订单状态验证器的实现：

@Component
public class OrderStatusValidator {
    
    private static final Map<Integer, Set<Integer>> validTransitions = 
        new HashMap<>();
    
    static {
        // 待支付 -> 已支付/已取消
        validTransitions.put(OrderStatus.UNPAID, 
            Set.of(OrderStatus.PAID, OrderStatus.CANCELLED));
        
        // 已支付 -> 已发货/退款中
        validTransitions.put(OrderStatus.PAID, 
            Set.of(OrderStatus.SHIPPED, OrderStatus.REFUNDING));
        
        // 已发货 -> 已完成
        validTransitions.put(OrderStatus.SHIPPED, 
            Set.of(OrderStatus.COMPLETED));
    }
    
    public static boolean isValidTransition(Integer currentStatus, Integer targetStatus) {
        Set<Integer> allowed = validTransitions.get(currentStatus);
        return allowed != null && allowed.contains(targetStatus);
    }
}

订单管理界面

商品分类体系设计

系统采用两级分类体系，支持灵活的商品组织和管理。

分类管理的Hibernate实体映射：

@Entity
@Table(name = "product_category")
public class ProductCategory {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "category_id")
    private Integer categoryId;
    
    @Column(name = "category_name", nullable = false, length = 50)
    private String categoryName;
    
    @Column(name = "parent_id")
    private Integer parentId;
    
    @Column(name = "sort_order")
    private Integer sortOrder;
    
    @Column(name = "is_visible")
    private Boolean visible;
    
    @OneToMany(mappedBy = "parentId", fetch = FetchType.LAZY)
    private Set<ProductCategory> children;
    
    @OneToMany(mappedBy = "category", fetch = FetchType.LAZY)
    private Set<Product> products;
    
    // 构造方法、getter和setter方法
    public ProductCategory() {}
    
    public ProductCategory(String categoryName, Integer parentId) {
        this.categoryName = categoryName;
        this.parentId = parentId;
        this.visible = true;
        this.sortOrder = 0;
    }
}

分类查询的DAO层实现：

@Repository("categoryDao")
public class CategoryDaoImpl extends HibernateDaoSupport implements CategoryDao {
    
    @Autowired
    public void setSessionFactoryOverride(SessionFactory sessionFactory) {
        super.setSessionFactory(sessionFactory);
    }
    
    @Override
    public List<ProductCategory> findRootCategories() {
        String hql = "FROM ProductCategory WHERE parentId IS NULL AND visible = true ORDER BY sortOrder";
        return (List<ProductCategory>) getHibernateTemplate().find(hql);
    }
    
    @Override
    public List<ProductCategory> findSubCategories(Integer parentId) {
        String hql = "FROM ProductCategory WHERE parentId = ? AND visible = true ORDER BY sortOrder";
        return (List<ProductCategory>) getHibernateTemplate().find(hql, parentId);
    }
    
    @Override
    public List<ProductCategory> findAllWithTreeStructure() {
        List<ProductCategory> roots = findRootCategories();
        for (ProductCategory root : roots) {
            root.setChildren(new HashSet<>(findSubCategories(root.getCategoryId())));
        }
        return roots;
    }
}

分类管理界面

用户权限管理安全机制

系统采用基于角色的访问控制（RBAC）模型，确保不同角色的用户只能访问授权资源。

权限拦截器的实现：

public class AuthorizationInterceptor extends AbstractInterceptor {
    
    private static final String[] EXCLUDE_ACTIONS = {
        "userLogin", "userRegister", "index", "productList"
    };
    
    @Override
    public String intercept(ActionInvocation invocation) throws Exception {
        String actionName = invocation.getProxy().getActionName();
        
        // 排除无需权限验证的action
        if (Arrays.asList(EXCLUDE_ACTIONS).contains(actionName)) {
            return invocation.invoke();
        }
        
        Map<String, Object> session = invocation.getInvocationContext().getSession();
        User user = (User) session.get("currentUser");
        
        if (user == null) {
            return "loginRedirect";
        }
        
        // 检查用户权限
        if (!hasPermission(user, actionName)) {
            return "noPermission";
        }
        
        return invocation.invoke();
    }
    
    private boolean hasPermission(User user, String actionName) {
        // 根据用户角色和action名称判断权限
        Set<String> permittedActions = getUserPermissions(user.getRole());
        return permittedActions.contains(actionName);
    }
    
    private Set<String> getUserPermissions(String role) {
        // 从数据库或配置文件中加载权限配置
        // 这里简化为硬编码示例
        Set<String> permissions = new HashSet<>();
        switch (role) {
            case "ADMIN":
                permissions.addAll(Arrays.asList(
                    "userManage", "productManage", "orderManage", 
                    "categoryManage", "inventoryManage"
                ));
                break;
            case "USER":
                permissions.addAll(Arrays.asList(
                    "shoppingCart", "orderHistory", "userProfile"
                ));
                break;
        }
        return permissions;
    }
}

购物车与订单生成逻辑

购物车模块采用Session和数据库双重存储策略，确保用户体验和数据持久性。

购物车Service的核心实现：

@Service("shoppingCartService")
@Transactional
public class ShoppingCartServiceImpl implements ShoppingCartService {
    
    @Autowired
    private CartItemDao cartItemDao;
    
    @Autowired
    private ProductDao productDao;
    
    @Override
    public void addToCart(Integer userId, Integer productId, Integer quantity) {
        CartItem existingItem = cartItemDao.findByUserAndProduct(userId, productId);
        
        if (existingItem != null) {
            // 更新已有商品数量
            existingItem.setQuantity(existingItem.getQuantity() + quantity);
            cartItemDao.update(existingItem);
        } else {
            // 新增购物车项
            CartItem newItem = new CartItem();
            newItem.setUserId(userId);
            newItem.setProductId(productId);
            newItem.setQuantity(quantity);
            newItem.setAddTime(new Date());
            cartItemDao.save(newItem);
        }
    }
    
    @Override
    public CartDTO getCartDetail(Integer userId) {
        List<CartItem> items = cartItemDao.findByUserId(userId);
        CartDTO cartDTO = new CartDTO();
        BigDecimal totalAmount = BigDecimal.ZERO;
        
        for (CartItem item : items) {
            Product product = productDao.findById(item.getProductId());
            CartItemDTO itemDTO = new CartItemDTO(item, product);
            cartDTO.addItem(itemDTO);
            totalAmount = totalAmount.add(itemDTO.getSubtotal());
        }
        
        cartDTO.setTotalAmount(totalAmount);
        cartDTO.setTotalItems(items.size());
        
        return cartDTO;
    }
}

购物车界面

实体模型与数据持久化设计

系统采用Hibernate实现对象关系映射，实体类设计充分体现了领域驱动设计的思想。

用户实体类的详细设计：

@Entity
@Table(name = "user")
public class User {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "user_id")
    private Integer userId;
    
    @Column(name = "username", unique = true, nullable = false, length = 50)
    private String username;
    
    @Column(name = "password", nullable = false, length = 100)
    private String password;
    
    @Column(name = "email", length = 100)
    private String email;
    
    @Column(name = "phone", length = 20)
    private String phone;
    
    @Column(name = "real_name", length = 50)
    private String realName;
    
    @Column(name = "role", length = 20)
    private String role = "USER";
    
    @Column(name = "registration_time")
    @Temporal(TemporalType.TIMESTAMP)
    private Date registrationTime;
    
    @Column(name = "last_login_time")
    @Temporal(TemporalType.TIMESTAMP)
    private Date lastLoginTime;
    
    @Column(name = "is_active")
    private Boolean active = true;
    
    @OneToMany(mappedBy = "user", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    private Set<Order> orders = new HashSet<>();
    
    @OneToMany(mappedBy = "user", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    private Set<Address> addresses = new HashSet<>();
    
    // 省略构造方法和其他方法
    
    public void addAddress(Address address) {
        addresses.add(address);
        address.setUser(this);
    }
    
    public void removeAddress(Address address) {
        addresses.remove(address);
        address.setUser(null);
    }
}

系统配置与集成策略

Spring的配置文件中体现了框架集成的核心思想：

applicationContext.xml的关键配置：

<!-- 数据源配置 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="com.mysql.jdbc.Driver"/>
    <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/fresh_mall"/>
    <property name="user" value="root"/>
    <property name="password" value="123456"/>
    <property name="maxPoolSize" value="50"/>
    <property name="minPoolSize" value="5"/>
    <property name="initialPoolSize" value="10"/>
</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.MySQL5Dialect</prop>
            <prop key="hibernate.show_sql">true</prop>
            <prop key="hibernate.format_sql">true</prop>
            <prop key="hibernate.hbm2ddl.auto">update</prop>
        </props>
    </property>
    <property name="packagesToScan">
        <list>
            <value>com.freshmall.entity</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"/>

<!-- Service层组件扫描 -->
<context:component-scan base-package="com.freshmall.service"/>

未来优化方向与技术演进

基于当前系统架构，提出以下优化建议：

1. 微服务架构改造 将单体应用拆分为商品服务、订单服务、用户服务、库存服务等微服务，提高系统可扩展性和团队开发效率。采用Spring Cloud技术栈实现服务治理、配置中心和链路追踪。

2. 引入Redis缓存集群 对热点商品数据、用户会话、购物车信息等使用Redis进行缓存，显著提升系统响应速度。实现多级缓存架构，降低数据库压力。

3. elasticsearch搜索优化 替代传统的数据库模糊查询，实现商品搜索的全文检索、拼音搜索、同义词扩展等高级功能，提升用户搜索体验。

4. 消息队列异步处理 引入RabbitMQ或Kafka处理高并发的订单创建、库存扣减、消息通知等场景，提高系统吞吐量和可靠性。

5. 大数据分析平台集成 构建用户行为分析、销售预测、库存优化等数据分析模块，为经营决策提供数据支持。

该系统通过SSH框架的有机整合，构建了一个功能完善、性能稳定的生鲜电商管理平台。其模块化设计和清晰的架构层次为后续的技术演进和功能

本文关键词
SSH框架生鲜电商管理系统库存管理数据库设计

上下篇

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