Skip to content

项目:家居网购-上 ​

[TOC]

概述 ​

jiaju_mall 采用经典的 JavaWeb MVC 模式与三层架构设计。在编写具体的会员、家居、购物车与订单业务之前,先构建一套高内聚、低耦合的通用底座,能够消除大量的重复样板代码,并为后续的全站事务控制提供底层支持。

image-20261023141037520

MVC 三层架构 ​

项目在纵向上划分为表现层、业务逻辑层与数据访问层,各层之间通过接口与 JavaBean 实体传递数据,严格遵循自上而下的单向依赖原则。

image-20261023140403587

三层架构 ​

表现层(Web 层):由 JSP 视图与 Servlet 控制器共同组成:

  • View(视图):位于 web/views/ 目录下,使用 JSP 与 JSTL/EL 表达式渲染商品列表、购物车及后台管理页面,并借助 jQuery 发起异步请求。
  • Controller(控制器):位于 com.hspedu.furns.web 包下,负责接收客户端请求、提取表单参数、调用 Service 层处理业务,并最终决定请求转发(Forward)、重定向(Redirect)或输出 JSON 响应。

业务逻辑层(Service 层):位于 com.hspedu.furns.service 包下,按接口与实现类分离的原则组织(如 FurnService 与 FurnServiceImpl)。该层专注于核心业务规则的编排(如注册重名校验、订单生成时的库存扣减与销量累加),通过组合一个或多个 DAO 完成复合操作,不直接操作 HTTP 请求对象或底层 SQL 语句。

数据访问层(DAO 层):位于 com.hspedu.furns.dao 包下,同样采用接口与实现类分离结构(如 FurnDAO 与 FurnDAOImpl)。所有具体 DAO 实现类统一继承泛型基类 BasicDAO,底层借助 Apache DBUtils 的 QueryRunner 执行单表增删改查。

实体模型层(Entity 层):位于 com.hspedu.furns.entity 包下,包含与数据库表结构一一对应的 POJO 类(如 Member、Furn、Order、OrderItem)以及纯内存业务模型(如分页模型 Page、会话购物车模型 Cart 与 CartItem)。实体属性名与表字段(或查询别名)及前端表单 name 属性保持一致,以满足反射映射要求。

基础工具与过滤层 ​

基础工具与过滤层位于 com.hspedu.furns.utils 与 com.hspedu.furns.filter 包下,提供跨层公共支撑能力,包括 Druid 连接池与线程本地连接管理、BeanUtils 表单自动封装、权限拦截器 AuthFilter 以及全局声明式事务过滤器 TransactionFilter。

MVC ​

MVC(Model-View-Controller,模型-视图-控制器) 是一种用于构建用户界面的软件架构设计模式。其核心思想是将数据模型与业务处理(Model)、界面渲染展示(View)和请求调度控制(Controller) 三者分离,改变早期将请求处理、数据库访问与 HTML 渲染混写在同一个 JSP 页面中的耦合做法,提升代码的可维护性与可扩展性。

下图展示了原生 JavaWeb 开发中,浏览器请求在 Servlet(控制器)、JavaBean(模型)与 JSP/HTML(视图)之间的标准 MVC 交互流程:

image-20261028225235198

1. 核心组件职责:

MVC 模式由以下三个各司其职的组件构成:

  1. 模型(Model):负责承载业务数据、封装业务规则并完成数据持久化。在 JavaWeb(含三层架构)中,Model 既包含用于封装数据的实体类(JavaBean / Entity,如 Furn、Member、Cart),也涵盖负责业务处理的 Service 层和负责查询数据库并封装处理的 DAO 层。

  2. 视图(View):负责数据的可视化渲染与用户交互界面的呈现。在本项目中由 JSP/HTML 页面配合 EL 表达式与 JSTL 标签库构成,仅负责从域对象(request、session)中提取 Model 数据并生成最终响应给浏览器的页面,不直接编写业务逻辑或 SQL 查询。

  3. 控制器(Controller):负责接收客户端请求并协调 Model 与 View 协同工作。在本项目中由 Servlet(如 BasicServlet 及其各业务子类)充当,负责接收浏览器提交的参数、调用 JavaBean(Service/DAO)执行业务处理,并根据处理结果将请求转发(Forward)或重定向至对应的 JSP/HTML 视图。

2. 标准执行流程:

结合上图,一次完整的 MVC 请求响应循环包含以下四个步骤:

  1. 发送请求:客户端浏览器通过表单提交或超链接向服务器端的控制器(Servlet)发送 HTTP 请求。

  2. 调用模型:Servlet 解析请求参数,调用 JavaBean(Service 与 DAO)查询数据并封装处理,实现与底层数据库的交互,随后将返回的模型数据存入请求域或会话域。

  3. 转发视图:Servlet 根据业务执行结果,通过请求转发(或重定向)调度至目标视图(JSP/HTML)。

  4. 渲染响应:JSP/HTML 从域对象中读取 JavaBean 数据并渲染生成 HTML 文档,最终向浏览器输出 HTTP 响应。

工程目录结构 ​

整个 Web 工程遵循标准的 JavaEE 目录规范,源码包名统一以 com.hspedu.furns 作为根命名空间:

sh
# 1. Java 服务端源码包结构
src/
└── com.hspedu.furns
  ├── dao             # 数据访问接口及 BasicDAO、impl 实现类
  ├── entity          # 数据库实体类与 Page、Cart 等领域模型
  ├── filter          # 权限验证 AuthFilter 与事务控制 TransactionFilter
  ├── service         # 业务逻辑接口及 impl 实现类
  ├── test            # JUnit 单元测试类(测试 DAO、Service 与工具类)
  ├── utils           # JDBCUtilsByDruid 与 DataUtils 通用工具类
  └── web             # BasicServlet 基类与各业务模块 Servlet

# 2. Web 静态资源与配置目录结构
web/
├── assets/             # CSS 样式、JS 脚本、字体与商品图片目录
├── views/              # 按 customer、manage、member、order 划分的 JSP 视图
├── index.jsp           # 商城首页入口(直接请求转发至 CustomerFurnServlet)
└── WEB-INF/
  ├── lib/            # druid、commons-dbutils、commons-beanutils、gson 等依赖包
  └── web.xml         # Servlet、Filter 及 Kaptcha 验证码部署描述符

image-20261023163821859

核心通用组件 ​

为了避免在每个业务模块中重复编写连接获取、SQL 结果集映射、请求 if-else 分发以及参数转换代码,项目抽象出四个核心基础组件。

JDBCUtilsByDruid ​

JDBCUtilsByDruid 负责在类加载阶段读取 src/druid.properties 初始化阿里巴巴 Druid 数据库连接池,并结合 ThreadLocal 将数据库 Connection 绑定到当前执行线程。该设计不仅消除了频繁创建物理连接的开销,还保证了同一请求线程在跨多个 DAO 方法调用时共享同一个数据库连接,为 TransactionFilter 实现统一提交与回滚奠定基础。

在 src/com/hspedu/furns/utils/JDBCUtilsByDruid.java 中实现连接绑定与事务控制,代码如下:

java
// 1. 导入必要的 JDBC、Druid 与 ThreadLocal 包
import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;

public class JDBCUtilsByDruid {

  private static DataSource ds;

  // 2. 声明 ThreadLocal 变量,用来以线程为单位隔离和共享 Connection
  private static ThreadLocal<Connection> threadLocal = new ThreadLocal<>();

  // 3. 静态代码块初始化 Druid 连接池
  static {
    Properties properties = new Properties();
    try {
      // 读取 src 目录下的配置文件
      InputStream is = JDBCUtilsByDruid.class.getClassLoader()
          .getResourceAsStream("druid.properties");
      properties.load(is);
      ds = DruidDataSourceFactory.createDataSource(properties);
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

  // 4. 获取与当前线程绑定的 Connection 连接
  public static Connection getConnection() {
    Connection connection = threadLocal.get();

    // 如果当前线程尚未绑定连接,则从 Druid 连接池中获取并绑定
    if (connection == null) {
      try {
        connection = ds.getConnection();
        threadLocal.set(connection);
      } catch (SQLException e) {
        e.printStackTrace();
        throw new RuntimeException(e);
      }
    }
    return connection;
  }

  // 5. 提交当前线程的事务,并关闭、解绑连接(用于 Filter 全局事务控制)
  public static void commit() {
    Connection connection = threadLocal.get();
    if (connection != null) {
      try {
        // 提交事务
        connection.commit();
        // 归还连接给 Druid 池
        connection.close();
      } catch (SQLException e) {
        e.printStackTrace();
        throw new RuntimeException(e);
      } finally {
        // 必须在 finally 块中解绑,防止线程复用导致内存泄漏
        threadLocal.remove();
      }
    }
  }

  // 6. 回滚当前线程的事务,并关闭、解绑连接(用于 Filter 异常捕获处理)
  public static void rollback() {
    Connection connection = threadLocal.get();
    if (connection != null) {
      try {
        // 回滚事务
        connection.rollback();
        // 归还连接给 Druid 池
        connection.close();
      } catch (SQLException e) {
        e.printStackTrace();
        throw new RuntimeException(e);
      } finally {
        // 必须在 finally 块中解绑
        threadLocal.remove();
      }
    }
  }

  // 7. 供非事务或常规查询场景下,释放资源的基础重载方法
  public static void close(ResultSet resultSet, Statement statement, Connection connection) {
    try {
      if (resultSet != null) {
        resultSet.close();
      }
      if (statement != null) {
        statement.close();
      }
      // 如果传入的连接不为空,且不是线程绑定的连接(非事务环境),则直接关闭
      if (connection != null && threadLocal.get() != connection) {
        connection.close();
      }
    } catch (SQLException e) {
      e.printStackTrace();
      throw new RuntimeException(e);
    }
  }
}

BasicDAO ​

BasicDAO 是基于泛型与 Apache DBUtils 封装的数据访问基类。它内部持有一个无参 QueryRunner 实例,向上提供通用的 update(执行增删改)、queryMulti(查询多行记录并封装为 BeanListHandler)、querySingle(查询单行记录并封装为 BeanHandler)以及 queryScalar(查询单行单列标量值并封装为 ScalarHandler)四个模板方法。子类仅需传入目标实体类的泛型参数与 SQL 语句即可完成数据持久化。

在 src/com/hspedu/furns/dao/BasicDAO.java 中编写泛型基类,所有方法在捕获 SQLException 时统一将其包装为 RuntimeException 向上抛出,以便外层的 TransactionFilter 感知异常并触发事务回滚:

java
package com.hspedu.furns.dao;

import com.hspedu.furns.utils.JDBCUtilsByDruid;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;

// 1. 定义泛型基类 BasicDAO<T>,由子类指定具体实体类型
public class BasicDAO<T> {

  // 2. 初始化 DBUtils 核心执行器 QueryRunner(无参构造,手动传入线程连接)
  private QueryRunner qr = new QueryRunner();

  // 3. 通用增删改方法,支持任意表结构与可变参数占位符
  public int update(String sql, Object... parameters) {
  Connection connection = null;
  try {
    // 从 ThreadLocal 获取当前请求线程绑定的数据库连接
    connection = JDBCUtilsByDruid.getConnection();
    return qr.update(connection, sql, parameters);
  } catch (SQLException e) {
    // 将编译期异常转为运行时异常向上抛出,触发 TransactionFilter 回滚
    throw new RuntimeException(e);
  }
  }

  // 4. 查询多行记录,通过 BeanListHandler 反射封装为实体集合
  public List<T> queryMulti(String sql, Class<T> clazz, Object... parameters) {
  Connection connection = null;
  try {
    connection = JDBCUtilsByDruid.getConnection();
    return qr.query(connection, sql, new BeanListHandler<T>(clazz), parameters);
  } catch (SQLException e) {
    throw new RuntimeException(e);
  }
  }

  // 5. 查询单行记录,通过 BeanHandler 反射封装为单个实体对象
  public T querySingle(String sql, Class<T> clazz, Object... parameters) {
  Connection connection = null;
  try {
    connection = JDBCUtilsByDruid.getConnection();
    return qr.query(connection, sql, new BeanHandler<T>(clazz), parameters);
  } catch (SQLException e) {
    throw new RuntimeException(e);
  }
  }

  // 6. 查询单行单列标量值,常用于 COUNT(*) 聚合统计
  public Object queryScalar(String sql, Object... parameters) {
  Connection connection = null;
  try {
    connection = JDBCUtilsByDruid.getConnection();
    return qr.query(connection, sql, new ScalarHandler(), parameters);
  } catch (SQLException e) {
    throw new RuntimeException(e);
  }
  }
}

注意:在引入 ThreadLocal 与 TransactionFilter 的全局事务架构下,BasicDAO 的各个方法中不再编写 finally { JDBCUtilsByDruid.close(null, null, connection); }。QueryRunner 在内部执行完毕后会自动关闭 PreparedStatement 与 ResultSet,而 Connection 则保持打开状态,直至请求线程返回 TransactionFilter 时由 JDBCUtilsByDruid.commit() 或 rollback() 统一关闭并解绑。

BasicServlet ​

BasicServlet 继承自 HttpServlet 并重写了 doGet 与 doPost 方法。在传统 Servlet 开发中,一个业务模块若包含增、删、改、查四项功能,往往需要定义四个独立的 Servlet 类或在 doPost 中编写冗长的分支判断。BasicServlet 借助模板方法模式与 Java 反射机制,约定前端请求统一携带 action 参数(如 action=login 或 action=add),在运行时动态查找并调用子类中与 action 同名的业务方法,从而实现一个模块对应一个 Servlet 的集中式管理。

在 src/com/hspedu/furns/web/BasicServlet.java 中编写反射派发基类,统一处理 UTF-8 请求编码、反射方法查找与异常向上传递:

java
package com.hspedu.furns.web;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.lang.reflect.Method;

// 1. 定义抽象基类 BasicServlet,应用模板方法模式统一处理请求派发
public abstract class BasicServlet extends HttpServlet {

  // 2. 重写 doPost,统一设置请求编码并执行反射方法分派
  @Override
  protected void doPost(HttpServletRequest req, HttpServletResponse resp)
    throws ServletException, IOException {
    // 必须在读取任何参数前设置 UTF-8 编码,解决 POST 中文乱码
    req.setCharacterEncoding("utf-8");

    // 3. 获取前端约定的 action 参数值(对应子类业务方法名)
    String action = req.getParameter("action");

    try {
      // 4. 利用动态绑定机制,通过 this.getClass() 获取当前运行期子类的 Class 对象
      Method declaredMethod = this.getClass().getDeclaredMethod(
        action, HttpServletRequest.class, HttpServletResponse.class);

      // 5. 反射执行子类中匹配的业务方法,将当前子类实例 this 与请求响应对象传入
      declaredMethod.invoke(this, req, resp);
    } catch (Exception e) {
      // 6. 将反射调用过程中的异常转为 RuntimeException 向上抛出,交由 TransactionFilter 回滚事务
      throw new RuntimeException(e);
    }
  }

  // 7. 重写 doGet 并委托给 doPost,使 GET 与 POST 请求共享同一套反射派发逻辑
  @Override
  protected void doGet(HttpServletRequest req, HttpServletResponse resp)
    throws ServletException, IOException {
    doPost(req, resp);
  }
}

DataUtils ​

DataUtils 封装了 Apache Commons BeanUtils 组件的 populate 方法与类型转换逻辑。在接收多字段表单提交(如新增家居、会员注册)时,只需一行代码即可将 req.getParameterMap() 中的键值对映射填充至目标 JavaBean 实例中,同时提供带默认值的字符串转整型辅助方法 parseInt,彻底替代繁琐的 req.getParameter 手动赋值与异常捕获代码。

在 src/com/hspedu/furns/utils/DataUtils.java 中编写工具类实现:

java
package com.hspedu.furns.utils;

import org.apache.commons.beanutils.BeanUtils;

import java.util.Map;

// 1. 封装表单参数反射注入与安全类型转换的通用工具类
public class DataUtils {

  // 2. 定义泛型方法,将 Map 中的请求参数自动映射至目标 JavaBean 实例
  public static <T> T copyParamToBean(Map value, T bean) {
    try {
      // 3. 调用 BeanUtils.populate 反射执行 setter 属性赋值与类型转换
      BeanUtils.populate(bean, value);
    } catch (Exception e) {
      e.printStackTrace();
    }
    return bean;
  }

  // 4. 将字符串安全转换为 int 类型,转换失败或为空时返回默认值 defaultVal
  public static int parseInt(String val, int defaultVal) {
    try {
      // 5. 当传入字符串非空时执行十进制整型解析
      if (val != null && !val.isEmpty()) {
      return Integer.parseInt(val);
      }
    } catch (NumberFormatException e) {
      // 6. 捕获数字格式异常并静默降级,避免非法参数中断请求链路
      System.out.println(val + " 格式不正确...");
    }
    return defaultVal;
  }
}

依赖约束:commons-beanutils-1.8.0.jar 在运行时强依赖日志门面库 commons-logging-1.1.1.jar。必须在 web/WEB-INF/lib 目录下同时导入这两个 JAR 包,否则调用 BeanUtils.populate 时会抛出 java.lang.NoClassDefFoundError: org/apache/commons/logging/LogFactory 错误。

数据库 ​

druid.properties ​

在 src/druid.properties 中配置 MySQL 数据源连接参数与连接池容量策略:

ini
# 1. 数据库驱动与连接地址配置
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/jiaju_mall?useSSL=true&useUnicode=true&characterEncoding=UTF-8
username=root
password=hsp

# 2. 连接池初始化与最小空闲连接数
initialSize=10
minIdle=5

# 3. 最大活跃连接数与最大等待毫秒数
maxActive=50
maxWait=5000

数据库创建 ​

数据库 jiaju_mall 的创建及商品表标准查询 SQL 规范如下:

sql
-- 1. 创建家居网购项目数据库并指定字符集
CREATE DATABASE jiaju_mall CHARSET utf8;
USE jiaju_mall;

-- 2. 按销量降序查询家居商品列表
SELECT id, `name`, maker, price, sales, stock, img_path AS imgPath
  FROM furn
  WHERE stock > 0
  ORDER BY sales DESC
  LIMIT 0, 4;

会员认证业务 ​

概述 ​

会员认证业务是家居网购项目(jiaju_mall)的入口业务模块,负责管理前台普通消费者与后台系统管理员的身份核验、账号注册及会话状态维护。该模块通过统一的会员控制器承接前端表单与异步校验请求,为后续的购物车导购、订单结账及后台商品维护提供身份凭证支撑。

认证业务流转全景 ​

会员认证业务围绕前台客户与后台管理员两类角色展开,包含用户名异步查重、新会员注册、会员登录与注销、管理员登录四个核心业务闭环:

  1. 用户名异步查重业务:用户在注册表单输入用户名并移开焦点时,前端自动发起异步请求核验该名称是否已被占用,实时在表单顶部提示可用状态,避免提交整张表单后才发现重名。

  2. 会员注册业务:用户填写用户名、密码、确认密码、电子邮箱与图形验证码后提交表单,后端依次核验验证码有效性、用户名唯一性,通过后将账号信息加密写入数据库,并引导至注册成功提示页。

  3. 会员登录与注销业务:已注册用户输入账号与密码发起登录,核验通过后将当前会员对象存入会话(Session),顶部导航栏随之展示欢迎语及订单管理入口;点击安全退出时销毁当前会话并返回商城首页。

  4. 管理员登录认证业务:后台管理人员通过独立的管理登录页提交管理员账号与密码,验证通过后进入后台管理主菜单页(manage_menu.jsp),进而操作后台商品与订单模块。

image-20261106091939129

会员认证模块各业务动作的请求分发与视图流转关系如下表所示:

业务动作触发页面请求 action 参数值业务处理结果流转目标
用户名异步查重views/member/login.jspisExistUsername响应 JSON 数据({"isExist": true/false}),页面局部刷新提示
会员账号注册views/member/login.jspregister成功转发至 register_ok.jsp;失败回显信息并转发回 login.jsp
会员账号登录views/member/login.jsplogin成功转发至 login_ok.jsp;失败回显错误信息与用户名并转发回 login.jsp
会员安全注销顶部导航栏菜单logout销毁当前会话并重定向至网站首页 index.jsp
管理员登录认证views/manage/manage_login.jspadminLogin成功转发至 manage_menu.jsp;失败返回 manage_login.jsp

会员数据表与实体模型 ​

会员认证业务的持久化数据存储于 member 表中。其中 username 字段具备唯一性约束,防止重复注册;password 字段采用定长 32 位字符存储经过 MD5() 加密后的密文,避免明文密码在数据库中直接暴露。

sql
-- 1. 创建会员信息表 member,密码字段固定为 32 位 MD5 密文
CREATE TABLE `member` (
    `id` INT PRIMARY KEY AUTO_INCREMENT,
    `username` VARCHAR(32) NOT NULL UNIQUE,
    `password` CHAR(32) NOT NULL,
    `email` VARCHAR(64) NOT NULL
) CHARSET utf8mb4;

-- 2. 注册前校验用户名是否已存在
SELECT `id`, `username`, `password`, `email`
    FROM `member`
    WHERE `username` = ?;

-- 3. 注册新会员时插入账号记录,密码通过 MD5 函数加密存储
INSERT INTO `member`(`username`, `password`, `email`)
    VALUES(?, MD5(?), ?);

-- 4. 登录时校验用户名与 MD5 加密后的密码是否匹配
SELECT `id`, `username`, `password`, `email`
    FROM `member`
    WHERE `username` = ? AND `password` = MD5(?);

与 member 表对应的业务实体类为 Member,用于在控制器、业务层、数据访问层以及 HttpSession 会话域之间传递当前用户的账号数据:

java
package com.hspedu.furns.entity;

// 1. 会员业务实体类,承载注册、登录与会话绑定的账号数据
public class Member {
  private Integer id;
  private String username;
  private String password;
  private String email;

  // 2. 无参构造器,供表单参数封装与查询结果集组装使用
  public Member() {
  }

  // 3. 全参构造器,用于初始化完整会员对象
  public Member(Integer id, String username, String password, String email) {
    this.id = id;
    this.username = username;
    this.password = password;
    this.email = email;
  }

  // 4. 账号属性的读取与设置方法
  public Integer getId() {
    return id;
  }

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

  public String getUsername() {
    return username;
  }

  public void setUsername(String username) {
    this.username = username;
  }

  public String getPassword() {
    return password;
  }

  public void setPassword(String password) {
    this.password = password;
  }

  public String getEmail() {
    return email;
  }

  public void setEmail(String email) {
    this.email = email;
  }
}

认证业务组件职责 ​

在会员认证业务链路中,数据访问层(MemberDAOImpl)与业务逻辑层(MemberServiceImpl)相互配合,为上层控制器(MemberServlet)提供标准化的业务方法支撑:

  1. 数据访问层(MemberDAOImpl):提供按用户名单条查询(queryMemberByUsername)、新增会员记录(saveMember)以及按用户名与密码联合查询(queryMemberByUsernameAndPassword)三个基础数据操作。

  2. 业务逻辑层(MemberServiceImpl):将数据访问层的查询结果与受影响行数转化为直观的业务判断结果——isExistsUsername 返回布尔值表示用户名是否已存在,registerMember 返回布尔值表示注册是否成功,login 返回匹配的 Member 实体对象供控制器写入会话。

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

import com.hspedu.furns.dao.MemberDAO;
import com.hspedu.furns.entity.Member;

// 1. 会员数据访问实现类,执行会员表查重、新增与登录核验 SQL
public class MemberDAOImpl extends BasicDAO<Member> implements MemberDAO {

  // 2. 根据用户名查询单条会员记录,供注册查重使用
  @Override
  public Member queryMemberByUsername(String username) {
    String sql = "SELECT `id`, `username`, `password`, `email` FROM `member` WHERE `username` = ?";
    return this.querySingle(sql, Member.class, username);
  }

  // 3. 插入新注册会员记录,返回受影响行数(1 表示成功,0 表示失败)
  @Override
  public int saveMember(Member member) {
    String sql = "INSERT INTO `member`(`username`, `password`, `email`) VALUES(?, MD5(?), ?)";
    return this.update(sql, member.getUsername(), member.getPassword(), member.getEmail());
  }

  // 4. 根据用户名与明文密码查询会员,SQL 内部通过 MD5 函数比对密文
  @Override
  public Member queryMemberByUsernameAndPassword(String username, String password) {
    String sql = "SELECT `id`, `username`, `password`, `email` FROM `member` WHERE `username` = ? AND `password` = MD5(?)";
    return this.querySingle(sql, Member.class, username, password);
  }
}

MemberServiceImpl 组合 MemberDAO 实例,对外暴露完整的会员认证业务方法:

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

import com.hspedu.furns.dao.MemberDAO;
import com.hspedu.furns.dao.impl.MemberDAOImpl;
import com.hspedu.furns.entity.Member;
import com.hspedu.furns.service.MemberService;

// 1. 会员业务逻辑实现类,编排注册、查重与登录校验规则
public class MemberServiceImpl implements MemberService {

  // 2. 组合 MemberDAO 数据访问对象
  private MemberDAO memberDAO = new MemberDAOImpl();

  // 3. 执行会员注册业务,受影响行数为 1 则代表注册成功
  @Override
  public boolean registerMember(Member member) {
    return memberDAO.saveMember(member) == 1;
  }

  // 4. 判断用户名是否已被注册,返回非 null 代表已存在
  @Override
  public boolean isExistsUsername(String username) {
    return memberDAO.queryMemberByUsername(username) != null;
  }

  // 5. 执行会员登录校验,返回匹配的 Member 实体或 null
  @Override
  public Member login(Member member) {
    return memberDAO.queryMemberByUsernameAndPassword(member.getUsername(), member.getPassword());
  }
}

会员注册流程 ​

会员注册业务负责新用户账号的创建。流程中通过前端与后端的“双重校验”(表单项核验、验证码防重以及用户名查重)确保注册数据的安全与唯一。最终通过业务层进行账号落库,并对用户注册状态进行差异化页面流转。

业务流转时序 ​

新会员注册从前台页面的表单提交开始,到系统完成入库并跳转至注册成功页,调用链路与页面控制的流转关系如下:

  1. 用户提交表单:用户在 login.jsp 的注册区填写并提交表单,触发 action="memberServlet?action=register" 请求。

  2. 验证码一次性销毁与校验:控制器提取表单中的验证码与 Session 中的验证码进行不区分大小写的比对。无论结果如何,必须在首期立即移除 Session 验证码,以阻断重复提交或脚本爆破攻击。

  3. 表单参数提取与实体封装:使用 Bean 填充工具批量提取 HTTP 请求参数,直接映射为 Member JavaBean 实例,简化字段拆分获取过程。

  4. 数据库唯一性查重:调用服务层校验用户名是否冲突。若已被注册,则触发“错误回显”机制,保存输入的数据并携带错误提示返回原表单页。

  5. 落库与流程流转:通过 Service 调用 DAO 执行加密写入,根据写入结果转发至注册成功页面(register_ok.jsp)或失败降级处理。

image-20261106092021631

客户端注册数据与验证码校验 ​

在 login.jsp 表单提交后,MemberServlet 的 register 方法作为业务调度的核心入口,首先承担起数据封装与第一道“安全关卡”——验证码核验的职责:

java
// 1. 继承 BasicServlet 承接多 Action 请求,声明业务层组件
public class MemberServlet extends BasicServlet {

  private MemberService memberService = new MemberServiceImpl();

  // 2. 调度会员注册流程
  public void register(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    // 3. 提取表单提交的验证码与会话中的真实验证码进行核验
    String code = req.getParameter("code");
    String token = (String) req.getSession().getAttribute("KAPTCHA_SESSION_KEY");

    // 4. 验证码执行“一次性”销毁,防止后退、刷新的表单二次提交
    req.getSession().removeAttribute("KAPTCHA_SESSION_KEY");

    // 5. 若验证码为空或不匹配,置入错误信息并回显除密码外的数据
    if (token == null || !token.equalsIgnoreCase(code)) {
      req.setAttribute("msg", "验证码错误");
      req.setAttribute("username", req.getParameter("username"));
      req.setAttribute("email", req.getParameter("email"));
      req.getRequestDispatcher("/views/member/login.jsp").forward(req, resp);
      return;
    }

    // 6. 自动化封装表单参数到 Member 实体对象中
    Member member = DataUtils.copyParamToBean(req.getParameterMap(), new Member());

    // 7. 业务核验:用户名唯一性校验。存在则回显报错并退回
    if (memberService.isExistsUsername(member.getUsername())) {
      req.setAttribute("msg", "用户名已存在");
      req.setAttribute("username", member.getUsername());
      req.setAttribute("email", member.getEmail());
      req.getRequestDispatcher("/views/member/login.jsp").forward(req, resp);
      return;
    }

    // 8. 业务处理:落库持久化,注册成功后跳转注册成功页
    if (memberService.registerMember(member)) {
      req.getRequestDispatcher("/views/member/register_ok.jsp").forward(req, resp);
    } else {
      // 9. 降级逻辑:处理极少发生的入库失败(如并发冲突或超长数据)
      req.setAttribute("msg", "注册失败,系统繁忙");
      req.setAttribute("username", member.getUsername());
      req.setAttribute("email", member.getEmail());
      req.getRequestDispatcher("/views/member/login.jsp").forward(req, resp);
    }
  }
}

用户名查重与账号入库 ​

在前两道防御通过后,控制器将通过业务层 MemberService 发起数据库层面的用户名重名检查。为保证业务语义的连贯性,后台直接抛开 SQL 行数等物理细节,将冲突判断升格为“存在”或“不存在”的逻辑状态。一旦用户名合法,便调用持久化动作,并在底层写入阶段直接应用 MD5 单向散列,在源头保护用户隐私。

sql
-- 1. 唯一性查重:根据待注册用户名查询现有记录
SELECT `id`, `username`, `password`, `email`
    FROM `member`
    WHERE `username` = 'jack_guest';

-- 2. 账号落库:插入新会员数据,使用 MD5 算法对密码加密
INSERT INTO `member` (`username`, `password`, `email`)
    VALUES ('jack_guest', MD5('password123'), 'jack@example.com');

-- 3. (安全防御参考)防重提交在服务层属于幂等保障,而数据层依靠 username 的 UNIQUE 约束兜底

结果跳转与表单错误回显 ​

注册业务对用户体验影响最大的是对异常分支的处理。为了降低用户的重复输入负担,流程设计中采用了“转发回显(Forward with History)”模式,而成功时则导向专门的成果展示页:

  1. 信息转发与暂存:当校验不通过(验证码错误或用户名存在)时,Servlet 使用 HttpServletRequest.setAttribute() 将用户先前输入的 username 与 email 暂存到 Request 域中。

  2. 页面转发回显:在通过 getRequestDispatcher("/views/member/login.jsp").forward(req, resp) 转发回到原注册页时,JSP 页面会通过 value="${requestScope.username}" 动态提取先前暂存的表单值。由于该过程发生在服务器内部(转发),浏览器的 URL 保持不变,同时用户之前填写的正确信息得以保留(除敏感密码外)。

  3. 注册成功流转:当注册入库成功,转发至 views/member/register_ok.jsp 页面。此时页面会展示欢迎信息,并引导用户点击“立即登录”前往登录模块。

会员登录注销 ​

会员登录与安全注销业务负责核验已注册用户的身份凭据,并在整个购物周期内维护或清理用户的会话状态。用户登录成功后,系统将其身份信息绑定至当前会话,从而解锁购物车结算与个人订单查询功能;用户主动点击安全退出时,系统立即销毁会话数据并返回商城首页。

登录与注销流转时序 ​

会员登录与安全注销涵盖表单提交、账密比对、会话状态写入与销毁四个核心业务环节,整体流转关系如下:

  1. 提交登录凭据:用户在 views/member/login.jsp 登录面板输入用户名与密码,提交表单触发 memberServlet?action=login 请求。

  2. 账密核验与会话绑定:MemberServlet 提取请求参数并封装为 Member 对象,交由 MemberService.login() 比对数据库记录。若查询返回非空 Member 对象,则将该对象存入 Session 域(键名为 member),并请求转发至 views/member/login_ok.jsp。

  3. 登录失败回显:若查询返回 null,说明用户名不存在或密码错误。控制器将错误提示("用户名或者密码错误")与用户已输入的 username 存入 Request 域,转发回 views/member/login.jsp 进行表单回显。

  4. 销毁会话与首页重定向:已登录用户点击顶部导航栏的“安全退出”链接,触发 memberServlet?action=logout 请求。控制器立即销毁当前 Session 会话,并通过重定向跳转回商城首页 index.jsp。

image-20261106092056801

会员账密核验与会话绑定 ​

在 MemberServlet 中,login 方法负责协调账密校验与成功/失败分支的页面流转,logout 方法负责清理会话并重定向至首页:

java
// 1. 处理会员登录请求,核验账号密码并维护会话状态
public void login(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  // 2. 将登录表单提交的 username 和 password 封装至 Member 实体
  Member member = DataUtils.copyParamToBean(req.getParameterMap(), new Member());

  // 3. 调用业务层校验账密,返回完整会员实体或 null
  Member loginMember = memberService.login(member);

  // 4. 登录失败时保存错误提示与已填用户名,转发回登录页回显
  if (loginMember == null) {
    req.setAttribute("msg", "用户名或者密码错误");
    req.setAttribute("username", member.getUsername());
    req.getRequestDispatcher("/views/member/login.jsp").forward(req, resp);
    return;
  }

  // 5. 登录成功时将完整会员对象存入 Session 域,转发至登录成功页
  req.getSession().setAttribute("member", loginMember);
  req.getRequestDispatcher("/views/member/login_ok.jsp").forward(req, resp);
}

// 6. 处理会员安全注销请求,销毁当前会话并重定向至商城首页
public void logout(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  // 7. 立即销毁当前用户的 Session 会话,清除登录凭证
  req.getSession().invalidate();

  // 8. 重定向至商城入口首页,避免刷新浏览器重复触发注销请求
  resp.sendRedirect(req.getContextPath() + "/index.jsp");
}

业务层调用 MemberDAOImpl.queryMemberByUsernameAndPassword() 时,底层 SQL 通过 MD5() 函数将用户输入的明文密码转换为密文后与表记录比对,仅当用户名与密码同时匹配时才返回对应的会员记录:

sql
-- 1. 根据会员输入的用户名与明文密码查询匹配的账号记录
SELECT `id`, `username`, `password`, `email`
    FROM `member`
    WHERE `username` = 'king' AND `password` = MD5('king');

导航栏登录态动态切换 ​

会员登录或注销后,前台商城首页(views/customer/index.jsp)与登录成功页(views/member/login_ok.jsp)的顶部导航栏会根据 Session 域中是否存在 member 对象动态切换操作入口:

  1. 未登录视图:当 sessionScope.member 为空时,顶部导航栏仅展示“登录”与“注册”链接,引导访客前往 views/member/login.jsp 完成身份认证。

  2. 已登录视图:当 sessionScope.member 非空时,顶部导航栏读取 ${sessionScope.member.username} 展示欢迎语,并开放“订单管理”与“安全退出”操作入口。

html
<!-- 1. 未登录状态:Session 域中不存在 member 对象,展示登录与注册入口 -->
<c:if test="${empty sessionScope.member}">
  <div class="header-tools">
    <a href="views/member/login.jsp">登录</a> |
    <a href="views/member/login.jsp">注册</a>
  </div>
</c:if>

<!-- 2. 已登录状态:展示会员名称、订单管理入口与安全退出链接 -->
<c:if test="${not empty sessionScope.member}">
  <div class="header-tools">
    <span>欢迎: ${sessionScope.member.username}</span>
    <a href="orderServlet?action=listOrder">订单管理</a>
    <a href="memberServlet?action=logout">安全退出</a>
  </div>
</c:if>

管理员登录认证 ​

管理员登录认证是连接前台商城与后台管理系统的安全入口业务。该流程通过独立的后台登录页面接收管理员凭据,核验账号有效性后将管理员身份绑定至当前会话,并引导进入后台管理主控菜单(manage_menu.jsp),为后续的后台商品增删改查与订单管理提供权限基础。

后台登录业务流转 ​

管理员从进入后台登录界面到成功打开后台管理主菜单,完整业务流转与分支跳转关系如下:

  1. 后台入口触发:管理员在前台页面点击“后台管理”入口链接,进入独立的后台管理员登录页(views/manage/manage_login.jsp)。

  2. 管理员凭据提交:管理员在表单中输入账号与密码并点击登录,表单通过隐藏域携带 action=adminLogin 参数提交至 MemberServlet。

  3. 身份核验与角色确认:控制器将表单参数封装为 Member 实体,调用业务层 memberService.login() 校验数据库账密,并核对当前登录账号是否具备管理员身份(如账号名为 admin)。

  4. 会话绑定与主控台流转:核验通过后,系统将管理员 Member 对象存入 Session 会话域,并请求转发至后台管理主菜单页(views/manage/manage_menu.jsp);若账密不匹配或非管理员账号,则将错误提示与已输入的用户名存入 Request 域,转发回 manage_login.jsp 进行回显。

image-20261106092129041

管理员登录表单与错误回显 ​

在后台登录页 views/manage/manage_login.jsp 中,表单通过 action="adminLogin" 隐藏域将请求精准分发至管理员登录处理方法,并在顶部预留 ${requestScope.msg} 区域用于展示认证失败提示:

html
<!-- 1. 展示后台登录失败时的错误提示信息 -->
<span class="errorMsg">${requestScope.msg}</span>

<form action="memberServlet" method="post">
  <!-- 2. 隐藏域指定请求分发动作为 adminLogin -->
  <input type="hidden" name="action" value="adminLogin" />
  <input type="text" name="username" value="${requestScope.username}" placeholder="用户名" />
  <input type="password" name="password" placeholder="密码" />

  <!-- 3. 提交管理员账号与密码凭据 -->
  <button type="submit">登录后台</button>
</form>

管理员身份核验与会话写入 ​

MemberServlet 中的 adminLogin 方法承接后台登录请求,复用业务层的账密校验能力,并在验证通过后建立会话状态:

java
// 1. 处理后台管理员登录认证请求
public void adminLogin(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  // 2. 将后台登录表单提交的账密参数封装为 Member 实体
  Member member = DataUtils.copyParamToBean(req.getParameterMap(), new Member());

  // 3. 调用业务层核验管理员账号与密码是否匹配
  Member adminMember = memberService.login(member);

  // 4. 校验失败或非管理员账号时,保存错误信息并转发回后台登录页
  if (adminMember == null || !"admin".equals(adminMember.getUsername())) {
    req.setAttribute("msg", "管理员账号或密码错误");
    req.setAttribute("username", member.getUsername());
    req.getRequestDispatcher("/views/manage/manage_login.jsp").forward(req, resp);
    return;
  }

  // 5. 校验通过,将管理员实体存入 Session 域并转发至后台管理主菜单页
  req.getSession().setAttribute("member", adminMember);
  req.getRequestDispatcher("/views/manage/manage_menu.jsp").forward(req, resp);
}

底层数据访问层执行账密比对时,同样通过 MD5() 函数校验管理员密码密文:

sql
-- 1. 核验管理员账号与 MD5 加密后的密码是否匹配
SELECT `id`, `username`, `password`, `email`
    FROM `member`
    WHERE `username` = 'admin' AND `password` = MD5('admin');

后台主控台业务导航 ​

管理员通过认证并转发至 views/manage/manage_menu.jsp 后,会话域中的 member 凭证将保障其顺利通过后续的后台权限拦截检查。在后台管理主菜单页中,管理员可通过顶部导航栏直接进入家居商品分页管理模块或订单管理模块:

html
<!-- 1. 后台管理主菜单导航区,提供家居商品分页管理与订单管理入口 -->
<div class="header-tools">
  <a href="manage/furnServlet?action=page&pageNo=1">家居管理</a>
  <a href="order_manage.jsp">订单管理</a>
  <!-- 2. 返回前台商城首页入口 -->
  <a href="index.jsp">返回首页</a>
</div>

后台商品管理 ​

概述 ​

后台商品管理是家居网购项目(jiaju_mall)面向系统管理员的核心运营模块,负责维护商城在售家居商品的完整生命周期。管理员通过后台管理主菜单进入家居管理界面后,可执行商品分页浏览、新商品上架、过期商品下架删除以及存量商品信息与实拍图的修改更新,所有数据变更实时同步至前台商城导购页。

商品管理业务全景 ​

后台商品管理业务由后台控制器 FurnServlet(映射路径为 /manage/furnServlet)统一调度,围绕分页列表视图(furn_manage.jsp)、新增视图(furn_add.jsp)与修改视图(furn_update.jsp)形成四个核心业务闭环:

image-20261109160850401

  1. 后台商品分页展示业务:管理员在后台主菜单点击“家居管理”或切换底部页码条时,系统按当前页码(pageNo)与每页条数(pageSize)查询商品子集及总记录数,组装为 Page<Furn> 分页对象后转发至 furn_manage.jsp 渲染表格。

  2. 后台商品新增业务:管理员在 furn_add.jsp 填写家居名称、制造商、价格、销量与库存并提交表单,系统完成数据格式校验与入库后,重定向回商品分页列表原页码,防止刷新浏览器导致商品重复上架。

  3. 后台商品删除业务:管理员在商品列表行尾点击删除按钮并经过弹窗确认后,系统携带商品编号(id)与当前所在页码(pageNo)执行删除操作,随后重定向回删除前的分页视图。

  4. 后台商品修改与图片上传业务:分为“回显”与“更新”两步——点击修改图标时先按 id 查询商品详情并转发至 furn_update.jsp 回显原数据;管理员修改文本属性或上传新商品实拍图后提交多部分表单,系统将新图片保存至服务器目录并更新数据库记录,最后重定向回原分页页码。

后台商品管理模块各业务动作的请求参数与视图流转关系如下表所示:

业务动作触发页面请求 action 参数值业务处理结果流转目标
后台商品分页展示views/manage/manage_menu.jsppage将 Page<Furn> 存入 Request 域,转发至 furn_manage.jsp
后台商品新增上架views/manage/furn_add.jspadd成功重定向至 manage/furnServlet?action=page&pageNo=...;校验失败转发回 furn_add.jsp
后台商品下架删除views/manage/furn_manage.jspdel删除成功后重定向至 manage/furnServlet?action=page&pageNo=...
修改页商品数据回显views/manage/furn_manage.jspshowFurn查询单条 Furn 存入 Request 域,转发至 furn_update.jsp
后台商品修改与传图views/manage/furn_update.jspupdate解析图文表单并更新入库,重定向至 manage/furnServlet?action=page&pageNo=...

商品数据表与实体模型 ​

后台商品数据持久化存储于 furn 表中。表中涵盖商品主键(id)、名称(name)、制造商(maker)、单价(price)、销量(sales)、库存(stock)以及商品图片相对路径(img_path):

sql
-- 1. 创建家居商品表 furn,设置默认图片路径字段
CREATE TABLE `furn` (
    `id` INT UNSIGNED PRIMARY KEY AUTO_INCREMENT,
    `name` VARCHAR(64) NOT NULL,
    `maker` VARCHAR(64) NOT NULL,
    `price` DECIMAL(11, 2) NOT NULL,
    `sales` INT UNSIGNED NOT NULL,
    `stock` INT UNSIGNED NOT NULL,
    `img_path` VARCHAR(256) NOT NULL
) CHARSET utf8mb4;

-- 2. 后台分页查询商品记录,使用别名对齐实体属性 imgPath
SELECT `id`, `name`, `maker`, `price`, `sales`, `stock`, `img_path` AS `imgPath`
    FROM `furn`
    LIMIT ?, ?;

-- 3. 后台新增家居商品记录
INSERT INTO `furn`(`id`, `name`, `maker`, `price`, `sales`, `stock`, `img_path`)
    VALUES(NULL, ?, ?, ?, ?, ?, ?);

-- 4. 根据商品编号更新家居名称、厂商、价格、销量、库存及图片路径
UPDATE `furn`
    SET `name` = ?, `maker` = ?, `price` = ?, `sales` = ?, `stock` = ?, `img_path` = ?
    WHERE `id` = ?;

-- 5. 根据商品编号删除指定家居记录
DELETE
    FROM `furn`
    WHERE `id` = ?;

与 furn 表对应的业务实体类为 Furn。在业务设计上,由于新增商品页面仅提交文本属性而不强制要求立即上传图片,Furn 实体将 imgPath 属性默认初始化为占位图路径 "assets/images/product-image/default.jpg",保证新上架商品在前后台列表中均能正常渲染缩略图:

java
package com.hspedu.furns.entity;

import java.math.BigDecimal;

// 1. 家居商品业务实体,承载商品展示、新增与修改的核心属性
public class Furn {
  private Integer id;
  private String name;
  private String maker;
  private BigDecimal price;
  private Integer sales;
  private Integer stock;
  // 2. 设置商品默认占位图路径,未上传图片时自动使用该路径
  private String imgPath = "assets/images/product-image/default.jpg";

  // 3. 无参构造器,供表单参数自动封装与结果集映射使用
  public Furn() {
  }

  // 4. 全参构造器,仅当传入非空图片路径时才覆盖默认占位图
  public Furn(Integer id, String name, String maker, BigDecimal price,
        Integer sales, Integer stock, String imgPath) {
    this.id = id;
    this.name = name;
    this.maker = maker;
    this.price = price;
    this.sales = sales;
    this.stock = stock;
    if (!(null == imgPath || "".equals(imgPath))) {
      this.imgPath = imgPath;
    }
  }
}

商品管理业务组件职责 ​

在后台商品管理链路中,FurnDAOImpl 负责执行单表持久化指令,FurnServiceImpl 负责编排增删改查调用并组装分页模型:

  1. 数据访问层(FurnDAOImpl):提供新增商品(addFurn)、按编号删除(deleteFurnById)、按编号查询单条详情(queryFurnById)、更新商品(updateFurn)以及分页所需的总行数统计(getTotalRow)与当前页列表查询(getPageItems)。

  2. 业务逻辑层(FurnServiceImpl):除向上层暴露增删改查方法外,核心职责是在 page(int pageNo, int pageSize) 方法中汇总总记录数、计算总页数(pageTotalCount)与起始索引(begin),将零散的数据查询结果封装为完整的 Page<Furn> 分页业务对象。

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

import com.hspedu.furns.dao.FurnDAO;
import com.hspedu.furns.entity.Furn;

import java.util.List;

// 1. 家居商品数据访问实现类,负责 furn 表的增删改查与分页统计
public class FurnDAOImpl extends BasicDAO<Furn> implements FurnDAO {

  // 2. 向数据库插入新家居商品记录
  @Override
  public int addFurn(Furn furn) {
    String sql = "INSERT INTO `furn`(`id`, `name`, `maker`, `price`, `sales`, `stock`, `img_path`) " +
        "VALUES(NULL, ?, ?, ?, ?, ?, ?)";
    return this.update(sql, furn.getName(), furn.getMaker(), furn.getPrice(),
        furn.getSales(), furn.getStock(), furn.getImgPath());
  }

  // 3. 根据商品编号删除对应家居记录
  @Override
  public int deleteFurnById(int id) {
    String sql = "DELETE FROM `furn` WHERE `id` = ?";
    return this.update(sql, id);
  }

  // 4. 根据商品编号查询单条家居记录,用于修改前的数据回显
  @Override
  public Furn queryFurnById(int id) {
    String sql = "SELECT `id`, `name`, `maker`, `price`, `sales`, `stock`, `img_path` AS `imgPath` " +
        "FROM `furn` WHERE `id` = ?";
    return this.querySingle(sql, Furn.class, id);
  }

  // 5. 根据商品编号更新家居各项属性与图片路径
  @Override
  public int updateFurn(Furn furn) {
    String sql = "UPDATE `furn` SET `name` = ?, `maker` = ?, `price` = ?, " +
        "`sales` = ?, `stock` = ?, `img_path` = ? WHERE `id` = ?";
    return this.update(sql, furn.getName(), furn.getMaker(), furn.getPrice(),
        furn.getSales(), furn.getStock(), furn.getImgPath(), furn.getId());
  }

  // 6. 统计商品总记录数,用于计算分页总页数
  @Override
  public int getTotalRow() {
    String sql = "SELECT COUNT(*) FROM `furn`";
    return ((Number) this.queryScalar(sql)).intValue();
  }

  // 7. 查询当前页码对应的商品数据列表
  @Override
  public List<Furn> getPageItems(int begin, int pageSize) {
    String sql = "SELECT `id`, `name`, `maker`, `price`, `sales`, `stock`, `img_path` AS `imgPath` " +
        "FROM `furn` LIMIT ?, ?";
    return this.queryMulti(sql, Furn.class, begin, pageSize);
  }
}

FurnServiceImpl 组合 FurnDAO 实例,对外提供商品维护与分页组装业务接口:

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;

// 1. 家居商品业务逻辑实现类,统筹后台商品增删改查与分页模型组装
public class FurnServiceImpl implements FurnService {

  // 2. 组合 FurnDAO 数据访问组件
  private FurnDAO furnDAO = new FurnDAOImpl();

  // 3. 新增家居商品业务
  @Override
  public int add(Furn furn) {
    return furnDAO.addFurn(furn);
  }

  // 4. 按编号删除指定家居商品业务
  @Override
  public int deleteFurnById(int id) {
    return furnDAO.deleteFurnById(id);
  }

  // 5. 按编号查询单件家居商品,支撑修改页数据回显
  @Override
  public Furn queryFurnById(int id) {
    return furnDAO.queryFurnById(id);
  }

  // 6. 更新家居商品信息与图片路径
  @Override
  public int updateFurn(Furn furn) {
    return furnDAO.updateFurn(furn);
  }

  // 7. 组装后台商品分页模型 Page<Furn>
  @Override
  public Page<Furn> page(int pageNo, int pageSize) {
    Page<Furn> page = new Page<>();
    page.setPageNo(pageNo);
    page.setPageSize(pageSize);
    int totalRow = furnDAO.getTotalRow();
    page.setTotalRow(totalRow);
    int pageTotalCount = totalRow / pageSize;
    if (totalRow % pageSize > 0) {
      pageTotalCount += 1;
    }
    page.setPageTotalCount(pageTotalCount);
    int begin = (pageNo - 1) * pageSize;
    page.setItems(furnDAO.getPageItems(begin, pageSize));
    return page;
  }
}

后台商品分页展示 ​

后台商品分页展示业务负责将数据库中的存量家居商品按页拆分呈现,替代早期全表一次性加载的展示方式。管理员从后台主菜单进入家居管理模块,或点击列表底部的分页导航条时,系统均通过该业务链路按需拉取指定页码的商品子集与分页元数据。

分页展示业务流转 ​

从管理员点击“家居管理”入口或切换页码开始,到页面完成当前页商品表格与底部页码条渲染,完整业务流转时序如下:

image-20261109160926573

  1. 触发分页请求:管理员在 views/manage/manage_menu.jsp 点击“家居管理”菜单(携带 action=page&pageNo=1),或在 views/manage/furn_manage.jsp 点击底部分页条(如“上一页”、“下一页”、具体页码数字),向 /manage/furnServlet 发起请求。

  2. 分页参数提取与兜底:控制器 FurnServlet.page() 从请求中提取目标页码 pageNo 与每页条数 pageSize。若前端未传参或参数格式非法,系统自动兜底为第 1 页、每页展示 3 条商品记录。

  3. 业务分页数据组装:业务层 FurnService.page() 先调用 FurnDAO.getTotalRow() 统计商品总记录数并计算总页数,再根据当前页码换算数据库起始行索引 begin,调用 FurnDAO.getPageItems() 获取当前页的商品集合,最终汇总封装为 Page<Furn> 对象。

  4. 视图转发与渲染:控制器将组装完成的 Page<Furn> 对象存入 Request 域,请求转发至 views/manage/furn_manage.jsp,由页面遍历渲染当前页商品行与分页导航按钮。

分页模型与数据计算 ​

为了在一次请求转发中同时向页面交付“商品列表数据”与“底部分页导航条所需的页码信息”,业务层使用 Page<T> 模型统一承载六项核心业务数据:

属性名业务含义数据来源与计算规则
pageNo当前所在页码由前端请求参数传入,默认值为 1
pageSize每页展示商品条数由前端传入或取常量 PAGE_SIZE = 3
totalRow商品总记录数执行 SELECT COUNT(*) FROM furn 统计得出
pageTotalCount商品总页数按 totalRow / pageSize 计算,若有余数则总页数加 1
items当前页商品集合执行 LIMIT begin, pageSize 查询得出,其中 begin = (pageNo - 1) * pageSize
url分页导航请求路径供前台带条件分页检索复用,后台列表固定请求 manage/furnServlet?action=page

Page<T> 分页业务模型的结构定义如下:

java
package com.hspedu.furns.entity;

import java.util.List;

// 1. 分页业务模型类,承载当前页商品数据列表与页码导航元数据
public class Page<T> {

  // 2. 定义后台默认每页展示的商品记录条数
  public static final Integer PAGE_SIZE = 3;

  private Integer pageNo;
  private Integer pageSize = PAGE_SIZE;
  private Integer pageTotalCount;
  private Integer totalRow;
  private List<T> items;
  private String url;

  // 3. 无参构造器
  public Page() {
  }

  // 4. 分页属性的读取与设置方法
  public Integer getPageNo() {
    return pageNo;
  }

  public void setPageNo(Integer pageNo) {
    this.pageNo = pageNo;
  }

  public List<T> getItems() {
    return items;
  }

  public void setItems(List<T> items) {
    this.items = items;
  }
}

在组装 Page<Furn> 的过程中,数据访问层先后执行总行数统计与当前页数据截取两条 SQL 语句(以查询第 1 页、每页 3 条为例):

sql
-- 1. 统计 furn 表中在售家居商品的总记录数
SELECT COUNT(*)
    FROM `furn`;

-- 2. 按起始行索引与每页条数截取当前页的商品列表
SELECT `id`, `name`, `maker`, `price`, `sales`, `stock`, `img_path` AS `imgPath`
    FROM `furn`
    LIMIT 0, 3;

控制器分页请求调度 ​

在 FurnServlet 中,page 方法负责接收前端分页参数、调用业务层获取 Page<Furn> 模型,并将数据转发至后台商品管理页面:

java
// 1. 后台家居商品管理控制器,承接商品分页与增删改查请求
public class FurnServlet extends BasicServlet {

  private FurnService furnService = new FurnServiceImpl();

  // 2. 处理后台商品分页展示请求
  public void page(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    // 3. 提取请求的页码与每页条数,未传参时默认为第 1 页、每页 3 条
    int pageNo = DataUtils.parseInt(req.getParameter("pageNo"), 1);
    int pageSize = DataUtils.parseInt(req.getParameter("pageSize"), Page.PAGE_SIZE);

    // 4. 调用业务层组装当前页的 Page<Furn> 分页模型对象
    Page<Furn> page = furnService.page(pageNo, pageSize);

    // 5. 将分页对象存入 Request 域并转发至后台商品管理页渲染
    req.setAttribute("page", page);
    req.getRequestDispatcher("/views/manage/furn_manage.jsp").forward(req, resp);
  }
}

后台列表与分页条渲染 ​

请求转发至 views/manage/furn_manage.jsp 后,页面分为上下两个业务区域进行数据绑定:

  1. 商品数据表格区:遍历 ${requestScope.page.items} 渲染当前页的每件家居商品。行尾的“修改”与“删除”链接在携带商品主键 id 的同时,一并附带 pageNo=${requestScope.page.pageNo} 参数,以便管理员完成修改或删除操作后能够精准回到当前浏览的分页位置。

  2. 底部分页导航区:根据 pageNo 与 pageTotalCount 的大小关系,动态控制“上一页”与“下一页”按钮的显隐,并通过页码循环渲染数字跳转链接,高亮标记当前所在页码。

html
<!-- 1. 遍历当前页商品集合,渲染后台商品管理表格行 -->
<c:forEach items="${requestScope.page.items}" var="furn">
  <tr>
    <td><img src="${furn.imgPath}" alt="商品图片" /></td>
    <td>${furn.name}</td>
    <td>${furn.maker}</td>
    <td>${furn.price}</td>
    <td>${furn.sales}</td>
    <td>${furn.stock}</td>
    <td>
      <!-- 2. 修改与删除入口均携带当前页码 pageNo,以便操作后返回原页 -->
      <a href="manage/furnServlet?action=showFurn&id=${furn.id}&pageNo=${requestScope.page.pageNo}">修改</a>
      <a class="deleteCss" href="manage/furnServlet?action=del&id=${furn.id}&pageNo=${requestScope.page.pageNo}"
        >删除</a
      >
    </td>
  </tr>
</c:forEach>

<!-- 3. 渲染底部分页导航条:当前页大于 1 时显示“上一页” -->
<div class="pro-pagination-style">
  <ul>
    <c:if test="${requestScope.page.pageNo > 1}">
      <li><a href="manage/furnServlet?action=page&pageNo=${requestScope.page.pageNo - 1}">上一页</a></li>
    </c:if>

    <!-- 4. 循环渲染页码数字按钮,当前页码高亮显示 -->
    <c:forEach begin="1" end="${requestScope.page.pageTotalCount}" var="i">
      <c:if test="${requestScope.page.pageNo == i}">
        <li><a class="active" href="manage/furnServlet?action=page&pageNo=${i}">${i}</a></li>
      </c:if>
      <c:if test="${requestScope.page.pageNo != i}">
        <li><a href="manage/furnServlet?action=page&pageNo=${i}">${i}</a></li>
      </c:if>
    </c:forEach>

    <!-- 5. 当前页小于总页数时显示“下一页” -->
    <c:if test="${requestScope.page.pageNo < requestScope.page.pageTotalCount}">
      <li><a href="manage/furnServlet?action=page&pageNo=${requestScope.page.pageNo + 1}">下一页</a></li>
    </c:if>
    <li><a>共 ${requestScope.page.pageTotalCount} 页 / ${requestScope.page.totalRow} 条记录</a></li>
  </ul>
</div>

后台商品新增删除 ​

后台商品新增与删除业务负责商城商品库的动态扩充与清理。管理员在后台商品分页列表页可以跳转至新增表单上架新家居,也可以直接对过期或下架商品执行删除。为保障运营操作的流畅性与数据安全性,两个流程均通过传递分页页码(pageNo)记忆操作位置,并在持久化完成后采用客户端重定向刷新列表视图。

新增与删除业务流转 ​

后台商品新增上架与下架删除从管理员在列表页触发操作开始,到最终重定向回原分页视图,完整业务流转时序如下:

image-20261109160953142

  1. 新增入口与页码传递:管理员在 views/manage/furn_manage.jsp 点击右上角“添加家居”按钮,链接携带当前分页位置参数(views/manage/furn_add.jsp?pageNo=${requestScope.page.pageNo})跳转至商品新增表单页。

  2. 新增表单提交与默认图兜底:管理员在 furn_add.jsp 填写家居名称、制造商、价格、销量与库存并提交表单(携带隐藏域 action=add 与 pageNo)。控制器将参数封装为 Furn 实体,未上传实拍图时自动采用实体预设的默认占位图路径(assets/images/product-image/default.jpg)写入数据库。

  3. 删除确认与参数提交:管理员在 furn_manage.jsp 商品行尾点击“删除”按钮,前端页面先弹出确认对话框核对拟删除的家居名称;管理员点击确认后,浏览器向 /manage/furnServlet 发送携带 action=del、商品编号 id 与当前页码 pageNo 的请求。

  4. 重定向刷新分页列表:无论是新增入库还是按编号删除,控制器在业务层执行完毕后均通过 sendRedirect 重定向至 /manage/furnServlet?action=page&pageNo=...,既使管理员回到操作前的分页位置,又避免刷新浏览器导致重复上架或重复删除。

后台商品新增上架 ​

在 views/manage/furn_add.jsp 新增页面中,表单通过隐藏域固定传入 action="add",并通过 ${param.pageNo} 接收从商品管理列表页传递过来的页码参数,以便商品上架后能返回对应的分页视图:

html
<!-- 1. 展示商品新增数据格式校验失败时的错误提示 -->
<span class="errorMsg">${requestScope.msg}</span>

<!-- 2. 提交新增家居表单,隐藏域携带 action=add 与来源页码 pageNo -->
<form action="manage/furnServlet" method="post">
  <input type="hidden" name="action" value="add" />
  <input type="hidden" name="pageNo" value="${param.pageNo}" />
  <input type="text" name="name" placeholder="请输入家居名称" />
  <input type="text" name="maker" placeholder="请输入制造商" />
  <input type="text" name="price" placeholder="请输入价格" />
  <input type="text" name="sales" placeholder="请输入销量" />
  <input type="text" name="stock" placeholder="请输入库存" />

  <!-- 3. 提交表单完成商品上架 -->
  <button type="submit">添加家居</button>
</form>

控制器 FurnServlet 的 add 方法接收新增表单数据,完成实体封装与入库调用:

java
// 1. 处理后台新增家居商品请求
public void add(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  // 2. 将表单提交的家居属性自动封装为 Furn 实体(自动赋予默认占位图路径)
  Furn furn = DataUtils.copyParamToBean(req.getParameterMap(), new Furn());

  // 3. 调用业务层将新商品持久化写入数据库
  furnService.add(furn);

  // 4. 重定向回商品分页列表原页码,避免刷新浏览器导致重复添加商品
  resp.sendRedirect(req.getContextPath() + "/manage/furnServlet?action=page&pageNo=" + req.getParameter("pageNo"));
}

后台商品下架删除 ​

为了防止管理员在商品列表中误触删除按钮导致商品数据丢失,furn_manage.jsp 在删除链接上绑定了前端弹窗确认逻辑。当管理员点击删除图标时,脚本从当前表格行提取家居名称并弹出确认提示,仅当管理员点击“确定”时才放行请求跳转,点击“取消”则中止删除动作。

确认删除后,控制器 FurnServlet 的 del 方法提取商品编号 id 与当前页码 pageNo,调用业务层移除数据库记录并重定向回原分页页码:

java
// 1. 处理后台下架删除家居商品请求
public void del(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  // 2. 提取待删除的商品编号 id 与操作前所在的分页页码 pageNo
  int id = DataUtils.parseInt(req.getParameter("id"), 0);
  int pageNo = DataUtils.parseInt(req.getParameter("pageNo"), 1);

  // 3. 调用业务层按编号删除指定家居记录
  furnService.deleteFurnById(id);

  // 4. 删除完成后重定向回原分页视图,保持管理员浏览位置不变
  resp.sendRedirect(req.getContextPath() + "/manage/furnServlet?action=page&pageNo=" + pageNo);
}

在底层数据访问层中,商品新增与删除分别对应 furn 表的插入与按主键删除语句:

sql
-- 1. 新增上架家居商品,未上传实拍图时使用默认占位图路径
INSERT INTO `furn`(`id`, `name`, `maker`, `price`, `sales`, `stock`, `img_path`)
    VALUES(NULL, '北欧风格小圆桌', '熊猫家居', 199.00, 10, 80, 'assets/images/product-image/default.jpg');

-- 2. 按商品主键编号下架删除指定家居记录
DELETE
    FROM `furn`
    WHERE `id` = 15;

后台商品修改更新 ​

后台商品修改更新业务负责对存量家居商品的文本属性(名称、制造商、单价、销量、库存)及商品实拍图片进行编辑维护。为保证管理员在修改过程中能直观对照原有商品数据,并在更新完成后无缝返回原浏览页码,该业务拆分为“原始数据查询回显”与“图文表单提交更新”两个连续的业务阶段。

修改更新业务流转 ​

管理员从后台商品分页列表点击“修改”入口,到完成图文编辑并重定向回原分页位置,完整业务流转时序如下:

image-20261109161014937

  1. 触发修改回显请求:管理员在 views/manage/furn_manage.jsp 点击指定商品行尾的“修改”按钮,请求携带 action=showFurn、商品编号 id 以及当前页码 pageNo 发送至 /manage/furnServlet。

  2. 查询原商品并转发回显:控制器 FurnServlet.showFurn() 根据 id 调用业务层查询出完整的 Furn 原始记录,将其存入 Request 域后转发至 views/manage/furn_update.jsp。修改页面在表单输入框中回显原文本属性与原商品图片,同时将 pageNo 保留在表单提交地址中。

  3. 提交多部分图文表单:管理员按需修改商品文本信息或选择新的本地实拍图后点击提交,表单以 multipart/form-data 格式向 manage/furnServlet?action=update&id=...&pageNo=... 发送请求。

  4. 属性覆盖与图片按需替换:控制器 FurnServlet.update() 先按 id 查出数据库中原有的 Furn 对象作为基准,随后遍历表单项——普通文本项直接覆盖对应属性;文件项仅在管理员实际选择了新图片时才将文件保存至服务器目录并更新 imgPath,未选择新图片则保留原图片路径不变。

  5. 持久化更新与列表重定向:业务层将更新后的 Furn 对象写入数据库,控制器最终通过重定向跳转回 /manage/furnServlet?action=page&pageNo=...,刷新展示修改后的商品分页列表。

原商品数据查询回显 ​

当管理员点击商品列表行的“修改”链接时,FurnServlet 的 showFurn 方法首先根据商品主键拉取原始数据,为修改页面提供回显数据源:

java
// 1. 处理后台商品修改前的数据回显请求
public void showFurn(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  // 2. 提取待修改的商品编号 id
  int id = DataUtils.parseInt(req.getParameter("id"), 0);

  // 3. 调用业务层查询该商品的完整原始信息
  Furn furn = furnService.queryFurnById(id);

  // 4. 将商品对象存入 Request 域并转发至商品修改表单页回显
  req.setAttribute("furn", furn);
  req.getRequestDispatcher("/views/manage/furn_update.jsp").forward(req, resp);
}

转发至 views/manage/furn_update.jsp 后,由于表单包含商品图片文件上传控件,表单标签必须声明 enctype="multipart/form-data"。为了使后端在解析多部分表单前就能直接通过 req.getParameter() 获取路由参数,表单的 action 属性直接在 URL 查询字符串中拼接 action=update、商品编号 ${requestScope.furn.id} 与来源页码 ${param.pageNo}:

html
<!-- 1. 多部分表单提交修改请求,URL 携带 action=update、商品编号 id 与来源页码 pageNo -->
<form
  action="manage/furnServlet?action=update&id=${requestScope.furn.id}&pageNo=${param.pageNo}"
  method="post"
  enctype="multipart/form-data"
>
  <!-- 2. 展示当前商品原图片,并提供文件选择框供管理员替换新实拍图 -->
  <img src="${requestScope.furn.imgPath}" alt="商品原图" />
  <input type="file" name="imgPath" />

  <!-- 3. 回显商品原有文本属性,允许管理员按需修改 -->
  <input type="text" name="name" value="${requestScope.furn.name}" />
  <input type="text" name="maker" value="${requestScope.furn.maker}" />
  <input type="text" name="price" value="${requestScope.furn.price}" />
  <input type="text" name="sales" value="${requestScope.furn.sales}" />
  <input type="text" name="stock" value="${requestScope.furn.stock}" />

  <!-- 4. 提交图文更新表单 -->
  <button type="submit">修改家居</button>
</form>

图文表单解析与商品更新 ​

在后台商品修改业务中,管理员可能只修改价格或库存而不更换商品图片,也可能同时替换商品实拍图。为了兼容这两种业务场景,FurnServlet.update() 先从数据库查出原 Furn 实体对象,再逐项解析表单提交的新数据:

java
// 1. 处理后台商品图文修改与更新入库请求
public void update(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  // 2. 提取商品编号并查询数据库中原有的 Furn 对象,防止未上传新图时丢失原图片路径
  int id = DataUtils.parseInt(req.getParameter("id"), 0);
  Furn furn = furnService.queryFurnById(id);

  // 3. 校验是否为多部分文件上传表单,解析所有表单项
  if (ServletFileUpload.isMultipartContent(req)) {
    DiskFileItemFactory diskFileItemFactory = new DiskFileItemFactory();
    ServletFileUpload servletFileUpload = new ServletFileUpload(diskFileItemFactory);
    servletFileUpload.setHeaderEncoding("utf-8");

    try {
      List<FileItem> list = servletFileUpload.parseRequest(req);
      for (FileItem fileItem : list) {
        // 4. 普通文本表单项:按字段名依次覆盖商品对象的文本与数值属性
        if (fileItem.isFormField()) {
          String fieldName = fileItem.getFieldName();
          String fieldValue = fileItem.getString("utf-8");
          if ("name".equals(fieldName)) {
            furn.setName(fieldValue);
          } else if ("maker".equals(fieldName)) {
            furn.setMaker(fieldValue);
          } else if ("price".equals(fieldName)) {
            furn.setPrice(new BigDecimal(fieldValue));
          } else if ("sales".equals(fieldName)) {
            furn.setSales(DataUtils.parseInt(fieldValue, 0));
          } else if ("stock".equals(fieldName)) {
            furn.setStock(DataUtils.parseInt(fieldValue, 0));
          }
        } else {
          // 5. 文件上传表单项:仅当管理员选择了新图片文件时才执行落盘并更新图片路径
          String name = fileItem.getName();
          if (!"".equals(name)) {
            String filePath = "/assets/images/product-image";
            String fileRealPath = req.getServletContext().getRealPath(filePath);
            File fileRealPathDirectory = new File(fileRealPath);
            if (!fileRealPathDirectory.exists()) {
              fileRealPathDirectory.mkdirs();
            }
            String fileName = UUID.randomUUID().toString() + "_" + System.currentTimeMillis() + "_" + name;
            fileItem.write(new File(fileRealPathDirectory + "/" + fileName));
            furn.setImgPath(filePath.substring(1) + "/" + fileName);
          }
        }
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

  // 6. 调用业务层将修改后的商品数据同步至数据库,并重定向回原分页视图
  furnService.updateFurn(furn);
  resp.sendRedirect(req.getContextPath() + "/manage/furnServlet?action=page&pageNo=" + req.getParameter("pageNo"));
}

在整个商品修改闭环中,数据访问层先后执行按主键查询单条记录与按主键更新全字段两条 SQL 语句:

sql
-- 1. 修改前按商品编号查询单条家居原始记录用于表单回显
SELECT `id`, `name`, `maker`, `price`, `sales`, `stock`, `img_path` AS `imgPath`
    FROM `furn`
    WHERE `id` = 12;

-- 2. 将管理员修改后的商品文本属性与最新图片路径更新至数据库
UPDATE `furn`
    SET `name` = '简约布艺沙发', `maker` = '蚂蚁家居', `price` = 680.00,
        `sales` = 25, `stock` = 60, `img_path` = 'assets/images/product-image/new_sofa.jpg'
    WHERE `id` = 12;