从零开始搭建第一个 JavaWeb 项目

一、开发环境准备

在开始搭建JavaWeb项目之前，我们需要准备好相应的开发环境，这是项目顺利进行的基础。本指南将详细介绍JDK、Web服务器和IDE的安装配置过程。

（一）JDK安装与配置

JDK（Java Development Kit）是Java开发的核心工具包，包含了Java编译器、运行时环境等必备组件。

1. 下载JDK

访问Oracle官网(https://www.oracle.com/java/technologies/downloads/)，根据自己的操作系统选择合适的JDK版本进行下载。建议选择稳定版本，如JDK 8或JDK 11。对于企业级开发，推荐使用LTS(Long-Term Support)版本以获得长期支持。

2. 安装JDK

运行下载的安装程序，按照提示进行安装。注意：

• 安装路径尽量选择没有空格和特殊字符的路径，例如"D:\Java\jdk1.8.0_301"
• 在Windows系统上，安装时建议记录安装路径，方便后续配置
• 对于Linux系统，可以使用包管理器安装或手动解压安装

3. 配置环境变量

Windows系统配置步骤：

1. 右键"此电脑"→"属性"→"高级系统设置"→"环境变量"
2. 新建系统变量"JAVA_HOME"，变量值为JDK的安装路径，如"D:\Java\jdk1.8.0_301"
3. 编辑系统变量"Path"，在末尾添加"%JAVA_HOME%\bin"和"%JAVA_HOME%\jre\bin"
4. 新建系统变量"CLASSPATH"，变量值为".;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar"（注意前面的点号表示当前目录）

Linux/Mac系统配置：

在~/.bashrc或~/.bash_profile文件中添加：

export JAVA_HOME=/usr/local/jdk1.8.0_301
export PATH=$JAVA_HOME/bin:$PATH
export CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar

4. 验证安装

打开命令提示符/终端，输入以下命令：

java -version
javac -version

如果能显示出对应的版本信息，则说明JDK安装配置成功。

（二）Web服务器安装

常用的JavaWeb服务器有Tomcat、Jetty等，这里以Tomcat为例进行讲解。

1. 下载Tomcat

访问Apache Tomcat官网(https://tomcat.apache.org/)，选择合适的版本下载：

• 生产环境建议使用稳定版本(如9.0.x)
• 开发环境可以尝试最新版本
• 下载压缩包形式(.zip或.tar.gz)便于安装和卸载

2. 解压安装

将下载的压缩包解压到合适的目录：

• Windows示例："D:\Tomcat\apache-tomcat-9.0.54"
• Linux/Mac示例："/usr/local/tomcat"

3. 配置环境变量（可选）

1. 新建系统变量"CATALINA_HOME"，变量值为Tomcat的安装目录
2. 在"Path"中添加"%CATALINA_HOME%\bin"(Windows)或"$CATALINA_HOME/bin"(Linux/Mac)

4. 验证安装

1. 进入Tomcat安装目录下的"bin"文件夹
2. Windows双击"startup.bat"，Linux/Mac执行"./startup.sh"
3. 打开浏览器，输入"http://localhost:8080"
4. 如果能看到Tomcat的欢迎页面，则说明安装成功

5. 常见问题处理

• 端口冲突：修改conf/server.xml中的8080端口
• 启动闪退：检查JAVA_HOME配置和日志文件(catalina.out/logs/catalina.log)
• 权限问题(Linux/Mac)：chmod +x *.sh

（三）IDE选择与配置

常用的Java开发IDE有Eclipse、IntelliJ IDEA等，这里以IntelliJ IDEA为例。

1. 下载安装IntelliJ IDEA

访问JetBrains官网(https://www.jetbrains.com/idea/)，选择合适版本：

• 社区版(免费)：适合基础Java开发
• 旗舰版(付费)：提供完整的Web开发支持

2. 配置JDK

1. 打开IntelliJ IDEA
2. 进入"File"→"Project Structure"→"SDKs"
3. 点击"+"号，选择"JDK"
4. 选择之前安装的JDK目录，完成JDK配置

3. 配置Tomcat

1. 进入"Run"→"Edit Configurations"
2. 点击"+"号，选择"Tomcat Server"→"Local"
3. 在"Application Server"中点击"Configure"
4. 选择Tomcat的安装目录，完成Tomcat配置

4. 创建JavaWeb项目

1. 选择"File"→"New"→"Project"
2. 选择"Java Enterprise"
3. 勾选"Web Application"选项
4. 配置项目名称和位置
5. 完成项目创建

5. 运行测试

1. 创建简单的Servlet或JSP文件
2. 配置部署描述符(web.xml)
3. 点击运行按钮，选择配置好的Tomcat服务器
4. 在浏览器中访问测试页面验证配置

通过以上步骤，您已经完成了JavaWeb开发环境的完整配置，可以开始进行项目开发了。

二、创建 JavaWeb 项目

（一）使用 IDE 创建项目详细步骤

1. 启动 IntelliJ IDEA

   • 双击桌面图标或通过开始菜单启动
   • 如果是首次使用，会显示欢迎界面；否则会显示最近项目列表

2. 新建项目

   • 点击 "Create New Project" 按钮
   • 在弹出的新建项目对话框中：
     • 左侧项目类型选择 "Java Enterprise"
     • 右侧模板选择 "Web Application"
     • 在下方配置区域：
       • 选择已安装的 JDK（建议使用 JDK 8 或以上版本）
       • 选择已配置的 Tomcat 服务器（如未配置，可点击 "New" 按钮添加）
       • 勾选 "Create web.xml" 选项（如需使用传统部署描述符）

3. 项目配置

   • 点击 "Next" 进入项目命名页面
   • 输入项目名称（如 "MyWebApp"）
   • 指定项目存储路径（建议使用不含空格和特殊字符的路径）
   • 选择项目类型（Maven 或普通 Java 项目）
   • 点击 "Finish" 完成创建

4. 初始项目验证

   • 等待 IDEA 完成项目初始化
   • 检查项目视图中是否生成基础目录结构
   • 确认自动生成的 index.jsp 文件是否正常显示

（二）项目结构详细解析

1. 源代码目录 (src/main/java)

   • 包结构示例：
     • com.example.controller：存放 Servlet 控制器
     • com.example.service：业务逻辑层
     • com.example.dao：数据访问层
     • com.example.model：实体类
   • 典型文件：
     • UserServlet.java：处理用户相关请求的Servlet
     • ProductService.java：商品业务逻辑实现

2. 资源目录 (src/main/resources)

   • 配置文件类型：
     • database.properties：数据库连接配置
     • log4j2.xml：日志系统配置
     • spring-context.xml：Spring框架配置
     • mybatis-config.xml：MyBatis框架配置
   • 特殊目录：
     • /static：存放静态资源（CSS/JS/图片）
     • /templates：存放模板文件（如Thymeleaf模板）

3. Web应用目录 (src/main/webapp)

   • 主要子目录：
     • /WEB-INF：
       • web.xml：配置示例：

         <web-app>
           <servlet>
             <servlet-name>demoServlet</servlet-name>
             <servlet-class>com.example.DemoServlet</servlet-class>
           </servlet>
           <servlet-mapping>
             <servlet-name>demoServlet</servlet-name>
             <url-pattern>/demo</url-pattern>
           </servlet-mapping>
         </web-app>
         

       • /classes：编译后的class文件输出目录
       • /lib：依赖库目录（如mysql-connector.jar）
     • /META-INF：存放应用元数据
   • 页面文件：
     • index.jsp：默认入口页面
     • login.jsp：用户登录页面
     • error/404.jsp：错误页面

4. Maven配置文件 (pom.xml)

   • 关键配置项：
     • <dependencies>：项目依赖声明

       <dependency>
         <groupId>javax.servlet</groupId>
         <artifactId>javax.servlet-api</artifactId>
         <version>4.0.1</version>
         <scope>provided</scope>
       </dependency>
       

     • <build>：构建配置
     • <properties>：项目属性设置

5. 补充说明

   • 现代项目可能使用的前端资源目录：
     • /src/main/webapp/resources：存放前端静态资源
     • /src/main/webapp/WEB-INF/views：存放视图文件
   • 测试目录结构：
     • /src/test/java：单元测试代码
     • /src/test/resources：测试资源配置

三、核心技术应用

（一）Servlet 详解

Servlet 是 JavaWeb 的核心组件，运行在服务器端，用于处理客户端的 HTTP 请求并生成响应。它遵循 Java EE 规范，是 Java Web 开发的基础。

创建 Servlet 的详细步骤

1. 创建 Servlet 类：
   • 在 "src/main/java" 目录下创建 Java 类
   • 继承 javax.servlet.http.HttpServlet 基类
   • 根据需要重写 doGet() 和 doPost() 方法

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;

@WebServlet("/HelloServlet")
public class HelloServlet extends HttpServlet {
    
    // 处理 GET 请求
    protected void doGet(HttpServletRequest request, HttpServletResponse response) 
            throws ServletException, IOException {
        // 设置响应内容类型和编码
        response.setContentType("text/html;charset=UTF-8");
        
        // 获取输出流
        PrintWriter out = response.getWriter();
        
        // 输出HTML内容
        out.println("<h1>Hello, JavaWeb!</h1>");
        out.println("<p>当前时间: " + new java.util.Date() + "</p>");
    }

    // 处理 POST 请求，通常转发给 doGet 处理
    protected void doPost(HttpServletRequest request, HttpServletResponse response) 
            throws ServletException, IOException {
        doGet(request, response);
    }
}

Servlet 配置的两种方式

1. 注解方式（推荐）：

   • 使用 @WebServlet 注解配置
   • 可以指定多个URL模式：@WebServlet({"/hello", "/hi"})
   • 支持初始化参数：@WebServlet(urlPatterns="/hello", initParams={@WebInitParam(name="param1", value="value1")})

2. XML 配置方式（传统）：

   • 在 web.xml 中配置 Servlet 和映射关系
   • 适用于 Servlet 3.0 之前版本或需要动态配置的场景

<!-- web.xml 配置示例 -->
<servlet>
    <servlet-name>HelloServlet</servlet-name>
    <servlet-class>com.example.HelloServlet</servlet-class>
    <init-param>
        <param-name>encoding</param-name>
        <param-value>UTF-8</param-value>
    </init-param>
</servlet>

<servlet-mapping>
    <servlet-name>HelloServlet</servlet-name>
    <url-pattern>/HelloServlet</url-pattern>
    <url-pattern>/hello</url-pattern>
</servlet-mapping>

Servlet 生命周期

1. 加载和实例化：容器加载 Servlet 类并创建实例
2. 初始化：调用 init() 方法（只执行一次）
3. 服务：对每个请求调用 service() 方法，然后分派到 doGet() 或 doPost()
4. 销毁：容器关闭时调用 destroy() 方法

（二）JSP 技术详解

JSP（JavaServer Pages）是一种动态网页技术标准，它允许在HTML页面中嵌入Java代码，简化了动态内容的生成。

创建 JSP 页面的完整示例

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ page import="java.util.Date" %>
<html>
<head>
    <title>首页</title>
    <style>
        body { font-family: Arial, sans-serif; margin: 20px; }
        h1 { color: #336699; }
    </style>
</head>
<body>
    <h1>欢迎来到我的第一个JavaWeb项目！</h1>
    
    <%-- 显示当前日期 --%>
    <p>当前时间: <%= new Date() %></p>
    
    <%-- 链接到Servlet --%>
    <a href="/HelloServlet">访问Servlet</a>
    
    <%-- 简单的条件判断 --%>
    <%
        String user = request.getParameter("user");
        if(user != null) {
    %>
            <p>欢迎您，<%= user %>!</p>
    <%
        } else {
    %>
            <p>请先登录</p>
    <%
        }
    %>
</body>
</html>

JSP 基本语法详解

1. 指令标签：

   • <%@ page ... %>：定义页面属性
   • <%@ include ... %>：静态包含其他文件
   • <%@ taglib ... %>：引入标签库

2. 脚本标签：

   <%
       // Java代码块
       String name = "张三";
       int count = 10;
   %>
   

3. 表达式标签：

   <p>用户名: <%= name %></p>
   <p>访问次数: <%= count + 1 %></p>
   

4. 声明标签：

   <%!
       // 声明成员变量和方法
       private int totalVisits = 0;
       
       public void incrementCount() {
           totalVisits++;
       }
   %>
   

JSP 内置对象

1. request：HttpServletRequest 对象
2. response：HttpServletResponse 对象
3. session：HttpSession 对象
4. application：ServletContext 对象
5. out：JspWriter 输出流对象
6. pageContext：PageContext 对象
7. config：ServletConfig 对象
8. page：当前 JSP 页面本身
9. exception：异常对象（仅在错误页中可用）

（三）过滤器（Filter）详解

过滤器用于对请求和响应进行预处理和后处理，可以实现诸如字符编码设置、权限验证、日志记录等功能。

创建过滤器的完整实现

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

@WebFilter("/*")
public class EncodingFilter implements Filter {
    
    private String encoding = "UTF-8";
    
    public void init(FilterConfig filterConfig) throws ServletException {
        // 从配置参数获取编码设置
        String configEncoding = filterConfig.getInitParameter("encoding");
        if(configEncoding != null) {
            this.encoding = configEncoding;
        }
    }

    public void doFilter(ServletRequest request, ServletResponse response, 
            FilterChain chain) throws IOException, ServletException {
        
        // 设置请求和响应编码
        request.setCharacterEncoding(encoding);
        response.setCharacterEncoding(encoding);
        response.setContentType("text/html;charset=" + encoding);
        
        // 记录请求信息
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        System.out.println("拦截请求: " + httpRequest.getRequestURI() 
                + " [方法: " + httpRequest.getMethod() + "]");
        
        // 继续执行过滤器链
        chain.doFilter(request, response);
        
        // 请求处理后的逻辑
        System.out.println("请求处理完成");
    }

    public void destroy() {
        // 清理资源
    }
}

过滤器配置方式

1. 注解方式：

   @WebFilter(
       urlPatterns = "/*",
       initParams = {
           @WebInitParam(name = "encoding", value = "UTF-8")
       },
       dispatcherTypes = {
           DispatcherType.REQUEST,
           DispatcherType.FORWARD
       }
   )
   

2. XML 配置方式：

   <filter>
       <filter-name>EncodingFilter</filter-name>
       <filter-class>com.example.EncodingFilter</filter-class>
       <init-param>
           <param-name>encoding</param-name>
           <param-value>UTF-8</param-value>
       </init-param>
   </filter>
   <filter-mapping>
       <filter-name>EncodingFilter</filter-name>
       <url-pattern>/*</url-pattern>
       <dispatcher>REQUEST</dispatcher>
       <dispatcher>FORWARD</dispatcher>
   </filter-mapping>
   

过滤器的典型应用场景

1. 字符编码处理
2. 身份验证和授权
3. 日志记录和审计
4. 数据压缩
5. XSS 和 SQL 注入防护
6. 响应时间统计

（四）监听器（Listener）详解

监听器用于监听 Web 应用中的各种事件，如 ServletContext、HttpSession 等对象的创建和销毁。

常用的监听器接口

1. ServletContextListener - 监听上下文生命周期
2. HttpSessionListener - 监听会话生命周期
3. ServletRequestListener - 监听请求生命周期
4. ServletContextAttributeListener - 监听上下文属性变化
5. HttpSessionAttributeListener - 监听会话属性变化
6. ServletRequestAttributeListener - 监听请求属性变化

监听器实现示例

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener;
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;

@WebListener
public class MyWebListener implements ServletContextListener, HttpSessionListener {
    
    // 上下文初始化
    public void contextInitialized(ServletContextEvent sce) {
        System.out.println("Web应用启动: " + sce.getServletContext().getContextPath());
        sce.getServletContext().setAttribute("appStartTime", System.currentTimeMillis());
    }
    
    // 上下文销毁
    public void contextDestroyed(ServletContextEvent sce) {
        long startTime = (Long) sce.getServletContext().getAttribute("appStartTime");
        long uptime = (System.currentTimeMillis() - startTime) / 1000;
        System.out.println("Web应用停止，运行时间: " + uptime + "秒");
    }
    
    // 会话创建
    public void sessionCreated(HttpSessionEvent se) {
        System.out.println("新会话创建, ID: " + se.getSession().getId());
        se.getSession().setMaxInactiveInterval(30 * 60); // 30分钟超时
    }
    
    // 会话销毁
    public void sessionDestroyed(HttpSessionEvent se) {
        System.out.println("会话销毁, ID: " + se.getSession().getId());
    }
}

监听器的配置方式

1. 注解方式：

   @WebListener
   public class MyListener implements ServletContextListener {
       // 实现方法
   }
   

2. XML 配置方式：

   <listener>
       <listener-class>com.example.MyListener</listener-class>
   </listener>
   

监听器的典型应用场景

1. 应用启动时初始化全局资源（如数据库连接池）
2. 统计在线用户数量
3. 记录应用运行时间
4. 会话超时处理
5. 资源清理和释放

（五）数据库连接详解

在 JavaWeb 项目中，数据库连接是核心功能之一。下面以 MySQL 为例详细介绍数据库连接。

数据库驱动的添加方式

1. 手动添加：

   • 下载 MySQL JDBC 驱动（如 mysql-connector-java-8.0.26.jar）
   • 放入 "src/main/webapp/WEB-INF/lib" 目录

2. Maven 依赖（推荐）： 在 pom.xml 中添加：

   <dependency>
       <groupId>mysql</groupId>
       <artifactId>mysql-connector-java</artifactId>
       <version>8.0.26</version>
   </dependency>
   

数据库连接工具类实现

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Properties;

public class DBUtil {
    // 数据库连接参数
    private static final String URL = "jdbc:mysql://localhost:3306/test";
    private static final String USER = "root";
    private static final String PASSWORD = "123456";
    
    // 静态代码块加载驱动
    static {
        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
            throw new RuntimeException("加载数据库驱动失败");
        }
    }
    
    // 获取数据库连接
    public static Connection getConnection() throws SQLException {
        Properties props = new Properties();
        props.setProperty("user", USER);
        props.setProperty("password", PASSWORD);
        props.setProperty("useSSL", "false");
        props.setProperty("useUnicode", "true");
        props.setProperty("characterEncoding", "UTF-8");
        props.setProperty("serverTimezone", "Asia/Shanghai");
        
        return DriverManager.getConnection(URL, props);
    }
    
    // 关闭连接
    public static void close(Connection conn) {
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

使用连接池优化性能

对于生产环境，推荐使用连接池（如 HikariCP、DBCP、C3P0）：

<!-- HikariCP 依赖 -->
<dependency>
    <groupId>com.zaxxer</groupId>
    <artifactId>HikariCP</artifactId>
    <version>4.0.3</version>
</dependency>

连接池配置示例：

import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;

public class DataSource {
    private static HikariDataSource dataSource;
    
    static {
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl("jdbc:mysql://localhost:3306/test");
        config.setUsername("root");
        config.setPassword("123456");
        config.setMaximumPoolSize(20);
        config.setMinimumIdle(5);
        config.setConnectionTimeout(30000);
        config.setIdleTimeout(600000);
        config.setMaxLifetime(1800000);
        
        dataSource = new HikariDataSource(config);
    }
    
    public static Connection getConnection() throws SQLException {
        return dataSource.getConnection();
    }
}

数据库操作最佳实践

1. 使用 try-with-resources 自动关闭资源
2. 使用 PreparedStatement 防止 SQL 注入
3. 合理处理事务
4. 及时释放数据库连接
5. 使用连接池管理连接

public List<User> getAllUsers() {
    List<User> users = new ArrayList<>();
    String sql = "SELECT id, username, email FROM users";
    
    try (Connection conn = DBUtil.getConnection();
         PreparedStatement pstmt = conn.prepareStatement(sql);
         ResultSet rs = pstmt.executeQuery()) {
        
        while (rs.next()) {
            User user = new User();
            user.setId(rs.getInt("id"));
            user.setUsername(rs.getString("username"));
            user.setEmail(rs.getString("email"));
            users.add(user);
        }
    } catch (SQLException e) {
        e.printStackTrace();
    }
    
    return users;
}

四、项目部署与运行

（一）部署项目到 Tomcat

1. 打开 IntelliJ IDEA，进入项目界面
2. 点击顶部菜单栏的 "Run" -> "Edit Configurations..." 打开运行配置窗口
3. 在左侧配置列表中选择之前配置好的 Tomcat 服务器（如未配置，需先添加 Tomcat Server）
4. 在 "Deployment" 选项卡中：
   • 点击 "+" 号添加部署项目
   • 在弹出的菜单中选择 "Artifact" 选项
   • 选择当前项目生成的 war 包（通常为项目名.war）或 war exploded（开发时推荐使用，支持热部署）
   • 点击 "OK" 确认选择
5. 在 "Server" 选项卡中可以设置：
   • 启动端口（默认8080）
   • 会话超时时间
   • 部署路径（默认/项目名）
6. 点击 "Apply" 保存配置
7. 点击 "OK" 完成全部配置

（二）运行项目

1. 在 IntelliJ IDEA 工具栏中：
   • 点击绿色三角形 "Run" 按钮以普通模式启动项目
   • 或点击绿色虫子图标 "Debug" 按钮以调试模式启动
2. 控制台将显示 Tomcat 启动日志，等待出现类似 "Server startup in xxx ms" 的启动完成信息
3. 项目启动成功后：
   • 打开任意浏览器（推荐 Chrome/Firefox）
   • 在地址栏输入 "http://localhost:8080/项目名称"（若修改了端口或路径需相应调整）
   • 按回车键访问项目首页
4. 开发调试时可使用：
   • 热部署功能（修改代码后无需重启）
   • 断点调试（Debug模式下）
   • 浏览器开发者工具（F12）查看请求响应

五、注意事项

1.版本兼容性详解

在Java Web开发中，各组件的版本兼容性至关重要：

1. JDK与Tomcat匹配：

   • JDK 8建议搭配Tomcat 8.5+
   • JDK 11建议搭配Tomcat 9.0+
   • JDK 17建议搭配Tomcat 10.0+
   • 不兼容的搭配会导致ClassLoader异常或启动失败

2. 数据库驱动要求：

   • MySQL 5.7需要mysql-connector-java 5.1.x
   • MySQL 8.0需要mysql-connector-java 8.0.x（注意时区设置）
   • Oracle 12c需要ojdbc8.jar
   • 驱动版本不匹配会出现连接异常或SQL执行错误

2.字符编码最佳实践

1. 全方位编码设置：

   • JSP页面：<%@ page contentType="text/html;charset=UTF-8" %>
   • HTML meta标签：<meta charset="UTF-8">
   • 过滤器配置：

     request.setCharacterEncoding("UTF-8");
     response.setCharacterEncoding("UTF-8");
     

   • 数据库连接：jdbc:mysql://...?useUnicode=true&characterEncoding=UTF-8

2. 常见乱码场景：

   • GET请求乱码：需配置Tomcat的server.xml的Connector加上URIEncoding="UTF-8"
   • 文件上传乱码：需在MultipartConfig中指定编码

3.路径处理方案

1. 路径处理方式对比：

   • 相对路径：../css/style.css（易受页面位置影响）
   • 绝对路径：/projectName/css/style.css（推荐）
   • 动态获取：${pageContext.request.contextPath}/css/style.css

2. 路径应用示例：

   <!-- 资源引用 -->
   <link href="${ctx}/css/bootstrap.min.css" rel="stylesheet">
   <!-- 表单提交 -->
   <form action="${ctx}/user/login" method="post">
   <!-- 图片引用 -->
   <img src="${ctx}/images/logo.png">
   

4.异常处理机制

1. 分层异常处理：

   • DAO层：捕获SQLException，转换为自定义异常
   • Service层：处理业务异常，记录日志
   • Controller层：捕获所有异常，返回友好提示
   • 全局异常处理器：使用@ControllerAdvice统一处理

2. 异常处理示例：

   try {
       // 业务代码
   } catch (BusinessException e) {
       logger.error("业务异常", e);
       return Result.error("操作失败，请稍后重试");
   } catch (Exception e) {
       logger.error("系统异常", e);
       return Result.error("系统繁忙，请稍后重试");
   }
   

5.数据库资源管理

1. 资源关闭方案：

   • 传统方式：

     finally {
         if(rs != null) rs.close();
         if(stmt != null) stmt.close();
         if(conn != null) conn.close();
     }
     

   • try-with-resources（推荐）：

     try (Connection conn = dataSource.getConnection();
          PreparedStatement ps = conn.prepareStatement(sql);
          ResultSet rs = ps.executeQuery()) {
         // 处理结果集
     }
     

2. 连接池配置：

   • 推荐使用HikariCP或Druid
   • 配置合理的maxPoolSize和idleTimeout
   • 监控连接泄漏

6.安全防护措施

1. 输入验证：

   • 前端验证：表单正则校验
   • 后端验证：Spring Validation
   • 敏感字符过滤：StringEscapeUtils.escapeHtml4(input)

2. SQL注入防护：

   • 必须使用PreparedStatement
   • 禁止字符串拼接SQL
   • MyBatis使用#{}而非${}

3. XSS防护：

   • 输出编码：<c:out value="${userInput}"/>
   • CSP策略设置
   • 富文本使用HTML过滤器（如jsoup）

7.项目备份策略

1. 版本控制方案：

   • 每日提交到Git远程仓库
   • 重要变更创建分支开发
   • 使用.gitignore排除不需要版本控制的文件

2. 备份策略示例：

   /project
   ├── src                # 源代码
   ├── doc                # 文档
   ├── sql                # 数据库脚本
   └── backup             # 手动备份目录
       ├── 20230501       # 按日期归档
       └── v1.0.0         # 按版本归档
   

3. 自动化：

   • 使用Jenkins定时构建归档
   • 数据库自动备份脚本
   • 重要数据同步到云存储