基于SSH框架的在线网络商城系统 - 源码深度解析

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

文章摘要

本系统是一款基于SSH（Struts2 + Spring + Hibernate）集成框架开发的在线网络商城，旨在为中小型企业及个人创业者提供一个功能完备、技术稳定、易于维护的电子商务解决方案。其核心业务价值在于将复杂的商品展示、交易流程与后台管理整合于一体，有效解决了传统线下门店或简易网店在商品管...

在电子商务蓬勃发展的时代背景下，传统零售模式正经历着深刻的数字化转型。对于众多中小型企业和个人创业者而言，自主搭建一个功能完善、运行稳定且易于维护的线上销售平台，是抓住市场机遇的关键。然而，技术门槛高、开发周期长、初期投入大等问题往往成为阻碍。“星辰商城”系统正是为解决这一痛点而设计，它基于成熟的SSH（Struts2 + Spring + Hibernate）集成框架，提供了一个开箱即用的企业级电子商务解决方案。

该系统采用经典的三层架构设计，将应用逻辑清晰地划分为表现层、业务逻辑层和持久层。这种分层模式不仅确保了代码的高内聚和低耦合，也极大地提升了系统的可扩展性和可维护性。表现层由Struts2框架负责，通过其强大的拦截器机制和类型转换功能，高效地处理用户请求与视图渲染。业务逻辑层依托Spring框架的IoC（控制反转）容器，对所有服务组件进行统一管理和依赖注入，同时利用其声明式事务管理能力，保障了如订单创建、库存扣减等核心业务操作的数据一致性。持久层则采用Hibernate作为ORM（对象关系映射）工具，将Java对象与数据库表进行映射，开发者可以更专注于面向对象的设计，而无需编写繁琐的SQL语句，从而提高了开发效率并降低了数据库操作的错误率。

数据库架构设计与核心表解析

一个稳健的电商系统，其根基在于精心设计的数据库模型。“星辰商城”的数据库由10张核心表构成，支撑着从用户管理、商品展示到订单交易的全流程业务。以下重点分析几个关键表的设计亮点。

1. 商品表 (product)

商品表是整个系统的数据核心，其设计直接影响到商品检索、展示和库存管理的效率。

CREATE TABLE `product` (
  `productId` INT NOT NULL AUTO_INCREMENT,
  `productName` VARCHAR(100) NOT NULL,
  `price` DECIMAL(10,2) NOT NULL,
  `stock` INT NOT NULL DEFAULT '0',
  `description` TEXT,
  `categoryId` INT NOT NULL,
  `imageUrl` VARCHAR(255),
  `status` TINYINT DEFAULT '1' COMMENT '1-上架, 0-下架',
  `createTime` DATETIME DEFAULT CURRENT_TIMESTAMP,
  `updateTime` DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (`productId`),
  KEY `idx_category` (`categoryId`),
  KEY `idx_status` (`status`),
  KEY `idx_name` (`productName`),
  CONSTRAINT `fk_product_category` FOREIGN KEY (`categoryId`) REFERENCES `product_category` (`categoryId`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

设计亮点分析：

  • 字段完整性：表结构涵盖了商品的基本信息（名称、价格）、库存状态、详细描述、分类归属以及可视化元素（图片链接），满足了前台展示和后台管理的全方位需求。
  • 索引优化：为categoryId、status和productName字段建立了索引。idx_category和idx_status联合使用可以高效地进行“某个分类下所有上架商品”的查询，这在商城首页按分类筛选商品时至关重要。idx_name索引则支持基于商品名称的模糊搜索，提升用户体验。
  • 数据约束与完整性：通过外键约束fk_product_category确保了每个商品都必须属于一个有效的商品分类，避免了脏数据的产生。AUTO_INCREMENT和DEFAULT值的使用也保证了数据的规范性和易用性。
  • 审计字段：createTime和updateTime字段自动记录数据的生命周期，对于数据追踪和运营分析非常有价值。

2. 订单主表 (order_main)

订单表是交易流程的枢纽，其设计需要兼顾查询性能与事务一致性。

CREATE TABLE `order_main` (
  `orderId` VARCHAR(32) NOT NULL,
  `userId` INT NOT NULL,
  `totalAmount` DECIMAL(10,2) NOT NULL,
  `orderStatus` TINYINT NOT NULL COMMENT '0-待支付, 1-已支付, 2-已发货, 3-已完成, 4-已取消',
  `paymentMethod` VARCHAR(20),
  `shippingAddress` TEXT NOT NULL,
  `createTime` DATETIME DEFAULT CURRENT_TIMESTAMP,
  `payTime` DATETIME,
  PRIMARY KEY (`orderId`),
  KEY `idx_user` (`userId`),
  KEY `idx_status` (`orderStatus`),
  KEY `idx_create_time` (`createTime`),
  CONSTRAINT `fk_order_user` FOREIGN KEY (`userId`) REFERENCES `user` (`userId`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

设计亮点分析：

  • 主键选择：没有使用常见的自增整数，而是采用了自定义的32位字符串（如UUID）作为主键orderId。这样做的好处在于，在分布式系统或数据迁移场景下，可以避免主键冲突，更具灵活性。同时，订单号本身可以直接作为业务标识使用。
  • 状态驱动：orderStatus字段清晰地定义了订单的生命周期状态。这种状态机模式是业务逻辑实现的基础，系统可以根据状态的变化触发不同的后续操作，例如支付成功后减库存、发货后发送通知等。
  • 复合查询优化：索引idx_user和idx_status的组合，可以极快地查询出“某个用户的所有待支付订单”。idx_create_time索引则便于进行按时间段的订单统计和数据分析，是后台报表功能的核心支撑。

核心功能实现深度解析

1. 用户认证与状态管理

用户登录是系统安全的门户。Struts2的Action负责处理登录请求，Spring管理的Service层处理业务逻辑，Hibernate负责数据持久化。

表现层 - LoginAction.java:

public class LoginAction extends ActionSupport {
    private String username;
    private String password;
    private UserService userService; // 由Spring注入

    // Struts2 自动将表单参数注入到此处
    public void setUsername(String username) { this.username = username; }
    public void setPassword(String password) { this.password = password; }

    public String execute() {
        try {
            User user = userService.authenticate(username, password);
            if (user != null) {
                // 登录成功，将用户信息存入Session
                Map session = ActionContext.getContext().getSession();
                session.put("currentUser", user);
                return SUCCESS;
            } else {
                addActionError("用户名或密码错误！");
                return ERROR;
            }
        } catch (Exception e) {
            addActionError("系统错误，登录失败！");
            return ERROR;
        }
    }
}

用户登录界面

业务逻辑层 - UserServiceImpl.java:

@Service("userService")
@Transactional // Spring声明式事务管理
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;

    @Override
    public User authenticate(String username, String password) {
        // 1. 根据用户名查询用户
        User user = userDao.findByUsername(username);
        if (user == null) {
            return null;
        }
        // 2. 对输入的密码进行加密后与数据库中的密文比对（此处为简化示例，实际应使用BCrypt等强哈希算法）
        String encryptedInputPassword = DigestUtils.md5DigestAsHex(password.getBytes());
        if (encryptedInputPassword.equals(user.getPassword())) {
            return user;
        }
        return null;
    }
}

技术要点：整个流程体现了SSH框架的完美协作。Struts2 Action作为控制器，干净利落地处理请求和响应；Spring的@Service和@Transactional注解将业务类纳入IoC容器管理并添加事务支持；Hibernate的UserDao则通过ORM方式安全地访问数据库。

2. 商品加入购物车与Session管理

购物车功能通常利用HttpSession在服务器端临时存储用户的选择，无需立即与数据库交互，保证响应速度。

CartAction.java (添加商品到购物车):

public class CartAction extends ActionSupport {
    private Integer productId;
    private Integer quantity;

    public String addItem() {
        // 从Session中获取购物车对象
        Map<Integer, CartItem> cart = (Map<Integer, CartItem>) ActionContext.getContext().getSession().get("cart");
        if (cart == null) {
            cart = new HashMap<>();
            ActionContext.getContext().getSession().put("cart", cart);
        }

        // 查询商品信息
        Product product = productService.getProductById(productId);
        if (product != null && product.getStock() >= quantity) {
            CartItem item = cart.get(productId);
            if (item != null) {
                // 如果购物车中已有该商品，更新数量
                item.setQuantity(item.getQuantity() + quantity);
            } else {
                // 否则，创建新的购物车项
                item = new CartItem(product, quantity);
                cart.put(productId, item);
            }
            addActionMessage("商品已成功加入购物车！");
        } else {
            addActionError("商品不存在或库存不足！");
        }
        return SUCCESS;
    }
}

添加商品到购物车

技术要点：此功能展示了无状态HTTP协议下状态保持的技巧。购物车数据保存在用户会话中，减轻了数据库的压力。CartItem是一个自定义的JavaBean，封装了商品信息和购买数量，这种面向对象的设计使得业务逻辑清晰易懂。

3. 下单与事务管理

下单是电商系统最核心、最复杂的业务流程，涉及库存检查、扣减、订单创建、订单项创建等多个数据库操作，必须在一个事务内完成，确保数据一致性。

OrderServiceImpl.java (创建订单):

@Override
@Transactional(rollbackFor = Exception.class) // 声明式事务，遇到任何异常都回滚
public OrderMain createOrder(Integer userId, Map<Integer, CartItem> cart, String address) throws BusinessException {
    // 1. 验证购物车和库存
    for (CartItem item : cart.values()) {
        Product product = productDao.get(item.getProduct().getProductId());
        if (product.getStock() < item.getQuantity()) {
            throw new BusinessException("商品 [" + product.getProductName() + "] 库存不足！");
        }
    }

    // 2. 创建订单主信息
    OrderMain order = new OrderMain();
    order.setOrderId(generateOrderId()); // 生成唯一订单号
    order.setUserId(userId);
    order.setShippingAddress(address);
    order.setOrderStatus(0); // 待支付
    // 计算总金额...
    order.setTotalAmount(calculateTotal(cart));

    // 3. 扣减库存并创建订单明细
    List<OrderDetail> details = new ArrayList<>();
    for (CartItem cartItem : cart.values()) {
        Product product = productDao.get(cartItem.getProduct().getProductId());

        // 扣减库存
        product.setStock(product.getStock() - cartItem.getQuantity());
        productDao.update(product); // Hibernate更新

        // 创建订单明细
        OrderDetail detail = new OrderDetail();
        detail.setOrderMain(order);
        detail.setProduct(product);
        detail.setQuantity(cartItem.getQuantity());
        detail.setUnitPrice(product.getPrice());
        details.add(detail);
    }
    order.setOrderDetails(details);

    // 4. 保存订单（主表和明细表）
    orderDao.save(order);
    return order;
}

提交订单信息

技术要点：该方法被@Transactional注解标记，这是Spring框架声明式事务管理的体现。如果在扣减库存或保存订单的任何一步发生异常，整个事务都会回滚，数据库将恢复到方法执行前的状态，有效防止了“超卖”或数据不一致的问题。这是保证交易安全性的关键技术。

4. 后台商品管理

后台管理功能允许管理员对商品进行增删改查，并通过Hibernate的强大查询能力实现分页和条件过滤。

ProductAction.java (分页查询商品列表):

public class ProductAction extends ActionSupport {
    private List<Product> productList;
    private int page = 1; // 当前页码
    private int pageSize = 10; // 每页记录数
    private int totalPages; // 总页数
    private String searchName; // 搜索条件

    public String list() {
        // 调用Service层方法，获取分页数据
        PageBean<Product> pageBean = productService.getProductsByPage(page, pageSize, searchName);
        this.productList = pageBean.getList();
        this.totalPages = pageBean.getTotalPages();
        return SUCCESS;
    }
    // ... getters and setters
}

ProductServiceImpl.java:

@Override
@Transactional(readOnly = true) // 只读事务，提升查询性能
public PageBean<Product> getProductsByPage(int page, int pageSize, String searchName) {
    PageBean<Product> pageBean = new PageBean<>();
    pageBean.setCurrentPage(page);
    pageBean.setPageSize(pageSize);

    // 使用Hibernate Criteria API构建动态查询
    Criteria criteria = sessionFactory.getCurrentSession().createCriteria(Product.class);
    
    // 添加搜索条件
    if (searchName != null && !searchName.trim().isEmpty()) {
        criteria.add(Restrictions.like("productName", "%" + searchName + "%"));
    }

    // 查询总记录数
    criteria.setProjection(Projections.rowCount());
    Long totalCount = (Long) criteria.uniqueResult();
    pageBean.setTotalCount(totalCount.intValue());

    // 清除投影，设置分页，查询当前页数据
    criteria.setProjection(null);
    criteria.setFirstResult((page - 1) * pageSize);
    criteria.setMaxResults(pageSize);
    criteria.setResultTransformer(Criteria.ROOT_ENTITY); // 确保返回的是Product对象列表

    List<Product> list = criteria.list();
    pageBean.setList(list);

    return pageBean;
}

后台商品管理

技术要点：这里展示了Hibernate Criteria API的灵活运用。它提供了一种面向对象的、类型安全的方式来构建查询，避免了拼接HQL或SQL字符串的麻烦和潜在风险。readOnly=true的事务属性提示数据库这是一个只读操作，某些数据库优化器可以据此进行性能优化。

实体模型与对象关系映射

Hibernate的核心在于ORM。系统通过精心设计的实体类及其关联映射，将数据库表结构转化为面向对象的模型。

订单与订单明细的一对多关系映射：

OrderMain.java (订单主实体):

@Entity
@Table(name = "order_main")
public class OrderMain implements Serializable {
    @Id
    private String orderId;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "userId")
    private User user;

    private BigDecimal totalAmount;
    private Integer orderStatus;

    // 一对多关系：一个订单包含多个明细
    @OneToMany(mappedBy = "orderMain", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    private Set<OrderDetail> orderDetails = new HashSet<>();

    // ... 其他字段及getter/setter
}

OrderDetail.java (订单明细实体):

@Entity
@Table(name = "order_detail")
public class OrderDetail {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long detailId;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "orderId")
    private OrderMain orderMain;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "productId")
    private Product product;

    private Integer quantity;
    private BigDecimal unitPrice;

    // ... getter/setter
}

技术要点：通过@OneToMany和@ManyToOne注解，清晰地定义了订单与明细之间的双向关联关系。cascade = CascadeType.ALL表示对主订单的保存、更新、删除等操作会级联影响到所有关联的明细，这在创建订单时非常方便，只需保存OrderMain对象，其下的OrderDetail集合会自动被持久化。fetch = FetchType.LAZY（延迟加载）是重要的性能优化手段，它意味着只有在真正访问orderDetails集合时，Hibernate才会去数据库加载这些数据，避免了不必要的查询。

功能展望与系统优化方向

“星辰商城”作为一个功能完备的基础版本，在未来仍有广阔的优化和扩展空间。

  1. 引入Redis缓存层：当前系统频繁访问的商品信息、分类信息等热点数据，可以存入Redis等内存数据库中，极大减轻MySQL的读取压力，提升系统响应速度。例如，将热门商品列表缓存10分钟，首页的QPS（每秒查询率）将得到显著提升。
  2. 实现分布式会话管理：目前用户会话（Session）存储在单个应用服务器的内存中，这在集群部署环境下会导致会话丢失问题。可以引入Spring Session框架，将会话数据存储到Redis或数据库中，实现会话共享，使系统具备横向扩展能力。
  3. 集成第三方支付与物流接口：将支付功能从模拟流程升级为集成支付宝、微信支付等真实支付网关。同时，对接快递鸟、菜鸟等物流接口，实现自动获取物流单号和实时轨迹跟踪，提升业务流程的自动化程度。
  4. 构建前后端分离架构：当前系统采用JSP作为视图技术，属于传统单体架构。未来可以考虑将前端与后端彻底分离，后端提供RESTful API，前端使用Vue.js、React等现代框架开发SPA（单页应用）。这种架构更利于团队协作、独立部署和用户体验的提升。
  5. 增强搜索功能与推荐算法：集成Elasticsearch替代数据库的LIKE查询，实现商品标题、描述的全文检索、拼音搜索和同义词搜索，并提供复杂的排序和聚合功能。在此基础上，可以基于用户的浏览和购买历史，实现简单的协同过滤推荐算法，为用户展示“猜你喜欢”的商品，提升转化率。

该系统作为SSH框架应用的典范，不仅实现了电子商务的核心功能，其清晰的三层架构、严谨的事务控制和高内聚低耦合的模块设计，为后续的功能扩展和技术演进

本文关键词
SSH框架在线网络商城源码解析数据库架构核心表设计

上下篇

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