Skip to content

项目:家居网购-下 ​

[TOC]

购物车导购业务 ​

概述 ​

购物车导购业务连接前台商品展示与订单交易结算两大模块,承担顾客从进入商城门户、浏览与按名称检索家居商品、将心仪商品加入购物车,到在购物车页面核对与调整采购明细的完整导购闭环。

导购与加购业务闭环 ​

前台导购与购物车管理围绕“商品检索展示”与“会话级采购暂存”两条主线展开,业务流转过程分为四个阶段:

image-20261109161053098

  1. 门户入口自动分发:顾客访问商城首页根路径(web/index.jsp)时,系统不直接渲染静态页面,而是自动将请求转发至前台导购控制器 CustomerFurnServlet 的 pageByName 业务动作,默认拉取第 1 页商品数据并渲染前台商城首页(views/customer/index.jsp)。

  2. 首页商品分页检索:顾客在商城首页可通过顶部搜索框输入家居名称关键字,或点击底部分页导航条切换页码。CustomerFurnServlet 根据关键字与分页参数查询匹配的 Page<Furn> 分页模型,并将搜索关键字回传绑定至分页导航条 URL 中,确保翻页过程中检索条件不丢失。

  3. 商品加购与库存校验:顾客在首页商品卡片点击“加入购物车”按钮时,前端首先校验该商品实时库存是否为 0;若库存充足,则向 CartServlet 发起加购请求(支持表单同步跳转 addItem 与 Ajax 异步刷新 addItemByAjax 两种交互方式),将目标 Furn 转换为 CartItem 存入当前顾客的 HttpSession 购物车对象 Cart 中,并实时刷新页面右上角的购物车总件数角标。

  4. 购物车明细维护:顾客点击右上角购物车图标进入购物车详情页(views/cart/cart.jsp),可查看已加购商品列表、单品小计、整车总件数与应付总金额,并可执行修改购买数量(updateCount)、移除单件商品(deleteItem)或清空整车(clear)等维护操作,确认无误后点击“去结账”进入订单结算流程。

jsp
<%-- 1. 网站根入口自动转发至前台导购控制器,默认加载第 1 页家居商品数据 --%>
<jsp:forward page="/customerFurnServlet?action=pageByName&pageNo=1"></jsp:forward>

业务组件与视图职责 ​

购物车导购业务涉及的前后端视图、控制器、业务接口与领域实体分工如下:

组件 / 视图名称所属层级核心业务职责
web/index.jsp门户入口视图拦截商城根路径访问请求,自动转发至 CustomerFurnServlet 加载首页商品分页数据
views/customer/index.jsp前台导购视图展示家居商品卡片列表、搜索栏、分页导航条及右上角购物车商品总件数角标,绑定加购事件
views/cart/cart.jsp购物车详情视图展示当前会话已加购的 CartItem 明细列表、整车总件数与总金额,提供数量修改、删除、清空及结账入口
CustomerFurnServlet前台导购控制器接收首页商品分页与关键字检索请求(pageByName),封装分页数据与检索链路参数并转发至前台首页
CartServlet购物车控制器承接商品加购(addItem、addItemByAjax)、数量更新(updateCount)、单品删除(deleteItem)与清空购物车(clear)请求
FurnService商品业务接口为前台导购提供按名称分页查询(pageByName),并为购物车加购动作提供按编号查询商品详情(queryFurnById)支撑
CartItem购物车明细实体封装购物车中单种家居商品的购买快照(编号、名称、单价、购买数量、单品小计金额)
Cart购物车领域模型驻留于 HttpSession 中,以 HashMap<Integer, CartItem> 维护当前顾客的全部采购明细,负责汇总整车总件数与总金额

CartItem ​

CartItem 对应购物车列表中的单行商品记录。当顾客在商城首页将某款家居商品加入购物车时,系统从数据库查询出最新的 Furn 商品信息,提取其编号(id)、名称(name)与单价(price),结合购买数量(count)与小计金额(totalPrice)构建 CartItem 实例:

java
package com.hspedu.furns.entity;

import java.math.BigDecimal;

// 1. 购物车商品明细项实体,封装单种家居商品的加购快照
public class CartItem {
  private Integer id;
  private String name;
  private BigDecimal price;
  private Integer count;
  private BigDecimal totalPrice;

  // 2. 初始化购物车商品项,记录商品编号、名称、单价、数量与初始小计金额
  public CartItem(Integer id, String name, BigDecimal price, Integer count, BigDecimal totalPrice) {
    this.id = id;
    this.name = name;
    this.price = price;
    this.count = count;
    this.totalPrice = totalPrice;
  }

  // 3. 读写商品购买数量与小计金额的访问方法
  public Integer getId() {
    return id;
  }

  public Integer getCount() {
    return count;
  }

  public void setCount(Integer count) {
    this.count = count;
  }

  public BigDecimal getPrice() {
    return price;
  }

  public BigDecimal getTotalPrice() {
    return totalPrice;
  }

  public void setTotalPrice(BigDecimal totalPrice) {
    this.totalPrice = totalPrice;
  }
}

Cart ​

家居网购项目的购物车采用会话级内存模型设计,不单独设立数据库表,而是将 Cart 实例直接保存在当前顾客的 HttpSession(属性名为 cart)中。Cart 内部通过 HashMap<Integer, CartItem> 组织数据,以商品编号 id 作为键,保证同一商品重复加购时直接合并数量与小计金额,不会产生重复行记录。

同时,Cart 对外提供 isEmpty、getTotalCount 与 getCartTotalPrice 属性计算方法,供前端 JSP 页面通过 EL 表达式(如 ${sessionScope.cart.totalCount}、${sessionScope.cart.cartTotalPrice})实时读取购物车状态、商品总件数与应付总金额:

java
package com.hspedu.furns.entity;

import java.math.BigDecimal;
import java.util.HashMap;
import java.util.Set;

// 1. 购物车会话模型,使用商品编号作为键管理多条 CartItem 明细
public class Cart {
  private HashMap<Integer, CartItem> items = new HashMap<>();

  // 2. 判断当前购物车是否为空,供前端页面控制空车提示与结账入口显隐
  public boolean isEmpty() {
    return items.size() == 0;
  }

  // 3. 遍历购物车全部明细项,累加计算商品总件数
  public Integer getTotalCount() {
    int totalCount = 0;
    Set<Integer> keys = items.keySet();
    for (Integer id : keys) {
      totalCount += items.get(id).getCount();
    }
    return totalCount;
  }

  // 4. 遍历购物车全部明细项,累加各明细小计得出整车应付总金额
  public BigDecimal getCartTotalPrice() {
    BigDecimal cartTotalPrice = new BigDecimal(0);
    Set<Integer> keys = items.keySet();
    for (Integer id : keys) {
      cartTotalPrice = cartTotalPrice.add(items.get(id).getTotalPrice());
    }
    return cartTotalPrice;
  }

  // 5. 暴露底层商品明细集合,供前端 EL 表达式遍历渲染购物车列表
  public HashMap<Integer, CartItem> getItems() {
    return items;
  }
}

首页商品分页检索 ​

首页商品分页检索业务将“商城门户初始商品展示”与“顶部搜索框按名称模糊查询”统一收敛至同一条业务链路(pageByName)中处理,并通过在分页模型 Page<Furn> 中动态绑定检索 URL,解决顾客在搜索结果页点击翻页时检索关键字丢失的问题。

分页检索业务流程 ​

顾客从进入商城首页、输入关键字搜索商品到点击页码翻页的完整业务流转过程分为四个步骤:

image-20261109161125948

  1. 检索请求触发:顾客首次访问 web/index.jsp 自动转发,或在 views/customer/index.jsp 顶部搜索栏输入家居名称点击“搜索”,抑或点击底部分页条页码,均向 CustomerFurnServlet 发送携带 action=pageByName 的请求。

  2. 参数归一化与链路拼接:CustomerFurnServlet 提取目标页码 pageNo(默认 1)、每页容量 pageSize(默认 4)及搜索关键字 name。若未传递 name 参数则将其归一化为空字符串 "";在获取分页数据后,将非空的 &name=关键字 追加至基础分页路径 customerFurnServlet?action=pageByName 末尾,并存入 Page 对象的 url 属性中。

  3. 分页模型组装:FurnServiceImpl 依次调用 FurnDAO 统计符合关键字的商品总记录数 totalRow、折算总页数 pageTotalCount,再计算当前页物理偏移量 begin 拉取当前页商品集合 items,封装为 Page<Furn> 返回。

  4. 商品卡片与分页条渲染:请求转发至 views/customer/index.jsp 后,视图层遍历 page.items 渲染家居商品卡片,并在底部分页导航条的每个页码超链接中直接引用 ${requestScope.page.url}&pageNo=目标页码,实现带条件的连续翻页。

FurnDAOImpl ​

持久层通过两个方法配合完成带条件的物理分页:首先使用 COUNT(*) 结合 LIKE 模糊匹配统计满足搜索关键字的商品总行数,随后通过 LIMIT ?, ? 截取当前页对应的商品记录列表。当搜索关键字为空字符串 "" 时,拼接后的通配符为 "%%",自动退化为查询全表商品:

sql
-- 1. 统计名称包含指定关键字的家居商品总记录数
SELECT COUNT(*)
    FROM `furn`
    WHERE `name` LIKE ?;

-- 2. 按名称关键字模糊检索并截取当前页的商品列表数据
SELECT `id`, `name`, `maker`, `price`, `sales`, `stock`, `img_path` AS `imgPath`
    FROM `furn`
    WHERE `name` LIKE ?
    LIMIT ?, ?;

FurnDAOImpl 在执行上述两条 SQL 时,负责在传入的 name 参数前后拼接 % 通配符:

java
package com.hspedu.furns.dao.impl;

import com.hspedu.furns.dao.FurnDAO;
import com.hspedu.furns.entity.Furn;
import java.util.List;

// 1. 家居商品持久层实现类,提供按名称模糊匹配的分页统计与列表查询
public class FurnDAOImpl extends BasicDAO<Furn> implements FurnDAO {

  // 2. 拼接百分号通配符,统计符合名称关键字的商品总行数
  @Override
  public int getTotalRowByName(String name) {
    String sql = "SELECT COUNT(*) FROM `furn` WHERE `name` LIKE ?";
    return ((Number) queryScalar(sql, "%" + name + "%")).intValue();
  }

  // 3. 根据起始索引、每页容量与名称关键字查询当前页商品集合
  @Override
  public List<Furn> getPageItemsByName(int begin, int pageSize, String name) {
    String sql = "SELECT `id`, `name`, `maker`, `price`, `sales`, " +
        "`stock`, `img_path` AS `imgPath` FROM `furn` " +
        "WHERE `name` LIKE ? LIMIT ?, ?";
    return queryMulti(sql, Furn.class, "%" + name + "%", begin, pageSize);
  }
}

FurnServiceImpl ​

FurnServiceImpl 中的 pageByName 方法负责将分散的分页参数与持久层查询结果组装为完整的 Page<Furn> 实体。业务层先查询匹配关键字的 totalRow 并根据能否整除 pageSize 算出总页数 pageTotalCount,再按照 (pageNo - 1) * pageSize 计算数据库表起始偏移量 begin,拉取当前页展示的 Furn 列表:

java
package com.hspedu.furns.service.impl;

import com.hspedu.furns.dao.FurnDAO;
import com.hspedu.furns.dao.impl.FurnDAOImpl;
import com.hspedu.furns.entity.Furn;
import com.hspedu.furns.entity.Page;
import com.hspedu.furns.service.FurnService;
import java.util.List;

// 1. 商品业务层实现类,编排总记录统计与分页数据拉取逻辑
public class FurnServiceImpl implements FurnService {

  // 2. 初始化商品持久层组件 FurnDAO
  private FurnDAO furnDAO = new FurnDAOImpl();

  // 3. 按商品名称关键字构建并返回完整的 Page 分页模型对象
  @Override
  public Page<Furn> pageByName(int pageNo, int pageSize, String name) {
    Page<Furn> page = new Page<>();
    page.setPageNo(pageNo);
    page.setPageSize(pageSize);

    // 4. 查询匹配关键字的商品总记录数,并计算总页数
    int totalRow = furnDAO.getTotalRowByName(name);
    page.setTotalRow(totalRow);
    int pageTotalCount = totalRow / pageSize;
    if (totalRow % pageSize > 0) {
      pageTotalCount += 1;
    }
    page.setPageTotalCount(pageTotalCount);

    // 5. 计算当前页物理偏移量 begin,拉取当前页商品列表并封装返回
    int begin = (pageNo - 1) * pageSize;
    List<Furn> items = furnDAO.getPageItemsByName(begin, pageSize, name);
    page.setItems(items);
    return page;
  }
}

CustomerFurnServlet ​

CustomerFurnServlet 负责承接前端检索请求并维护翻页条件链路。当顾客从门户首页初次进入时,请求未携带 name 参数,pageByName 将 null 归一化为 "" 以查询全部商品;当顾客输入关键字搜索时,pageByName 将 &name=关键字 拼接到 url 中并写入 page.setUrl(...),使前端分页导航条在翻页时自动携带原搜索词:

java
package com.hspedu.furns.web;

import com.hspedu.furns.entity.Furn;
import com.hspedu.furns.entity.Page;
import com.hspedu.furns.service.FurnService;
import com.hspedu.furns.service.impl.FurnServiceImpl;
import com.hspedu.furns.utils.DataUtils;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

// 1. 前台顾客导购控制器,承接商城首页商品分页展示与名称检索请求
public class CustomerFurnServlet extends BasicServlet {

  // 2. 声明并初始化商品业务层组件 FurnService
  private FurnService furnService = new FurnServiceImpl();

  // 3. 处理首页商品分页检索请求,兼容初始全量加载与关键字模糊搜索
  protected void pageByName(HttpServletRequest req, HttpServletResponse resp)
      throws ServletException, IOException {
    // 4. 解析目标页码与每页容量,未传递时默认查第 1 页且每页展示 4 条
    int pageNo = DataUtils.parseInt(req.getParameter("pageNo"), 1);
    int pageSize = DataUtils.parseInt(req.getParameter("pageSize"), Page.PAGE_SIZE);

    // 5. 提取搜索关键字,若未携带参数则归一化为空字符串以查询全量商品
    String name = req.getParameter("name");
    if (null == name) {
      name = "";
    }

    // 6. 调用业务层获取分页模型,并拼接携带检索关键字的分页导航基础 URL
    Page<Furn> page = furnService.pageByName(pageNo, pageSize, name);
    StringBuilder url = new StringBuilder("customerFurnServlet?action=pageByName");
    if (!"".equals(name)) {
      url.append("&name=").append(name);
    }
    page.setUrl(url.toString());

    // 7. 将分页模型存入 Request 域并请求转发至前台商城首页视图
    req.setAttribute("page", page);
    req.getRequestDispatcher("/views/customer/index.jsp").forward(req, resp);
  }
}

首页视图渲染与翻页保持 ​

在前台商城首页视图(views/customer/index.jsp)中,顶部搜索表单、中部商品展示列表与底部分页导航条通过 requestScope.page 协同工作。底部分页导航条无需感知当前是否处于关键字搜索状态,直接将 ${requestScope.page.url} 作为超链接前缀并追加 &pageNo=${i},即可在翻页时自动保留搜索条件:

jsp
<%-- 1. 顶部家居名称搜索表单,提交至 CustomerFurnServlet 的 pageByName 方法 --%>
<form action="customerFurnServlet" method="post">
    <input type="hidden" name="action" value="pageByName"/>
    <input type="text" name="name" placeholder="请输入家居名称"/>
    <button type="submit">搜索</button>
</form>

<%-- 2. 遍历当前页商品集合,渲染商城首页家居商品展示卡片 --%>
<c:forEach items="${requestScope.page.items}" var="furn">
    <div class="product">
        <img src="${furn.imgPath}" alt="Product"/>
        <h5>${furn.name}</h5>
        <ul>
            <li>厂商: ${furn.maker}</li>
            <li>价格: ¥${furn.price}</li>
            <li>销量: ${furn.sales} | 库存: ${furn.stock}</li>
        </ul>
    </div>
</c:forEach>

<%-- 3. 底部分页导航条,直接复用已绑定检索关键字的 page.url 拼接目标页码 --%>
<div class="pro-pagination-style">
    <ul>
        <c:if test="${requestScope.page.pageNo > 1}">
            <li><a href="${requestScope.page.url}&pageNo=${requestScope.page.pageNo - 1}">上页</a></li>
        </c:if>
        <c:forEach begin="1" end="${requestScope.page.pageTotalCount}" var="i">
            <li><a href="${requestScope.page.url}&pageNo=${i}">${i}</a></li>
        </c:forEach>
        <c:if test="${requestScope.page.pageNo < requestScope.page.pageTotalCount}">
            <li><a href="${requestScope.page.url}&pageNo=${requestScope.page.pageNo + 1}">下页</a></li>
        </c:if>
    </ul>
</div>

购物车商品加购 ​

购物车商品加购业务负责承接顾客在商城首页发起的商品选购动作。系统在前端对缺货商品进行拦截,在后端根据商品编号查询实时商品数据并封装为 CartItem,合并至当前会话的 Cart 模型中,同时提供基于 Referer 的同步跳回与基于 Gson 的 Ajax 异步角标刷新两种业务交付路径。

加购业务流程 ​

顾客在商城首页点击“Add To Cart”将家居商品加入购物车的完整业务流转过程分为四个步骤:

image-20261109161149970

  1. 前端库存校验与加购触发:商城首页(views/customer/index.jsp)在渲染每个商品卡片时,先判断当前商品的实时库存 furn.stock 是否大于 0。若库存为 0,按钮禁用并提示“暂时缺货”;若库存充足,顾客点击按钮后读取自定义属性 furnId,向 CartServlet 发送携带商品编号 id 的加购请求。

  2. 商品核验与明细封装:CartServlet 接收商品编号 id 后,调用 FurnService.queryFurnById(id) 从数据库查询最新的 Furn 实体。确认商品存在且库存有效后,提取其编号、名称与单价,构建初始购买数量为 1、初始小计金额等于单价的 CartItem 实例。

  3. 会话购物车获取与合并:控制器从当前顾客的 HttpSession 中获取属性名为 cart 的 Cart 对象;若顾客是首次加购(cart == null),则新建 Cart 实例并绑定至 HttpSession 中,随后调用 cart.addItem(item) 按商品编号合并采购数量与小计金额。

  4. 原页状态保持与角标更新:

    • 在同步加购链路(addItem)中,控制器读取 HTTP 请求头中的 Referer 地址,重定向回顾客发起加购前所在的导购分页或搜索结果页。
    • 在异步加购链路(addItemByAjax)中,控制器调用 cart.getTotalCount() 汇总最新整车商品总件数,通过 Gson 序列化为 JSON 响应流返回前端,由前端脚本局部刷新页面右上角的购物车件数角标,避免整页刷新导致页面滚动位置重置。

Cart ​

Cart 模型的 addItem 方法负责处理同一商品的重复加购合并逻辑。当新构建的 CartItem 传入时,系统以商品编号 cartItem.getId() 作为键在 items 集合中检索:若返回 null 说明首次选购该商品,直接存入集合;若已存在对应记录,则在原购买数量 count 基础上加 1,并将原小计金额 totalPrice 与商品单价 price 累加:

java
package com.hspedu.furns.entity;

import java.math.BigDecimal;
import java.util.HashMap;

// 1. 购物车领域模型,维护当前会话中的商品加购明细集合
public class Cart {
  private HashMap<Integer, CartItem> items = new HashMap<>();

  // 2. 将目标家居商品项加入购物车,按商品编号自动合并重复加购项
  public void addItem(CartItem cartItem) {
    CartItem item = items.get(cartItem.getId());

    // 3. 若购物车中尚无该商品,则直接作为新明细项存入集合
    if (null == item) {
      items.put(cartItem.getId(), cartItem);
    } else {
      // 4. 若已存在该商品,则购买数量加 1 并累加更新单品小计金额
      item.setCount(item.getCount() + 1);
      item.setTotalPrice(item.getTotalPrice().add(item.getPrice()));
    }
  }
}

CartServlet ​

CartServlet 提供 addItem 与 addItemByAjax 两个业务入口。两者共享相同的商品查询、库存校验与 Session 购物车合并流程,区别在于响应交付方式:addItem 通过重定向回 Referer 地址刷新整页,而 addItemByAjax 将最新的 cartTotalCount 封装进 Map 并转为 JSON 字符串写回客户端:

java
package com.hspedu.furns.web;

import com.google.gson.Gson;
import com.hspedu.furns.entity.Cart;
import com.hspedu.furns.entity.CartItem;
import com.hspedu.furns.entity.Furn;
import com.hspedu.furns.service.FurnService;
import com.hspedu.furns.service.impl.FurnServiceImpl;
import com.hspedu.furns.utils.DataUtils;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

// 1. 购物车业务控制器,处理商品同步加购与 Ajax 异步加购请求
public class CartServlet extends BasicServlet {

  // 2. 初始化商品业务层组件,用于按编号查询待加购的家居商品详情
  private FurnService furnService = new FurnServiceImpl();

  // 3. 同步加购流程:将商品加入 Session 购物车后重定向回原导购页面
  protected void addItem(HttpServletRequest req, HttpServletResponse resp)
      throws ServletException, IOException {
    int id = DataUtils.parseInt(req.getParameter("id"), 0);
    Furn furn = furnService.queryFurnById(id);
    if (null == furn || furn.getStock() <= 0) {
      resp.sendRedirect(req.getHeader("Referer"));
      return;
    }

    // 4. 构建初始数量为 1 的购物车明细项,并获取或创建会话级 Cart 对象
    CartItem item = new CartItem(furn.getId(), furn.getName(), furn.getPrice(), 1, furn.getPrice());
    Cart cart = (Cart) req.getSession().getAttribute("cart");
    if (null == cart) {
      cart = new Cart();
      req.getSession().setAttribute("cart", cart);
    }
    cart.addItem(item);

    // 5. 读取请求头 Referer,重定向回发起加购动作的商品列表页
    String referer = req.getHeader("Referer");
    resp.sendRedirect(referer);
  }

  // 6. 异步加购流程:加购完成后通过 JSON 返回最新购物车总件数
  protected void addItemByAjax(HttpServletRequest req, HttpServletResponse resp)
      throws ServletException, IOException {
    int id = DataUtils.parseInt(req.getParameter("id"), 0);
    Furn furn = furnService.queryFurnById(id);
    if (null == furn || furn.getStock() <= 0) {
      return;
    }

    // 7. 将商品合并至 Session 购物车,统计整车商品总件数写回前端
    CartItem item = new CartItem(furn.getId(), furn.getName(), furn.getPrice(), 1, furn.getPrice());
    Cart cart = (Cart) req.getSession().getAttribute("cart");
    if (null == cart) {
      cart = new Cart();
      req.getSession().setAttribute("cart", cart);
    }
    cart.addItem(item);

    // 8. 封装最新购物车总件数并序列化为 JSON 响应流输出
    Map<String, Object> resultMap = new HashMap<>();
    resultMap.put("cartTotalCount", cart.getTotalCount());
    String resultJson = new Gson().toJson(resultMap);
    resp.getWriter().write(resultJson);
  }
}

首页加购交互与角标刷新 ​

在前台商城首页(views/customer/index.jsp)中,每个商品卡片的加购按钮通过自定义属性 furnId="${furn.id}" 绑定当前商品编号,并由 <c:if> 标签根据 furn.stock 控制按钮是否可点击。页面加载完成后,jQuery 为所有加购按钮绑定点击事件,调用 $.getJSON 请求 addItemByAjax,并在回调函数中将返回的 data.cartTotalCount 写入顶部导航栏的 span.header-action-num 节点:

jsp
<%-- 1. 顶部导航栏购物车图标与商品总件数角标显示区域 --%>
<a href="views/cart/cart.jsp" class="header-action-btn header-action-btn-cart">
    <i class="icon-handbag"></i>
    <span class="header-action-num">${sessionScope.cart.totalCount}</span>
</a>

<%-- 2. 商品卡片底部加购按钮:校验实时库存大于 0 时允许点击加购 --%>
<div class="actions">
    <c:if test="${furn.stock > 0}">
        <button title="Add To Cart" class="add-to-cart" furnId="${furn.id}">
            Add To Cart
        </button>
    </c:if>
    <c:if test="${furn.stock == 0}">
        <button title="Add To Cart" class="add-to-cart" disabled="disabled">
            暂时缺货
        </button>
    </c:if>
</div>

<%-- 3. 绑定加购按钮点击事件,发送 Ajax 请求并局部刷新右上角购物车总件数 --%>
<script type="text/javascript">
    $(function () {
        $("button.add-to-cart").click(function () {
            var furnId = $(this).attr("furnId");
            $.getJSON(
                "cartServlet",
                {
                    "action": "addItemByAjax",
                    "id": furnId
                },
                function (data) {
                    $("span.header-action-num").text(data.cartTotalCount);
                }
            );
        });
    });
</script>

购物车明细维护 ​

购物车明细维护业务承接顾客进入购物车详情页(views/cart/cart.jsp)后的核对与调整需求。系统从当前会话的 Cart 模型中读取已加购商品列表,支持顾客在线调整单品购买数量、定点移除不需要的单件商品或一键清空整个购物车,并在每次变更后实时重算单品小计、整车总件数与应付总金额。

明细维护业务流程 ​

顾客在购物车详情页查看采购清单并执行数量更新、单品删除与整车清空的完整业务流转过程分为四个环节:

image-20261109161210745

  1. 购物车列表遍历回显:顾客点击导航栏购物车图标进入 views/cart/cart.jsp 时,页面通过 JSTL 遍历 sessionScope.cart.items 映射集合(其中每个 entry.value 对应一个 CartItem 实例),依次渲染商品名称、单价、当前购买数量、单品小计,并在底部汇总栏读取 cart.totalCount 与 cart.cartTotalPrice 展示整车总件数与总金额。

  2. 购买数量修改与小计重算:顾客在购物车行内修改数量输入框(或点击加减按钮)触发 change 事件时,前端脚本先校验输入值是否为合法正整数。校验通过后提取当前商品编号 furnId 与新数量 count,跳转至 CartServlet 的 updateCount 动作;后端更新对应 CartItem 的购买数量并按 单价 × 新数量 重新计算单品小计,最后通过 Referer 重定向回购物车页刷新汇总数据。

  3. 单件商品定点移除:顾客点击某行商品右侧的“删除”链接时,前端弹出确认对话框提示待删除的家居名称;顾客确认后向 CartServlet 发送携带 action=deleteItem&id=商品编号 的请求,后端将该商品编号对应的键值对从 Cart.items 集合中移除并重定向回购物车页。

  4. 购物车一键清空:顾客点击底部汇总栏的“清空购物车”链接并通过弹窗确认后,向 CartServlet 发送 action=clear 请求,后端清空当前会话 Cart 中的全部明细项,页面刷新后恢复为空车提示状态。

Cart ​

Cart 领域模型提供 updateCount、deleteItem 与 clear 三个核心维护方法。其中 updateCount 在修改目标 CartItem 的 count 属性后,立即调用 BigDecimal.multiply 将商品单价与新购买数量相乘以更新 totalPrice,从而保证后续页面读取 getCartTotalPrice() 时能够汇总出准确的最新整车总价:

java
package com.hspedu.furns.entity;

import java.math.BigDecimal;
import java.util.HashMap;

// 1. 购物车领域模型,提供明细数量修改、单品移除与整车清空业务方法
public class Cart {
  private HashMap<Integer, CartItem> items = new HashMap<>();

  // 2. 根据商品编号更新购买数量,并重新计算该商品项的小计金额
  public void updateCount(int id, int count) {
    CartItem item = items.get(id);
    if (null != item) {
      item.setCount(count);
      item.setTotalPrice(item.getPrice().multiply(new BigDecimal(item.getCount())));
    }
  }

  // 3. 根据商品编号从购物车明细集合中移除指定商品项
  public void deleteItem(int id) {
    items.remove(id);
  }

  // 4. 清空当前购物车中的所有商品明细项
  public void clear() {
    items.clear();
  }
}

CartServlet ​

CartServlet 中的 updateCount、deleteItem 与 clear 方法均围绕当前会话中的 cart 属性展开操作。控制器在完成参数提取与空指针防护后,直接调用 Cart 模型的对应方法修改内存状态,并统一读取请求头中的 Referer 地址执行重定向,使浏览器自动刷新购物车详情页:

java
package com.hspedu.furns.web;

import com.hspedu.furns.entity.Cart;
import com.hspedu.furns.utils.DataUtils;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

// 1. 购物车业务控制器,处理商品数量更新、单品删除与清空购物车请求
public class CartServlet extends BasicServlet {

  // 2. 接收商品编号与新数量,更新 Session 购物车明细并重定向回购物车页
  protected void updateCount(HttpServletRequest req, HttpServletResponse resp)
      throws ServletException, IOException {
    int id = DataUtils.parseInt(req.getParameter("id"), 0);
    int count = DataUtils.parseInt(req.getParameter("count"), 1);

    // 3. 从当前会话中获取购物车对象并执行数量与小计更新
    Cart cart = (Cart) req.getSession().getAttribute("cart");
    if (null != cart) {
      cart.updateCount(id, count);
    }
    resp.sendRedirect(req.getHeader("Referer"));
  }

  // 4. 根据传入的商品编号删除购物车中的对应商品项
  protected void deleteItem(HttpServletRequest req, HttpServletResponse resp)
      throws ServletException, IOException {
    int id = DataUtils.parseInt(req.getParameter("id"), 0);
    Cart cart = (Cart) req.getSession().getAttribute("cart");
    if (null != cart) {
      cart.deleteItem(id);
    }
    resp.sendRedirect(req.getHeader("Referer"));
  }

  // 5. 清空当前会话购物车中的全部商品明细,并刷新购物车视图
  protected void clear(HttpServletRequest req, HttpServletResponse resp)
      throws ServletException, IOException {
    Cart cart = (Cart) req.getSession().getAttribute("cart");
    if (null != cart) {
      cart.clear();
    }
    resp.sendRedirect(req.getHeader("Referer"));
  }
}

购物车视图渲染与维护交互 ​

在购物车详情视图(views/cart/cart.jsp)中,表格区通过 <c:forEach> 遍历展示每件已加购商品,并在数量输入框上通过 furnId="${entry.value.id}" 绑定商品编号。当顾客输入非法数量时,前端脚本通过 this.defaultValue 将输入框恢复为修改前的原始数值;当顾客点击删除或清空按钮时,通过 confirm 弹窗防止误操作:

jsp
<%-- 1. 遍历 Session 购物车中的 items 集合,渲染每行商品明细与操作按钮 --%>
<c:if test="${not empty sessionScope.cart.items}">
    <c:forEach items="${sessionScope.cart.items}" var="entry">
        <tr>
            <td class="product-name">${entry.value.name}</td>
            <td class="product-price-cart">¥${entry.value.price}</td>
            <td class="product-quantity">
                <input class="cart-plus-minus-box" furnId="${entry.value.id}"
                       type="text" value="${entry.value.count}"/>
            </td>
            <td class="product-subtotal">¥${entry.value.totalPrice}</td>
            <td class="product-remove">
                <a class="delItem" href="cartServlet?action=deleteItem&id=${entry.value.id}">删除</a>
            </td>
        </tr>
    </c:forEach>
</c:if>

<%-- 2. 底部汇总栏:展示整车商品总件数、应付总金额、清空入口与结账入口 --%>
<h4>
    共 ${sessionScope.cart.totalCount} 件商品 总价 ¥${sessionScope.cart.cartTotalPrice} 元
    <a class="clearCart" href="cartServlet?action=clear">清空购物车</a>
    <a href="orderServlet?action=saveOrder">去结账</a>
</h4>

<%-- 3. 绑定数量修改校验、单品删除确认与清空购物车确认前端交互脚本 --%>
<script type="text/javascript">
    $(function () {
        $("input.cart-plus-minus-box").change(function () {
            var count = $(this).val();
            var reg = /^[1-9]\d*$/;
            if (!reg.test(count)) {
                alert("请输入正确的购买数量");
                $(this).val(this.defaultValue);
                return false;
            }
            var furnId = $(this).attr("furnId");
            location.href = "cartServlet?action=updateCount&count=" + count + "&id=" + furnId;
        });

        $("a.delItem").click(function () {
            var furnName = $(this).parent().parent().find("td:eq(0)").text();
            return confirm("确认要删除【" + furnName + "】吗?");
        });

        $("a.clearCart").click(function () {
            return confirm("确认要清空购物车吗?");
        });
    });
</script>

订单交易结算 ​

概述 ​

订单交易结算业务是家居网购项目前台导购流程的最终转化环节,负责将顾客暂存于会话购物车(Cart)中的采购明细转化为持久化的数据库订单记录,同步完成家居商品库存扣减、销量累加与购物车清空,并提供历史订单查询、订单商品明细回溯以及未登录交易拦截能力。

交易结算业务闭环 ​

订单交易结算围绕“结账落库”、“库存联动”、“订单回溯”与“访问控制”四个核心环节形成完整的业务闭环:

image-20261109161236789

  1. 前置身份与空车校验:当顾客在购物车详情页点击“去结账”或访问订单管理页面时,AuthFilter 与 OrderServlet 依次核验当前 HttpSession 中是否存在已登录的 member 对象以及非空的 cart 对象。若顾客尚未登录,系统自动拦截并转发至会员登录页(views/member/login.jsp);若购物车为空,则直接重定向回商城门户首页。

  2. 订单生成与库存销量联动:校验通过后,OrderService 基于当前时间戳与会员编号生成全局唯一的订单编号(orderId),先将订单汇总信息写入订单主表(order),再遍历购物车中的全部 CartItem 转化为 OrderItem 逐条写入订单明细从表(order_item)。每写入一条明细,系统同步增加对应 Furn 商品的销量(sales)并扣减库存(stock),全部落库后清空当前会话购物车,重定向至结账成功页(views/order/checkout.jsp)展示订单号。

  3. 历史订单与明细回溯:顾客在结账成功页或商城顶部导航栏点击“订单管理”时,系统向 OrderServlet 发起 listOrder 请求,按当前登录会员的 id 查询其名下全部历史 Order 列表并渲染至 views/order/order.jsp。顾客点击某笔订单右侧的详情入口时,进一步发起 listOrderItem 请求,查询该订单关联的全部 OrderItem 明细并汇总整单商品件数与总金额,渲染至 views/order/order_detail.jsp。

  4. 多表写操作一致性保障:单次结账动作横跨 order、order_item 与 furn 三张数据表的多条 SQL 更新。系统在业务外围配合事务控制机制,确保订单主表插入、明细插入与商品库存扣减要么全部成功提交,要么在任一环节异常时整体回滚,防止出现生成了空订单或扣减了库存却未生成明细的账实不符问题。

业务组件与视图职责 ​

订单交易结算模块涉及的页面视图、控制器、拦截器、业务接口与领域实体职责划分如下:

组件 / 视图名称所属层级核心业务职责
views/order/checkout.jsp结账结果视图展示结账成功后生成的唯一订单编号,提供前往“订单管理”页面的导航入口
views/order/order.jsp订单列表视图展示当前会员名下的历史订单列表(订单号、生成时间、总金额、状态)及查看详情入口
views/order/order_detail.jsp订单详情视图展示指定订单包含的全部商品快照(商品名称、单价、数量、小计)及整单总件数与总金额
OrderServlet订单业务控制器承接生成订单(saveOrder)、查询历史订单列表(listOrder)与查询订单详情(listOrderItem)请求
AuthFilter权限拦截过滤器拦截未登录访客对购物车结算、订单查询及后台管理路径的非法访问请求
OrderService订单业务接口编排订单主表保存、订单明细保存、商品销量与库存更新以及购物车清空的完整结账流程
OrderDAO订单主表持久层负责向 order 表插入新订单记录,以及按会员编号 member_id 查询历史订单集合
OrderItemDAO订单明细持久层负责向 order_item 表插入订单商品明细,以及按订单号 order_id 查询商品快照列表
Order订单主表实体封装单笔订单的编号、下单时间、订单总价、发货状态与归属会员编号
OrderItem订单明细实体封装订单内单种家居商品的购买快照(明细编号、商品名称、成交单价、数量、小计、所属订单号)

订单主从表结构设计 ​

订单持久化采用主从表(一对多)结构设计:一张订单主表(order)记录整笔交易的汇总金额、状态与所属会员,对应多条订单明细从表(order_item)记录该笔订单购买的具体商品快照。由于 order 是 SQL 语法保留字,在编写建表与查询 SQL 时必须使用反引号 order 包裹表名,并通过 AS 别名将下划线字段映射为实体类的驼峰属性名:

sql
-- 1. 创建订单主表,因 order 为 SQL 保留字需使用反引号包裹
CREATE TABLE `order` (
    `id` VARCHAR(64) PRIMARY KEY,
    `create_time` DATETIME NOT NULL,
    `price` DECIMAL(11, 2) NOT NULL,
    `status` TINYINT NOT NULL,
    `member_id` INT NOT NULL
) CHARSET utf8mb4;

-- 2. 创建订单明细从表,通过 order_id 关联所属订单主表编号
CREATE TABLE `order_item` (
    `id` INT PRIMARY KEY AUTO_INCREMENT,
    `name` VARCHAR(64) NOT NULL,
    `price` DECIMAL(11, 2) NOT NULL,
    `count` INT NOT NULL,
    `total_price` DECIMAL(11, 2) NOT NULL,
    `order_id` VARCHAR(64) NOT NULL
) CHARSET utf8mb4;

-- 3. 按会员编号查询历史订单列表,并通过列别名对齐 Order 实体驼峰属性
SELECT `id`, `create_time` AS `createTime`, `price`, `status`, `member_id` AS `memberId`
    FROM `order`
    WHERE `member_id` = ?;

Order ​

Order 实体对应数据库中的 order 主表。其中订单编号 id 采用字符串类型(由系统时间戳拼接会员编号生成),price 取自结账时刻购物车汇总的应付总金额 cart.getCartTotalPrice(),status 表示订单流转状态(0 代表未发货,1 代表已发货,2 代表已结账),memberId 绑定当前登录会员的主键编号:

java
package com.hspedu.furns.entity;

import java.math.BigDecimal;
import java.util.Date;

// 1. 订单主表实体,封装整笔交易订单的汇总信息与归属会员
public class Order {
  private String id;
  private Date createTime;
  private BigDecimal price;
  private Integer status;
  private Integer memberId;

  // 2. 显式提供无参构造器,供 DBUtils 反射封装历史订单查询结果
  public Order() {
  }

  // 3. 有参构造器,在结账生成新订单时初始化订单核心字段
  public Order(String id, Date createTime, BigDecimal price, Integer status, Integer memberId) {
    this.id = id;
    this.createTime = createTime;
    this.price = price;
    this.status = status;
    this.memberId = memberId;
  }

  // 4. 读写订单编号、总金额与所属会员编号的访问方法
  public String getId() {
    return id;
  }

  public void setId(String id) {
    this.id = id;
  }

  public BigDecimal getPrice() {
    return price;
  }

  public Integer getMemberId() {
    return memberId;
  }
}

OrderItem ​

OrderItem 实体对应数据库中的 order_item 从表。在结账生成订单时,系统将购物车中的每一个 CartItem 转化为一个 OrderItem 实例,将其当时的商品名称、成交单价、购买数量与单品小计固化下来,并通过 orderId 属性与主表 Order 的订单号建立关联,避免后续后台修改商品价格影响历史订单快照:

java
package com.hspedu.furns.entity;

import java.math.BigDecimal;

// 1. 订单明细项实体,记录单笔订单中选购的具体家居商品交易快照
public class OrderItem {
  private Integer id;
  private String name;
  private BigDecimal price;
  private Integer count;
  private BigDecimal totalPrice;
  private String orderId;

  // 2. 显式提供无参构造器,供 DBUtils 反射组装订单详情列表
  public OrderItem() {
  }

  // 3. 有参构造器,将购物车中的 CartItem 转换为持久化的订单明细记录
  public OrderItem(Integer id, String name, BigDecimal price,
           Integer count, BigDecimal totalPrice, String orderId) {
    this.id = id;
    this.name = name;
    this.price = price;
    this.count = count;
    this.totalPrice = totalPrice;
    this.orderId = orderId;
  }

  // 4. 读写明细购买数量、小计金额与关联订单编号的访问方法
  public Integer getCount() {
    return count;
  }

  public BigDecimal getTotalPrice() {
    return totalPrice;
  }

  public String getOrderId() {
    return orderId;
  }
}

订单结账生成 ​

订单结账生成业务负责将顾客在购物车页面确认采购的商品集合转化为正式交易单据。系统在核验购物车状态与会员登录身份后,依次完成订单主表写入、订单明细从表批量落库、关联家居商品销量增加与库存扣减,并在清空当前会话购物车后通过重定向跳转至结账结果页展示订单号,防止顾客刷新页面产生重复下单。

结账生成业务流程 ​

顾客在购物车详情页点击“去结账”直至生成订单号并展示结账结果页的完整业务流转过程分为四个步骤:

image-20261109161301821

  1. 结账前置状态核验:顾客在 views/cart/cart.jsp 点击“去结账”向 OrderServlet 发起 action=saveOrder 请求。控制器首先检查 HttpSession 中的 cart 是否存在且非空(若为空则直接重定向回商城首页 index.jsp),随后检查 member 登录凭证是否存在(若未登录则转发至 /views/member/login.jsp 引导顾客登录)。

  2. 订单主表记录生成:OrderServiceImpl 以当前系统毫秒级时间戳拼接会员编号(System.currentTimeMillis() + "" + memberId)生成全局唯一的订单编号 orderId,提取购物车应付总金额 cart.getCartTotalPrice() 构建初始状态为 0(未发货)的 Order 主表实体,调用 OrderDAO.saveOrder 写入 order 表。

  3. 明细落库与库存销量联动:业务层遍历购物车 cart.getItems() 中的每一项 CartItem,将其封装为关联当前 orderId 的 OrderItem 实体并调用 OrderItemDAO.saveOrderItem 写入 order_item 从表;同时按商品编号查询出数据库中对应的 Furn 实体,将其销量加上本次购买数量(sales + count)、库存减去本次购买数量(stock - count),调用 FurnDAO.updateFurn 同步更新回 furn 表。

  4. 购物车清空与防重重定向:全部商品明细与库存更新完成后,业务层调用 cart.clear() 清空当前会话购物车并返回 orderId。OrderServlet 将生成的 orderId 存入 HttpSession 域,通过 sendRedirect 重定向至 views/order/checkout.jsp 展示结账单号,阻断浏览器刷新重复触发下单请求。

OrderDAOImpl ​

结账落库过程依次执行订单主表插入、订单明细从表插入以及家居商品表销量与库存更新三条核心 DML 语句:

sql
-- 1. 向订单主表插入新生成的订单汇总记录
INSERT INTO `order`(`id`, `create_time`, `price`, `status`, `member_id`)
    VALUES(?, ?, ?, ?, ?);

-- 2. 向订单明细从表插入单种家居商品的购买快照
INSERT INTO `order_item`(`id`, `name`, `price`, `count`, `total_price`, `order_id`)
    VALUES(?, ?, ?, ?, ?, ?);

-- 3. 结账生成明细后同步更新对应家居商品的销量与库存
UPDATE `furn`
    SET `name` = ?, `maker` = ?, `price` = ?, `sales` = ?, `stock` = ?, `img_path` = ?
    WHERE `id` = ?;

OrderDAOImpl 负责将封装了唯一订单号、下单时间、整车总价、初始发货状态与所属会员编号的 Order 实体写入 order 主表:

java
package com.hspedu.furns.dao.impl;

import com.hspedu.furns.dao.OrderDAO;
import com.hspedu.furns.entity.Order;

// 1. 订单主表持久层实现类,负责将新生成的 Order 实体持久化至数据库
public class OrderDAOImpl extends BasicDAO<Order> implements OrderDAO {

  // 2. 执行 INSERT 语句保存订单主表信息,返回受影响的行数
  @Override
  public int saveOrder(Order order) {
    String sql = "INSERT INTO `order`(`id`, `create_time`, `price`, `status`, `member_id`) " +
        "VALUES(?, ?, ?, ?, ?)";
    return update(sql, order.getId(), order.getCreateTime(),
        order.getPrice(), order.getStatus(), order.getMemberId());
  }
}

OrderItemDAOImpl ​

OrderItemDAOImpl 负责将从购物车 CartItem 转换而来的 OrderItem 实体写入 order_item 从表,记录单笔订单中每件商品在成交时刻的名称、单价、购买数量与小计金额:

java
package com.hspedu.furns.dao.impl;

import com.hspedu.furns.dao.OrderItemDAO;
import com.hspedu.furns.entity.OrderItem;

// 1. 订单明细从表持久层实现类,负责保存单条订单商品快照记录
public class OrderItemDAOImpl extends BasicDAO<OrderItem> implements OrderItemDAO {

  // 2. 将购物车转换而来的 OrderItem 明细写入 order_item 表
  @Override
  public int saveOrderItem(OrderItem orderItem) {
    String sql = "INSERT INTO `order_item`(`id`, `name`, `price`, `count`, `total_price`, `order_id`) " +
        "VALUES(?, ?, ?, ?, ?, ?)";
    return update(sql, orderItem.getId(), orderItem.getName(), orderItem.getPrice(),
        orderItem.getCount(), orderItem.getTotalPrice(), orderItem.getOrderId());
  }
}

OrderServiceImpl ​

OrderServiceImpl 中的 saveOrder 方法是结账业务的核心编排节点。该方法内部组合 OrderDAO、OrderItemDAO 与 FurnDAO 三个持久层组件,先写入订单主表记录,随后在遍历购物车 items 集合的过程中逐条保存订单明细并同步修改对应家居商品的销量与库存,最后调用 cart.clear() 清空会话购物车:

java
package com.hspedu.furns.service.impl;

import com.hspedu.furns.dao.FurnDAO;
import com.hspedu.furns.dao.OrderDAO;
import com.hspedu.furns.dao.OrderItemDAO;
import com.hspedu.furns.dao.impl.FurnDAOImpl;
import com.hspedu.furns.dao.impl.OrderDAOImpl;
import com.hspedu.furns.dao.impl.OrderItemDAOImpl;
import com.hspedu.furns.entity.*;
import com.hspedu.furns.service.OrderService;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

// 1. 订单业务层实现类,组合三个 DAO 组件完成订单生成与库存销量联动
public class OrderServiceImpl implements OrderService {

  // 2. 初始化订单主表、订单明细从表与家居商品持久层组件
  private OrderDAO orderDAO = new OrderDAOImpl();
  private OrderItemDAO orderItemDAO = new OrderItemDAOImpl();
  private FurnDAO furnDAO = new FurnDAOImpl();

  // 3. 根据购物车数据与会员编号生成订单,返回唯一订单号
  @Override
  public String saveOrder(Cart cart, int memberId) {
    String orderId = System.currentTimeMillis() + "" + memberId;
    Order order = new Order(orderId, new Date(), cart.getCartTotalPrice(), 0, memberId);
    orderDAO.saveOrder(order);

    // 4. 遍历购物车明细集合,逐条构建并保存 OrderItem 记录
    HashMap<Integer, CartItem> items = cart.getItems();
    for (Map.Entry<Integer, CartItem> entry : items.entrySet()) {
      CartItem item = entry.getValue();
      OrderItem orderItem = new OrderItem(null, item.getName(), item.getPrice(),
          item.getCount(), item.getTotalPrice(), orderId);
      orderItemDAO.saveOrderItem(orderItem);

      // 5. 同步查询对应家居商品,累加销量并扣减实时库存
      Furn furn = furnDAO.queryFurnById(item.getId());
      furn.setSales(furn.getSales() + item.getCount());
      furn.setStock(furn.getStock() - item.getCount());
      furnDAO.updateFurn(furn);
    }

    // 6. 持久化完成后清空当前会话购物车,返回生成的订单编号
    cart.clear();
    return orderId;
  }
}

OrderServlet ​

OrderServlet 的 saveOrder 方法负责承接前端结账请求并执行前置防御校验。若会话中的购物车为空则退回首页,若顾客尚未登录则转发至登录页;当订单成功生成后,控制器将 orderId 放入 Session 域并使用 sendRedirect 重定向至 checkout.jsp,避免使用请求转发导致顾客刷新结账页时重复提交订单:

java
package com.hspedu.furns.web;

import com.hspedu.furns.entity.Cart;
import com.hspedu.furns.entity.Member;
import com.hspedu.furns.service.OrderService;
import com.hspedu.furns.service.impl.OrderServiceImpl;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

// 1. 订单业务控制器,承接购物车结账生成订单请求
public class OrderServlet extends BasicServlet {

  // 2. 声明并初始化订单业务层组件 OrderService
  private OrderService orderService = new OrderServiceImpl();

  // 3. 处理去结账请求,核验会话状态后生成订单并重定向至结账结果页
  protected void saveOrder(HttpServletRequest req, HttpServletResponse resp)
      throws ServletException, IOException {
    // 4. 校验当前会话购物车是否存在且非空,若为空则重定向回商城首页
    Cart cart = (Cart) req.getSession().getAttribute("cart");
    if (null == cart || cart.isEmpty()) {
      resp.sendRedirect(req.getContextPath() + "/index.jsp");
      return;
    }

    // 5. 校验当前顾客是否已登录,未登录则转发至会员登录页面
    Member member = (Member) req.getSession().getAttribute("member");
    if (null == member) {
      req.getRequestDispatcher("/views/member/login.jsp").forward(req, resp);
      return;
    }

    // 6. 调用业务层生成订单,将订单号存入 Session 并重定向至 checkout.jsp
    String orderId = orderService.saveOrder(cart, member.getId());
    req.getSession().setAttribute("orderId", orderId);
    resp.sendRedirect(req.getContextPath() + "/views/order/checkout.jsp");
  }
}

结账视图跳转与结果展示 ​

在购物车详情视图(views/cart/cart.jsp)与结账成功视图(views/order/checkout.jsp)中,前端通过超链接发起 saveOrder 请求,并在重定向到达 checkout.jsp 后直接从 sessionScope.orderId 中读取刚刚生成的订单编号向顾客展示,同时在顶部提供前往“订单管理”查看历史订单的入口:

jsp
<%-- 1. 购物车详情页(views/cart/cart.jsp)底部去结账触发入口 --%>
<a href="orderServlet?action=saveOrder">去结账</a>

<%-- 2. 结账结果页(views/order/checkout.jsp)从 Session 域读取并回显订单编号 --%>
<div class="checkout-area">
    <h3>你的订单已生成,订单号为:${sessionScope.orderId}</h3>
</div>

<%-- 3. 结账结果页顶部导航栏提供前往历史订单列表的查询入口 --%>
<div class="header-action-num">
    <a href="orderServlet?action=listOrder">订单管理</a>
</div>

订单历史查询 ​

订单历史查询业务为已登录顾客提供交易记录回溯能力,包含“历史订单列表查询(listOrder)”与“单笔订单商品明细下钻(listOrderItem)”两个递进环节。系统根据当前会话中的会员身份隔离查询其名下的订单主表记录,并支持按订单号进一步调取成交时刻的商品快照列表及汇总数据。

历史订单与明细查询流程 ​

顾客从点击“订单管理”查看历史订单列表,到点击“查看详情”调取某笔订单商品明细的完整业务流转过程分为四个步骤:

image-20261109161333348

  1. 历史订单列表请求与身份核验:顾客在结账成功页(views/order/checkout.jsp)或商城首页顶部导航栏点击“订单管理”,向 OrderServlet 发起携带 action=listOrder 的请求。控制器从 HttpSession 中提取当前登录的 member 对象;若未登录则转发至 /views/member/login.jsp,若已登录则提取其主键编号 member.getId()。

  2. 会员归属订单检索与状态映射:OrderServiceImpl 调用 OrderDAO.queryOrderByMemberId 检索 order 表中 member_id 等于当前会员编号的全部历史订单,封装为 List<Order> 存入 Request 域并转发至 views/order/order.jsp。视图层遍历订单列表并将整型状态码(0、1、2)映射为“未发货”、“已发货”、“已结账”文本展示。

  3. 订单商品明细下钻查询:顾客在历史订单列表中点击某笔订单右侧的“查看详情”超链接,向 OrderServlet 发起携带 action=listOrderItem&orderId=目标订单号 的请求。控制器调用 OrderService.queryOrderItemByOrderId 检索 order_item 从表中归属于该 orderId 的全部商品快照记录。

  4. 整单件数与金额汇总回显:控制器将查询出的 List<OrderItem> 存入 Request 域并转发至订单详情页(views/order/order_detail.jsp)。视图层在遍历展示每项商品名称、成交单价、购买数量与小计金额的同时,通过 JSTL <c:set> 标签逐行累加计算出该笔订单的商品总件数 totalCount 与整单总金额 totalPrice。

OrderDAOImpl ​

历史订单列表与单笔订单明细分别基于 order 主表的 member_id 外键与 order_item 从表的 order_id 外键执行条件查询,并通过 AS 列别名对齐实体类的驼峰属性:

sql
-- 1. 按当前登录会员编号查询其名下全部历史订单记录
SELECT `id`, `create_time` AS `createTime`, `price`, `status`, `member_id` AS `memberId`
    FROM `order`
    WHERE `member_id` = ?;

-- 2. 按订单编号查询该笔订单关联的全部商品购买明细快照
SELECT `id`, `name`, `price`, `count`, `total_price` AS `totalPrice`, `order_id` AS `orderId`
    FROM `order_item`
    WHERE `order_id` = ?;

OrderDAOImpl 中的 queryOrderByMemberId 方法负责根据传入的会员编号查询该顾客名下的所有 Order 实体列表:

java
package com.hspedu.furns.dao.impl;

import com.hspedu.furns.dao.OrderDAO;
import com.hspedu.furns.entity.Order;
import java.util.List;

// 1. 订单主表持久层实现类,提供按会员编号查询历史订单列表能力
public class OrderDAOImpl extends BasicDAO<Order> implements OrderDAO {

  // 2. 查询指定会员名下的全部订单记录,通过列别名映射驼峰属性
  @Override
  public List<Order> queryOrderByMemberId(int memberId) {
    String sql = "SELECT `id`, `create_time` AS `createTime`, `price`, " +
        "`status`, `member_id` AS `memberId` FROM `order` " +
        "WHERE `member_id` = ?";
    return queryMulti(sql, Order.class, memberId);
  }
}

OrderItemDAOImpl ​

OrderItemDAOImpl 中的 queryOrderItemByOrderId 方法负责根据传入的订单编号 orderId,从 order_item 从表中拉取该笔订单包含的全部 OrderItem 商品明细快照:

java
package com.hspedu.furns.dao.impl;

import com.hspedu.furns.dao.OrderItemDAO;
import com.hspedu.furns.entity.OrderItem;
import java.util.List;

// 1. 订单明细持久层实现类,提供按订单编号回溯商品明细列表能力
public class OrderItemDAOImpl extends BasicDAO<OrderItem> implements OrderItemDAO {

  // 2. 根据所属订单号查询对应的全部 OrderItem 商品快照集合
  @Override
  public List<OrderItem> queryOrderItemByOrderId(String orderId) {
    String sql = "SELECT `id`, `name`, `price`, `count`, " +
        "`total_price` AS `totalPrice`, `order_id` AS `orderId` " +
        "FROM `order_item` WHERE `order_id` = ?";
    return queryMulti(sql, OrderItem.class, orderId);
  }
}

OrderServiceImpl ​

OrderServiceImpl 对外提供 queryOrderByMemberId 与 queryOrderItemByOrderId 两个查询方法,分别委托 OrderDAO 与 OrderItemDAO 完成主表订单检索与从表明细检索:

java
package com.hspedu.furns.service.impl;

import com.hspedu.furns.dao.OrderDAO;
import com.hspedu.furns.dao.OrderItemDAO;
import com.hspedu.furns.dao.impl.OrderDAOImpl;
import com.hspedu.furns.dao.impl.OrderItemDAOImpl;
import com.hspedu.furns.entity.Order;
import com.hspedu.furns.entity.OrderItem;
import com.hspedu.furns.service.OrderService;
import java.util.List;

// 1. 订单业务层实现类,编排历史订单列表查询与订单明细查询业务
public class OrderServiceImpl implements OrderService {

  // 2. 初始化订单主表与订单明细从表持久层组件
  private OrderDAO orderDAO = new OrderDAOImpl();
  private OrderItemDAO orderItemDAO = new OrderItemDAOImpl();

  // 3. 根据会员编号查询该会员名下的所有历史订单
  @Override
  public List<Order> queryOrderByMemberId(int memberId) {
    return orderDAO.queryOrderByMemberId(memberId);
  }

  // 4. 根据订单编号查询该笔订单下属的所有商品明细项
  @Override
  public List<OrderItem> queryOrderItemByOrderId(String orderId) {
    return orderItemDAO.queryOrderItemByOrderId(orderId);
  }
}

OrderServlet ​

OrderServlet 中的 listOrder 与 listOrderItem 方法分别承接订单列表请求与订单详情请求。由于这两类查询的数据仅在当前次页面渲染周期内有效,控制器统一将查询结果存入 Request 域(属性名分别为 orders 与 orderItems),并通过请求转发(forward)交由对应 JSP 视图渲染:

java
package com.hspedu.furns.web;

import com.hspedu.furns.entity.Member;
import com.hspedu.furns.entity.Order;
import com.hspedu.furns.entity.OrderItem;
import com.hspedu.furns.service.OrderService;
import com.hspedu.furns.service.impl.OrderServiceImpl;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.List;

// 1. 订单业务控制器,处理历史订单列表展示与单笔订单详情查询请求
public class OrderServlet extends BasicServlet {

  // 2. 声明并初始化订单业务层组件 OrderService
  private OrderService orderService = new OrderServiceImpl();

  // 3. 查询当前登录会员的历史订单列表并转发至订单管理页
  protected void listOrder(HttpServletRequest req, HttpServletResponse resp)
      throws ServletException, IOException {
    // 4. 校验会话中的会员登录状态,未登录则转发至登录页
    Member member = (Member) req.getSession().getAttribute("member");
    if (null == member) {
      req.getRequestDispatcher("/views/member/login.jsp").forward(req, resp);
      return;
    }

    // 5. 按会员主键编号查询历史订单集合,存入 Request 域并转发渲染
    List<Order> orders = orderService.queryOrderByMemberId(member.getId());
    req.setAttribute("orders", orders);
    req.getRequestDispatcher("/views/order/order.jsp").forward(req, resp);
  }

  // 6. 根据请求传递的订单号查询商品购买明细并转发至订单详情页
  protected void listOrderItem(HttpServletRequest req, HttpServletResponse resp)
      throws ServletException, IOException {
    String orderId = req.getParameter("orderId");

    // 7. 查询该笔订单对应的 OrderItem 列表,存入 Request 域并转发渲染
    List<OrderItem> orderItems = orderService.queryOrderItemByOrderId(orderId);
    req.setAttribute("orderItems", orderItems);
    req.getRequestDispatcher("/views/order/order_detail.jsp").forward(req, resp);
  }
}

订单列表与详情视图渲染 ​

在订单管理页(views/order/order.jsp)中,页面遍历 requestScope.orders 渲染每笔订单的编号、下单时间、总金额与发货状态,并在“查看详情”超链接中动态拼接 orderId=${order.id};在订单详情页(views/order/order_detail.jsp)中,页面遍历 requestScope.orderItems 展示商品明细,同时借助 <c:set> 累加每行商品的 count 与 totalPrice,在表格底部输出整单汇总信息:

jsp
<%-- 1. 订单管理页(views/order/order.jsp)遍历展示当前会员的历史订单列表 --%>
<c:if test="${not empty requestScope.orders}">
    <c:forEach items="${requestScope.orders}" var="order">
        <tr>
            <td class="product-name">${order.id}</td>
            <td class="product-price-cart">${order.createTime}</td>
            <td class="product-quantity">¥${order.price}</td>
            <c:if test="${order.status == 0}">
                <td class="product-subtotal">未发货</td>
            </c:if>
            <c:if test="${order.status == 1}">
                <td class="product-subtotal">已发货</td>
            </c:if>
            <c:if test="${order.status == 2}">
                <td class="product-subtotal">已结账</td>
            </c:if>
            <td class="product-remove">
                <a href="orderServlet?action=listOrderItem&orderId=${order.id}">查看详情</a>
            </td>
        </tr>
    </c:forEach>
</c:if>

<%-- 2. 订单详情页(views/order/order_detail.jsp)遍历商品明细并累加总件数与总金额 --%>
<c:forEach items="${requestScope.orderItems}" var="orderItem">
    <tr>
        <td class="product-name">${orderItem.name}</td>
        <td class="product-price-cart">¥${orderItem.price}</td>
        <td class="product-quantity">${orderItem.count}</td>
        <td class="product-subtotal">¥${orderItem.totalPrice}</td>
    </tr>
    <c:set var="totalCount" value="${totalCount + orderItem.count}"/>
    <c:set var="totalPrice" value="${totalPrice + orderItem.totalPrice}"/>
</c:forEach>

<%-- 3. 订单详情页底部汇总回显该笔订单的商品总件数与应付总价 --%>
<h4>共 ${totalCount} 件商品 总价 ¥${totalPrice} 元</h4>

交易权限拦截 ​

交易权限拦截业务负责统一收口商城受保护资源(购物车操作、订单结算与历史查询、后台商品管理)的访问边界,同时为跨表结账业务提供全链路事务一致性兜底。系统在请求进入控制器前拦截未登录访客的非法访问(兼容普通页面跳转与 Ajax 异步加购请求),并通过过滤器外围包裹的事务提交与回滚机制,确保订单落库与库存扣减的原子性。

权限拦截与事务保障流程 ​

访客或会员发起加购、结账、订单查询及后台管理请求时的权限校验与事务兜底流转过程分为四个步骤:

image-20261109161400482

  1. 受控路径匹配与白名单放行:当请求命中 web.xml 中配置的受保护路径(如 /views/cart/*、/views/order/*、/views/manage/*、/cartServlet、/orderServlet、/manage/furnServlet)时,首先进入 AuthFilter。过滤器读取初始化参数 excludedUrls 白名单(如后台登录入口 /views/manage/manage_login.jsp 与前台登录页 /views/member/login.jsp),若当前请求路径在白名单内则直接调用 filterChain.doFilter 放行。

  2. 会话身份核验与分流阻断:若请求不在白名单内,AuthFilter 从 HttpSession 中读取属性名为 member 的登录会员对象:

    • 若 member != null,说明顾客或管理员已完成认证,直接放行至后续链路。
    • 若 member == null,说明当前访客未登录。过滤器通过 WebUtils.isAjaxRequest 判断请求类型:对于普通同步请求,直接请求转发至会员登录页(/views/member/login.jsp);对于商城首页发起的 Ajax 异步加购请求,由于局部异步请求无法直接执行服务端页面转发,过滤器将登录页地址封装为 {"url": "views/member/login.jsp"} 的 JSON 响应写回客户端,由前端脚本捕获后执行整页跳转。
  3. 跨表业务共享连接执行:通过权限校验的请求进入 TransactionFilter 并继续放行至 OrderServlet.saveOrder。在订单主表插入、订单明细插入与商品库存扣减的多步 DAO 调用中,JDBCUtilsByDruid 从当前线程的 ThreadLocal 容器中获取同一个开启了手动事务(setAutoCommit(false))的数据库连接,确保三张表的更新处于同一事务上下文中。

  4. 事务统一提交与异常回滚:若 OrderService.saveOrder 全链路正常执行完毕,外围 TransactionFilter 调用 JDBCUtilsByDruid.commit() 统一提交事务并归还连接;若中途发生任何 SQL 异常或运行期异常,底层 BasicDAO 将异常向上转型为 RuntimeException 抛出,由 TransactionFilter 捕获并调用 JDBCUtilsByDruid.rollback() 整体回滚已写入的半成品订单与库存变更,最后重定向至全局错误页 /views/error/500.jsp。

web.xml ​

在 web/WEB-INF/web.xml 配置文件中,系统通过 <filter-mapping> 声明 AuthFilter 监控的受保护页面目录与业务控制器路径,并通过 <init-param> 配置无需登录即可访问的白名单路径;同时配置 TransactionFilter 拦截所有业务请求以包裹事务边界:

xml
<!-- 1. 配置权限拦截过滤器 AuthFilter 及放行白名单初始化参数 -->
<filter>
    <filter-name>AuthFilter</filter-name>
    <filter-class>com.hspedu.furns.filter.AuthFilter</filter-class>
    <init-param>
        <param-name>excludedUrls</param-name>
        <param-value>/views/manage/manage_login.jsp,/views/member/login.jsp</param-value>
    </init-param>
</filter>
<!-- 2. 指定需要登录认证才允许访问的视图目录与控制器 URL 规则 -->
<filter-mapping>
    <filter-name>AuthFilter</filter-name>
    <url-pattern>/views/cart/*</url-pattern>
    <url-pattern>/views/manage/*</url-pattern>
    <url-pattern>/views/member/*</url-pattern>
    <url-pattern>/views/order/*</url-pattern>
    <url-pattern>/cartServlet</url-pattern>
    <url-pattern>/manage/furnServlet</url-pattern>
    <url-pattern>/orderServlet</url-pattern>
</filter-mapping>

<!-- 3. 配置全局事务过滤器 TransactionFilter,为跨表订单结算提供事务兜底 -->
<filter>
    <filter-name>TransactionFilter</filter-name>
    <filter-class>com.hspedu.furns.filter.TransactionFilter</filter-class>
</filter>
<!-- 4. 拦截全部动态请求,在请求放行前后控制数据库事务提交与异常回滚 -->
<filter-mapping>
    <filter-name>TransactionFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

AuthFilter ​

AuthFilter 在容器启动执行 init 方法时,将 excludedUrls 参数按逗号拆分为白名单集合。在 doFilter 拦截逻辑中,若访问路径不在白名单内且 Session 中不存在 member 对象,则区分同步请求与 Ajax 异步请求分别执行页面转发或返回重定向 URL 的 JSON 报文:

java
package com.hspedu.furns.filter;

import com.google.gson.Gson;
import com.hspedu.furns.entity.Member;
import com.hspedu.furns.utils.WebUtils;
import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

// 1. 交易与管理权限拦截过滤器,阻断未登录访客访问购物车、订单及后台资源
public class AuthFilter implements Filter {

  // 2. 保存无需登录即可直接放行的白名单路径集合
  private List<String> excludedUrls;

  // 3. 读取 web.xml 中的 excludedUrls 配置并解析为字符串列表
  @Override
  public void init(FilterConfig filterConfig) throws ServletException {
    String strExcludedUrls = filterConfig.getInitParameter("excludedUrls");
    String[] splitUrl = strExcludedUrls.split(",");
    excludedUrls = Arrays.asList(splitUrl);
  }

  // 4. 校验请求路径与会话登录凭证,区分同步请求与 Ajax 请求执行未登录跳转
  @Override
  public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse,
             FilterChain filterChain) throws IOException, ServletException {
    HttpServletRequest req = (HttpServletRequest) servletRequest;
    String url = req.getServletPath();

    // 5. 若当前请求路径不在白名单中,则核验 Session 中的登录会员对象
    if (!excludedUrls.contains(url)) {
      Member member = (Member) req.getSession().getAttribute("member");
      if (null == member) {
        // 6. 普通同步请求直接转发至登录页,Ajax 请求返回包含跳转地址的 JSON
        if (!WebUtils.isAjaxRequest(req)) {
          req.getRequestDispatcher("/views/member/login.jsp")
              .forward(servletRequest, servletResponse);
        } else {
          Map<String, Object> resultMap = new HashMap<>();
          resultMap.put("url", "views/member/login.jsp");
          String resultJson = new Gson().toJson(resultMap);
          servletResponse.getWriter().write(resultJson);
        }
        return;
      }
    }

    // 7. 已登录或命中白名单路径,正常放行至后续过滤器及业务 Servlet
    filterChain.doFilter(servletRequest, servletResponse);
  }

  @Override
  public void destroy() {
  }
}

异步加购拦截与前端跳转配合 ​

当未登录访客在商城首页(views/customer/index.jsp)点击“Add To Cart”按钮触发 Ajax 加购时,AuthFilter 拦截该请求并返回 {"url": "views/member/login.jsp"}。前端加购脚本在回调函数中先检查 data.url 是否为 undefined:若未定义说明当前已登录且加购成功,正常刷新右上角购物车件数角标;若存在 data.url 则通过 location.href 引导浏览器跳转至会员登录页:

jsp
<%-- 1. 商城首页(views/customer/index.jsp)处理 Ajax 加购响应与未登录拦截跳转 --%>
<script type="text/javascript">
    $(function () {
        $("button.add-to-cart").click(function () {
            var furnId = $(this).attr("furnId");
            $.getJSON(
                "cartServlet",
                {
                    "action": "addItemByAjax",
                    "id": furnId
                },
                // 2. 若后端过滤器未返回跳转 url,说明已登录,局部刷新购物车总件数角标
                function (data) {
                    if (data.url == undefined) {
                        $("span.header-action-num").text(data.cartTotalCount);
                    } else {
                        // 3. 若返回了 url 属性,说明访客未登录被 AuthFilter 拦截,执行整页跳转
                        location.href = data.url;
                    }
                }
            );
        });
    });
</script>

TransactionFilter ​

为保证结账生成订单时多表写入(order、order_item、furn)的数据一致性,TransactionFilter 在 filterChain.doFilter 外围包裹 try-catch 块。当整条业务链路无异常完成时,调用 JDBCUtilsByDruid.commit() 持久化全部变更;一旦捕获到下层抛出的任何异常,立即调用 JDBCUtilsByDruid.rollback() 撤销当前线程数据库连接上的所有未提交操作,并转发至统一错误提示页:

java
package com.hspedu.furns.filter;

import com.hspedu.furns.utils.JDBCUtilsByDruid;
import javax.servlet.*;
import java.io.IOException;

// 1. 订单交易事务保障过滤器,统一控制请求周期内的数据库事务提交与回滚
public class TransactionFilter implements Filter {

  // 2. 放行请求执行业务,正常结束则提交事务,捕获异常则回滚并转发至错误页
  @Override
  public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse,
             FilterChain filterChain) throws IOException, ServletException {
    try {
      filterChain.doFilter(servletRequest, servletResponse);
      // 3. 业务链路正常执行完毕,提交当前线程绑定的数据库事务并关闭连接
      JDBCUtilsByDruid.commit();
    } catch (Exception e) {
      // 4. 结账或业务执行期间发生异常,整体回滚事务防止账实不符
      JDBCUtilsByDruid.rollback();
      // 5. 记录异常堆栈并请求转发至 500 全局错误提示视图
      e.printStackTrace();
      servletRequest.getRequestDispatcher("/views/error/500.jsp")
          .forward(servletRequest, servletResponse);
    }
  }

  @Override
  public void init(FilterConfig filterConfig) throws ServletException {
  }

  @Override
  public void destroy() {
  }
}