Java MVC架构实现信息录入与显示完整项目实战

张天筝

344人浏览 · 2025-10-10 12:17:12

张天筝 · 2025-10-10 12:17:12 发布

简介：Java MVC是一种广泛应用于Web开发的架构模式，通过Model-View-Controller分离关注点，提升代码可维护性与扩展性。本压缩包“javaMVC信息录入与显示test.rar”提供了一个基于Java的MVC实践示例，涵盖模型层数据库操作、视图层数据展示（如JSP）及控制器层请求处理（如Spring MVC注解），并包含实体类与数据库表字段映射、CRUD功能实现以及测试验证等内容。该项目经过实际测试，帮助开发者深入理解MVC设计模式在Java Web应用中的落地实践。
javaMVC信息录入与显示test.rar

1. Java MVC架构模式概述

MVC（Model-View-Controller）作为一种经典的软件设计模式，在Java Web开发中占据核心地位。本章将深入剖析MVC的三大组件——模型（Model）、视图（View）和控制器（Controller）之间的职责划分与协作机制，阐述其在提升代码可维护性、解耦业务逻辑与用户界面方面的关键作用。通过对比传统Servlet开发模式与MVC模式的差异，揭示MVC如何有效支持分层架构设计，并为后续章节的技术实现奠定理论基础。

graph TD
    A[用户请求] --> B(Controller)
    B --> C{处理请求}
    C --> D[调用Model]
    D --> E[执行业务/数据操作]
    E --> F[返回结果给Controller]
    F --> G[选择View]
    G --> H[渲染页面]
    H --> I[响应用户]

结合实际项目“javaMVC信息录入与显示test.rar”的功能目标，说明MVC如何支撑信息录入、数据持久化与动态展示的完整流程，帮助开发者建立清晰的系统架构认知。

2. Model层设计与数据库连接配置

在Java MVC架构中，Model层作为系统的核心数据处理单元，承担着业务逻辑封装、数据持久化操作以及与数据库交互的重任。它不仅决定了系统的可扩展性与稳定性，更直接影响到后续视图展示和控制器调度的效率与准确性。一个结构清晰、职责明确的Model层能够有效解耦数据访问逻辑与业务规则，提升代码复用率，并为后期维护提供坚实基础。本章将深入探讨Model层的设计理念、数据库连接的配置管理机制、连接池技术的应用优化路径，以及异常处理策略的构建方式，结合实际开发场景，全面解析如何打造高效、稳定且易于维护的数据访问体系。

2.1 Model层的核心职责与设计原则

Model层是MVC模式中的“大脑”，负责管理应用程序的状态和行为。其核心任务包括实体对象的建模、业务逻辑的实现、数据访问接口的定义与执行，以及对底层数据库资源的操作封装。良好的Model层设计应遵循高内聚、低耦合的原则，确保各模块之间职责分明，便于独立测试和替换。

2.1.1 Model在MVC中的角色定位

在传统的Servlet+JSP开发模式中，常常出现Java代码与HTML混杂的情况，导致业务逻辑、数据显示和用户输入控制高度耦合，难以维护。而引入MVC后，Model层被赋予了独立的角色——它是唯一可以直接访问数据库或外部服务的组件，其他层次（如Controller和View）只能通过调用Model提供的方法来获取或修改数据。

以“用户信息录入”功能为例，当用户提交表单时，Controller接收请求参数并调用UserService.saveUser()方法；该方法属于Model层的一部分，内部进一步委托给UserDAO完成INSERT语句的执行。整个过程中，Controller不直接操作SQL，也不了解数据库结构，仅关注流程控制，从而实现了逻辑分离。

这种分层设计带来了显著优势：
- 可测试性强 ：Model层可以脱离Web容器进行单元测试；
- 可替换性高 ：若未来更换ORM框架（如从JDBC切换到MyBatis），只需调整DAO实现类，不影响上层逻辑；
- 安全性增强 ：敏感操作集中于Model层，便于统一做事务控制和权限校验。

public class UserController extends HttpServlet {
    private UserService userService = new UserService(); // Model层实例

    protected void doPost(HttpServletRequest request, HttpServletResponse response) 
            throws ServletException, IOException {
        String name = request.getParameter("name");
        String email = request.getParameter("email");

        User user = new User();
        user.setName(name);
        user.setEmail(email);

        userService.saveUser(user); // 调用Model层方法
        response.sendRedirect("list.jsp");
    }
}

代码逻辑逐行分析 ：
- 第2行：声明 UserService 实例，代表业务逻辑层，属于Model范畴；
- 第6~9行：从HTTP请求中提取参数并封装为 User 实体对象；
- 第11行：调用 saveUser() 方法，触发数据持久化动作，完全屏蔽底层细节；
- 第13行：重定向至列表页，由View层负责渲染结果。

该设计体现了典型的职责划分：Controller只做路由与参数传递，真正的存储逻辑由Model完成。

2.1.2 领域模型与数据访问对象（DAO）的分离策略

为了进一步细化Model层内部结构，现代Java Web项目普遍采用“领域模型 + DAO”的双层结构。其中：

领域模型（Domain Model） ：即POJO类（Plain Old Java Object），用于映射数据库表结构，通常包含属性、getter/setter、equals/hashCode等标准方法；
数据访问对象（Data Access Object, DAO） ：封装对数据库的具体操作，如增删改查，隐藏JDBC API的复杂性。

二者之间的关系可通过以下UML类图表示：

classDiagram
    class User {
        -id: Long
        -name: String
        -email: String
        +getId(): Long
        +setName(String): void
        +toString(): String
    }

    class UserDao {
        -connection: Connection
        +save(User): boolean
        +findById(Long): User
        +findAll(): List~User~
        +update(User): int
        +deleteById(Long): boolean
    }

    User <.. UserDao : uses

流程图说明 ：
- User 类表示用户实体，对应数据库中的 user_info 表；
- UserDao 类负责所有对该表的操作；
- 箭头方向表明 UserDao 依赖 User 对象作为数据载体。

这种分离带来如下好处：
1. 职责清晰 ：实体类专注数据结构描述，DAO专注数据操作；
2. 便于扩展 ：新增查询方法只需在DAO中添加，不影响实体定义；
3. 支持多表关联 ：复杂的联合查询可在DAO中组合多个实体返回。

例如，在实现“根据邮箱查找用户”功能时：

public User findByEmail(String email) {
    String sql = "SELECT id, name, email FROM user_info WHERE email = ?";
    try (Connection conn = DataSourceUtil.getConnection();
         PreparedStatement ps = conn.prepareStatement(sql)) {
        ps.setString(1, email);
        ResultSet rs = ps.executeQuery();
        if (rs.next()) {
            return new User(
                rs.getLong("id"),
                rs.getString("name"),
                rs.getString("email")
            );
        }
    } catch (SQLException e) {
        e.printStackTrace();
    }
    return null;
}

参数说明 ：
- email ：输入参数，用于条件匹配；
- PreparedStatement 使用占位符防止SQL注入；
- 返回类型为 User ，体现面向对象的数据封装。

该方法位于 UserDao 中，体现了DAO作为数据库代理的角色。

2.1.3 基于SRP原则的模块化设计实践

单一职责原则（Single Responsibility Principle, SRP）是SOLID设计原则之首，强调一个类应当只有一个引起它变化的原因。在Model层设计中，这意味着每个DAO类应仅对应一张主表，避免“万能DAO”现象。

类名	对应表	职责范围
`UserDao`	`user_info`	用户增删改查、登录验证
`RoleDao`	`role`	角色管理、权限分配
`UserRoleDao`	`user_role`	多对多关系维护

若将上述功能全部塞入一个 BaseDao 类中，会导致该类频繁变更，违反SRP。相反，按表拆分DAO，使得每个类职责单一，修改风险可控。

此外，还可引入 Service层 作为中介，协调多个DAO协作。例如注册新用户时需同时写入 user_info 和 user_role 两张表：

public class UserService {
    private UserDao userDao = new UserDao();
    private UserRoleDao userRoleDao = new UserRoleDao();

    public boolean register(User user, Long roleId) {
        Connection conn = null;
        try {
            conn = DataSourceUtil.getConnection();
            conn.setAutoCommit(false);

            User savedUser = userDao.save(conn, user);
            userRoleDao.bindRole(conn, savedUser.getId(), roleId);

            conn.commit();
            return true;
        } catch (Exception e) {
            if (conn != null) {
                try {
                    conn.rollback();
                } catch (SQLException ex) {
                    ex.printStackTrace();
                }
            }
            return false;
        } finally {
            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

代码逻辑分析 ：
- 使用手动事务控制保证原子性；
- save() 和 bindRole() 共享同一连接；
- 出现异常时回滚，防止脏数据写入。

此设计展示了SRP与事务管理的结合应用，提升了系统的健壮性。

2.2 数据库连接配置文件管理

数据库连接信息属于敏感且易变的配置项，硬编码在源码中既不安全也不利于部署。因此，必须通过外部化配置文件进行统一管理。

2.2.1 application.properties与db.properties的区别与选择

在Java项目中常见的配置文件格式有两种：

文件类型	用途	所属生态	示例内容
`application.properties`	Spring Boot全局配置	Spring生态	server.port=8080 spring.datasource.url=jdbc:mysql://…
`db.properties`	自定义JDBC连接配置	原生JDBC项目	db.driver=com.mysql.cj.jdbc.Driver db.url=jdbc:mysql://localhost:3306/test_db

对于非Spring项目（如本例“javaMVC信息录入与显示test.rar”），推荐使用 db.properties ，因其命名直观、结构简单，适合轻量级环境。

创建 src/main/resources/db.properties 文件：

db.driver=com.mysql.cj.jdbc.Driver
db.url=jdbc:mysql://localhost:3306/test_db?useSSL=false&serverTimezone=UTC
db.username=root
db.password=123456
db.initialSize=5
db.maxActive=20

参数说明 ：
- useSSL=false ：本地测试关闭SSL加密；
- serverTimezone=UTC ：避免时区警告；
- initialSize/maxActive ：连接池初始与最大连接数。

2.2.2 数据源（DataSource）的配置参数详解

要建立数据库连接，必须正确设置以下四个关键参数：

参数	作用	示例值	注意事项
JDBC URL	指定数据库地址和实例	`jdbc:mysql://host:port/dbname`	必须包含协议、主机、端口、数据库名
驱动类名	加载对应的JDBC驱动	`com.mysql.cj.jdbc.Driver`	MySQL 8+需使用 `.cj.` 包路径
用户名	登录凭据	`root`	生产环境不应使用root账户
密码	认证凭证	`******`	应加密存储或使用密钥管理工具

这些参数共同构成 DataSource 初始化的基础。

2.2.3 使用Properties类加载配置文件并实现动态读取

Java提供了 java.util.Properties 类用于读取 .properties 文件。以下是通用的工具类实现：

public class ConfigLoader {
    private static final Properties props = new Properties();

    static {
        try (InputStream input = ConfigLoader.class.getClassLoader()
                .getResourceAsStream("db.properties")) {
            if (input == null) {
                throw new RuntimeException("Unable to find db.properties");
            }
            props.load(input);
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }

    public static String getProperty(String key) {
        return props.getProperty(key);
    }
}

代码逻辑逐行解读 ：
- 第3行：静态变量存储配置集合；
- 第5~12行：类加载时自动加载 db.properties ；
- 第7行：使用类加载器定位资源路径，兼容JAR包部署；
- 第15~17行：提供公共方法按键取值。

随后可在 DataSourceUtil 中调用：

public class DataSourceUtil {
    public static Connection getConnection() throws SQLException {
        String driver = ConfigLoader.getProperty("db.driver");
        String url = ConfigLoader.getProperty("db.url");
        String username = ConfigLoader.getProperty("db.username");
        String password = ConfigLoader.getProperty("db.password");

        try {
            Class.forName(driver);
        } catch (ClassNotFoundException e) {
            throw new RuntimeException("Driver not found", e);
        }
        return DriverManager.getConnection(url, username, password);
    }
}

扩展性说明 ：
此方式支持热更新配置（配合定时重载），也可扩展为支持YAML、JSON等格式。

2.3 连接池技术的引入与性能优化

频繁创建和销毁数据库连接会消耗大量系统资源，严重影响性能。连接池通过预先创建一组连接并重复利用，极大缓解这一问题。

2.3.1 为什么需要数据库连接池

每次调用 DriverManager.getConnection() 都会经历TCP握手、身份认证、权限检查等开销，耗时可达数十毫秒。假设每秒处理100个请求，则每天浪费近3小时在连接建立上。

连接池的优势体现在：
- 减少连接创建开销 ：连接复用，避免重复初始化；
- 控制并发连接数 ：防止数据库过载；
- 提供监控能力 ：统计活跃/空闲连接数；
- 支持超时与回收机制 ：自动清理无效连接。

2.3.2 常见连接池实现（如HikariCP、C3P0）在MVC项目中的集成方式

目前主流连接池包括：

名称	特点	性能排名	Maven依赖
HikariCP	极致性能、简洁API	★★★★★	`com.zaxxer:HikariCP`
C3P0	功能丰富、老牌稳定	★★★☆☆	`com.mchange:c3p0`
DBCP	Apache出品、轻量	★★☆☆☆	`org.apache.commons:commons-dbcp2`

推荐使用HikariCP，因其延迟极低、吞吐量高。

集成步骤如下：

添加Maven依赖：

<dependency>
    <groupId>com.zaxxer</groupId>
    <artifactId>HikariCP</artifactId>
    <version>5.0.1</version>
</dependency>

创建 HikariConfig 并初始化数据源：

public class HikariDataSourceUtil {
    private static HikariDataSource dataSource;

    static {
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl(ConfigLoader.getProperty("db.url"));
        config.setUsername(ConfigLoader.getProperty("db.username"));
        config.setPassword(ConfigLoader.getProperty("db.password"));
        config.setDriverClassName(ConfigLoader.getProperty("db.driver"));
        config.setMaximumPoolSize(Integer.parseInt(ConfigLoader.getProperty("db.maxActive")));
        config.setMinimumIdle(5);
        config.setConnectionTimeout(30000); // 30秒
        config.setIdleTimeout(600000);      // 10分钟
        config.setMaxLifetime(1800000);     // 30分钟

        dataSource = new HikariDataSource(config);
    }

    public static Connection getConnection() throws SQLException {
        return dataSource.getConnection();
    }
}

参数说明 ：
- maximumPoolSize=20 ：最多20个连接；
- minimumIdle=5 ：始终保持5个空闲连接；
- maxLifetime ：防止连接过期失效。

在DAO中调用：

try (Connection conn = HikariDataSourceUtil.getConnection();
     PreparedStatement ps = conn.prepareStatement(sql)) {
    // 执行查询...
} // 自动归还连接至池

流程图展示连接获取过程 ：

sequenceDiagram
    participant App as Application
    participant Pool as HikariCP Pool
    participant DB as Database

    App->>Pool: getConnection()
    alt 有空闲连接
        Pool-->>App: 返回可用连接
    else 无空闲连接 & 未达上限
        Pool->>DB: 创建新连接
        Pool-->>App: 返回新建连接
    else 达到最大连接数
        Pool->>App: 等待（直至超时）
    end

2.3.3 连接泄漏检测与资源释放最佳实践

最常见的问题是连接未正确关闭，造成“连接泄漏”。HikariCP可通过以下配置开启检测：

db.leakDetectionThreshold=5000  # 超过5秒未归还即报警

同时，务必使用 try-with-resources 语法：

public List<User> findAll() {
    String sql = "SELECT * FROM user_info";
    List<User> users = new ArrayList<>();
    try (Connection conn = HikariDataSourceUtil.getConnection();
         Statement stmt = conn.createStatement();
         ResultSet rs = stmt.executeQuery(sql)) {

        while (rs.next()) {
            users.add(mapRowToUser(rs));
        }
    } catch (SQLException e) {
        e.printStackTrace();
    }
    return users;
}

优势说明 ：
- try-with-resources 确保 Connection 、 Statement 、 ResultSet 自动关闭；
- 即使发生异常也能释放资源；
- 不再需要显式 finally{ close() } 。

2.4 数据库连接的异常处理机制

数据库操作充满不确定性，网络中断、认证失败、死锁等问题随时可能发生。健全的异常处理机制是保障系统稳定的关键。

2.4.1 SQLException的捕获与日志记录

所有JDBC操作都可能抛出 SQLException ，必须被捕获并妥善处理：

public User findById(Long id) {
    String sql = "SELECT * FROM user_info WHERE id = ?";
    try (Connection conn = HikariDataSourceUtil.getConnection();
         PreparedStatement ps = conn.prepareStatement(sql)) {

        ps.setLong(1, id);
        try (ResultSet rs = ps.executeQuery()) {
            if (rs.next()) {
                return mapRowToUser(rs);
            }
        }
    } catch (SQLException e) {
        System.err.println("Query failed for id=" + id);
        e.printStackTrace(); // 实际项目应使用SLF4J记录到日志文件
    }
    return null;
}

建议使用日志框架替代 printStackTrace() ：

private static final Logger logger = LoggerFactory.getLogger(UserDao.class);

logger.error("Database query error", e);

2.4.2 连接失败时的重试策略与降级方案

在网络不稳定环境下，可实施指数退避重试机制：

public Connection getConnectionWithRetry(int maxRetries) throws SQLException {
    for (int i = 0; i < maxRetries; i++) {
        try {
            return HikariDataSourceUtil.getConnection();
        } catch (SQLException e) {
            if (i == maxRetries - 1) throw e;
            long waitTime = (long) Math.pow(2, i) * 1000;
            try {
                Thread.sleep(waitTime);
            } catch (InterruptedException ie) {
                Thread.currentThread().interrupt();
            }
        }
    }
    return null;
}

降级方案建议 ：
- 缓存最近一次成功查询结果；
- 返回友好提示页面而非空白错误；
- 启用只读模式，禁用写操作。

综上所述，Model层不仅是数据通道，更是系统稳定性的基石。通过合理设计DAO结构、科学管理配置、引入连接池并完善异常处理，才能构建出高性能、高可用的企业级Java Web应用。

3. 实体类与数据库表字段映射规范

在Java Web开发中，MVC架构的Model层承担着数据建模的核心职责。其中， 实体类（Entity）作为业务数据的载体 ，直接决定了应用程序与数据库之间的交互方式和数据一致性保障能力。一个设计良好的实体类不仅需要符合Java语言的最佳实践，还必须与底层数据库表结构形成清晰、准确、可维护的映射关系。本章节将系统性地探讨实体类的设计准则、字段类型映射策略、主键生成机制以及在实际项目中的落地方法，重点围绕“用户信息录入”这一典型场景展开深入分析。

3.1 实体类（Entity）的设计准则

实体类是领域模型的具体实现，它封装了业务对象的状态及其基本行为。在MVC模式中，实体类通常位于 com.example.model 或 com.example.entity 包下，是DAO层操作的数据单元，也是Controller向View传递数据的基础结构。

3.1.1 JavaBean规范与POJO类的封装要求

JavaBean是一种遵循特定命名和结构约定的POJO（Plain Old Java Object），其核心特征包括：

所有属性私有化（private）
提供无参构造函数
属性通过public getter/setter方法暴露
可序列化（实现Serializable接口）

这些规则确保了实体类能够在框架间自由传输，尤其是在JSP页面使用EL表达式访问时具备良好的兼容性。

import java.io.Serializable;
import java.time.LocalDateTime;

public class UserInfo implements Serializable {
    private static final long serialVersionUID = 1L;

    private Long id;
    private String username;
    private String email;
    private Integer age;
    private LocalDateTime createTime;

    public UserInfo() {}

    // Getters and Setters
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }

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

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

    public Integer getAge() { return age; }
    public void setAge(Integer age) { this.age = age; }

    public LocalDateTime getCreateTime() { return createTime; }
    public void setCreateTime(LocalDateTime createTime) { this.createTime = createTime; }
}

代码逻辑逐行解读：

implements Serializable ：使对象支持序列化，便于在网络传输或持久化缓存中使用。
serialVersionUID ：显式定义版本号，避免反序列化时因类结构变更导致InvalidClassException。
私有属性+公共getter/setter：符合JavaBean规范，保证封装性和可扩展性。
无参构造函数：多数ORM框架和反射工具依赖此构造器创建实例。

参数说明： LocalDateTime 用于替代过时的 Date ，提供更精确的时间语义； Integer 而非 int 允许null值表示未设置年龄。

3.1.2 属性命名与数据库字段的对应关系

数据库字段常采用下划线命名法（如 user_name ），而Java属性多为驼峰命名（ userName ）。二者之间的映射可通过以下方式解决：

数据库字段名	Java属性名	映射方式
user_id	userId	驼峰转换
create_time	createTime	自动识别
is_active	active	布尔前缀去除

主流框架如MyBatis默认支持自动驼峰转下划线，也可通过注解显式指定：

@Column(name = "is_active")
private Boolean active;

Mermaid流程图：属性映射解析过程

graph TD
    A[Java属性: isActive] --> B{是否布尔类型?}
    B -- 是 --> C[尝试匹配 is_active / active]
    B -- 否 --> D[转换为下划线形式: is_active]
    C --> E[执行SQL查询]
    D --> E
    E --> F[结果集映射回对象]

该流程展示了框架如何智能推断字段映射路径，提升开发效率的同时降低出错概率。

3.1.3 使用注解或XML进行映射的优劣分析

目前主流ORM框架支持两种映射配置方式：注解（Annotation）与XML配置文件。

对比维度	注解方式	XML方式
可读性	高，代码与元数据一体化	中，需跳转文件查看
维护成本	修改频繁时易造成代码污染	集中管理，适合复杂映射
编译期检查	支持IDE提示与编译校验	运行时解析，错误发现滞后
框架依赖	强耦合于具体ORM（如JPA）	解耦更好，可跨框架迁移
动态调整灵活性	低，需重新编译	高，热更新配置

推荐实践 ：中小型项目优先使用注解以提高开发速度；大型企业级系统建议结合两者优势，核心实体用注解，复杂关联用XML补充。

3.2 字段类型映射一致性保障

确保数据库字段与Java类型的正确匹配，是防止运行时异常和数据丢失的关键环节。

3.2.1 数据库数据类型与Java类型的匹配规则

不同类型数据库略有差异，但通用映射如下表所示：

SQL Type	MySQL示例	Java Type	JDBC Type Code
INTEGER	INT, TINYINT	Integer / int	Types.INTEGER
BIGINT	BIGINT	Long	Types.BIGINT
VARCHAR(n)	VARCHAR(255)	String	Types.VARCHAR
TEXT	TEXT	String	Types.LONGVARCHAR
DATETIME / TIMESTAMP	DATETIME	LocalDateTime	Types.TIMESTAMP
DATE	DATE	LocalDate	Types.DATE
BOOLEAN / TINYINT(1)	BOOLEAN	Boolean	Types.BOOLEAN
DECIMAL(p,s)	DECIMAL(10,2)	BigDecimal	Types.DECIMAL

注意：不同驱动对同一SQL类型的映射可能不同，例如Oracle的 NUMBER 常映射为 BigDecimal 而非 Double 。

3.2.2 时间日期类型的处理

传统 java.util.Date 存在线程安全问题且API设计不合理。现代应用应优先选用 java.time 包下的新时间API：

@Entity
public class UserInfo {
    @Column(name = "create_time")
    private LocalDateTime createTime; // 推荐：精确到纳秒，不可变

    @Column(name = "birth_date")
    private LocalDate birthDate; // 仅日期部分

    @Column(name = "last_login_time")
    private ZonedDateTime lastLoginTime; // 带时区信息
}

JDBC 4.2+ 支持直接绑定 LocalDateTime 到 TIMESTAMP 字段，无需手动转换：

preparedStatement.setObject(1, LocalDateTime.now());
ResultSet rs = stmt.executeQuery("SELECT create_time FROM users");
LocalDateTime time = rs.getObject("create_time", LocalDateTime.class);

代码逻辑说明：

setObject() 利用泛型自动识别目标类型，简化类型转换。
getObject(columnName, Class<T>) 是类型安全的取值方式，优于 getTimestamp().toLocalDateTime() 。

3.2.3 空值（NULL）映射与Optional的应用探讨

数据库字段允许NULL时，Java端应使用包装类型接收：

private Integer age; // 允许null
private String middleName; // 可为空中间名

对于服务层调用，可结合 Optional 提升空值安全性：

public Optional<UserInfo> findById(Long id) {
    UserInfo user = jdbcTemplate.queryForObject(sql, rowMapper, id);
    return Optional.ofNullable(user);
}

调用方处理逻辑更加清晰：

Optional<UserInfo> opt = userService.findById(1L);
opt.ifPresentOrElse(
    u -> System.out.println("用户名：" + u.getUsername()),
    () -> System.out.println("用户不存在")
);

虽然JPA不直接支持 Optional 作为实体属性类型，但在DAO返回值和服务接口中广泛适用。

3.3 主键生成策略与唯一性约束

主键是实体唯一标识，直接影响数据一致性与性能表现。

3.3.1 自增主键、UUID、雪花算法的选择场景

策略	优点	缺点	适用场景
AUTO_INCREMENT	简单高效，连续递增	单点瓶颈，分库分表困难	单机系统、小规模应用
UUID	全局唯一，无需协调	存储开销大（36字符），无序	分布式部署、离线注册
雪花算法（Snowflake）	64位整数，趋势递增，高并发友好	需引入第三方库或自研	微服务架构、高并发写入

MySQL示例：

CREATE TABLE users (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    uuid CHAR(36) UNIQUE NOT NULL DEFAULT (UUID())
);

Java中使用HikariCP连接池配合自增主键获取：

KeyHolder keyHolder = new GeneratedKeyHolder();
jdbcTemplate.update(connection -> {
    PreparedStatement ps = connection.prepareStatement(
        "INSERT INTO users(username,email) VALUES (?,?)",
        Statement.RETURN_GENERATED_KEYS);
    ps.setString(1, user.getUsername());
    ps.setString(2, user.getEmail());
    return ps;
}, keyHolder);

Number generatedId = keyHolder.getKey();
user.setId(generatedId.longValue());

参数说明：

Statement.RETURN_GENERATED_KEYS ：通知数据库返回自动生成的主键。
GeneratedKeyHolder ：Spring提供的工具类，用于捕获插入后的主键值。

3.3.2 在实体类中标识主键字段的标准做法

使用JPA注解明确标注主键：

import javax.persistence.*;

@Entity
@Table(name = "users")
public class UserInfo {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private Long id;

    // other fields...
}

注解	作用说明
`@Id`	标识主键字段
`@GeneratedValue`	定义生成策略
`IDENTITY`	依赖数据库自增（如MySQL AUTO_INCREMENT）
`SEQUENCE`	使用序列（Oracle/PostgreSQL）
`TABLE`	使用专用表模拟序列，兼容性好但性能低

3.3.3 外键关联建模与级联操作的预设考虑

当涉及多表关系时，应在实体中建立关联：

@Entity
public class UserAddress {
    @Id
    private Long id;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "user_id", foreignKey = @ForeignKey(name = "fk_user_addr"))
    private UserInfo user;

    private String detail;
}

级联操作配置示例：

@OneToMany(mappedBy = "user", cascade = CascadeType.ALL, orphanRemoval = true)
private List<UserAddress> addresses = new ArrayList<>();

orphanRemoval = true 表示删除集合中元素时自动清除数据库记录。

3.4 映射规范在项目中的落地实践

以“javaMVC信息录入与显示test.rar”项目为例，完整演示实体类构建全过程。

3.4.1 以“用户信息录入”为例构建UserInfo实体

需求：录入用户名、邮箱、年龄、注册时间。

对应建表语句：

CREATE TABLE user_info (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    username VARCHAR(50) NOT NULL UNIQUE,
    email VARCHAR(100) NOT NULL,
    age INT DEFAULT NULL,
    create_time DATETIME DEFAULT CURRENT_TIMESTAMP
);

对应的Java实体：

@Entity
@Table(name = "user_info")
public class UserInfo implements Serializable {
    private static final long serialVersionUID = 1L;

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "username", length = 50, nullable = false, unique = true)
    private String username;

    @Column(name = "email", length = 100, nullable = false)
    private String email;

    @Column(name = "age")
    private Integer age;

    @Column(name = "create_time")
    private LocalDateTime createTime;

    // constructors, getters, setters...
}

3.4.2 利用Lombok简化模板代码

引入Lombok注解减少冗余代码：

<!-- pom.xml -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.30</version>
    <scope>provided</scope>
</dependency>

改造后实体类：

@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
@EqualsAndHashCode(of = "id")
@Entity
@Table(name = "user_info")
public class UserInfo implements Serializable {
    private static final long serialVersionUID = 1L;

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "username", length = 50, nullable = false, unique = true)
    private String username;

    @Column(name = "email", length = 100, nullable = false)
    private String email;

    @Column(name = "age")
    private Integer age;

    @CreationTimestamp
    @Column(name = "create_time", updatable = false)
    private LocalDateTime createTime;
}

Lombok注解	功能
`@Data`	自动生成getter/setter/toString/equal/hashCode
`@NoArgsConstructor`	无参构造函数
`@AllArgsConstructor`	全参构造函数
`@Builder`	支持流式创建对象
`@EqualsAndHashCode`	控制equals依据字段

3.4.3 编写单元测试验证实体序列化与反序列化正确性

@Test
public void testUserInfoSerialization() throws IOException, ClassNotFoundException {
    // Given
    UserInfo original = UserInfo.builder()
        .id(1L)
        .username("zhangsan")
        .email("zhangsan@example.com")
        .age(25)
        .createTime(LocalDateTime.now().truncatedTo(java.time.temporal.ChronoUnit.SECONDS))
        .build();

    // When: 序列化
    ByteArrayOutputStream bos = new ByteArrayOutputStream();
    ObjectOutputStream oos = new ObjectOutputStream(bos);
    oos.writeObject(original);
    oos.close();

    // When: 反序列化
    ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
    ObjectInputStream ois = new ObjectInputStream(bis);
    UserInfo deserialized = (UserInfo) ois.readObject();
    ois.close();

    // Then
    assertEquals(original.getId(), deserialized.getId());
    assertEquals(original.getUsername(), deserialized.getUsername());
    assertEquals(original.getEmail(), deserialized.getEmail());
    assertEquals(original.getAge(), deserialized.getAge());
    assertEquals(original.getCreateTime(), deserialized.getCreateTime());
}

表格：测试覆盖点清单

测试项	是否覆盖	说明
ID传递	✅	主键一致性
字符串字段完整性	✅	用户名、邮箱
包装类型null处理	✅	年龄可为空
时间精度一致性	⚠️	注意截断毫秒
hashCode/equals逻辑	✅	`@EqualsAndHashCode` 生效

建议统一使用 truncatedTo(SECONDS) 避免因纳秒差异导致断言失败。

综上所述，实体类的设计不仅仅是简单的字段复制，而是贯穿命名规范、类型匹配、主键策略、可维护性与测试验证的综合性工程任务。只有建立起标准化的映射体系，才能为后续DAO层操作、Controller数据流转及前端展示打下坚实基础。

4. CRUD操作SQL语句编写与DAO层实现

在Java MVC架构中，数据访问对象（DAO）是连接业务逻辑与持久化存储的核心桥梁。它负责封装所有对数据库的操作，包括增删改查（CRUD），并将这些操作抽象为清晰、可复用的接口方法。本章将深入探讨如何规范地编写SQL语句，设计健壮的DAO层结构，并通过JDBC实现具体的数据库交互逻辑。同时结合“用户信息录入”这一典型场景，展示从SQL构造到异常处理、再到性能测试的完整开发流程。

4.1 SQL语句的规范化编写

SQL作为与数据库直接通信的语言，其质量直接影响系统的安全性、可维护性与执行效率。尤其在Web应用中，不当的SQL编写方式极易引发SQL注入攻击或性能瓶颈。因此，必须遵循严格的编写规范，采用参数化查询、合理拼接条件、控制更新范围等策略，确保数据操作的安全与高效。

4.1.1 INSERT语句的参数化构造与防注入措施

INSERT语句用于向数据库表中插入新记录，是最基础的写入操作之一。但在实际开发中，若直接拼接字符串构建SQL，会带来严重的安全风险。

安全问题示例：

String sql = "INSERT INTO user_info(name, email) VALUES('" + name + "', '" + email + "')";

上述代码存在明显的SQL注入漏洞——攻击者可通过输入 ' OR '1'='1 等恶意字符串篡改SQL语义。

正确做法：使用PreparedStatement进行参数化

String sql = "INSERT INTO user_info(name, email, create_time) VALUES(?, ?, ?)";
try (Connection conn = dataSource.getConnection();
     PreparedStatement pstmt = conn.prepareStatement(sql)) {
    pstmt.setString(1, userInfo.getName());
    pstmt.setString(2, userInfo.getEmail());
    pstmt.setTimestamp(3, new Timestamp(System.currentTimeMillis()));
    int rowsAffected = pstmt.executeUpdate();
}

逻辑分析与参数说明
- ? 是占位符，表示待绑定的参数，避免了字符串拼接；
- setString(index, value) 方法按位置设置参数值，底层自动转义特殊字符；
- executeUpdate() 返回影响行数，可用于判断插入是否成功；
- 使用 try-with-resources 自动关闭资源，防止连接泄漏。

该模式不仅提升了安全性，也提高了SQL执行计划的缓存命中率，有利于数据库优化器重用执行路径。

4.1.2 SELECT查询的条件拼接与分页实现

SELECT语句常用于根据动态条件检索数据。当多个筛选字段可选时，需灵活拼接WHERE子句。

动态查询示例（带分页）

SELECT id, name, email, create_time 
FROM user_info 
WHERE 1=1 
  AND (:name IS NULL OR name LIKE CONCAT('%', :name, '%'))
  AND (:email IS NULL OR email = :email)
ORDER BY create_time DESC
LIMIT ? OFFSET ?

虽然原生JDBC不支持命名参数，但可通过StringBuilder手动拼接并管理参数列表：

public List<UserInfo> findUsers(String name, String email, int page, int size) {
    StringBuilder sql = new StringBuilder("SELECT id, name, email, create_time FROM user_info WHERE 1=1");
    List<Object> params = new ArrayList<>();

    if (name != null && !name.trim().isEmpty()) {
        sql.append(" AND name LIKE ?");
        params.add("%" + name + "%");
    }
    if (email != null && !email.trim().isEmpty()) {
        sql.append(" AND email = ?");
        params.add(email);
    }
    sql.append(" ORDER BY create_time DESC LIMIT ? OFFSET ?");
    params.add(size);
    params.add((page - 1) * size);

    return jdbcTemplate.query(sql.toString(), params.toArray(), rowMapper);
}

参数	类型	说明
`name`	String	模糊匹配用户名
`email`	String	精确匹配邮箱
`page`	int	当前页码（从1开始）
`size`	int	每页条数
`params`	List	动态收集预编译参数

扩展讨论 ：对于复杂查询，建议引入Query DSL工具如JOOQ或MyBatis-Plus，提升类型安全与编码效率。

4.1.3 UPDATE与DELETE操作的安全性控制

UPDATE和DELETE属于高危操作，一旦条件缺失可能导致全表更新或误删数据。

不安全示例（危险！）

UPDATE user_info SET name = 'admin';
-- 缺少WHERE，导致所有记录被修改！

推荐实践：强制主键约束 + 参数化

String sql = "UPDATE user_info SET name = ?, email = ? WHERE id = ?";
int rows = jdbcTemplate.update(sql, userInfo.getName(), userInfo.getEmail(), userInfo.getId());

if (rows == 0) {
    throw new DataAccessException("未找到ID为" + userInfo.getId() + "的记录");
}

同样，DELETE操作应始终携带主键条件：

String sql = "DELETE FROM user_info WHERE id = ?";
int result = jdbcTemplate.update(sql, id);
if (result == 0) log.warn("尝试删除不存在的用户ID: {}", id);

安全性检查流程图（Mermaid）

graph TD
    A[开始执行UPDATE/DELETE] --> B{是否有主键条件?}
    B -- 否 --> C[拒绝执行, 抛出异常]
    B -- 是 --> D[使用PreparedStatement绑定参数]
    D --> E[执行SQL]
    E --> F{影响行数是否为0?}
    F -- 是 --> G[记录警告日志]
    F -- 否 --> H[操作成功]

此流程确保每一条修改类语句都经过严格校验，降低人为失误带来的系统风险。

4.2 DAO接口定义与实现分离

良好的DAO设计应遵循“面向接口编程”的原则，将行为契约与具体实现解耦，便于单元测试与后期替换持久化技术（如切换至Hibernate或MyBatis）。

4.2.1 定义通用DAO接口（GenericDAO ）的方法契约

public interface GenericDAO<T, ID> {
    T findById(ID id);
    List<T> findAll();
    T save(T entity);
    T update(T entity);
    boolean deleteById(ID id);
    List<T> findByCriteria(Map<String, Object> criteria);
    Page<T> findPaginated(int page, int size);
}

方法	描述
`findById`	根据主键查询单个实体
`findAll`	查询全部记录（慎用大表）
`save`	插入新实体
`update`	更新已有实体
`deleteById`	删除指定ID的记录
`findByCriteria`	条件查询（Map传参）
`findPaginated`	分页查询封装

该泛型接口适用于大多数实体类型，提升代码复用性。

4.2.2 基于JDBC的UserInfoDAOImpl具体实现

public class UserInfoDAOImpl implements UserInfoDAO {

    private DataSource dataSource;

    public UserInfoDAOImpl(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    @Override
    public UserInfo findById(Long id) {
        String sql = "SELECT id, name, email, create_time FROM user_info WHERE id = ?";
        try (Connection conn = dataSource.getConnection();
             PreparedStatement pstmt = conn.prepareStatement(sql)) {

            pstmt.setLong(1, id);
            try (ResultSet rs = pstmt.executeQuery()) {
                if (rs.next()) {
                    return mapRowToEntity(rs);
                }
            }
        } catch (SQLException e) {
            throw new DataAccessException("查询用户失败", e);
        }
        return null;
    }

    private UserInfo mapRowToEntity(ResultSet rs) throws SQLException {
        UserInfo user = new UserInfo();
        user.setId(rs.getLong("id"));
        user.setName(rs.getString("name"));
        user.setEmail(rs.getString("email"));
        user.setCreateTime(rs.getTimestamp("create_time").toLocalDateTime());
        return user;
    }
}

逐行解读分析
- 第7行：构造函数注入DataSource，符合依赖倒置原则；
- 第12行：SQL语句使用占位符防止注入；
- 第15行： setLong(1, id) 绑定第一个参数；
- 第17行： executeQuery() 执行查询并返回结果集；
- 第19行： mapRowToEntity 将结果映射为Java对象；
- 第28行：自定义异常封装底层SQLException，向上抛出统一异常类型。

这种实现方式保持了低耦合、高内聚的设计风格，易于集成Spring等容器框架。

4.2.3 使用PreparedStatement防止SQL注入攻击

PreparedStatement不仅是性能优化手段，更是核心安全机制。其原理如下：

特性	说明
预编译	SQL模板提前编译，参数仅作值传递
参数绑定	使用 `setXxx()` 方法设置值，自动转义引号、分号等
执行计划缓存	数据库可缓存执行路径，提升批量操作效率

对比实验表明，在1万次插入操作中，PreparedStatement比Statement快约30%，且完全杜绝注入风险。

4.3 数据访问异常的封装与传播

数据库操作不可避免会出现异常，如连接超时、死锁、主键冲突等。若直接暴露SQLException给上层调用者，会导致代码侵入性强、难以维护。因此需要建立统一的异常体系。

4.3.1 自定义DataAccessException统一异常体系

public abstract class DataAccessException extends RuntimeException {
    public DataAccessException(String message) {
        super(message);
    }

    public DataAccessException(String message, Throwable cause) {
        super(message, cause);
    }
}

// 具体子类
public class ResourceAccessException extends DataAccessException { /* 连接失败 */ }
public class ConcurrencyFailureException extends DataAccessException { /* 死锁 */ }
public class DataAccessIntegrityViolationException extends DataAccessException { /* 主键冲突 */ }

在DAO中捕获SQLException后转换为对应业务异常：

} catch (SQLException e) {
    switch (e.getErrorCode()) {
        case 1062:
            throw new DataAccessIntegrityViolationException("邮箱已存在", e);
        case 1213:
            throw new ConcurrencyFailureException("发生死锁，请重试", e);
        default:
            throw new ResourceAccessException("数据库资源访问失败", e);
    }
}

4.3.2 try-catch-finally块中资源关闭的最佳实践

早期JDBC需手动释放资源，易遗漏：

Connection conn = null;
PreparedStatement pstmt = null;
ResultSet rs = null;
try {
    conn = dataSource.getConnection();
    pstmt = conn.prepareStatement(sql);
    rs = pstmt.executeQuery();
    // 处理结果
} catch (SQLException e) {
    throw new DataAccessException(e);
} finally {
    if (rs != null) try { rs.close(); } catch (SQLException e) {}
    if (pstmt != null) try { pstmt.close(); } catch (SQLException e) {}
    if (conn != null) try { conn.close(); } catch (SQLException e) {}
}

这种方式冗长且容易出错。

4.3.3 引入try-with-resources自动管理Connection、Statement、ResultSet

现代Java推荐使用自动资源管理机制：

try (Connection conn = dataSource.getConnection();
     PreparedStatement pstmt = conn.prepareStatement(sql);
     ResultSet rs = pstmt.executeQuery()) {

    while (rs.next()) {
        users.add(mapRowToEntity(rs));
    }
} catch (SQLException e) {
    throw new DataAccessException("查询失败", e);
}

优势分析 ：
- 所有实现了 AutoCloseable 接口的资源都会在块结束时自动关闭；
- 即使发生异常也能保证资源释放；
- 显著减少样板代码，提高可读性。

该机制已成为JDBC开发的事实标准。

4.4 DAO层测试与执行效率评估

DAO层是系统稳定性的基石，必须通过充分的自动化测试验证其功能正确性与性能表现。

4.4.1 使用JUnit对addUser、findUserById等方法进行黑盒测试

@Test
public void testAddUserAndFindById() {
    // 准备测试数据
    UserInfo user = new UserInfo();
    user.setName("张三");
    user.setEmail("zhangsan@test.com");

    // 执行插入
    UserInfo saved = userDao.save(user);
    assertNotNull(saved.getId());

    // 查询验证
    UserInfo queried = userDao.findById(saved.getId());
    assertEquals(user.getName(), queried.getName());
    assertEquals(user.getEmail(), queried.getEmail());
}

断言	验证内容
`saved.getId() != null`	主键生成正常
`queried != null`	可反向查询
字段值一致	序列化/反序列化无损

建议配合H2内存数据库进行集成测试，避免污染生产环境。

4.4.2 执行计划分析与索引优化建议

使用EXPLAIN分析关键查询性能：

EXPLAIN SELECT * FROM user_info WHERE email = 'test@example.com';

输出示例：
| id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
|----|-------------|------------|------|---------------|-------------|---------|-------|------|-------------|
| 1 | SIMPLE | user_info | ref | idx_email | idx_email | 194 | const | 1 | Using index |

优化建议 ：
- 若 type=ALL 表示全表扫描，应创建索引；
- key=null 说明未命中索引；
- 对频繁查询字段（如email）建立唯一索引加速查找。

CREATE UNIQUE INDEX idx_email ON user_info(email);

4.4.3 批量插入场景下的性能调优技巧

当需要导入大量数据时，逐条INSERT效率极低。可通过以下方式优化：

方式一：使用addBatch + executeBatch

String sql = "INSERT INTO user_info(name, email) VALUES(?, ?)";
try (Connection conn = dataSource.getConnection();
     PreparedStatement pstmt = conn.prepareStatement(sql)) {

    conn.setAutoCommit(false); // 关闭自动提交

    for (UserInfo u : userList) {
        pstmt.setString(1, u.getName());
        pstmt.setString(2, u.getEmail());
        pstmt.addBatch();
    }

    pstmt.executeBatch();
    conn.commit();
}

性能对比表格（插入10,000条记录）

方法	耗时（ms）	CPU占用	内存峰值
单条INSERT	8,200	高	中
addBatch + executeBatch	950	中	低
MyBatis BatchExecutor	780	中	低

结论：批量提交可提升近9倍性能，强烈推荐用于数据迁移、初始化等场景。

综上所述，DAO层不仅是MVC架构中Model的重要组成部分，更是保障系统稳定性、安全性和高性能的关键环节。通过规范化SQL编写、合理的接口抽象、严谨的异常处理以及全面的测试覆盖，可以构建出既可靠又高效的持久化访问层，为整个Web应用提供坚实的数据支撑。

5. View层使用JSP进行数据展示

在Java Web应用的MVC架构中，视图（View）承担着用户界面呈现与交互响应的关键职责。作为连接后端逻辑与前端用户的桥梁，View层不仅要确保数据准确、结构清晰地输出，还需兼顾用户体验、安全防护和可维护性。JSP（JavaServer Pages）作为一种成熟且广泛使用的服务器端动态页面技术，在传统Java Web开发中扮演了核心角色。尽管现代前后端分离趋势日益明显，但在中小型项目或内部管理系统中，JSP因其集成简便、开发快速、支持EL表达式与JSTL标签库等优势，仍具备不可忽视的应用价值。

本章将围绕“javaMVC信息录入与显示test.rar”项目的实际需求，深入探讨如何利用JSP构建高效、安全、易维护的数据展示界面。从基础渲染机制到高级交互设计，再到安全性优化与静态资源管理，系统化剖析JSP在MVC模式下的最佳实践路径。通过真实代码示例、流程图建模与性能对比表格，全面揭示JSP作为视图组件的技术内涵及其演进方向。

5.1 JSP作为MVC视图的技术优势与局限

JSP本质上是一种基于Servlet的动态网页生成技术，允许开发者在HTML中嵌入Java代码片段（Scriptlet）、表达式（Expression）以及声明（Declaration），从而实现服务端动态内容渲染。其运行机制依赖于容器（如Tomcat）将JSP文件首次请求时编译为对应的Servlet类，并由该Servlet处理后续请求，最终输出HTML流至客户端浏览器。

5.1.1 JSP与HTML混合输出的渲染机制

JSP最显著的特点是其“模板+逻辑”的混合编程模型。开发者可以在标准HTML结构中插入 <% %> 、 <%= %> 等形式的Java代码块，实现在页面内直接访问后端传递的数据对象。例如：

<!-- userInfoList.jsp -->
<html>
<head><title>用户信息列表</title></head>
<body>
    <h2>所有用户信息</h2>
    <table border="1">
        <tr><th>ID</th><th>姓名</th><th>邮箱</th><th>注册时间</th></tr>
        <% List<UserInfo> users = (List<UserInfo>) request.getAttribute("users"); %>
        <% for (UserInfo user : users) { %>
            <tr>
                <td><%= user.getId() %></td>
                <td><%= user.getName() %></td>
                <td><%= user.getEmail() %></td>
                <td><%= user.getCreateTime() %></td>
            </tr>
        <% } %>
    </table>
</body>
</html>

代码逻辑逐行解读分析：

第6行：通过 request.getAttribute("users") 获取控制器放入请求域中的用户集合。这是典型的MVC数据传递方式。
第7–10行：使用Java脚本循环遍历集合并输出每一行记录。这种写法虽然功能完整，但破坏了HTML的结构性与可读性，属于早期JSP开发常见反模式。

该方式的优点在于开发门槛低、调试直观；缺点则是业务逻辑与视图高度耦合，难以测试与复用，违背了MVC分层原则。因此，随着JSP的发展，引入了更为优雅的替代方案——EL表达式与JSTL标签库。

5.1.2 EL表达式与JSTL标签库在页面中的应用价值

为了提升JSP的可维护性与表达能力，JSP 2.0引入了 EL（Expression Language） 和 JSTL（JSP Standard Tag Library） ，极大减少了对Java脚本的依赖。

使用EL表达式简化数据访问

EL表达式以 ${} 语法形式出现，能够自动解析作用域（page → request → session → application）中的属性值，无需显式类型转换：

<p>欢迎用户：${user.name}</p>
<p>共录入 ${totalUsers} 条记录</p>

上述代码会自动查找 requestScope.user 或 sessionScope.user 中的 name 属性，调用其getter方法完成取值，极大提升了开发效率。

引入JSTL实现结构化控制流

JSTL提供了一系列标准标签，涵盖条件判断、循环、格式化等功能。常用核心标签包括：

标签	功能说明
`<c:if>`	条件判断
`<c:forEach>`	集合遍历
`<c:set>`	变量赋值
`<fmt:formatDate>`	时间格式化

以下是一个结合EL与JSTL重构后的用户列表页示例：

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>

<html>
<head><title>用户信息列表</title></head>
<body>
    <h2>用户信息管理</h2>
    <c:if test="${empty users}">
        <p style="color:red;">暂无用户数据！</p>
    </c:if>
    <table border="1" cellpadding="8">
        <tr bgcolor="#f0f0f0">
            <th>ID</th>
            <th>姓名</th>
            <th>邮箱</th>
            <th>注册时间</th>
            <th>操作</th>
        </tr>
        <c:forEach var="user" items="${users}">
            <tr>
                <td>${user.id}</td>
                <td>${user.name}</td>
                <td>${user.email}</td>
                <td>
                    <fmt:formatDate value="${user.createTime}" pattern="yyyy-MM-dd HH:mm:ss"/>
                </td>
                <td>
                    <a href="edit?id=${user.id}">编辑</a> | 
                    <a href="delete?id=${user.id}" onclick="return confirm('确认删除？')">删除</a>
                </td>
            </tr>
        </c:forEach>
    </table>
</body>
</html>

参数说明与扩展性分析：

var="user" ：定义迭代变量名；
items="${users}" ：指定待遍历的集合，来自Controller设置；
<fmt:formatDate> ：避免在Java层格式化日期字符串，保持原始类型完整性；
onclick="return confirm(...)" ：简单前端交互增强用户体验。

该实现完全剥离了Java脚本，使页面更接近纯HTML结构，便于前端协作与后期维护。

JSP视图的整体技术权衡

下表总结了JSP在当前技术生态中的优势与局限：

维度	优势	局限
开发效率	内置Servlet容器支持，无需额外框架	混合编码易导致混乱
调试便利性	错误堆栈指向具体JSP行号	编译延迟影响热更新体验
性能表现	初次编译后性能稳定	大量小文件增加I/O负担
安全性	支持自定义标签过滤XSS	默认不转义需手动干预
前后端协作	不适合复杂SPA场景	HTML/CSS/JS组织松散

graph TD
    A[JSP页面请求] --> B{是否首次访问?}
    B -- 是 --> C[容器解析JSP]
    C --> D[生成.java Servlet源码]
    D --> E[编译为.class文件]
    E --> F[执行Servlet doGet/doPost]
    F --> G[输出HTML响应]
    B -- 否 --> H[直接执行已编译Servlet]
    H --> G

该流程图展示了JSP的生命周期机制：只有第一次请求触发编译过程，之后均由生成的Servlet实例处理，体现了其“一次编译、多次执行”的高效特性。

5.2 页面结构设计与数据绑定

高质量的View层不仅需要正确展示数据，还应具备良好的结构设计、语义清晰的布局以及灵活的数据绑定机制。在MVC架构中，Controller负责准备数据并存入请求域或会话域，而JSP则专注于消费这些数据并将其可视化。

5.2.1 列表页展示所有用户信息的表格布局

一个典型的用户信息列表页应当包含分页导航、搜索筛选、排序提示及操作按钮。以下是基于Bootstrap风格的响应式表格结构设计：

<div class="container mt-4">
    <div class="d-flex justify-content-between align-items-center mb-3">
        <h4>用户信息列表</h4>
        <a href="add" class="btn btn-primary btn-sm">新增用户</a>
    </div>

    <table class="table table-striped table-hover">
        <thead class="table-dark">
            <tr>
                <th scope="col">#</th>
                <th scope="col">姓名</th>
                <th scope="col">邮箱</th>
                <th scope="col">电话</th>
                <th scope="col">创建时间</th>
                <th scope="col">操作</th>
            </tr>
        </thead>
        <tbody>
            <c:forEach var="user" items="${users}" varStatus="status">
                <tr>
                    <th scope="row">${status.index + 1}</th>
                    <td>${user.name}</td>
                    <td>${user.email}</td>
                    <td>${user.phone}</td>
                    <td><fmt:formatDate value="${user.createTime}" pattern="yyyy-MM-dd"/></td>
                    <td>
                        <a href="edit?id=${user.id}" class="btn btn-outline-warning btn-sm">编辑</a>
                        <a href="delete?id=${user.id}" class="btn btn-outline-danger btn-sm"
                           onclick="return confirm('确定要删除【${user.name}】吗？')">删除</a>
                    </td>
                </tr>
            </c:forEach>
        </tbody>
    </table>

    <nav aria-label="分页导航">
        <ul class="pagination justify-content-center">
            <li class="page-item ${currentPage == 1 ? 'disabled' : ''}">
                <a class="page-link" href="?page=${currentPage - 1}">上一页</a>
            </li>
            <c:forEach begin="1" end="${totalPages}" var="i">
                <li class="page-item ${i == currentPage ? 'active' : ''}">
                    <a class="page-link" href="?page=${i}">${i}</a>
                </li>
            </c:forEach>
            <li class="page-item ${currentPage == totalPages ? 'disabled' : ''}">
                <a class="page-link" href="?page=${currentPage + 1}">下一页</a>
            </li>
        </ul>
    </nav>
</div>

关键点解析：

varStatus="status" ：提供索引、计数、首尾判断等元信息；
fmt:formatDate ：统一日期格式，避免前端解析歧义；
分页链接采用 ?page=n 查询参数方式，便于Controller捕获；
按钮添加CSS类提升视觉反馈，符合现代UI规范。

5.2.2 使用 `<c:forEach>` 遍历集合输出多行记录

<c:forEach> 不仅是JSP中最常用的迭代标签，也支持多种高级特性：

属性	描述	示例
`items`	要遍历的集合或数组	`${users}`
`var`	当前元素变量名	`user`
`varStatus`	状态对象（index, count, first, last）	`${status.first}`
`begin/end/step`	控制起止与步长	`begin="0" end="9"`

<c:forEach items="${roles}" var="role" varStatus="vs">
    <div class="role-item ${vs.first ? 'highlight' : ''}">
        [${vs.count}] 角色名称: ${role.roleName}
        <c:if test="${vs.last}"><br><small>这是最后一个角色。</small></c:if>
    </div>
</c:forEach>

此代码段演示了如何利用 varStatus 实现首项高亮、末项提示等交互细节，体现JSTL的强大控制能力。

5.2.3 表单页实现信息录入的input控件绑定

新增或编辑用户的表单页需实现双向数据绑定。对于新增操作，字段为空；对于编辑，则需回显已有数据。

<form action="save" method="post">
    <input type="hidden" name="id" value="${user.id}" />

    <div class="form-group">
        <label>姓名 *</label>
        <input type="text" name="name" value="${user.name}" required class="form-control"/>
    </div>

    <div class="form-group">
        <label>邮箱 *</label>
        <input type="email" name="email" value="${user.email}" required class="form-control"/>
    </div>

    <div class="form-group">
        <label>电话</label>
        <input type="tel" name="phone" value="${user.phone}" class="form-control"/>
    </div>

    <button type="submit" class="btn btn-success">保存</button>
    <a href="list" class="btn btn-secondary">取消</a>
</form>

注意事项：

所有输入框 value 属性均使用EL绑定 ${user.xxx} ；
隐藏字段用于传递主键ID，区分新增与更新；
添加 required 属性实现基础前端校验；
提交路径指向Controller映射的 /save 接口。

5.3 前端交互逻辑与后端数据联动

真正的Web应用不仅仅是静态展示，更需实现前后端协同工作。JSP虽处于服务端，但仍可通过合理设计实现丰富的交互行为。

5.3.1 提交表单到Controller的路径配置

表单 action 属性决定了请求提交的目标URL。通常遵循RESTful命名规范：

<!-- 新增页面 -->
<form action="${pageContext.request.contextPath}/user/add" method="post">

<!-- 编辑页面 -->
<form action="${pageContext.request.contextPath}/user/update" method="post">

其中 ${pageContext.request.contextPath} 确保上下文路径动态适配，防止硬编码问题。

5.3.2 错误提示信息的回显机制（request.setAttribute）

当表单校验失败时，Controller可将错误信息存入request域并在JSP中展示：

// UserController.java
if (name == null || name.trim().isEmpty()) {
    request.setAttribute("error", "姓名不能为空！");
    request.getRequestDispatcher("/WEB-INF/views/user/form.jsp").forward(request, response);
    return;
}

对应JSP接收并显示错误：

<c:if test="${not empty error}">
    <div class="alert alert-danger">${error}</div>
</c:if>

同时保留原输入值，形成完整的错误恢复流程。

5.3.3 成功跳转与重定向策略的选择（forward vs redirect）

操作成功后应选择合适的跳转方式：

方式	特点	适用场景
`RequestDispatcher.forward()`	服务器内部跳转，保留request数据	表单处理结果展示
`response.sendRedirect()`	客户端重定向，清除request数据	防止重复提交（PRG模式）

推荐在表单提交后使用 Post-Redirect-Get（PRG）模式 ：

// 保存成功后重定向
response.sendRedirect(request.getContextPath() + "/user/list");

避免刷新页面导致重复插入。

sequenceDiagram
    participant User
    participant Browser
    participant Controller
    participant JSP

    User->>Browser: 提交表单
    Browser->>Controller: POST /save
    Controller->>DAO: save(user)
    alt 保存成功
        Controller->>Browser: Redirect to /list
        Browser->>Controller: GET /list
        Controller->>DAO: findAll()
        DAO-->>Controller: List<User>
        Controller->>JSP: forward with users
        JSP-->>Browser: Render table
    else 校验失败
        Controller->>JSP: forward with errors
        JSP-->>Browser: Show form + error
    end

该序列图清晰表达了PRG模式的工作流程，强调了重定向在状态一致性保障中的重要性。

5.4 视图层安全性与用户体验优化

随着网络安全威胁加剧，View层不再只是“展示工具”，而是必须承担一定的防御职责。

5.4.1 XSS防护：对输出内容进行HTML转义

若用户输入包含 <script>alert(1)</script> ，直接输出将引发跨站脚本攻击。解决方案如下：

<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>
<td>${fn:escapeXml(user.comment)}</td>

或使用自定义EL函数进行全局转义封装。

5.4.2 静态资源（CSS、JS）的组织与引用路径管理

建议将静态资源置于 /static/css , /static/js 目录下，并通过上下文路径引用：

<link rel="stylesheet" href="${pageContext.request.contextPath}/static/css/bootstrap.min.css">
<script src="${pageContext.request.contextPath}/static/js/app.js"></script>

也可借助Servlet 3.0+的资源映射功能统一管理。

5.4.3 响应式布局初步尝试与浏览器兼容性处理

引入Bootstrap框架即可快速实现移动端适配：

<meta name="viewport" content="width=device-width, initial-scale=1">
<link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.2/dist/css/bootstrap.min.css" rel="stylesheet">

并通过栅格系统划分区域：

<div class="row">
    <div class="col-md-6 offset-md-3">
        <!-- 表单居中显示 -->
    </div>
</div>

同时注意IE兼容性问题，必要时添加polyfill支持。

综上所述，JSP虽非前沿技术，但在特定场景下依然具有强大生命力。通过科学运用EL、JSTL、PRG模式与安全防护手段，完全可以构建出稳健、安全、美观的企业级管理系统界面。

6. Controller层请求处理与系统集成测试

6.1 控制器的注解驱动开发模式

在现代Java Web开发中，基于注解的控制器设计已成为主流。通过Spring框架提供的 @Controller 和请求映射注解，开发者可以摆脱传统Servlet中繁琐的继承结构与 doGet / doPost 方法重写，实现更加灵活、语义清晰的请求处理逻辑。

@Controller注解的作用机制与组件注册

@Controller 是Spring MVC的核心构造型注解之一，用于标识一个类为控制器组件。当该类被标注后，在应用上下文初始化阶段，Spring的组件扫描机制（如 @ComponentScan ）会自动将其注册为Bean，并纳入IoC容器管理。

@Controller
public class UserController {
    // 请求处理方法
}

结合配置类或XML配置启用组件扫描后，无需手动实例化或注册，即可实现依赖注入与其他Bean的协同工作。

@RequestMapping及其衍生注解的精准匹配

@RequestMapping 是最基础的请求映射注解，可用于类级别定义公共路径前缀，也可用于方法级别指定具体URL与HTTP方法。

@Controller
@RequestMapping("/users")
public class UserController {

    @GetMapping("/{id}")
    public ModelAndView getUserById(@PathVariable Long id) {
        // 根据ID查询用户并返回视图
        return new ModelAndView("userDetail");
    }

    @PostMapping("/add")
    public String addUser(@RequestParam String name, 
                          @RequestParam String email,
                          Model model) {
        // 处理新增用户逻辑
        model.addAttribute("message", "用户添加成功！");
        return "redirect:/users/list";
    }
}

参数说明 ：
- @PathVariable : 绑定URI模板变量（如 /users/123 中的 123 ）
- @RequestParam : 获取请求参数（GET查询参数或POST表单字段）
- Model : 向视图传递数据的对象，其生命周期限于本次请求

Spring还提供了更细粒度的派生注解：
- @GetMapping → 等价于 @RequestMapping(method = RequestMethod.GET)
- @PostMapping → 等价于 @RequestMapping(method = RequestMethod.POST)
- @PutMapping , @DeleteMapping 等，提升代码可读性

方法参数绑定实战示例

以下是一个完整的信息录入控制器方法，展示多类型参数绑定：

@PostMapping("/save")
public String saveUserInfo(
    @RequestParam("name") String userName,
    @RequestParam("age") int userAge,
    @RequestParam(value = "email", required = false) String userEmail,
    @ModelAttribute UserInfo userInfo,
    BindingResult result,
    Model model,
    HttpServletRequest request
) {
    if (result.hasErrors()) {
        model.addAttribute("error", "输入数据有误");
        return "inputForm";
    }

    userService.save(userInfo);
    request.getSession().setAttribute("lastAction", "用户信息已保存");

    return "redirect:/users/list";
}

上述代码展示了多种常见参数类型的使用场景，体现了Spring MVC强大的数据绑定能力。

6.2 前后端交互流程的完整串联

MVC架构的价值在于清晰地划分职责。以“用户信息录入”功能为例，完整的调用链如下所示：

sequenceDiagram
    participant Browser
    participant Controller
    participant Service
    participant DAO
    participant Database

    Browser->>Controller: POST /users/save (表单提交)
    Controller->>Service: 调用userService.save(user)
    Service->>DAO: userDao.insert(user)
    DAO->>Database: 执行INSERT SQL
    Database-->>DAO: 返回主键
    DAO-->>Service: 返回结果
    Service-->>Controller: 成功标志
    Controller-->>Browser: redirect:/users/list

请求域中数据传递的生命周期管理

在转发（forward）过程中， request.setAttribute() 设置的数据仅在当前请求周期内有效；而重定向（redirect）则开启新请求，原数据丢失。因此常用 RedirectAttributes 跨重定向传递提示信息：

@GetMapping("/delete/{id}")
public String deleteUser(@PathVariable Long id, RedirectAttributes redirectAttrs) {
    try {
        userService.delete(id);
        redirectAttrs.addFlashAttribute("msg", "删除成功！");
    } catch (Exception e) {
        redirectAttrs.addFlashAttribute("error", "删除失败：" + e.getMessage());
    }
    return "redirect:/users/list";
}

addFlashAttribute 将数据存入session并在下一次请求后自动清除，适合用于操作反馈提示。

RESTful风格URL设计实践

REST原则提倡使用资源名词+HTTP动词表达操作意图。例如：

操作	URL	HTTP方法
查询所有	`/api/users`	GET
查询单个	`/api/users/123`	GET
创建用户	`/api/users`	POST
更新用户	`/api/users/123`	PUT
删除用户	`/api/users/123`	DELETE

这种设计提升了接口的可理解性和一致性，有利于前后端协作与API文档生成。

6.3 功能测试与JUnit集成验证

为确保Controller逻辑正确，需编写单元测试模拟HTTP请求环境。

编写测试类模拟HTTP请求调用Controller方法

使用Spring Test模块配合MockMvc进行无服务器测试：

@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
@ContextHierarchy({
    @ContextConfiguration(classes = {WebConfig.class}),
    @ContextConfiguration(classes = {ServiceConfig.class})
})
public class UserControllerTest {

    @Autowired
    private WebApplicationContext wac;

    private MockMvc mockMvc;

    @Before
    public void setup() {
        this.mockMvc = MockMvcBuilders.webAppContextSetup(this.wac).build();
    }

    @Test
    public void testAddUser_ShouldRedirectToListPage() throws Exception {
        mockMvc.perform(post("/users/add")
                .param("name", "张三")
                .param("email", "zhangsan@example.com"))
                .andExpect(status().is3xxRedirection())
                .andExpect(redirectedUrl("/users/list"));
    }

    @Test
    public void testListUsers_ShouldReturnUserListView() throws Exception {
        mockMvc.perform(get("/users/list"))
                .andExpect(view().name("userList"))
                .andExpect(model().attributeExists("userList"));
    }
}

使用Mockito模拟DAO层行为进行隔离测试

避免真实数据库依赖，提高测试速度与稳定性：

@ExtendWith(MockitoExtension.class)
class UserControllerUnitTest {

    @Mock
    private UserService userService;

    @InjectMocks
    private UserController userController;

    @Test
    void whenGetUserById_thenReturnsUserView() {
        // Given
        UserInfo mockUser = new UserInfo(1L, "李四", 25, "lisi@test.com");
        when(userService.findById(1L)).thenReturn(mockUser);

        // When & Then
        ModelAndView mv = userController.getUserById(1L);
        assertEquals("userDetail", mv.getViewName());
        assertEquals(mockUser, mv.getModel().get("user"));
    }
}

断言数据库状态变化与页面跳转结果的一致性

结合内存数据库（如H2）进行集成测试，验证最终数据一致性：

@Test
@Sql(scripts = "/clean.sql", executionPhase = ExecutionPhase.BEFORE_TEST_METHOD)
void whenSaveUser_thenDataPersisted() throws Exception {
    mockMvc.perform(post("/users/save")
            .param("name", "王五")
            .param("age", "30")
            .param("email", "wangwu@test.com"))
        .andExpect(redirectedUrl("/users/list"));

    try (Connection conn = dataSource.getConnection();
         Statement stmt = conn.createStatement();
         ResultSet rs = stmt.executeQuery("SELECT COUNT(*) FROM users WHERE name='王五'")) {
        assertTrue(rs.next());
        assertEquals(1, rs.getInt(1));
    }
}

6.4 ORM框架的可选集成路径

尽管JDBC提供了底层控制力，但在复杂项目中维护SQL与对象映射成本较高。引入ORM框架可显著提升开发效率。

MyBatis在现有JDBC基础上的平滑替换方案

MyBatis允许保留SQL编写自由度的同时，实现自动映射。迁移步骤包括：

添加依赖：

<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.11</version>
</dependency>

定义Mapper接口与XML映射文件：

public interface UserMapper {
    @Insert("INSERT INTO users(name,age,email) VALUES(#{name},#{age},#{email})")
    void insert(UserInfo user);
}

替换原有DAO实现，保持Service层不变，实现无缝过渡。

Hibernate+Spring Boot自动化配置的未来扩展方向

采用Spring Data JPA + Hibernate组合，进一步简化CRUD操作：

@Repository
public interface UserRepository extends JpaRepository<UserInfo, Long> {
    List<UserInfo> findByAgeGreaterThan(int age);
}

只需定义接口，Spring Data自动生成实现，支持分页、排序、条件查询等高级功能。

对比原生JDBC与ORM在开发效率与性能间的权衡决策

维度	原生JDBC	MyBatis	Hibernate/JPA
开发效率	低（需手动映射）	中	高
性能控制	高（完全掌控SQL）	高	中
学习成本	低	中	高
适用场景	小型项目、高性能要求场景	中大型项目、复杂SQL需求	快速开发、标准CRUD为主项目
SQL透明性	完全透明	显式可见	自动生成，难以调试
分页支持	手动拼接	XML中定制	内置Pageable接口
缓存机制	无	一级/二级缓存	L1/L2缓存支持
动态SQL	字符串拼接风险高	`<if>` 标签安全构建	Criteria API或HQL
批量操作	PreparedStatement批量执行	`<foreach>` 标签批量插入	EntityManager.flush()
事务管理	手动commit/rollback	SqlSession控制	@Transactional注解声明式
异常体系	SQLException检查异常	PersistenceException运行时异常	DataAccessException统一包装

选择应根据团队技术栈、项目规模与长期维护成本综合评估。对于“javaMVC信息录入与显示test.rar”这类教学或原型项目，建议从JDBC入手理解底层原理，再逐步演进至ORM框架。

本文还有配套的精品资源，点击获取

AI Agent技术社区

Agent 垂直技术社区，欢迎活跃、内容共建。

更多推荐

AI Agent上线前，需要划清哪些业务边界

AI Agent技术社区

别再把 AI Agent 理解成“大模型加工具”：一文讲透 Token、Skill、RAG、MCP、SDD 与 Harness

本文从工程视角重新拆解 AI Agent，说明为什么 Agent 并不等于“大模型加工具”。文章系统分析 Token、Prompt、Tool、Skill、RAG、MCP、SDD 与 Harness 的职责边界，并通过供应商风险分析案例，讲解生产级 Agent 如何完成任务规划、工具调用、状态管理、结果验证、权限控制和人工审批。

AI Agent技术社区

GitHub今日热榜 | 2026-07-17：教育Agent与极低量化分庭抗礼

GitHub热门项目速览：OpenCut（视频编辑插件化重构）与hallmark（反AI设计工具）连续霸榜，Star增速超100%；DeepTutor（教育Agent）发布新版本后二次爆发；新上榜项目包括Graphify（代码知识图谱）、1-bit量化LLM演示等，显示AI Agent生态持续分化。前四名中三个是Agent技能项目，反映技术趋势已从单一赛道发展为默认语境。

AI Agent技术社区

所有评论(0)

查看更多评论

张天筝

@weixin_35294091

已为社区贡献121条内容

Java MVC架构实现信息录入与显示完整项目实战

张天筝

1. Java MVC架构模式概述

2. Model层设计与数据库连接配置

2.1 Model层的核心职责与设计原则

2.1.1 Model在MVC中的角色定位

2.1.2 领域模型与数据访问对象（DAO）的分离策略

2.1.3 基于SRP原则的模块化设计实践

2.2 数据库连接配置文件管理

2.2.1 application.properties与db.properties的区别与选择

2.2.2 数据源（DataSource）的配置参数详解

2.2.3 使用Properties类加载配置文件并实现动态读取

2.3 连接池技术的引入与性能优化

2.3.1 为什么需要数据库连接池

2.3.2 常见连接池实现（如HikariCP、C3P0）在MVC项目中的集成方式

2.3.3 连接泄漏检测与资源释放最佳实践

2.4 数据库连接的异常处理机制

2.4.1 SQLException的捕获与日志记录

2.4.2 连接失败时的重试策略与降级方案

3. 实体类与数据库表字段映射规范

3.1 实体类（Entity）的设计准则

3.1.1 JavaBean规范与POJO类的封装要求

代码逻辑逐行解读：

3.1.2 属性命名与数据库字段的对应关系

Mermaid流程图：属性映射解析过程

3.1.3 使用注解或XML进行映射的优劣分析

3.2 字段类型映射一致性保障

3.2.1 数据库数据类型与Java类型的匹配规则

3.2.2 时间日期类型的处理

代码逻辑说明：

3.2.3 空值（NULL）映射与Optional的应用探讨

3.3 主键生成策略与唯一性约束

3.3.1 自增主键、UUID、雪花算法的选择场景

参数说明：

3.3.2 在实体类中标识主键字段的标准做法

3.3.3 外键关联建模与级联操作的预设考虑

3.4 映射规范在项目中的落地实践

3.4.1 以“用户信息录入”为例构建UserInfo实体

3.4.2 利用Lombok简化模板代码

3.4.3 编写单元测试验证实体序列化与反序列化正确性

表格：测试覆盖点清单

4. CRUD操作SQL语句编写与DAO层实现

4.1 SQL语句的规范化编写

4.1.1 INSERT语句的参数化构造与防注入措施

安全问题示例：

正确做法：使用PreparedStatement进行参数化

4.1.2 SELECT查询的条件拼接与分页实现

动态查询示例（带分页）

4.1.3 UPDATE与DELETE操作的安全性控制

不安全示例（危险！）

推荐实践：强制主键约束 + 参数化

安全性检查流程图（Mermaid）

4.2 DAO接口定义与实现分离

4.2.1 定义通用DAO接口（GenericDAO ）的方法契约

4.2.2 基于JDBC的UserInfoDAOImpl具体实现

4.2.3 使用PreparedStatement防止SQL注入攻击

4.3 数据访问异常的封装与传播

4.3.1 自定义DataAccessException统一异常体系

4.3.2 try-catch-finally块中资源关闭的最佳实践

4.3.3 引入try-with-resources自动管理Connection、Statement、ResultSet

4.4 DAO层测试与执行效率评估

4.4.1 使用JUnit对addUser、findUserById等方法进行黑盒测试

4.4.2 执行计划分析与索引优化建议

4.4.3 批量插入场景下的性能调优技巧

方式一：使用addBatch + executeBatch

性能对比表格（插入10,000条记录）

5. View层使用JSP进行数据展示

5.1 JSP作为MVC视图的技术优势与局限

5.1.1 JSP与HTML混合输出的渲染机制

5.1.2 EL表达式与JSTL标签库在页面中的应用价值

使用EL表达式简化数据访问

引入JSTL实现结构化控制流

JSP视图的整体技术权衡

5.2 页面结构设计与数据绑定

5.2.1 列表页展示所有用户信息的表格布局

5.2.2 使用 <c:forEach> 遍历集合输出多行记录

5.2.3 表单页实现信息录入的input控件绑定

5.3 前端交互逻辑与后端数据联动

5.3.1 提交表单到Controller的路径配置

5.3.2 错误提示信息的回显机制（request.setAttribute）

5.2.2 使用 `<c:forEach>` 遍历集合输出多行记录