本文还有配套的精品资源，点击获取 menu-r.4af5f7ec.gif

简介：Java Web开发涵盖HTTP协议、Servlet、JSP、MVC设计模式、数据库连接、过滤器、监听器及会话管理等核心技术。本资料 javawebppt 以PPT形式系统讲解Java Web开发基础知识，适合初学者全面掌握Web应用开发流程。内容注重理论与实践结合，帮助学习者构建结构清晰、可维护性强的Web应用程序，并掌握服务器端逻辑处理、动态页面生成、用户状态管理等关键技能。
JavaWebPPT

1. Java Web开发概述

Java Web开发是构建企业级互联网应用的核心技术体系，凭借其跨平台性、稳定性与生态丰富性，广泛应用于大型分布式系统中。本章将引导读者从基础概念出发，逐步理解Web应用的运行机制与开发流程。

1.1 Java Web的基本概念

Java Web是指使用Java技术构建的基于HTTP协议的网络应用程序。其运行环境通常包括Web服务器（如Tomcat）、Servlet容器、JSP引擎及后端数据库等组件。Java Web的核心在于通过Servlet和JSP实现动态网页的生成与交互。

一个典型的Java Web应用由客户端（浏览器）、Web服务器、应用服务器和数据库四部分组成，形成“客户端-服务器”架构。用户通过浏览器发送HTTP请求，服务器接收并处理请求，最终返回HTML页面或JSON数据。

1.1.1 Java Web技术栈概览

技术组件 作用描述
Servlet 处理HTTP请求与响应
JSP 生成动态HTML页面
JDBC 连接与操作数据库
JavaBean 封装业务数据
JSTL/EL 简化JSP中的逻辑控制与数据展示
MVC框架（如Spring MVC） 实现业务逻辑与视图分离，提升可维护性

1.1.2 Web应用的工作流程

graph TD
    A[客户端浏览器] --> B[发送HTTP请求]
    B --> C[Web服务器接收请求]
    C --> D{请求类型判断}
    D -->|Servlet| E[执行业务逻辑]
    D -->|JSP| F[生成动态页面]
    E --> G[数据库交互]
    F --> H[返回HTML响应]
    E --> H
    H --> I[客户端显示结果]

如上图所示，Java Web应用通过分层协作完成用户请求的处理与响应，体现了其模块化与可扩展性的设计优势。

1.2 开发环境搭建

在开始Java Web开发之前，必须配置好相应的开发与运行环境。以下是搭建Java Web开发环境的基本步骤：

1.2.1 安装JDK

Java Development Kit（JDK）是Java开发的基础工具包，包含编译器、运行时环境和工具库。

  • 下载地址： Oracle JDK
  • 安装后配置环境变量 JAVA_HOME 与 PATH

验证安装：

java -version
javac -version

1.2.2 配置IDE（以IntelliJ IDEA为例）

IntelliJ IDEA是Java Web开发的主流IDE，支持Servlet、JSP、Spring等框架的开发与调试。

  1. 下载并安装 IntelliJ IDEA
  2. 安装后创建新项目，选择 Java Enterprise 类型
  3. 配置应用服务器（如Tomcat）

1.2.3 安装Web服务器（Tomcat）

Apache Tomcat 是一个轻量级的Servlet容器，常用于Java Web应用的部署与测试。

  • 下载地址： Apache Tomcat
  • 解压后设置环境变量 CATALINA_HOME
  • 启动服务器：
    bash cd $CATALINA_HOME/bin ./startup.sh
  • 访问 http://localhost:8080 验证Tomcat是否启动成功

通过以上步骤，即可搭建一个完整的Java Web开发环境，为后续的学习与实践打下基础。

2. HTTP协议基础与应用

Web开发的核心在于客户端与服务器之间的数据通信，而HTTP（HyperText Transfer Protocol）协议正是实现这种通信的基础。HTTP是一种无状态、基于请求-响应模型的应用层协议，广泛应用于浏览器与服务器之间的交互场景。理解HTTP协议的基本结构、会话控制机制以及安全策略，是构建稳定、高效Web应用的关键前提。本章将深入探讨HTTP协议的核心组成部分、请求与响应的交互方式、常见方法与状态码，以及在现代Web开发中的实际应用。

2.1 HTTP协议的基本结构

HTTP协议的通信过程基于请求（Request）和响应（Response）的模型，客户端发送请求，服务器接收并处理请求后返回响应。为了深入理解HTTP的工作机制，我们需要从其基本结构入手，解析请求与响应的格式、常见的HTTP方法以及HTTP状态码的含义。

2.1.1 请求与响应的格式解析

HTTP请求和响应都遵循特定的格式规范，包括起始行（Start Line）、头部（Headers）、空行（CRLF）和消息主体（Message Body）四个部分。

HTTP请求格式示例：
GET /index.html HTTP/1.1
Host: www.example.com
User-Agent: Mozilla/5.0
Accept: text/html,application/xhtml+xml
Accept-Language: en-US,en;q=0.9
HTTP响应格式示例：
HTTP/1.1 200 OK
Date: Mon, 27 Jul 2024 12:00:00 GMT
Server: Apache/2.4.1 (Unix)
Content-Type: text/html; charset=UTF-8
Content-Length: 138

<html>
<head><title>Example</title></head>
<body>Hello World</body>
</html>
格式解析：
组成部分 描述
起始行 请求行（GET /index.html HTTP/1.1）或状态行（HTTP/1.1 200 OK）
头部字段 键值对形式，用于传递元信息（如 Host、User-Agent、Content-Type）
空行 分隔头部与正文，表示头部结束
消息主体 可选，请求或响应中携带的数据内容（如 POST 请求的数据、HTML 响应内容）
示例代码分析：

以下是一个使用 Python 的 http.client 模块模拟 HTTP 请求的示例：

import http.client

conn = http.client.HTTPConnection("www.example.com")
conn.request("GET", "/index.html")
response = conn.getresponse()

print("Status:", response.status)
print("Reason:", response.reason)
print("Headers:", response.getheaders())
print("Body:", response.read().decode())

逐行解释：

  1. http.client.HTTPConnection("www.example.com") ：创建一个到目标服务器的连接对象。
  2. conn.request("GET", "/index.html") ：发起一个 GET 请求。
  3. response = conn.getresponse() ：获取服务器返回的响应对象。
  4. response.status 和 response.reason ：分别表示 HTTP 状态码和状态描述。
  5. response.getheaders() ：获取响应头信息。
  6. response.read() ：读取响应正文内容并解码输出。

2.1.2 常见的HTTP方法（GET、POST、PUT、DELETE）

HTTP方法定义了客户端希望服务器执行的操作类型，最常见的方法包括 GET、POST、PUT 和 DELETE。

方法 描述 幂等性 安全性
GET 获取资源 是 是
POST 创建资源 否 否
PUT 更新资源 是 否
DELETE 删除资源 是 否
使用示例（使用 curl 发送请求）：
# 发送 GET 请求
curl -X GET "http://example.com/data"

# 发送 POST 请求
curl -X POST "http://example.com/data" -H "Content-Type: application/json" -d '{"name":"test"}'

# 发送 PUT 请求
curl -X PUT "http://example.com/data/1" -H "Content-Type: application/json" -d '{"name":"updated"}'

# 发送 DELETE 请求
curl -X DELETE "http://example.com/data/1"

逻辑分析：

  • -X ：指定请求方法。
  • -H ：设置请求头字段。
  • -d ：指定请求体内容（用于 POST、PUT）。

2.1.3 HTTP状态码及其含义

HTTP状态码由三位数字组成，用于指示请求的处理结果。常见状态码如下：

状态码 含义
200 请求成功
201 资源已创建
301 永久重定向
302 临时重定向
400 请求错误（Bad Request）
401 未授权（Unauthorized）
403 禁止访问（Forbidden）
404 资源未找到（Not Found）
500 内部服务器错误（Internal Server Error）
502 网关错误（Bad Gateway）
示例代码（Node.js Express 返回状态码）：
const express = require('express');
const app = express();

app.get('/success', (req, res) => {
    res.status(200).send('成功');
});

app.get('/not-found', (req, res) => {
    res.status(404).send('资源未找到');
});

app.get('/server-error', (req, res) => {
    res.status(500).send('服务器内部错误');
});

app.listen(3000, () => {
    console.log('Server is running on port 3000');
});

逐行解释：

  1. res.status(200) ：设置 HTTP 响应状态码为 200。
  2. res.send() ：发送响应内容给客户端。
  3. 每个路由处理函数对应不同的状态码和响应内容。

2.2 HTTP头部信息与会话控制

HTTP协议是无状态的，这意味着每次请求都是独立的，服务器无法直接识别用户身份。为了解决这一问题，HTTP提供了头部信息（Headers）和会话控制机制（如 Cookie 与 Session），用于在客户端与服务器之间传递上下文信息。

2.2.1 常用头部字段（Host、User-Agent、Content-Type）

HTTP头部字段是客户端和服务器之间传递元数据的重要方式，以下是几个关键头部字段：

头部字段 描述
Host 指定请求的目标主机名
User-Agent 表示客户端类型（浏览器、设备等）
Content-Type 指定请求或响应体的MIME类型
Accept 表示客户端可以处理的内容类型
Authorization 携带认证信息（如 Token）
示例代码（使用 JavaScript fetch API 设置请求头）：
fetch('https://api.example.com/data', {
    method: 'GET',
    headers: {
        'Host': 'api.example.com',
        'User-Agent': 'MyApp/1.0',
        'Authorization': 'Bearer <token>'
    }
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));

逐行解释：

  1. headers ：设置请求头字段。
  2. Authorization ：用于携带认证信息（如 JWT Token）。
  3. fetch ：发起异步请求并处理响应。

2.2.2 Cookie与Session在会话控制中的作用

Cookie 是客户端保存的键值对，服务器可以通过 Set-Cookie 头部设置；Session 则是服务器端存储的用户状态信息，通常通过 Cookie 中的 Session ID 进行关联。

Cookie 工作流程图（使用 Mermaid 格式）：
graph TD
    A[客户端发起请求] --> B[服务器响应]
    B --> C{是否包含 Set-Cookie 头部?}
    C -->|是| D[客户端保存 Cookie]
    C -->|否| E[继续请求]
    D --> F[后续请求携带 Cookie]
    F --> G[服务器识别用户]
示例代码（Node.js Express 中使用 Cookie）：
const express = require('express');
const cookieParser = require('cookie-parser');
const app = express();

app.use(cookieParser());

app.get('/set-cookie', (req, res) => {
    res.cookie('username', 'john_doe', { maxAge: 900000, httpOnly: true });
    res.send('Cookie set');
});

app.get('/get-cookie', (req, res) => {
    const username = req.cookies.username;
    if (username) {
        res.send(`Hello ${username}`);
    } else {
        res.send('No cookie found');
    }
});

app.listen(3000, () => {
    console.log('Server running on port 3000');
});

逐行解释：

  1. res.cookie() ：设置 Cookie，并指定最大生存时间与安全选项。
  2. req.cookies ：读取客户端发送的 Cookie。
  3. httpOnly: true ：防止 XSS 攻击，限制 Cookie 仅通过 HTTP 传输。

2.3 HTTP安全机制

随着Web应用的复杂化，HTTP协议本身的安全性逐渐暴露不足。为此，HTTPS、CSRF防护、CORS等安全机制应运而生，用于提升Web应用的安全性。

2.3.1 HTTPS与SSL/TLS加密通信

HTTPS 是 HTTP 协议与 SSL/TLS 协议的结合，用于加密客户端与服务器之间的通信，防止数据被窃听或篡改。

HTTPS 工作流程简图（Mermaid）：
sequenceDiagram
    participant Client
    participant Server

    Client->>Server: 发起 HTTPS 请求
    Server-->>Client: 返回 SSL/TLS 证书
    Client->>Server: 验证证书并生成会话密钥
    Server-->>Client: 使用密钥加密通信
Nginx 配置 HTTPS 示例：
server {
    listen 443 ssl;
    server_name example.com;

    ssl_certificate /path/to/fullchain.pem;
    ssl_certificate_key /path/to/privkey.pem;

    location / {
        proxy_pass http://localhost:3000;
    }
}

参数说明：

  • ssl_certificate ：SSL证书路径。
  • ssl_certificate_key ：私钥文件路径。
  • proxy_pass ：将请求代理到后端服务。

2.3.2 跨站请求伪造（CSRF）防护

CSRF 是一种攻击方式，攻击者诱导用户在已登录的 Web 应用中执行非预期的操作。为防止 CSRF，常见的防护机制包括：

  • 使用 Token（如 Anti-CSRF Token）
  • 检查 Referer 头部
  • SameSite Cookie 属性
示例代码（Spring Boot 中启用 CSRF 防护）：
@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .csrf(csrf -> csrf.disable())  // 默认启用，可显式启用或配置
            .authorizeRequests()
            .anyRequest().authenticated()
            .and()
            .formLogin();
        return http.build();
    }
}

逐行解释：

  1. csrf.disable() ：禁用 CSRF 防护（生产环境应谨慎使用）。
  2. .csrf(csrf -> csrf.csrfTokenRepository(CookieCsrfTokenRepository.withHttpOnlyFalse())) ：可配置基于 Cookie 的 Token 存储。

2.3.3 跨域资源共享（CORS）策略

CORS 是一种机制，允许网页从不同域请求资源，避免同源策略限制。通过设置响应头，服务器可以控制哪些域可以访问其资源。

示例代码（Node.js Express 启用 CORS）：
const express = require('express');
const cors = require('cors');
const app = express();

app.use(cors());

app.get('/data', (req, res) => {
    res.json({ message: 'CORS enabled' });
});

app.listen(3000, () => {
    console.log('Server running on port 3000');
});

逐行解释：

  1. cors() ：启用默认 CORS 策略，允许所有来源访问。
  2. 可自定义策略，如限制允许的来源、方法等。

本章从HTTP协议的基础结构出发，详细解析了请求与响应的格式、常见的HTTP方法与状态码，探讨了HTTP头部信息的作用与会话控制机制（Cookie与Session），并进一步介绍了HTTPS、CSRF防护与CORS等安全机制的实际应用。这些内容构成了现代Web开发中网络通信的核心基础，为后续的Servlet与Web框架开发提供了理论与实践支持。

3. Servlet设计与实现

Servlet 是 Java Web 开发中最核心的组件之一，它作为运行在服务器端的 Java 程序，负责接收客户端的请求并返回响应。通过 Servlet，我们可以实现与 HTTP 协议的深度交互，处理表单提交、会话管理、请求转发等功能。本章将从 Servlet 的基础概念入手，逐步深入到其请求处理机制、上下文管理和生命周期控制，帮助开发者掌握构建高性能 Web 应用的核心技能。

3.1 Servlet基础概念

Servlet 是运行在 Web 服务器上的 Java 类，它通过实现 Servlet 接口来处理 HTTP 请求。理解 Servlet 的基本结构和继承关系，是掌握 Java Web 开发的第一步。

3.1.1 Servlet接口与GenericServlet类

Servlet 技术的核心是 javax.servlet.Servlet 接口，所有 Servlet 类都必须直接或间接实现该接口。这个接口定义了以下五个核心方法：

方法名 描述
void init(ServletConfig config) 初始化方法，在 Servlet 第一次被加载时调用
ServletConfig getServletConfig() 获取 Servlet 的配置信息
void service(ServletRequest req, ServletResponse res) 处理客户端请求并生成响应
String getServletInfo() 返回 Servlet 的相关信息（如作者、版本等）
void destroy() 销毁方法，在 Servlet 被卸载前调用

GenericServlet 是一个实现了 Servlet 接口的抽象类，它提供了对通用协议的支持，但不依赖于具体的通信协议（如 HTTP）。因此，如果你希望编写一个支持其他协议的 Servlet，可以继承该类。

import javax.servlet.*;
import java.io.IOException;

public class MyGenericServlet extends GenericServlet {
    @Override
    public void service(ServletRequest request, ServletResponse response) throws ServletException, IOException {
        response.getWriter().write("Hello from GenericServlet");
    }
}

代码解析：

  • MyGenericServlet 继承自 GenericServlet ，并重写了 service 方法。
  • service 方法接收 ServletRequest 和 ServletResponse 对象，分别用于读取请求和写入响应。
  • 该示例中，Servlet 会向客户端输出 “Hello from GenericServlet”。

3.1.2 HttpServlet的继承与实现

在实际开发中，大多数 Servlet 是基于 HTTP 协议的。 HttpServlet 是 GenericServlet 的子类，专为 HTTP 请求设计，提供了 doGet 、 doPost 、 doPut 等方法，分别对应不同的 HTTP 方法。

import javax.servlet.http.*;
import java.io.*;

public class HelloHttpServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
        response.setContentType("text/html");
        PrintWriter out = response.getWriter();
        out.println("<h1>Hello from HttpServlet</h1>");
    }
}

代码解析：

  • HelloHttpServlet 继承自 HttpServlet ，并重写了 doGet 方法。
  • doGet 方法用于处理 HTTP GET 请求。
  • setContentType("text/html") 设置响应内容类型为 HTML。
  • 使用 PrintWriter 向客户端输出 HTML 内容。

3.1.3 Servlet的部署与配置（web.xml与注解）

Servlet 的部署方式有两种：通过 web.xml 配置文件进行配置，或者使用 Java 注解 @WebServlet 。

使用 web.xml 配置 Servlet
<servlet>
    <servlet-name>HelloHttpServlet</servlet-name>
    <servlet-class>com.example.HelloHttpServlet</servlet-class>
</servlet>

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

说明：

  • <servlet> 标签定义了 Servlet 的名称和类路径。
  • <servlet-mapping> 将 Servlet 映射到 URL 路径 /hello 。
  • 当用户访问 http://localhost:8080/app/hello 时，会触发该 Servlet。
使用注解配置 Servlet
@WebServlet("/hello")
public class HelloHttpServlet extends HttpServlet {
    // doGet 方法实现同上
}

说明：

  • 使用 @WebServlet("/hello") 注解将该 Servlet 映射到 /hello 路径。
  • 这种方式更简洁，适用于现代开发框架如 Spring Boot。

3.2 Servlet请求与响应处理

Servlet 的核心功能是处理客户端请求并生成响应。理解 HttpServletRequest 和 HttpServletResponse 的使用方法，是构建交互式 Web 应用的关键。

3.2.1 HttpServletRequest的解析与参数获取

HttpServletRequest 封装了客户端的 HTTP 请求信息，包括请求方法、URL、参数、头部等。

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
    String name = request.getParameter("name");
    response.setContentType("text/html");
    PrintWriter out = response.getWriter();
    out.println("<h1>Hello, " + name + "</h1>");
}

参数获取说明：

  • request.getParameter("name") 获取 URL 中的查询参数（如 ?name=Tom ）。
  • 也可以使用 getParameterValues() 获取多个值的数组（如复选框）。
示例请求：
GET /hello?name=John HTTP/1.1

响应结果：

<h1>Hello, John</h1>

3.2.2 HttpServletResponse的响应内容生成

HttpServletResponse 用于向客户端发送响应，包括状态码、响应头和响应体。

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
    response.setStatus(HttpServletResponse.SC_OK);
    response.setHeader("X-Custom-Header", "MyValue");
    response.getWriter().write("This is plain text response.");
}

说明：

  • setStatus() 设置 HTTP 状态码，如 SC_OK 表示 200。
  • setHeader() 可以设置自定义响应头。
  • getWriter() 用于写入文本响应内容。

3.2.3 请求转发与重定向的实现方式

Servlet 中可以使用请求转发（forward）或重定向（redirect）来控制请求流程。

请求转发（Forward）

请求转发在服务器端完成，客户端地址不变。

RequestDispatcher dispatcher = request.getRequestDispatcher("/another");
dispatcher.forward(request, response);

说明：

  • RequestDispatcher 用于将请求转发到另一个资源（如另一个 Servlet 或 JSP）。
  • 转发是在服务器内部完成的，客户端不知道发生了跳转。
重定向（Redirect）

重定向是客户端行为，浏览器会发起新的请求。

response.sendRedirect("http://example.com");

说明：

  • sendRedirect() 会向客户端发送 302 状态码和新的 URL。
  • 浏览器会重新请求新地址，地址栏会变化。

3.3 Servlet上下文与生命周期管理

Servlet 的生命周期由 Web 容器（如 Tomcat）管理，包括初始化、服务和销毁三个阶段。此外， ServletContext 和 ServletConfig 提供了全局和局部配置的访问能力。

3.3.1 ServletContext与ServletConfig的作用

ServletConfig

ServletConfig 提供了当前 Servlet 的配置信息，通常用于获取初始化参数。

public class ConfigServlet extends HttpServlet {
    private String appName;

    @Override
    public void init(ServletConfig config) throws ServletException {
        appName = config.getInitParameter("app-name");
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
        response.getWriter().write("Application Name: " + appName);
    }
}

web.xml 配置： 

<servlet>
    <servlet-name>ConfigServlet</servlet-name>
    <servlet-class>com.example.ConfigServlet</servlet-class>
    <init-param>
        <param-name>app-name</param-name>
        <param-value>MyWebApp</param-value>
    </init-param>
</servlet>
ServletContext

ServletContext 是 Web 应用级别的对象，所有 Servlet 都可以访问它，常用于共享全局数据。

@Override
public void init(ServletConfig config) throws ServletException {
    super.init(config);
    ServletContext context = config.getServletContext();
    context.setAttribute("siteName", "JavaWebSite");
}

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
    ServletContext context = getServletContext();
    String siteName = (String) context.getAttribute("siteName");
    response.getWriter().write("Site Name: " + siteName);
}

说明：

  • setAttribute() 和 getAttribute() 用于在应用范围内共享数据。
  • 常用于存储全局配置、数据库连接池等。

3.3.2 Servlet的线程安全问题与解决方案

由于 Servlet 是单例的，默认情况下多个请求会共享同一个 Servlet 实例，这可能导致线程安全问题。

示例问题：
public class CounterServlet extends HttpServlet {
    private int count = 0;

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
        count++;
        response.getWriter().write("Count: " + count);
    }
}

当多个用户同时访问时， count 变量会出现并发问题。

解决方案：
  1. 使用同步代码块： 
private int count = 0;
private Object lock = new Object();

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
    synchronized (lock) {
        count++;
        response.getWriter().write("Count: " + count);
    }
}
  1. 使用线程安全的数据结构： 
private AtomicInteger count = new AtomicInteger(0);

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
    int current = count.incrementAndGet();
    response.getWriter().write("Count: " + current);
}
  1. 避免使用实例变量：

尽量使用局部变量或线程局部变量（ ThreadLocal ）来避免并发冲突。

总结与延伸

本章详细介绍了 Servlet 的基本结构、请求与响应处理机制，以及上下文管理和线程安全问题。掌握这些内容后，开发者可以构建出结构清晰、逻辑严谨的 Web 应用。

在下一章中，我们将进入 JSP 的世界，学习如何通过 JSP 页面实现动态内容的展示，并理解 JSP 与 Servlet 的关系。

4. JSP页面开发与原理

JSP（Java Server Pages）是 Java Web 开发中用于构建动态网页的重要技术，它通过将 Java 代码嵌入 HTML 页面中，实现了业务逻辑与页面展示的分离。JSP 本质上是 Servlet 的一种简化形式，它在运行时被容器翻译成对应的 Servlet 源码并编译执行。本章将从 JSP 的基本语法入手，逐步深入探讨其内置对象、EL 表达式、JSTL 标签库，并解析其底层执行流程与性能优化策略。

4.1 JSP的基本语法与指令

JSP 页面由 HTML、Java 脚本和 JSP 指令组成，通过这些元素可以构建出动态内容丰富的网页。掌握 JSP 的语法结构与常用指令是开发 JSP 页面的第一步。

4.1.1 JSP声明、表达式与脚本片段

JSP 中的 Java 代码片段主要分为三种形式：声明（Declaration）、表达式（Expression）和脚本片段（Scriptlet）。

声明（Declaration）

声明用于定义类级变量或方法，使用 <%! %> 标签包裹：

<%!
    int count = 0;
    String greet(String name) {
        return "Hello, " + name;
    }
%>

逻辑分析：

  • <%! 开始和 %> 结束，用于声明类级变量和方法。
  • count 变量将在整个 JSP 页面中可见。
  • greet() 方法可以在页面中多次调用。
表达式（Expression）

表达式用于输出 Java 表达式的结果，使用 <%= %> 标签包裹：

<p>当前计数为：<%= count %></p>
<p>问候语：<%= greet("Tom") %></p>

逻辑分析：

  • <%= count %> 将变量 count 的值输出到 HTML 页面中。
  • <%= greet("Tom") %> 调用方法并输出结果。
脚本片段（Scriptlet）

脚本片段用于嵌入 Java 逻辑代码，使用 <% %> 标签包裹：

<%
    count++;
    out.println("页面被访问了 " + count + " 次");
%>

逻辑分析：

  • count++ 对变量进行自增操作。
  • out.println() 是 JSP 中的内置对象 JspWriter ，用于向客户端输出内容。

⚠️ 注意：虽然这些脚本标签提供了灵活性，但过度使用会破坏 JSP 与 Java 代码的分离性，推荐将业务逻辑放在 JavaBean 或 Servlet 中。

4.1.2 page、include、taglib指令的使用

JSP 指令用于控制页面的整体行为，常见的指令包括 page 、 include 和 taglib 。

page 指令

page 指令用于设置整个 JSP 页面的属性：

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>

参数说明：

  • language="java" ：指定 JSP 页面使用的语言。
  • contentType="text/html; charset=UTF-8" ：设置响应的内容类型和字符编码。
  • pageEncoding="UTF-8" ：指定页面的字符编码。
include 指令

include 指令用于静态包含其他页面内容：

<%@ include file="header.jsp" %>

逻辑分析：

  • 在翻译阶段将 header.jsp 的内容合并到当前页面中。
  • 适用于静态内容的复用，如页眉、页脚等。
taglib 指令

taglib 指令用于引入自定义标签库（如 JSTL）：

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

参数说明：

  • prefix="c" ：指定标签库的前缀。
  • uri ：指定标签库的命名空间。

4.1.3 JSP动作标签（jsp:include、jsp:forward）

JSP 动作标签用于控制页面运行时的行为，常见标签包括 jsp:include 和 jsp:forward 。

jsp:include 动作标签

jsp:include 在请求处理阶段动态包含另一个资源：

<jsp:include page="menu.jsp" />

逻辑分析：

  • 在请求处理时动态调用 menu.jsp 。
  • 与 include 指令不同， jsp:include 是在运行时完成的，可以动态传递参数。
jsp:forward 动作标签

jsp:forward 用于将请求转发到另一个资源：

<jsp:forward page="login.jsp" />

逻辑分析：

  • 请求被转发到 login.jsp 页面，客户端地址栏不变。
  • 通常用于在控制器中根据逻辑跳转视图。

4.2 JSP内置对象与EL表达式

JSP 提供了一系列内置对象来简化开发，同时结合 EL（Expression Language）表达式和 JSTL（JSP Standard Tag Library）标签库，可以有效减少页面中的 Java 代码。

4.2.1 request、session、application等内置对象

JSP 内置对象无需声明即可直接使用，常见的包括：

内置对象 作用描述
request 封装客户端请求数据
response 封装服务器响应
session 用于保存用户会话信息
application 代表整个 Web 应用上下文
pageContext 页面上下文，用于访问其他内置对象

示例： 

<%
    // 获取请求参数
    String username = request.getParameter("username");

    // 设置 session 属性
    session.setAttribute("user", username);

    // 获取 application 属性
    String appName = application.getInitParameter("appName");
%>

逻辑分析：

  • request.getParameter() 用于获取客户端传来的参数。
  • session.setAttribute() 将用户信息保存在会话中。
  • application.getInitParameter() 获取 web.xml 中配置的全局参数。

4.2.2 EL表达式的语法与常用操作

EL 表达式通过 ${} 语法访问 JSP 内置对象、JavaBean 属性等，极大地简化了页面逻辑。

基本语法：
<p>用户名：${param.username}</p>
<p>会话用户：${sessionScope.user}</p>

逻辑分析：

  • ${param.username} 等价于 request.getParameter("username") 。
  • ${sessionScope.user} 等价于 session.getAttribute("user") 。
支持的操作：
操作符 示例 描述
. ${user.name} 访问 JavaBean 属性
[] ${user["name"]} 支持动态键名
empty ${empty user} 判断是否为空
逻辑运算符 ${user != null} 判断是否为非空

4.2.3 JSTL标签库的引入与使用

JSTL（JSP Standard Tag Library）是一组标准标签库，提供控制流程、迭代、格式化等功能。

引入 JSTL：
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
常见标签：
标签名 功能描述
<c:if> 条件判断
<c:choose> 多条件分支判断
<c:forEach> 遍历集合

示例： 

<c:if test="${not empty user}">
    <p>欢迎用户：${user}</p>
</c:if>

<c:forEach var="item" items="${list}">
    <p>${item}</p>
</c:forEach>

逻辑分析：

  • <c:if> 根据 test 条件判断是否输出内容。
  • <c:forEach> 遍历集合 list ，每次迭代将当前元素赋值给 item 。

4.3 JSP的执行流程与编译机制

JSP 的运行机制本质上是将其翻译为 Servlet，然后编译执行。理解 JSP 的执行流程有助于优化性能并排查问题。

4.3.1 JSP的翻译与编译过程

JSP 的生命周期可以分为以下几个阶段：

graph TD
    A[JSP文件] --> B[翻译阶段]
    B --> C[生成Java Servlet源码]
    C --> D[编译阶段]
    D --> E[生成Servlet类文件]
    E --> F[执行阶段]
    F --> G[响应客户端]
翻译阶段：

当第一次访问 JSP 页面时，容器会将 .jsp 文件翻译成 .java 文件，例如 index.jsp 会被翻译成 index_jsp.java 。

编译阶段：

容器调用 Java 编译器将 .java 文件编译为 .class 文件，生成对应的 Servlet 类。

执行阶段：

Servlet 类被加载并执行，生成 HTML 响应返回给客户端。

4.3.2 JSP与Servlet的对应关系

JSP 实质上是 Servlet 的一种封装形式，每个 JSP 页面都会被映射为一个 Servlet 类。

JSP 类结构示例：
public final class index_jsp extends HttpJspBase {
    public void _jspService(HttpServletRequest request, HttpServletResponse response) {
        // 页面内容处理逻辑
    }
}

逻辑分析：

  • HttpJspBase 是 Tomcat 提供的基类，继承自 HttpServlet 。
  • _jspService() 方法处理页面逻辑，类似于 doGet() 或 doPost() 。

4.3.3 JSP性能优化策略

为了提升 JSP 页面的性能，可以采取以下优化策略：

1. 禁用自动重新编译（Production 环境）

在 web.xml 中配置：

<jsp-config>
    <jsp-property-group>
        <url-pattern>*.jsp</url-pattern>
        <development>false</development>
    </jsp-property-group>
</jsp-config>

作用：

  • 禁用自动检测 JSP 文件修改并重新编译的功能，适用于生产环境。
2. 减少脚本使用

避免在 JSP 中大量使用 <% %> 脚本，推荐使用 EL 表达式和 JSTL 标签。

3. 启用缓存机制

对于静态内容，可以设置缓存头：

<% response.setHeader("Cache-Control", "max-age=3600"); %>
4. 使用页面缓存插件（如 OSCache）

通过第三方缓存插件缓存页面片段，减少重复渲染。

5. 分离业务逻辑与展示逻辑

将复杂逻辑封装到 JavaBean 或 Service 中，保持 JSP 页面简洁。

通过本章的学习，我们掌握了 JSP 的基本语法结构、内置对象与表达式技术，并深入理解了其底层执行机制与性能优化方法。下一章将围绕 MVC 设计模式展开，探讨如何将 JSP 与 Servlet 结合，构建结构清晰的 Web 应用。

5. MVC设计模式实战

在现代Web开发中， MVC（Model-View-Controller）设计模式 已经成为构建结构清晰、可维护、可扩展应用的核心架构模式之一。它通过将业务逻辑、数据模型和用户界面分离，使得系统更易于维护与扩展。Java Web开发中，MVC模式广泛应用于Servlet、JSP、Spring MVC等技术栈中。本章将深入探讨MVC的核心思想、其在Java Web中的具体实现方式，并结合自定义框架和Spring MVC的使用，展示如何在实际项目中应用MVC进行开发。

5.1 MVC模式的核心思想

MVC是一种将用户界面与业务逻辑分离的设计模式，广泛应用于图形界面和Web开发中。它的核心思想是通过三部分的职责划分，提高系统的解耦性与可维护性。

5.1.1 Model、View、Controller的职责划分

  • Model（模型） ：负责数据的处理与业务逻辑的实现，通常包括数据库操作、业务规则、数据封装等。例如，Java中的JavaBean或POJO类，通常用于封装数据模型。
  • View（视图） ：负责用户界面的展示，接收用户输入，并将数据以可视化的方式呈现给用户。在Java Web中，JSP通常承担View的角色。
  • Controller（控制器） ：负责接收用户的请求，协调Model与View之间的交互。在Java Web中，Servlet通常作为Controller，负责处理请求并决定响应内容。
组件 职责 示例
Model 数据处理与业务逻辑 JavaBean、DAO类
View 界面展示 JSP页面
Controller 请求处理与流程控制 Servlet类

通过这种职责划分，MVC使得系统结构清晰，便于团队协作与代码维护。例如，前端开发人员可以专注于View的优化，而后端开发人员则可以专注于Model与Controller的实现，互不干扰。

5.1.2 MVC与三层架构的对比分析

在企业级应用中，常提到的 三层架构 （表现层、业务逻辑层、数据访问层）与MVC模式有相似之处，但也有本质区别：

模式 层级划分 特点
MVC Controller（控制层）、Model（模型层）、View（视图层） 强调前后端分离，适合Web应用开发
三层架构 表现层、业务逻辑层、数据访问层 更适用于传统C/S架构，强调模块化设计

MVC模式中的Controller通常对应三层架构中的表现层与部分业务逻辑的结合，而Model则可能包含业务逻辑与数据访问两部分。因此，MVC在Web开发中更加轻量且灵活。

5.2 Java Web中的MVC实现

在Java Web开发中，MVC模式可以通过Servlet、JSP与JavaBean的组合实现。本节将详细介绍三者在MVC架构中的角色与协作方式。

5.2.1 Servlet作为控制器的实现

Servlet是Java Web应用中最常见的控制器实现方式。它接收HTTP请求，处理用户输入，并决定将哪些数据传递给视图层。

@WebServlet("/login")
public class LoginServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String username = request.getParameter("username");
        String password = request.getParameter("password");

        // 调用Model进行验证
        User user = new UserDAO().findUser(username, password);

        if (user != null) {
            request.setAttribute("user", user);
            request.getRequestDispatcher("welcome.jsp").forward(request, response);
        } else {
            response.sendRedirect("error.jsp");
        }
    }
}

代码逻辑分析：
1. @WebServlet("/login") ：将该Servlet映射到 /login 路径。
2. doPost 方法处理POST请求，获取用户输入。
3. 调用 UserDAO （Model）进行数据库验证。
4. 根据验证结果，决定跳转到哪个JSP页面（View）。

参数说明：
- request.getParameter("username") ：获取用户提交的用户名。
- request.setAttribute("user", user) ：将用户对象绑定到请求作用域中，供JSP使用。
- request.getRequestDispatcher("welcome.jsp").forward(...) ：转发请求至指定JSP页面。

5.2.2 JSP作为视图的展示方式

JSP（Java Server Pages）用于动态生成HTML页面，承担MVC中的View角色。它通过EL表达式和JSTL标签库与Servlet进行数据交互。

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Welcome</title>
</head>
<body>
    <h2>欢迎，${user.username}！</h2>
    <p>您的邮箱是：${user.email}</p>
</body>
</html>

代码逻辑分析：
1. <%@ page contentType="text/html;charset=UTF-8" language="java" %> ：设置页面内容类型与字符编码。
2. ${user.username} ：通过EL表达式从request作用域中获取绑定的user对象的username属性。

优势：
- JSP将HTML与Java代码分离，提高了可维护性。
- 支持EL表达式和JSTL标签，使页面逻辑更简洁。

5.2.3 JavaBean作为模型的数据封装

JavaBean是符合特定规范的Java类，通常用于封装数据。在MVC中，它作为Model的一部分，负责与数据库交互。

public class User {
    private String username;
    private String email;

    // Getter and Setter
    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 class UserDAO {
    public User findUser(String username, String password) {
        // 假设从数据库查询用户
        if ("admin".equals(username) && "123456".equals(password)) {
            User user = new User();
            user.setUsername(username);
            user.setEmail("admin@example.com");
            return user;
        }
        return null;
    }
}

代码逻辑分析：
1. User 类是一个典型的JavaBean，用于封装用户数据。
2. UserDAO 类模拟数据库操作，返回一个User对象。
3. findUser 方法中模拟了数据库查询逻辑，实际开发中应使用JDBC或ORM框架。

参数说明：
- username 、 password ：用户登录信息。
- email ：用户邮箱，作为额外信息返回。

5.3 MVC框架的扩展与优化

随着Java Web开发的演进，出现了许多基于MVC模式的框架，如Struts、Spring MVC等。它们在简化开发、提升性能、增强安全性方面提供了强大支持。

5.3.1 自定义MVC框架的设计思路

我们可以基于Servlet、JSP与JavaBean构建一个简单的MVC框架，其核心流程如下：

graph TD
    A[用户请求] --> B{Controller处理}
    B --> C[调用Model]
    C --> D[获取数据]
    D --> E[返回结果给Controller]
    E --> F[决定View]
    F --> G[渲染页面]
    G --> H[响应用户]

核心组件设计：
- DispatcherServlet ：统一处理请求，作为前端控制器。
- ModelAndView ：封装模型数据与视图名称。
- ViewResolver ：解析视图路径，返回JSP页面。

这种设计使得请求流程清晰，便于扩展与维护。

5.3.2 使用Spring MVC进行企业级开发

Spring MVC是目前最流行的Java Web MVC框架，它基于Spring IoC容器，提供了强大的注解驱动开发能力。

@Controller
public class UserController {
    @Autowired
    private UserService userService;

    @RequestMapping("/user/{id}")
    public String getUser(@PathVariable int id, Model model) {
        User user = userService.getUserById(id);
        model.addAttribute("user", user);
        return "userDetails";
    }
}

代码逻辑分析：
1. @Controller ：声明该类为控制器。
2. @RequestMapping("/user/{id}") ：将 /user/{id} 路径映射到该方法。
3. @PathVariable int id ：从URL中提取用户ID。
4. model.addAttribute("user", user) ：将数据添加到模型中，供视图使用。
5. return "userDetails" ：返回视图名称，Spring MVC会自动解析为 userDetails.jsp 。

优势：
- 支持注解驱动，减少XML配置。
- 集成IoC容器，便于依赖注入与管理。
- 支持RESTful风格，适合前后端分离架构。

5.3.3 MVC模式下的异常处理机制

在MVC应用中，异常处理是保障系统健壮性的关键。Java Web中可以通过 try-catch 、 @ControllerAdvice 等方式统一处理异常。

@ControllerAdvice
public class GlobalExceptionHandler {
    @ExceptionHandler(UserNotFoundException.class)
    public String handleUserNotFound() {
        return "error/userNotFound";
    }

    @ExceptionHandler(Exception.class)
    public String handleGeneralError() {
        return "error/general";
    }
}

代码逻辑分析：
1. @ControllerAdvice ：全局异常处理器，适用于所有控制器。
2. @ExceptionHandler(UserNotFoundException.class) ：处理特定异常。
3. 返回错误页面路径，由视图渲染。

参数说明：
- UserNotFoundException ：自定义异常类，表示用户未找到。
- Exception.class ：通用异常处理，用于兜底。

建议：
- 按照业务逻辑定义自定义异常类。
- 使用日志记录异常信息，便于排查问题。

5.3.4 MVC开发的常见问题与优化策略

  1. 视图与逻辑耦合 ：JSP中尽量避免Java代码，使用EL表达式和JSTL标签。
  2. 控制器臃肿 ：合理拆分Controller类，使用注解驱动，提高可读性。
  3. 性能瓶颈 ：采用缓存机制（如Redis）、连接池（如Druid）提升系统响应速度。
  4. 安全性问题 ：对用户输入进行过滤与验证，防止XSS与SQL注入。

总结

MVC设计模式是Java Web开发中实现高内聚、低耦合架构的重要手段。通过Servlet作为控制器、JSP作为视图、JavaBean作为模型的组合，可以快速构建结构清晰的Web应用。同时，借助Spring MVC等框架，可以进一步提升开发效率与系统可维护性。本章通过实例与流程图展示了MVC在Java Web中的具体实现方式，并探讨了自定义框架与企业级开发的实践方法，为后续深入学习打下坚实基础。

6. JDBC数据库连接与操作

数据库作为Web应用中持久化数据的核心组件，其与Java程序的交互依赖于JDBC（Java Database Connectivity）这一标准API。本章将深入解析JDBC的工作机制、核心接口的使用方式，并结合实际代码演示数据库连接、SQL执行以及性能优化的实践技巧。

6.1 JDBC基础与驱动类型

6.1.1 JDBC的工作原理与核心接口

JDBC 是 Java 提供的一套用于连接和操作数据库的标准 API。其核心在于通过接口抽象屏蔽不同数据库的实现差异，从而实现数据库无关的访问方式。

JDBC 的工作流程大致如下：

graph TD
    A[Java应用] --> B[DriverManager]
    B --> C[加载数据库驱动]
    C --> D[建立数据库连接]
    D --> E[执行SQL语句]
    E --> F[处理结果集]
    F --> G[关闭资源]

JDBC 核心接口包括 ：

接口名 作用说明
DriverManager 管理数据库驱动，用于建立连接
Connection 表示与数据库的连接，用于创建 Statement
Statement 用于执行静态 SQL 语句
PreparedStatement 预编译 SQL 语句，防止 SQL 注入
ResultSet 存储 SQL 查询的结果集

6.1.2 常见的JDBC驱动类型与选择

根据数据库厂商不同，JDBC 驱动主要分为以下几类：

  • Type 1：JDBC-ODBC Bridge Driver （已淘汰）
  • Type 2：Native API Partly Java Driver （本地库依赖，不推荐）
  • Type 3：Network Protocol Driver （中间件通信，适用于分布式）
  • Type 4：Thin Driver / Pure Java Driver （直接连接数据库，推荐）

主流数据库驱动示例 ：

数据库 JDBC驱动类名 连接URL示例
MySQL com.mysql.cj.jdbc.Driver jdbc:mysql://localhost:3306/mydb
PostgreSQL org.postgresql.Driver jdbc:postgresql://localhost:5432/mydb
Oracle oracle.jdbc.driver.OracleDriver jdbc:oracle:thin:@localhost:1521:orcl

6.2 数据库连接与SQL执行

6.2.1 Connection的获取与事务管理

建立数据库连接是 JDBC 操作的第一步，通常通过 DriverManager.getConnection() 实现。

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

public class DBConnection {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/mydb";
        String user = "root";
        String password = "123456";

        try {
            // 加载驱动（MySQL 8+ 可省略）
            Class.forName("com.mysql.cj.jdbc.Driver");

            // 获取连接
            Connection conn = DriverManager.getConnection(url, user, password);
            System.out.println("数据库连接成功");

            // 开启事务
            conn.setAutoCommit(false);

            // 执行SQL操作...
            // conn.commit(); // 提交事务
            // conn.rollback(); // 回滚事务

            conn.close(); // 关闭连接
        } catch (ClassNotFoundException | SQLException e) {
            e.printStackTrace();
        }
    }
}

说明 ：
- setAutoCommit(false) ：开启手动事务控制
- commit() ：提交事务
- rollback() ：事务回滚

6.2.2 Statement与PreparedStatement的使用

Statement 用于执行静态 SQL 语句，适合查询、更新等简单操作。

import java.sql.*;

public class JdbcExample {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/mydb";
        String user = "root";
        String password = "123456";

        try (Connection conn = DriverManager.getConnection(url, user, password);
             Statement stmt = conn.createStatement()) {

            String sql = "INSERT INTO users (name, email) VALUES ('张三', 'zhangsan@example.com')";
            int rowsAffected = stmt.executeUpdate(sql);
            System.out.println(rowsAffected + " 行插入成功");

        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

PreparedStatement 支持参数化 SQL，防止 SQL 注入，推荐在业务开发中使用。

import java.sql.*;

public class PreparedStatementExample {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/mydb";
        String user = "root";
        String password = "123456";

        String sql = "INSERT INTO users (name, email) VALUES (?, ?)";

        try (Connection conn = DriverManager.getConnection(url, user, password);
             PreparedStatement pstmt = conn.prepareStatement(sql)) {

            pstmt.setString(1, "李四");
            pstmt.setString(2, "lisi@example.com");

            int rowsAffected = pstmt.executeUpdate();
            System.out.println(rowsAffected + " 行插入成功");

        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

6.2.3 ResultSet的处理与结果映射

执行查询操作后，可通过 ResultSet 获取结果集数据。

import java.sql.*;

public class ResultSetExample {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/mydb";
        String user = "root";
        String password = "123456";

        String sql = "SELECT id, name, email FROM users";

        try (Connection conn = DriverManager.getConnection(url, user, password);
             Statement stmt = conn.createStatement();
             ResultSet rs = stmt.executeQuery(sql)) {

            while (rs.next()) {
                int id = rs.getInt("id");
                String name = rs.getString("name");
                String email = rs.getString("email");
                System.out.println("ID: " + id + ", 姓名: " + name + ", 邮箱: " + email);
            }

        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

说明 ：
- rs.next() ：移动指针到下一行
- rs.getInt("列名") ：获取指定列的数据

6.3 数据库连接池与性能优化

6.3.1 连接池的基本原理与常见实现（如C3P0、Druid）

频繁创建和关闭数据库连接会带来性能损耗。连接池通过维护一个可用连接的缓存池，实现连接的复用，提升系统吞吐能力。

常见的连接池实现 ：

连接池 特点
C3P0 早期常用，配置简单
HikariCP 性能最优，推荐使用
Druid 阿里出品，支持监控

以 HikariCP 为例的配置示例 ：

<!-- pom.xml 添加依赖 -->
<dependency>
    <groupId>com.zaxxer</groupId>
    <artifactId>HikariCP</artifactId>
    <version>5.0.1</version>
</dependency>

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

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;

public class HikariExample {
    public static void main(String[] args) throws SQLException {
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl("jdbc:mysql://localhost:3306/mydb");
        config.setUsername("root");
        config.setPassword("123456");
        config.setMaximumPoolSize(10);
        config.setIdleTimeout(30000);
        config.setConnectionTestQuery("SELECT 1");

        DataSource dataSource = new HikariDataSource(config);

        try (Connection conn = dataSource.getConnection()) {
            System.out.println("连接成功");
        }
    }
}

6.3.2 SQL注入防护与PreparedStatement的高级用法

使用 PreparedStatement 而非字符串拼接 SQL 是防止 SQL 注入的根本手段。以下为反例演示：

// 不安全的SQL拼接（易被注入）
String query = "SELECT * FROM users WHERE username = '" + username + "' AND password = '" + password + "'";
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery(query);

攻击示例 ：

username = "admin";
password = "' OR '1'='1";

最终SQL ：

SELECT * FROM users WHERE username = 'admin' AND password = '' OR '1'='1'

该语句始终为真，绕过登录验证。

安全写法（推荐） ：

String sql = "SELECT * FROM users WHERE username = ? AND password = ?";
PreparedStatement pstmt = conn.prepareStatement(sql);
pstmt.setString(1, username);
pstmt.setString(2, password);
ResultSet rs = pstmt.executeQuery();

6.3.3 数据库连接的异常处理与日志记录

JDBC 操作中可能出现多种异常，如数据库连接失败、SQL 语法错误、结果集访问越界等。建议统一捕获并记录日志。

import java.sql.*;

public class ExceptionHandlingExample {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/mydb";
        String user = "root";
        String password = "wrong_password"; // 故意错误密码

        try (Connection conn = DriverManager.getConnection(url, user, password)) {
            System.out.println("连接成功");
        } catch (SQLException e) {
            System.err.println("数据库异常: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

建议 ：
- 使用日志框架（如 Log4j、SLF4J）替代 System.out.println
- 对连接、SQL、结果集操作进行详细日志记录，便于排查问题

下一节将围绕“数据库事务管理与多线程并发控制”展开，进一步深入JDBC在企业级应用中的实战技巧。

本文还有配套的精品资源，点击获取 menu-r.4af5f7ec.gif

简介：Java Web开发涵盖HTTP协议、Servlet、JSP、MVC设计模式、数据库连接、过滤器、监听器及会话管理等核心技术。本资料 javawebppt 以PPT形式系统讲解Java Web开发基础知识，适合初学者全面掌握Web应用开发流程。内容注重理论与实践结合，帮助学习者构建结构清晰、可维护性强的Web应用程序，并掌握服务器端逻辑处理、动态页面生成、用户状态管理等关键技能。


本文还有配套的精品资源，点击获取
menu-r.4af5f7ec.gif

Logo
亚马逊云科技技术品牌专区

更多推荐

cover

生成式AI如何理解企业信息？从实体关系到结构化数据建设实践

avatar 亚马逊云科技技术品牌专区
cover

2026国际物联网连接服务商综合实力排名：企业出海选型参考

avatar 亚马逊云科技技术品牌专区

精选出海通信AI创业资源：Twilio扶持计划解析

同时关注演示在细节处理上的精细度，以及是否具备突出的亮点，能够彰显企业如何创造性地运用新兴技术——如AI、AI代理、LLM及相关平台——结合Twilio在语音、电子邮件、WhatsApp、Conversations、SMS或Segment等渠道上的能力。：清晰展示他们如何使用基于或集成于Twilio平台的新兴技术（语音、身份、生成式AI、对话式AI、LLM驱动代理及其他突破性创新，例如语音、电子邮

avatar 亚马逊云科技技术品牌专区