简介：JSP数据库编程是Java Web开发的重要组成部分，本指南将深入探讨JSP与数据库交互的基础知识、核心技术和最佳实践。通过JDBC，JSP可以连接和操作关系型数据库。本指南将详细讲解如何加载驱动、建立连接、执行SQL、处理结果集和关闭资源。此外，还将介绍JavaBeans、DAO、事务管理、MVC架构、数据库连接池、JNDI和ORM框架等高级特性和最佳实践，帮助读者构建高效、可靠的Web应用。
1. JSP数据库编程简介
JSP（JavaServer Pages）是一种用于创建动态Web页面的技术，它允许开发人员在HTML中嵌入Java代码。JSP数据库编程是使用JSP与数据库交互，实现数据管理功能。
JSP数据库编程的主要优点包括：
- 动态性： JSP可以根据用户输入或数据库数据动态生成Web页面。
- 可重用性： JSP组件可以被重用，减少重复代码。
- 平台独立性： JSP代码可以在任何支持Java的Web服务器上运行。
2. JDBC简介
2.1 JDBC概述
JDBC（Java Database Connectivity）是Java语言中用于数据库连接和操作的标准API。它提供了一组通用的、与数据库无关的接口，允许Java程序访问各种关系型数据库管理系统（RDBMS），如MySQL、Oracle、PostgreSQL等。
JDBC通过JDBC驱动程序实现与不同数据库的连接。JDBC驱动程序是一个特定于数据库的软件组件，负责将JDBC API调用转换为数据库特定的协议。
2.2 JDBC架构
JDBC架构主要由以下组件组成：
- JDBC API： 提供了一组用于连接、执行SQL语句和处理结果集的接口和类。
- JDBC驱动程序： 实现JDBC API，并负责与特定数据库进行通信。
- 数据库： 存储和管理数据的目标系统。
2.3 JDBC连接
2.3.1 连接建立
要建立与数据库的连接，需要使用 DriverManager 类。 DriverManager 负责加载和注册JDBC驱动程序，并通过 getConnection() 方法获取数据库连接。
import java.sql.Connection;
import java.sql.DriverManager;
public class JDBCConnection {
public static void main(String[] args) {
// JDBC URL、用户名和密码
String url = "jdbc:mysql://localhost:3306/test";
String user = "root";
String password = "password";
try {
// 加载并注册MySQL驱动程序
Class.forName("com.mysql.cj.jdbc.Driver");
// 获取数据库连接
Connection conn = DriverManager.getConnection(url, user, password);
// 使用连接执行数据库操作
} catch (Exception e) {
e.printStackTrace();
} finally {
// 关闭连接
if (conn != null) {
conn.close();
}
}
}
}
2.3.2 连接参数
getConnection() 方法接受三个参数：
- JDBC URL： 指定数据库的类型、主机、端口和数据库名称。
- 用户名： 连接数据库的用户名。
- 密码： 连接数据库的密码。
2.3.3 连接池
连接池是一种优化数据库连接管理的技术。它维护一个预先配置的数据库连接池，应用程序可以从中获取和释放连接。连接池可以提高性能，减少连接建立和关闭的开销。
2.4 JDBC语句执行
2.4.1 Statement对象
Statement 对象用于执行SQL语句。它提供 execute() 方法，可以执行各种类型的SQL语句，如 SELECT 、 INSERT 、 UPDATE 和 DELETE 。
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
public class JDBCStatement {
public static void main(String[] args) {
// JDBC URL、用户名和密码
String url = "jdbc:mysql://localhost:3306/test";
String user = "root";
String password = "password";
try {
// 获取数据库连接
Connection conn = DriverManager.getConnection(url, user, password);
// 创建Statement对象
Statement stmt = conn.createStatement();
// 执行SQL语句
String sql = "SELECT * FROM users";
stmt.execute(sql);
// 处理结果集
} catch (Exception e) {
e.printStackTrace();
} finally {
// 关闭Statement对象和连接
if (stmt != null) {
stmt.close();
}
if (conn != null) {
conn.close();
}
}
}
}
2.4.2 PreparedStatement对象
PreparedStatement 对象用于执行预编译的SQL语句。预编译可以提高性能，因为它允许数据库在执行前检查和优化SQL语句。
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
public class JDBCPreparedStatement {
public static void main(String[] args) {
// JDBC URL、用户名和密码
String url = "jdbc:mysql://localhost:3306/test";
String user = "root";
String password = "password";
try {
// 获取数据库连接
Connection conn = DriverManager.getConnection(url, user, password);
// 创建PreparedStatement对象
String sql = "SELECT * FROM users WHERE id = ?";
PreparedStatement pstmt = conn.prepareStatement(sql);
// 设置参数
pstmt.setInt(1, 1);
// 执行SQL语句
pstmt.execute();
// 处理结果集
} catch (Exception e) {
e.printStackTrace();
} finally {
// 关闭PreparedStatement对象和连接
if (pstmt != null) {
pstmt.close();
}
if (conn != null) {
conn.close();
}
}
}
}
2.4.3 CallableStatement对象
CallableStatement 对象用于执行存储过程和函数。存储过程和函数是预定义的SQL语句块，可以接受参数并返回结果。
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.CallableStatement;
public class JDBCCallableStatement {
public static void main(String[] args) {
// JDBC URL、用户名和密码
String url = "jdbc:mysql://localhost:3306/test";
String user = "root";
String password = "password";
try {
// 获取数据库连接
Connection conn = DriverManager.getConnection(url, user, password);
// 创建CallableStatement对象
String sql = "{call get_user_info(?)}";
CallableStatement cstmt = conn.prepareCall(sql);
// 设置参数
cstmt.setInt(1, 1);
// 执行存储过程
cstmt.execute();
// 处理结果集
} catch (Exception e) {
e.printStackTrace();
} finally {
// 关闭CallableStatement对象和连接
if (cstmt != null) {
cstmt.close();
}
if (conn != null) {
conn.close();
}
}
}
}
3. 数据库连接建立与关闭
3.1 数据库连接建立
3.1.1 DriverManager连接方式
DriverManager是JDBC中最常用的连接方式，其连接步骤如下：
- 加载JDBC驱动程序：使用
Class.forName()方法加载对应的JDBC驱动程序类。 - 获取数据库连接：使用
DriverManager.getConnection()方法获取数据库连接对象，该方法需要传入数据库连接URL、用户名和密码。
// 加载JDBC驱动程序
Class.forName("com.mysql.jdbc.Driver");
// 获取数据库连接
Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "password");
3.1.2 DataSource连接方式
DataSource是Java EE规范中定义的接口，它提供了获取数据库连接的统一方式。使用DataSource连接数据库的步骤如下：
- 获取DataSource对象：通过JNDI或其他方式获取DataSource对象。
- 获取数据库连接：使用DataSource的
getConnection()方法获取数据库连接对象。
// 获取DataSource对象
DataSource dataSource = (DataSource) new InitialContext().lookup("java:comp/env/jdbc/test");
// 获取数据库连接
Connection conn = dataSource.getConnection();
3.2 数据库连接关闭
数据库连接使用完成后，需要及时关闭以释放资源。关闭连接的步骤如下：
- 关闭结果集：如果存在未关闭的结果集，需要先关闭结果集。
- 关闭Statement：如果存在未关闭的Statement，需要先关闭Statement。
- 关闭连接：使用
Connection.close()方法关闭数据库连接。
// 关闭结果集
ResultSet rs = stmt.executeQuery("select * from test");
rs.close();
// 关闭Statement
Statement stmt = conn.createStatement();
stmt.close();
// 关闭连接
conn.close();
3.3 连接池
连接池是一种管理数据库连接的机制，它可以提高数据库连接的效率和性能。连接池的原理是预先创建一定数量的数据库连接，并将其存储在池中。当应用程序需要连接数据库时，可以从连接池中获取一个可用的连接。使用完连接后，可以将连接归还到连接池中，以便其他应用程序使用。
3.3.1 连接池的优势
使用连接池具有以下优势：
- 提高性能：连接池可以避免频繁创建和销毁数据库连接，从而提高数据库连接的效率。
- 节省资源：连接池可以复用数据库连接，从而减少数据库服务器的负载。
- 提高稳定性：连接池可以保证应用程序始终能够获得可用的数据库连接，从而提高应用程序的稳定性。
3.3.2 连接池的实现
Java中可以使用以下技术实现连接池：
- JDBC连接池： JDBC规范中定义了
javax.sql.DataSource接口，它提供了连接池的功能。 - 第三方连接池： 可以使用第三方连接池库，例如Apache Commons DBCP、HikariCP等。
3.4 JNDI
JNDI（Java Naming and Directory Interface）是一种用于访问命名和目录服务的Java API。在JSP数据库编程中，可以使用JNDI来管理数据库连接。
3.4.1 JNDI的优势
使用JNDI管理数据库连接具有以下优势：
- 集中管理： 可以使用JNDI将数据库连接信息集中存储在命名服务中，从而方便管理和维护。
- 可移植性： JNDI是Java标准，因此可以在不同的平台和应用程序中使用。
- 安全性： JNDI可以提供安全机制，以保护数据库连接信息。
3.4.2 JNDI的实现
在JSP中可以使用以下步骤使用JNDI管理数据库连接：
- 创建JNDI数据源：使用
Context.bind()方法将数据源绑定到JNDI名称。 - 在JSP页面中使用JNDI查找数据源：使用
InitialContext.lookup()方法查找JNDI名称绑定的数据源。 - 获取数据库连接：使用数据源的
getConnection()方法获取数据库连接。
// 创建JNDI数据源
Context ctx = new InitialContext();
ctx.bind("java:comp/env/jdbc/test", dataSource);
// 在JSP页面中使用JNDI查找数据源
DataSource dataSource = (DataSource) new InitialContext().lookup("java:comp/env/jdbc/test");
// 获取数据库连接
Connection conn = dataSource.getConnection();
4. SQL语句执行与结果集处理
4.1 SQL语句执行
4.1.1 Statement接口
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
public class StatementDemo {
public static void main(String[] args) {
// 1. 加载数据库驱动
try {
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
// 2. 获取数据库连接
Connection conn = null;
try {
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "password");
} catch (SQLException e) {
e.printStackTrace();
}
// 3. 创建Statement对象
Statement stmt = null;
try {
stmt = conn.createStatement();
} catch (SQLException e) {
e.printStackTrace();
}
// 4. 执行SQL语句
String sql = "SELECT * FROM user";
try {
stmt.executeQuery(sql);
} catch (SQLException e) {
e.printStackTrace();
}
// 5. 关闭Statement对象
try {
stmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
// 6. 关闭数据库连接
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
代码逻辑逐行解读：
- 第1行： 加载数据库驱动。
- 第5行： 获取数据库连接。
- 第9行： 创建Statement对象。
- 第13行： 执行SQL语句。
- 第17行： 关闭Statement对象。
- 第21行： 关闭数据库连接。
4.1.2 PreparedStatement接口
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
public class PreparedStatementDemo {
public static void main(String[] args) {
// 1. 加载数据库驱动
try {
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
// 2. 获取数据库连接
Connection conn = null;
try {
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "password");
} catch (SQLException e) {
e.printStackTrace();
}
// 3. 创建PreparedStatement对象
String sql = "INSERT INTO user (name, age) VALUES (?, ?)";
PreparedStatement pstmt = null;
try {
pstmt = conn.prepareStatement(sql);
} catch (SQLException e) {
e.printStackTrace();
}
// 4. 设置参数
try {
pstmt.setString(1, "John");
pstmt.setInt(2, 20);
} catch (SQLException e) {
e.printStackTrace();
}
// 5. 执行SQL语句
try {
pstmt.executeUpdate();
} catch (SQLException e) {
e.printStackTrace();
}
// 6. 关闭PreparedStatement对象
try {
pstmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
// 7. 关闭数据库连接
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
代码逻辑逐行解读：
- 第1行： 加载数据库驱动。
- 第5行： 获取数据库连接。
- 第9行： 创建PreparedStatement对象。
- 第13行： 设置参数。
- 第17行： 执行SQL语句。
- 第21行： 关闭PreparedStatement对象。
- 第25行： 关闭数据库连接。
4.2 结果集处理
4.2.1 ResultSet接口
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class ResultSetDemo {
public static void main(String[] args) {
// 1. 加载数据库驱动
try {
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
// 2. 获取数据库连接
Connection conn = null;
try {
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "password");
} catch (SQLException e) {
e.printStackTrace();
}
// 3. 创建Statement对象
Statement stmt = null;
try {
stmt = conn.createStatement();
} catch (SQLException e) {
e.printStackTrace();
}
// 4. 执行SQL语句
String sql = "SELECT * FROM user";
ResultSet rs = null;
try {
rs = stmt.executeQuery(sql);
} catch (SQLException e) {
e.printStackTrace();
}
// 5. 遍历结果集
try {
while (rs.next()) {
int id = rs.getInt("id");
String name = rs.getString("name");
int age = rs.getInt("age");
System.out.println("id=" + id + ", name=" + name + ", age=" + age);
}
} catch (SQLException e) {
e.printStackTrace();
}
// 6. 关闭ResultSet对象
try {
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
// 7. 关闭Statement对象
try {
stmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
// 8. 关闭数据库连接
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
代码逻辑逐行解读：
- 第1行： 加载数据库驱动。
- 第5行： 获取数据库连接。
- 第9行： 创建Statement对象。
- 第13行： 执行SQL语句。
- 第17行： 遍历结果集。
- 第29行： 关闭ResultSet对象。
- 第33行： 关闭Statement对象。
- 第37行： 关闭数据库连接。
5. JavaBeans与DAO
5.1 JavaBeans简介
JavaBeans是Java平台中的一种可重用组件，它遵循特定的设计模式，具有以下特点：
- 可序列化： JavaBeans可以被序列化为字节流，以便在网络上传输或持久化到文件中。
- 属性： JavaBeans可以通过属性访问和修改其内部状态。
- 事件： JavaBeans可以通过事件机制与其他组件通信。
- 定制： JavaBeans可以通过定制来满足特定需求。
JavaBeans广泛应用于GUI开发、数据库交互和业务逻辑处理等领域。
5.2 JavaBeans与数据库交互
JavaBeans可以与数据库交互，实现数据访问和操作。通常的做法是使用JavaBeans封装数据库表中的数据，并通过属性访问和修改数据。
例如，我们可以创建一个 Student JavaBean来表示数据库中的 student 表：
public class Student {
private int id;
private String name;
private int age;
// 省略getter和setter方法
}
5.3 DAO设计模式
DAO（Data Access Object）设计模式是一种用于访问和操作数据库的模式。它将数据库交互逻辑与业务逻辑分离，提高了代码的可维护性和可重用性。
DAO设计模式通常包含以下组件：
- DAO接口： 定义数据库交互的方法。
- DAO实现类： 实现DAO接口，提供具体的数据库交互逻辑。
- 业务逻辑： 使用DAO对象访问和操作数据库。
例如，我们可以创建一个 StudentDAO 接口来定义与 student 表交互的方法：
public interface StudentDAO {
List<Student> findAll();
Student findById(int id);
void insert(Student student);
void update(Student student);
void delete(int id);
}
然后，我们可以创建一个 StudentDAOImpl 类来实现 StudentDAO 接口，提供具体的数据库交互逻辑：
public class StudentDAOImpl implements StudentDAO {
@Override
public List<Student> findAll() {
// 省略数据库交互逻辑
}
@Override
public Student findById(int id) {
// 省略数据库交互逻辑
}
@Override
public void insert(Student student) {
// 省略数据库交互逻辑
}
@Override
public void update(Student student) {
// 省略数据库交互逻辑
}
@Override
public void delete(int id) {
// 省略数据库交互逻辑
}
}
通过使用DAO设计模式，我们可以将数据库交互逻辑与业务逻辑分离，提高代码的可维护性和可重用性。
6. 事务管理
6.1 事务的概念与特性
事务是数据库中的一组操作，这些操作要么全部成功，要么全部失败。事务具有以下特性：
- 原子性 (Atomicity) ：事务中的所有操作要么全部执行，要么全部不执行。
- 一致性 (Consistency) ：事务执行前后，数据库必须处于一致的状态。
- 隔离性 (Isolation) ：一个事务对数据库的修改对其他事务不可见，直到事务提交。
- 持久性 (Durability) ：一旦事务提交，其对数据库的修改将永久保存。
6.2 JDBC事务处理
JDBC提供了 Connection 对象的事务管理方法：
-
setAutoCommit(boolean)：设置是否自动提交事务。 -
commit()：手动提交当前事务。 -
rollback()：手动回滚当前事务。
// 开启事务
connection.setAutoCommit(false);
// 执行操作
try {
// ...
connection.commit();
} catch (SQLException e) {
connection.rollback();
} finally {
// 关闭连接
connection.close();
}
6.3 事务处理中的异常处理
事务处理中可能会出现异常，需要进行异常处理。JDBC提供了以下异常类：
-
SQLException：一般数据库异常。 -
SQLTransactionRollbackException：事务回滚异常。
try {
// 开启事务
connection.setAutoCommit(false);
// 执行操作
try {
// ...
connection.commit();
} catch (SQLException e) {
// 回滚事务
connection.rollback();
throw e;
}
} catch (SQLException e) {
// 关闭连接
connection.close();
throw e;
}
简介：JSP数据库编程是Java Web开发的重要组成部分，本指南将深入探讨JSP与数据库交互的基础知识、核心技术和最佳实践。通过JDBC，JSP可以连接和操作关系型数据库。本指南将详细讲解如何加载驱动、建立连接、执行SQL、处理结果集和关闭资源。此外，还将介绍JavaBeans、DAO、事务管理、MVC架构、数据库连接池、JNDI和ORM框架等高级特性和最佳实践，帮助读者构建高效、可靠的Web应用。
扫一扫
4万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
