JDBC使用
参考：尚硅谷JDBC。
1 JDBC简介
-
JDBC(Java Database Connectivity)是一个独立于特定数据库管理系统、通用的SQL数据库存取和操作的公共接口（一组API），定义了用来访问数据库的标准Java类库，（java.sql,javax.sql）使用这些类库可以以一种标准的方法、方便地访问数据库资源。 -
JDBC为访问不同的数据库提供了一种统一的途径，为开发者屏蔽了一些细节问题。 -
JDBC的目标是使Java程序员使用JDBC可以连接任何提供了JDBC驱动程序的数据库系统，这样就使得程序员无需对特定的数据库系统的特点有过多的了解，从而大大简化和加快了开发过程。 -
如果没有
JDBC，那么Java程序访问数据库时是这样的：
- 有了
JDBC，Java程序访问数据库时是这样的：
-
方便了开发者和厂家的开发。
-
JDBC程序编写步骤：
2 获取数据库连接
-
四要素：
-
Driver接口实现类； -
URL； -
用户名；
-
密码；
-
-
数据库连接的不同方式：
public class ConnectionTest {
// 方式一
@Test
public void testConnection1() throws SQLException {
// 获取Driver实现类对象
Driver driver = new com.mysql.jdbc.Driver();
// url: http://localhost:8080/gmall/keyboard.jpg
// jdbc: mysql:协议
// localhost: ip地址
// 3306: 默认mysql的端口号
// test: test数据库
// String url = "jdbc:mysql://localhost:3306/test"; // 无法连接成功
String url = "jdbc:mysql://localhost:3306/test";
// 将用户名和密码封装在Properties中
Properties info = new Properties();
info.setProperty("user", "root");
info.setProperty("password", "123456");
Connection conn = driver.connect(url, info);
System.out.println(conn);
}
// 方式二：对方式一的迭代:在如下的程序中不出现第三方的api,使得程序具有更好的可移植性
@Test
public void testConnection2() throws Exception {
// 1.获取Driver实现类对象：使用反射
Class clazz = Class.forName("com.mysql.jdbc.Driver");
Driver driver = (Driver) clazz.newInstance();
// 2.提供要连接的数据库
String url = "jdbc:mysql://localhost:3306/test";
// 3.提供连接需要的用户名和密码
Properties info = new Properties();
info.setProperty("user", "root");
info.setProperty("password", "123456");
// 4.获取连接
Connection conn = driver.connect(url, info);
System.out.println(conn);
}
// 方式三：使用DriverManager替换Driver
@Test
public void testConnection3() throws Exception {
// 1.除了 driver, 提供另外三个连接的基本信息：
String url = "jdbc:mysql://localhost:3306/test";
String user = "root";
String password = "123456";
// 2.获取Driver实现类对象：使用反射
Class clazz = Class.forName("com.mysql.jdbc.Driver");
Driver driver = (Driver) clazz.newInstance();
// 3.注册驱动
DriverManager.registerDriver(driver);
// 4.获取连接
Connection conn = DriverManager.getConnection(url, user, password);
System.out.println(conn);
}
// 方式四：可以只是加载驱动，不用显示的注册驱动过了。
@Test
public void testConnection4() throws Exception {
// 1.除了 driver, 提供另外三个连接的基本信息：
String url = "jdbc:mysql://localhost:3306/test";
String user = "root";
String password = "123456";
// 2.加载Driver
// 这一步也可以省略，因为lib\mysql-connector-java-5.1.37-bin.jar!\META-INF\services\java.sql.Driver文件中配置了
// 但是不要省略，因为其他厂家的驱动可能不能省略
Class.forName("com.mysql.jdbc.Driver"); // 加载 mysql 时，com.mysql.jdbc.Driver已经帮助我们注册了驱动
// 3.获取连接
Connection conn = DriverManager.getConnection(url, user, password);
System.out.println(conn);
}
// 方式五(final版)：将数据库连接需要的4个基本信息声明在配置文件中，通过读取配置文件的方式，获取连接
/*
* 此种方式的好处？
* 1.实现了数据与代码的分离。实现了解耦
* 2.如果需要修改配置文件信息，可以避免程序重新打包。
*/
@Test
public void getConnection() throws Exception {
/* 配置文件信息如下：
user=root
password=123456
url=jdbc:mysql://localhost:3306/test?rewriteBatchedStatements=true
driverClass=com.mysql.jdbc.Driver
*/
// 1.读取配置文件中的4个基本信息
InputStream is = ConnectionTest.class.getClassLoader().getResourceAsStream(JDBCUtils.PORPERTYPATH + "jdbc.properties");
Properties pros = new Properties();
pros.load(is);
String user = pros.getProperty("user");
String password = pros.getProperty("password");
String url = pros.getProperty("url");
String driverClass = pros.getProperty("driverClass");
// 2.加载驱动
Class.forName(driverClass);
// 3.获取连接
Connection conn = DriverManager.getConnection(url, user, password);
System.out.println(conn);
}
}
3 实现CRUD操作
3.1 Statement
-
不推荐使用
Statement实现CRUD操作，因为存在如下问题：-
问题一：存在拼串操作，繁琐；
-
问题二：存在SQL注入问题；
-
问题三：无法处理
BLOB数据；
-
-
演示
SQL注入问题：
public class StatementTest {
// 使用Statement的弊端：需要拼写sql语句，并且存在SQL注入的问题
// 如何避免出现sql注入：只要用 PreparedStatement(从Statement扩展而来) 取代 Statement
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("请输入用户名：");
String user = scanner.nextLine();
System.out.print("请输入密码：");
String password = scanner.nextLine();
// user = 1' or
// password = =1 or '1' = '1
// SELECT user,password FROM user_table WHERE user = '' AND password = ''
// SELECT user,password FROM user_table WHERE user = '1' or ' AND password = '=1 or '1' = '1'
String sql = "SELECT user,password FROM user_table WHERE user = '" + user + "' AND password = '" + password + "'";
User returnUser = get(sql, User.class);
if (returnUser != null) {
System.out.println("登录成功");
} else {
System.out.println("用户名不存在或密码错误");
}
}
// 使用Statement实现对数据表的查询操作
public static <T> T get(String sql, Class<T> clazz) {
T t = null;
Connection conn = null;
Statement st = null;
ResultSet rs = null;
try {
// 1.加载配置文件
InputStream is = StatementTest.class.getClassLoader().getResourceAsStream(JDBCUtils.PORPERTYPATH + "jdbc.properties");
Properties pros = new Properties();
pros.load(is);
// 2.读取配置信息
String user = pros.getProperty("user");
String password = pros.getProperty("password");
String url = pros.getProperty("url");
String driverClass = pros.getProperty("driverClass");
// 3.加载驱动
Class.forName(driverClass);
// 4.获取连接
conn = DriverManager.getConnection(url, user, password);
st = conn.createStatement();
rs = st.executeQuery(sql);
// 获取结果集的元数据
ResultSetMetaData rsmd = rs.getMetaData();
// 获取结果集的列数
int columnCount = rsmd.getColumnCount();
if (rs.next()) {
t = clazz.newInstance();
for (int i = 0; i < columnCount; i++) {
// //1. 获取列的名称
// String columnName = rsmd.getColumnName(i+1);
// 1. 获取列的别名
String columnName = rsmd.getColumnLabel(i + 1);
// 2. 根据列名获取对应数据表中的数据
Object columnVal = rs.getObject(columnName);
// 3. 将数据表中得到的数据，封装进对象
Field field = clazz.getDeclaredField(columnName);
field.setAccessible(true);
field.set(t, columnVal);
}
return t;
}
} catch (Exception e) {
e.printStackTrace();
} finally {
// 关闭资源
if (rs != null) {
try {
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if (st != null) {
try {
st.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if (conn != null) {
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
return null;
}
}
3.2 使用PreparedStatement实现CRUD操作
- 使用
Statement或者PreparedStatement进行CRUD操作的流程基本一样，如下图：
-
PreparedStatement介绍：-
可以通过调用
Connection对象的 preparedStatement(String sql) 方法获取PreparedStatement对象； -
PreparedStatement接口是Statement的子接口，它表示一条预编译过的SQL语句； -
PreparedStatement对象所代表的SQL 语句中的参数用问号（?）来表示，调用PreparedStatement对象的setXxx()方法来设置这些参数。setXxx()方法有两个参数，第一个参数是要设置的SQL语句中的参数的索引（从 1 开始），第二个是设置的SQL语句中的参数的值。
-
-
PreparedStatement和Statement的对比：-
代码的可读性和可维护性。
-
PreparedStatement 能最大可能提高性能：
-
DBServer会对预编译语句提供性能优化。因为预编译语句有可能被重复调用，所以语句在被DBServer的编译器编译后的执行代码被缓存下来，那么下次调用时只要是相同的预编译语句就不需要编译，只要将参数直接传入编译过的语句执行代码中就会得到执行。 -
在
Statement语句中,即使是相同操作但因为数据内容不一样，所以整个语句本身不能匹配，没有缓存语句的意义。事实是没有数据库会对普通语句编译后的执行代码缓存。这样每执行一次都要对传入的语句编译一次。 -
(语法检查，语义检查，翻译成二进制命令，缓存)
-
-
PreparedStatement可以防止SQL注入。
-
-
Java与SQL对应数据类型转换表：
| Java类型 | SQL类型 |
|---|---|
| boolean | bit |
| byte | tinyint |
| short | smallint |
| int | integer |
| long | bigint |
| String | char，varchar，longvarchar |
| byte array | binary， var binary |
| java.sql.Date | date |
| java.sql.Time | time |
| java.sql.Timestamp | timestamp |
- 为了方便使用，可以将数据库的连接、释放和
CRUD操作写到一个工具类中，如下：
/**
* Content: 此 utils 自己实现 JDBC
*/
public class JDBCUtils {
// 配置文件路径, DBCP连接池需要 src\\
public static final String PORPERTYPATH = "_0000_study\\_db\\_jdbc\\util\\";
public static final String PORPERTYPATHSRC = "src\\" + PORPERTYPATH;
// 获取数据库的连接
public static Connection getConnection() throws Exception {
// 1.读取配置文件中的4个基本信息
InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream(PORPERTYPATH + "jdbc.properties");
Properties pros = new Properties();
pros.load(is);
String user = pros.getProperty("user");
String password = pros.getProperty("password");
String url = pros.getProperty("url");
String driverClass = pros.getProperty("driverClass");
// 2.加载驱动
Class.forName(driverClass);
// 3.获取连接
Connection conn = DriverManager.getConnection(url, user, password);
return conn;
}
// 关闭 Connection 的操作
public static void closeResource(Connection conn) {
closeResource(conn, null, null);
}
// 关闭 Connection 和 Statement 的操作
public static void closeResource(Connection conn, Statement ps) {
closeResource(conn, ps, null);
}
// 关闭资源操作
public static void closeResource(Connection conn, Statement ps, ResultSet rs) {
try {
if (conn != null)
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
try {
if (ps != null)
ps.close();
} catch (SQLException e) {
e.printStackTrace();
}
try {
if (rs != null)
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
// 通用的增删改操作: 针对不同的操作（增删改），针对不同的表
// 无返回值
public static void update(String sql, Object... args) { // sql中占位符的个数与可变形参的长度相同！
Connection conn = null;
PreparedStatement ps = null;
try {
// 1.获取数据库的连接
conn = JDBCUtils.getConnection();
// 2.预编译sql语句，返回PreparedStatement的实例
ps = conn.prepareStatement(sql);
// 3.填充占位符
for (int i = 0; i < args.length; i++) {
ps.setObject(i + 1, args[i]); // 小心参数声明错误！！
}
// 4.执行
ps.execute();
} catch (Exception e) {
e.printStackTrace();
} finally {
// 5.资源的关闭
JDBCUtils.closeResource(conn, ps);
}
}
// 通用的增删改操作: 针对不同的操作（增删改），针对不同的表
// 有返回值, 返回增删改影响的行数
public static int updateRow(String sql, Object... args) { // sql中占位符的个数与可变形参的长度相同！
Connection conn = null;
PreparedStatement ps = null;
try {
// 1.获取数据库的连接
conn = JDBCUtils.getConnection();
// 2.预编译sql语句，返回PreparedStatement的实例
ps = conn.prepareStatement(sql);
// 3.填充占位符
for (int i = 0; i < args.length; i++) {
ps.setObject(i + 1, args[i]); // 小心参数声明错误！！
}
// 4.执行
/*
* ps.execute():
* 如果执行的是查询操作，有返回结果，则此方法返回true;
* 如果执行的是增、删、改操作，没有返回结果，则此方法返回false.
*/
// 方式一：
// return ps.execute();
// 方式二：
return ps.executeUpdate();
} catch (Exception e) {
e.printStackTrace();
} finally {
// 5.资源的关闭
JDBCUtils.closeResource(conn, ps);
}
return 0;
}
// 针对于不同的表的通用的查询操作，返回表中的一条记录
public static <T> T getInstance(Class<T> clazz, String sql, Object... args) {
Connection conn = null;
PreparedStatement ps = null;
ResultSet rs = null;
try {
// 1.获取数据库的连接
conn = JDBCUtils.getConnection();
// 2.预编译sql语句，返回PreparedStatement的实例
ps = conn.prepareStatement(sql);
// 3.填充占位符
for (int i = 0; i < args.length; i++) {
ps.setObject(i + 1, args[i]);
}
// 4.执行,并返回结果集
rs = ps.executeQuery();
// 获取结果集的元数据: ResultSetMetaData
ResultSetMetaData rsmd = rs.getMetaData();
// 通过 ResultSetMetaData 获取结果集中的列数
int columnCount = rsmd.getColumnCount();
if (rs.next()) {
T t = clazz.newInstance();
// 处理结果集一行数据中的每一个列
for (int i = 0; i < columnCount; i++) {
// 获取列值
Object columValue = rs.getObject(i + 1);
// 获取每个列的列名
// String columnName = rsmd.getColumnName(i + 1);
String columnLabel = rsmd.getColumnLabel(i + 1);
// 给t对象指定的columnName属性，赋值为columValue：通过反射
Field field = clazz.getDeclaredField(columnLabel);
field.setAccessible(true);
field.set(t, columValue);
}
return t;
}
} catch (Exception e) {
e.printStackTrace();
} finally {
// 5.资源的关闭
JDBCUtils.closeResource(conn, ps, rs);
}
return null;
}
// 针对于不同的表的通用的查询操作，返回表中的记录集合
public static <T> List<T> getForList(Class<T> clazz, String sql, Object... args) {
Connection conn = null;
PreparedStatement ps = null;
ResultSet rs = null;
try {
// 1.获取数据库的连接
conn = JDBCUtils.getConnection();
// 2.预编译sql语句，返回PreparedStatement的实例
ps = conn.prepareStatement(sql);
// 3.填充占位符
for (int i = 0; i < args.length; i++) {
ps.setObject(i + 1, args[i]);
}
// 4.执行,并返回结果集
rs = ps.executeQuery();
// 获取结果集的元数据: ResultSetMetaData
ResultSetMetaData rsmd = rs.getMetaData();
// 通过 ResultSetMetaData 获取结果集中的列数
int columnCount = rsmd.getColumnCount();
//创建集合对象
ArrayList<T> list = new ArrayList<>();
while (rs.next()) {
T t = clazz.newInstance();
// 处理结果集一行数据中的每一个列: 给t对象指定的属性赋值
for (int i = 0; i < columnCount; i++) {
// 获取列值
Object columValue = rs.getObject(i + 1);
// 获取每个列的列名
// String columnName = rsmd.getColumnName(i + 1);
String columnLabel = rsmd.getColumnLabel(i + 1);
// 给t对象指定的columnName属性，赋值为columValue：通过反射
Field field = clazz.getDeclaredField(columnLabel);
field.setAccessible(true);
field.set(t, columValue);
}
list.add(t);
}
return list;
} catch (Exception e) {
e.printStackTrace();
} finally {
// 5.资源的关闭
JDBCUtils.closeResource(conn, ps, rs);
}
return null;
}
/*
* 考虑事务之后的更新操作，senior包中才用到这些函数
*/
// 通用的增删改操作---version 2.0 （考虑上事务）
public static int updateRowWithTx(Connection conn, String sql, Object... args) { // sql中占位符的个数与可变形参的长度相同！
PreparedStatement ps = null;
try {
// 1.获取数据库的连接 ---- 此时不需要这一步骤
// 2.预编译sql语句，返回PreparedStatement的实例
ps = conn.prepareStatement(sql);
// 3.填充占位符
for (int i = 0; i < args.length; i++) {
ps.setObject(i + 1, args[i]); // 小心参数声明错误！！
}
// 4.执行
return ps.executeUpdate();
} catch (Exception e) {
e.printStackTrace();
} finally {
// 5.资源的关闭
JDBCUtils.closeResource(null, ps);
}
return 0;
}
// 通用的查询操作，用于返回数据表中的一条记录（version 2.0：考虑上事务）
public static <T> T getInstanceWithTx(Connection conn, Class<T> clazz, String sql, Object... args) {
PreparedStatement ps = null;
ResultSet rs = null;
try {
// 1.获取数据库的连接 ---- 此时不需要这一步骤
// 2.预编译sql语句，返回PreparedStatement的实例
ps = conn.prepareStatement(sql);
// 3.填充占位符
for (int i = 0; i < args.length; i++) {
ps.setObject(i + 1, args[i]);
}
// 4.执行,并返回结果集
rs = ps.executeQuery();
// 获取结果集的元数据: ResultSetMetaData
ResultSetMetaData rsmd = rs.getMetaData();
// 通过 ResultSetMetaData 获取结果集中的列数
int columnCount = rsmd.getColumnCount();
if (rs.next()) {
T t = clazz.newInstance();
// 处理结果集一行数据中的每一个列
for (int i = 0; i < columnCount; i++) {
// 获取列值
Object columValue = rs.getObject(i + 1);
// 获取每个列的列名
// String columnName = rsmd.getColumnName(i + 1);
String columnLabel = rsmd.getColumnLabel(i + 1);
// 给t对象指定的columnName属性，赋值为columValue：通过反射
Field field = clazz.getDeclaredField(columnLabel);
field.setAccessible(true);
field.set(t, columValue);
}
return t;
}
} catch (Exception e) {
e.printStackTrace();
} finally {
// 5.资源的关闭
JDBCUtils.closeResource(null, ps, rs);
}
return null;
}
// 通用的查询操作，用于返回数据表中的记录集合（version 2.0：考虑上事务）
public static <T> List<T> getForListWithTx(Connection conn, Class<T> clazz, String sql, Object... args) {
PreparedStatement ps = null;
ResultSet rs = null;
try {
// 1.获取数据库的连接 ---- 此时不需要这一步骤
// 2.预编译sql语句，返回PreparedStatement的实例
ps = conn.prepareStatement(sql);
// 3.填充占位符
for (int i = 0; i < args.length; i++) {
ps.setObject(i + 1, args[i]);
}
// 4.执行,并返回结果集
rs = ps.executeQuery();
// 获取结果集的元数据: ResultSetMetaData
ResultSetMetaData rsmd = rs.getMetaData();
// 通过 ResultSetMetaData 获取结果集中的列数
int columnCount = rsmd.getColumnCount();
//创建集合对象
ArrayList<T> list = new ArrayList<>();
while (rs.next()) {
T t = clazz.newInstance();
// 处理结果集一行数据中的每一个列: 给t对象指定的属性赋值
for (int i = 0; i < columnCount; i++) {
// 获取列值
Object columValue = rs.getObject(i + 1);
// 获取每个列的列名
// String columnName = rsmd.getColumnName(i + 1);
String columnLabel = rsmd.getColumnLabel(i + 1);
// 给t对象指定的columnName属性，赋值为columValue：通过反射
Field field = clazz.getDeclaredField(columnLabel);
field.setAccessible(true);
field.set(t, columValue);
}
list.add(t);
}
return list;
} catch (Exception e) {
e.printStackTrace();
} finally {
// 5.资源的关闭
JDBCUtils.closeResource(null, ps, rs);
}
return null;
}
// 返回数据库当前会话(Session)的隔离级别
public static String getTransactionIsolation(Connection conn) throws SQLException {
int level = conn.getTransactionIsolation();
switch (level) {
case 0:
return "TRANSACTION_NONE";
case 1:
return "TRANSACTION_READ_UNCOMMITTED";
case 2:
return "TRANSACTION_READ_COMMITTED";
case 4:
return "TRANSACTION_REPEATABLE_READ";
case 8:
return "TRANSACTION_SERIALIZABLE";
}
throw new RuntimeException("Error Transaction Isolation Level!");
}
// 设置数据库的隔离级别，只能更改当前 Session 的隔离级别
public static void setTransactionIsolation(Connection conn, int level) throws SQLException {
conn.setTransactionIsolation(level); // mysql源码中有错误检查
}
// 用于查询特殊值的通用方法 比如：SELECT COUNT(*) FROM user_table;
public static <E> E getValue(Connection conn, String sql, Object... args) {
PreparedStatement ps = null;
ResultSet rs = null;
try {
// 1.获取数据库的连接 ---- 此时不需要这一步骤
// 2.预编译sql语句，返回PreparedStatement的实例
ps = conn.prepareStatement(sql);
// 3.填充占位符
for (int i = 0; i < args.length; i++) {
ps.setObject(i + 1, args[i]);
}
// 4.执行,并返回结果集
rs = ps.executeQuery();
if (rs.next()) {
return (E) rs.getObject(1);
}
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
// 5.资源的关闭
JDBCUtils.closeResource(null, ps, rs);
}
return null;
}
}
4 操作BLOB类型字段
-
BLOB类型-
MySQL中，BLOB是一个二进制大型对象，是一个可以存储大量数据的容器，它能容纳不同大小的数据。 -
插入
BLOB类型的数据必须使用PreparedStatement，因为BLOB类型的数据无法使用字符串拼接写的。 -
MySQL的四种BLOB类型（除了在存储的最大信息量上不同外，他们是等同的）。 -
实际使用中根据需要存入的数据大小定义不同的
BLOB类型。 -
需要注意的是：如果存储的文件过大，数据库的性能会下降。
-
如果在指定了相关的
Blob类型以后，还报错：xxx too large，那么在mysql的安装目录下，找到my.ini文件加上如下的配置参数： max_allowed_packet=16M。同时注意：修改了my.ini文件之后，需要重新启动mysql服务。
-
| 类型 | 大小（单位：字节） |
|---|---|
| TinyBlob | 最大255 |
| Blob | 最大65K |
| MediumBlob | 最大16M |
| LongBlob | 最大4G |
Java代码对Blob的操作演示：
/**
* 测试使用PreparedStatement操作Blob类型的数据
* 对于 mediumblob, 图片大于 1MB, 会抛出 PacketTooBigException, 解决方式：
* 在mysql的安装目录下，找my.ini文件加上如下的配置参数：max_allowed_packet=16M
*/
public class BlobTest {
// 向数据表customers中插入Blob类型的字段
@Test
public void testInsert() throws Exception {
// 1.获取数据库的连接
Connection conn = JDBCUtils.getConnection();
// 2.预编译sql语句，返回PreparedStatement的实例
String sql = "insert into customers(name,email,birth,photo)values(?,?,?,?)";
PreparedStatement ps = conn.prepareStatement(sql);
// 3.填充占位符
ps.setObject(1, "mice");
ps.setObject(2, "mice@qq.com");
ps.setObject(3, "2008-09-08");
String path = "src/友情与爱情.jpg";
FileInputStream is = new FileInputStream(new File(path));
ps.setBlob(4, is);
// 4.执行
ps.execute();
// 5.资源的关闭
JDBCUtils.closeResource(conn, ps);
}
// 查询数据表customers中Blob类型的字段
@Test
public void testQuery() {
Connection conn = null;
PreparedStatement ps = null;
InputStream is = null;
FileOutputStream fos = null;
ResultSet rs = null;
try {
// 1.获取数据库连接
conn = JDBCUtils.getConnection();
// 2.预编译sql语句，返回 PreparedStatement 的实例
String sql = "select id,name,email,birth,photo from customers where id = ?";
ps = conn.prepareStatement(sql);
// 3.填充占位符
ps.setInt(1, 20);
// 4.执行,并返回结果集
rs = ps.executeQuery();
if (rs.next()) {
// // 方式一：
// int id = rs.getInt(1);
// String name = rs.getString(2);
// String email = rs.getString(3);
// Date birth = rs.getDate(4);
// 方式二：
int id = rs.getInt("id");
String name = rs.getString("name");
String email = rs.getString("email");
Date birth = rs.getDate("birth");
Customer cust = new Customer(id, name, email, birth);
System.out.println(cust);
// 将Blob类型的字段下载下来，以文件的方式保存在本地
Blob photo = rs.getBlob("photo");
is = photo.getBinaryStream();
String path = "src/friendshipAndLove.jpg";
fos = new FileOutputStream(path);
byte[] buffer = new byte[1024];
int len;
while ((len = is.read(buffer)) != -1) {
fos.write(buffer, 0, len);
}
}
} catch (Exception e) {
e.printStackTrace();
} finally {
// 5.资源的关闭
try {
if (is != null)
is.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
if (fos != null)
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
JDBCUtils.closeResource(conn, ps, rs);
}
}
}
5 批量插入
-
当需要成批插入或者更新记录时，可以采用
Java的批量更新机制，这一机制允许多条语句一次性提交给数据库批量处理。通常情况下比单独提交处理更有效率。JDBC的批量处理语句包括下面三个方法：
addBatch(String)：添加需要批量处理的SQL语句或是参数；executeBatch()：执行批量处理语句；clearBatch()：清空缓存的数据
-
Java批量插入
/**
* 演示批量插入
* 使用PreparedStatement实现批量数据的操作
* update、delete本身就具有批量操作的效果。
*
* 此时的批量操作，主要指的是批量插入。使用PreparedStatement如何实现更高效的批量插入？
*
* 题目：向goods表中插入20000条数据
* CREATE TABLE goods(
* id INT PRIMARY KEY AUTO_INCREMENT,
* NAME VARCHAR(25)
* );
* 查询 goods 表中记录数量：SELECT COUNT(*) FROM goods;
* 清空 goods 表：TRUNCATE TABLE goods;
* 方式一：使用Statement
* Connection conn = JDBCUtils.getConnection();
* Statement st = conn.createStatement();
* for(int i = 1;i <= 20000;i++){
* String sql = "insert into goods(name)values('name_" + i + "')";
* st.execute(sql);
* }
*/
public class BatchInsertTest {
// 批量插入的方式二：使用PreparedStatement
@Test
public void batchInsertTest1() {
Connection conn = null;
PreparedStatement ps = null;
try {
long start = System.currentTimeMillis();
// 1.获取数据库连接
conn = JDBCUtils.getConnection();
// 2.预编译sql语句，返回PreparedStatement的实例
String sql = "insert into goods(name) values(?)";
ps = conn.prepareStatement(sql);
// 3.填充占位符
for (int i = 1; i <= 20000; i++) {
ps.setObject(1, "name_" + i);
// 4.执行
ps.execute();
}
long end = System.currentTimeMillis();
System.out.println("花费的时间为：" + (end - start) / 1000.0 + "s"); // 20000条数据：30s
} catch (Exception e) {
e.printStackTrace();
} finally {
// 5.资源的关闭
JDBCUtils.closeResource(conn, ps);
}
}
/*
* 批量插入的方式三：
* 1.addBatch()、executeBatch()、clearBatch()
* 2.mysql服务器默认是关闭批处理的，我们需要通过一个参数，让mysql开启批处理的支持。
* ?rewriteBatchedStatements=true 写在配置文件的url后面
* 3.使用更新的mysql 驱动：mysql-connector-java-5.1.37-bin.jar
*/
@Test
public void batchInsertTest2() {
Connection conn = null;
PreparedStatement ps = null;
try {
long start = System.currentTimeMillis();
// 1.获取数据库连接
conn = JDBCUtils.getConnection();
// 2.预编译sql语句，返回PreparedStatement的实例
String sql = "insert into goods(name) values(?)";
ps = conn.prepareStatement(sql);
// 3.填充占位符
for (int i = 1; i <= 1000000; i++) {
ps.setObject(1, "name_" + i);
// (1) "攒"sql
ps.addBatch();
if (i % 500 == 0) {
// 4.执行 (2) 执行batch
ps.executeBatch();
// (3) 清空batch
ps.clearBatch();
}
}
long end = System.currentTimeMillis();
// 2万条数据：0.592s 100万条数据：11.7s
System.out.println("花费的时间为：" + (end - start) / 1000.0 + "s");
} catch (Exception e) {
e.printStackTrace();
} finally {
// 5.资源的关闭
JDBCUtils.closeResource(conn, ps);
}
}
// 批量插入的方式四：设置连接不允许自动提交数据
@Test
public void batchInsertTest3() {
Connection conn = null;
PreparedStatement ps = null;
try {
long start = System.currentTimeMillis();
// 1.获取数据库连接
conn = JDBCUtils.getConnection();
conn.setAutoCommit(false); // 设置不允许自动提交数据
// 2.预编译sql语句，返回PreparedStatement的实例
String sql = "insert into goods(name) values(?)";
ps = conn.prepareStatement(sql);
// 3.填充占位符
for (int i = 1; i <= 1000000; i++) {
ps.setObject(1, "name_" + i);
// (1) "攒"sql
ps.addBatch();
if (i % 500 == 0) {
// 4.执行 (2) 执行batch
ps.executeBatch();
// (3) 清空batch
ps.clearBatch();
}
}
conn.commit(); // 提交数据
long end = System.currentTimeMillis();
// 100万条数据：7.573s
System.out.println("花费的时间为：" + (end - start) / 1000.0 + "s");
} catch (Exception e) {
e.printStackTrace();
} finally {
// 5.资源的关闭
JDBCUtils.closeResource(conn, ps);
}
}
}
6 事务
-
事务：一组逻辑操作单元，使数据从一种一致性状态变换到另一种一致性状态。
-
事务的
ACID原则：-
原子性（Atomicity）
原子性是指事务是一个不可分割的工作单位，事务中的操作要么都发生，要么都不发生。 -
一致性（Consistency）
事务必须使数据库从一个一致性状态变换到另外一个一致性状态。 -
隔离性（Isolation）
事务的隔离性是指一个事务的执行不能被其他事务干扰，即一个事务内部的操作及使用的数据对并发的其他事务是隔离的，并发执行的各个事务之间不能互相干扰。 -
持久性（Durability）
持久性是指一个事务一旦被提交，它对数据库中数据的改变就是永久性的，接下来的其他操作和数据库故障不应该对其有任何影响。
-
-
数据库的并发问题：
-
对于同时运行的多个事务，当这些事务访问数据库中相同的数据时，如果没有采取必要的隔离机制，就会导致各种并发问题：
-
脏读：对于两个事务
T1, T2，T1读取了已经被T2更新但还没有被提交的字段。之后，若T2回滚，T1读取的内容就是临时且无效的。 -
不可重复读：对于两个事务
T1, T2，T1读取了一个字段，然后T2更新了该字段。之后，T1再次读取同一个字段, 值就不同了。 -
幻读：对于两个事务
T1, T2，T1从一个表中读取了一个字段，然后T2在该表中插入了一些新的行。之后，如果T1再次读取同一个表，就会多出几行。
-
-
数据库事务的隔离性：数据库系统必须具有隔离并发运行各个事务的能力，使它们不会相互影响，避免各种并发问题。
-
一个事务与其他事务隔离的程度称为隔离级别。数据库规定了多种事务隔离级别，不同隔离级别对应不同的干扰程度，隔离级别越高，数据一致性就越好，但并发性越弱。
-
-
数据库提供的4种事务隔离级别：
- Oracle 支持的 2 种事务隔离级别：READ COMMITED, SERIALIZABLE。 Oracle 默认的事务隔离级别为: READ COMMITED 。
- Mysql 支持 4 种事务隔离级别。Mysql 默认的事务隔离级别为: REPEATABLE READ。
Java代码演示：
/*
* 1.什么叫数据库事务？
* 事务：一组逻辑操作单元,使数据从一种状态变换到另一种状态。
* > 一组逻辑操作单元：一个或多个DML操作。
*
* 2.事务处理的原则：保证所有事务都作为一个工作单元来执行，即使出现了故障，都不能改变这种执行方式。
* 当在一个事务中执行多个操作时，要么所有的事务都被提交(commit)，那么这些修改就永久地保存
* 下来；要么数据库管理系统将放弃所作的所有修改，整个事务回滚(rollback)到最初状态。
*
* 3.数据一旦提交，就不可回滚
*
* 4.哪些操作会导致数据的自动提交？
* > DDL(Create、Drop、Alter等)操作一旦执行，都会自动提交。
* > set autocommit = false 对DDL操作失效
* > DML(增删改)默认情况下，一旦执行，就会自动提交。
* > 我们可以通过set autocommit = false的方式取消DML操作的自动提交。
* > 默认在关闭连接时，会自动的提交数据
*/
public class TransactionTest {
/*
* 针对于数据表 user_table 来说：
* AA 用户给 BB 用户转账 100
*
* update user_table set balance = balance - 100 where user = 'AA';
* update user_table set balance = balance + 100 where user = 'BB';
*/
@Test
public void testUpdateWithTx() {
Connection conn = null;
try {
// 1.获取数据库的连接
conn = JDBCUtils.getConnection();
conn.setAutoCommit(false); // (1) 取消 DML 语句自动提交
// 2.设置预编译sql语句 (返回PreparedStatement的实例: 在 updateRowWithTx 中有实现)
String sql1 = "update user_table set balance = balance - 100 where user = ?";
JDBCUtils.updateRowWithTx(conn, sql1, "AA");
// // 模拟网络异常
// System.out.println(10 / 0);
String sql2 = "update user_table set balance = balance + 100 where user = ?";
JDBCUtils.updateRowWithTx(conn, sql2, "BB");
System.out.println("转账成功");
// (2) 提交数据
conn.commit();
} catch (Exception e) {
e.printStackTrace();
// (3) 回滚数据
try {
if (conn != null)
conn.rollback();
} catch (SQLException e1) {
e1.printStackTrace();
}
} finally {
// (4) 修改连接 conn 为自动提交数据，这里不写也行，主要是针对数据库连接池的使用
try {
if (conn != null)
conn.setAutoCommit(true);
} catch (SQLException e2) {
e2.printStackTrace();
}
// 5.资源的关闭
JDBCUtils.closeResource(conn);
}
}
// 设置、获取数据库当前会话(Session)的隔离级别
@Test
public void testTransactionIsolationLevel() {
Connection conn = null;
try {
// 获取连接
conn = JDBCUtils.getConnection();
// 设置当前连接 conn 的隔离级别
JDBCUtils.setTransactionIsolation(conn, Connection.TRANSACTION_READ_COMMITTED);
// 获取当前连接 conn 的隔离级别
System.out.println(JDBCUtils.getTransactionIsolation(conn));
} catch (Exception e) {
e.printStackTrace();
} finally {
JDBCUtils.closeResource(conn);
}
}
}
7 综合实例
- 本例子中使用到了4个包，如下图：
-
其中
BaseDao是负责和数据库交互的类。DAO：Data Access Object，访问数据信息的类和接口，包括了对数据的CRUD（Create、Retrival、Update、Delete），而不包含任何业务相关的信息。有时也称作：BaseDao。其作用是：为了实现功能的模块化，更有利于代码的维护和升级。 -
pojo中存放JavaBean，这里面的类对应数据库的表，其实例对象对应表中的一条数据。 -
service中存放对不同表的操作的接口以及实现类，例如ICustomerService规范了对customer表的操作，而CustomerServiceImpl实现了这些操作。CustomerServiceImpl实现了接口ICustomerService，并继承了BaseDao，如下图：
-
test是对上述实现的测试。 -
注意：
Order、IOrderService、OrderServiceImpl是针对另一个表的一套结构。也就是说，每增加一个表，就会增加三个类似的内容。 -
下面是各个类中的内容：
/**
* DAO: data(base) access object
* 封装了针对于数据表的通用的操作
*/
public abstract class BaseDao<T> {
private Class<T> clazz = null;
{
// 获取当前 BaseDAO 的子类继承的父类中的泛型
Type genericSuperclass = this.getClass().getGenericSuperclass();
ParameterizedType paramType = (ParameterizedType) genericSuperclass;
Type[] typeArguments = paramType.getActualTypeArguments(); // 获取了父类的泛型参数
clazz = (Class<T>) typeArguments[0]; // 泛型的第一个参数
}
// 通用的增删改操作---version 2.0 （考虑上事务）
public int updateRowWithTx(Connection conn, String sql, Object... args) { // sql中占位符的个数与可变形参的长度相同！
PreparedStatement ps = null;
try {
// 1.获取数据库的连接 ---- 此时不需要这一步骤
// 2.预编译sql语句，返回PreparedStatement的实例
ps = conn.prepareStatement(sql);
// 3.填充占位符
for (int i = 0; i < args.length; i++) {
ps.setObject(i + 1, args[i]); // 小心参数声明错误！！
}
// 4.执行
return ps.executeUpdate();
} catch (Exception e) {
e.printStackTrace();
} finally {
// 5.资源的关闭
JDBCUtils.closeResource(null, ps);
}
return 0;
}
// 通用的查询操作，用于返回数据表中的一条记录（version 2.0：考虑上事务）
public T getInstanceWithTx(Connection conn, String sql, Object... args) {
PreparedStatement ps = null;
ResultSet rs = null;
try {
// 1.获取数据库的连接 ---- 此时不需要这一步骤
// 2.预编译sql语句，返回PreparedStatement的实例
ps = conn.prepareStatement(sql);
// 3.填充占位符
for (int i = 0; i < args.length; i++) {
ps.setObject(i + 1, args[i]);
}
// 4.执行,并返回结果集
rs = ps.executeQuery();
// 获取结果集的元数据: ResultSetMetaData
ResultSetMetaData rsmd = rs.getMetaData();
// 通过 ResultSetMetaData 获取结果集中的列数
int columnCount = rsmd.getColumnCount();
if (rs.next()) {
T t = clazz.newInstance();
// 处理结果集一行数据中的每一个列
for (int i = 0; i < columnCount; i++) {
// 获取列值
Object columValue = rs.getObject(i + 1);
// 获取每个列的列名
// String columnName = rsmd.getColumnName(i + 1);
String columnLabel = rsmd.getColumnLabel(i + 1);
// 给t对象指定的columnName属性，赋值为columValue：通过反射
Field field = clazz.getDeclaredField(columnLabel);
field.setAccessible(true);
field.set(t, columValue);
}
return t;
}
} catch (Exception e) {
e.printStackTrace();
} finally {
// 5.资源的关闭
JDBCUtils.closeResource(null, ps, rs);
}
return null;
}
// 通用的查询操作，用于返回数据表中的记录集合（version 2.0：考虑上事务）
public List<T> getForListWithTx(Connection conn, String sql, Object... args) {
PreparedStatement ps = null;
ResultSet rs = null;
try {
// 1.获取数据库的连接 ---- 此时不需要这一步骤
// 2.预编译sql语句，返回PreparedStatement的实例
ps = conn.prepareStatement(sql);
// 3.填充占位符
for (int i = 0; i < args.length; i++) {
ps.setObject(i + 1, args[i]);
}
// 4.执行,并返回结果集
rs = ps.executeQuery();
// 获取结果集的元数据: ResultSetMetaData
ResultSetMetaData rsmd = rs.getMetaData();
// 通过 ResultSetMetaData 获取结果集中的列数
int columnCount = rsmd.getColumnCount();
//创建集合对象
ArrayList<T> list = new ArrayList<>();
while (rs.next()) {
T t = clazz.newInstance();
// 处理结果集一行数据中的每一个列: 给t对象指定的属性赋值
for (int i = 0; i < columnCount; i++) {
// 获取列值
Object columValue = rs.getObject(i + 1);
// 获取每个列的列名
// String columnName = rsmd.getColumnName(i + 1);
String columnLabel = rsmd.getColumnLabel(i + 1);
// 给t对象指定的columnName属性，赋值为columValue：通过反射
Field field = clazz.getDeclaredField(columnLabel);
field.setAccessible(true);
field.set(t, columValue);
}
list.add(t);
}
return list;
} catch (Exception e) {
e.printStackTrace();
} finally {
// 5.资源的关闭
JDBCUtils.closeResource(null, ps, rs);
}
return null;
}
// 用于查询特殊值的通用方法 比如：SELECT COUNT(*) FROM user_table;
public <E> E getValue(Connection conn, String sql, Object... args) {
PreparedStatement ps = null;
ResultSet rs = null;
try {
// 1.获取数据库的连接 ---- 此时不需要这一步骤
// 2.预编译sql语句，返回PreparedStatement的实例
ps = conn.prepareStatement(sql);
// 3.填充占位符
for (int i = 0; i < args.length; i++) {
ps.setObject(i + 1, args[i]);
}
// 4.执行,并返回结果集
rs = ps.executeQuery();
if (rs.next()) {
return (E) rs.getObject(1);
}
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
// 5.资源的关闭
JDBCUtils.closeResource(null, ps, rs);
}
return null;
}
}
import java.sql.Date;
/*
* ORM编程思想 （object relational mapping）对象数据映射
* 一个数据表对应一个java类
* 表中的一条记录对应java类的一个对象
* 表中的一个字段对应java类的一个属性
*/
public class Customer {
private int id;
private String name;
private String email;
private Date birth;
public Customer() {
super();
}
public Customer(int id, String name, String email, Date birth) {
super();
this.id = id;
this.name = name;
this.email = email;
this.birth = birth;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public Date getBirth() {
return birth;
}
public void setBirth(Date birth) {
this.birth = birth;
}
@Override
public String toString() {
return "Customer [id=" + id + ", name=" + name + ", email=" + email + ", birth=" + birth + "]";
}
}
import java.sql.Connection;
import java.sql.Date;
import java.util.List;
/**
* 此接口用于规范针对于customers表的常用操作
*/
public interface ICustomerService {
// 将 cust 对象添加到数据库中
void insert(Connection conn, Customer cust);
// 针对指定的id，删除表中的一条记录
void deleteById(Connection conn, int id);
// 针对内存中的 cust 对象，去修改数据表中指定的记录
void update(Connection conn, Customer cust);
// 针对指定的 id 查询得到对应的 Customer 对象
Customer getCustomerById(Connection conn, int id);
// 查询表中的所有记录构成的集合
List<Customer> getAll(Connection conn);
// 返回数据表中的数据的条目数
Long getCount(Connection conn);
// 返回数据表中最大的生日
Date getMaxBirth(Connection conn);
}
import java.sql.Connection;
import java.sql.Date;
import java.util.List;
/**
* ICustomerService规范的实现
*/
public class CustomerServiceImpl extends BaseDao<Customer> implements ICustomerService {
@Override
public void insert(Connection conn, Customer cust) {
String sql = "insert into customers(name,email,birth)values(?,?,?)";
updateRowWithTx(conn, sql, cust.getName(), cust.getEmail(), cust.getBirth());
}
@Override
public void deleteById(Connection conn, int id) {
String sql = "delete from customers where id = ?";
updateRowWithTx(conn, sql, id);
}
@Override
public void update(Connection conn, Customer cust) {
String sql = "update customers set name = ?,email = ?,birth = ? where id = ?";
updateRowWithTx(conn, sql, cust.getName(), cust.getEmail(), cust.getBirth(), cust.getId());
}
@Override
public Customer getCustomerById(Connection conn, int id) {
String sql = "select id,name,email,birth from customers where id = ?";
Customer customer = getInstanceWithTx(conn, sql, id);
return customer;
}
@Override
public List<Customer> getAll(Connection conn) {
String sql = "select id,name,email,birth from customers";
List<Customer> list = getForListWithTx(conn, sql);
return list;
}
@Override
public Long getCount(Connection conn) {
String sql = "select count(*) from customers";
return getValue(conn, sql);
}
@Override
public Date getMaxBirth(Connection conn) {
String sql = "select max(birth) from customers";
return getValue(conn, sql);
}
}
import java.sql.Connection;
import java.sql.Date;
import java.util.List;
/**
* Content: junit 测试
*/
public class CustomerServiceImplTest {
private CustomerServiceImpl dao = new CustomerServiceImpl();
@Test
public void testInsert() {
Connection conn = null;
try {
conn = JDBCUtils.getConnection();
Customer cust = new Customer(1, "于小飞", "xiaofei@126.com", new Date(43534646435L));
dao.insert(conn, cust);
System.out.println("添加成功");
} catch (Exception e) {
e.printStackTrace();
} finally {
JDBCUtils.closeResource(conn, null);
}
}
@Test
public void testDeleteById() {
Connection conn = null;
try {
conn = JDBCUtils.getConnection();
dao.deleteById(conn, 13);
System.out.println("删除成功");
} catch (Exception e) {
e.printStackTrace();
} finally {
JDBCUtils.closeResource(conn, null);
}
}
@Test
public void testUpdateConnectionCustomer() {
Connection conn = null;
try {
conn = JDBCUtils.getConnection();
Customer cust = new Customer(18, "贝多芬", "beiduofen@126.com", new Date(453465656L));
dao.update(conn, cust);
System.out.println("修改成功");
} catch (Exception e) {
e.printStackTrace();
} finally {
JDBCUtils.closeResource(conn, null);
}
}
@Test
public void testGetCustomerById() {
Connection conn = null;
try {
conn = JDBCUtils.getConnection();
Customer cust = dao.getCustomerById(conn, 19);
System.out.println(cust);
} catch (Exception e) {
e.printStackTrace();
} finally {
JDBCUtils.closeResource(conn, null);
}
}
@Test
public void testGetAll() {
Connection conn = null;
try {
conn = JDBCUtils.getConnection();
List<Customer> list = dao.getAll(conn);
list.forEach(System.out::println);
System.out.println("");
} catch (Exception e) {
e.printStackTrace();
} finally {
JDBCUtils.closeResource(conn, null);
}
}
@Test
public void testGetCount() {
Connection conn = null;
try {
conn = JDBCUtils.getConnection();
Long count = dao.getCount(conn);
System.out.println("表中的记录数为：" + count);
} catch (Exception e) {
e.printStackTrace();
} finally {
JDBCUtils.closeResource(conn, null);
}
}
@Test
public void testGetMaxBirth() {
Connection conn = null;
try {
conn = JDBCUtils.getConnection();
Date maxBirth = dao.getMaxBirth(conn);
System.out.println("最大的生日为：" + maxBirth);
} catch (Exception e) {
e.printStackTrace();
} finally {
JDBCUtils.closeResource(conn, null);
}
}
}
8 数据库连接池
8.1 JDBC数据库连接池的必要性
- 在使用开发基于数据库的web程序时，传统的模式基本是按以下步骤：
- 在主程序（如
servlet、beans）中建立数据库连接； - 进行sql操作；
- 断开数据库连接。
- 在主程序（如
- 这种模式开发，存在的问题：
- 普通的
JDBC数据库连接使用DriverManager来获取，每次向数据库建立连接的时候都要将Connection加载到内存中，再验证用户名和密码（得花费0.05s～1s的时间）。这样的方式将会消耗大量的资源和时间。 - 对于每一次数据库连接，使用完后都得断开。否则，如果程序出现异常而未能关闭，将会导致数据库系统中的内存泄漏，最终将导致重启数据库。
- 普通的
8.2 数据库连接池技术
- 为解决传统开发中的数据库连接问题，可以采用数据库连接池技术。
- 数据库连接池的基本思想：就是为数据库连接建立一个“缓冲池”。预先在缓冲池中放入一定数量的连接，当需要建立数据库连接时，只需从“缓冲池”中取出一个，使用完毕之后再放回去。
- 数据库连接池负责分配、管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而不是重新建立一个。
- 数据库连接池在初始化时将创建一定数量的数据库连接放到连接池中，这些数据库连接的数量是由最小数据库连接数来设定的。无论这些数据库连接是否被使用，连接池都将一直保证至少拥有这么多的连接数量。连接池的最大数据库连接数量限定了这个连接池能占有的最大连接数，当应用程序向连接池请求的连接数超过最大连接数量时，这些请求将被加入到等待队列中。
- 数据库连接池技术的优点：
- 资源重用：由于数据库连接得以重用，避免了频繁创建，释放连接引起的大量性能开销。在减少系统消耗的基础上，另一方面也增加了系统运行环境的平稳性。
- 更快的系统反应速度：数据库连接池在初始化过程中，往往已经创建了若干数据库连接置于连接池中备用，此时连接的初始化工作均已完成。对于业务请求处理而言，直接利用现有可用连接，避免了数据库连接初始化和释放过程的时间开销，从而减少了系统的响应时间。
- 新的资源分配手段：对于多应用共享同一数据库的系统而言，可在应用层通过数据库连接池的配置，实现某一应用最大可用数据库连接数的限制，避免某一应用独占所有的数据库资源。
- 统一的连接管理，避免数据库连接泄漏：在较为完善的数据库连接池实现中，可根据预先的占用超时设定，强制回收被占用连接，从而避免了常规数据库连接操作中可能出现的资源泄露。
8.3 多种开源的数据库连接池
JDBC的数据库连接池使用javax.sql.DataSource来表示，DataSource只是一个接口，该接口通常由服务器（Weblogic, WebSphere, Tomcat）提供实现，也有一些开源组织提供实现：- DBCP 是
Apache提供的数据库连接池。tomcat服务器自带dbcp数据库连接池。速度相对c3p0较快，但因自身存在BUG，Hibernate3已不再提供支持。 - C3P0 是一个开源组织提供的一个数据库连接池，速度相对较慢，稳定性还可以。
hibernate官方推荐使用。 - Proxool 是
sourceforge下的一个开源项目数据库连接池，有监控连接池状态的功能，稳定性较c3p0差一点。 - BoneCP 是一个开源组织提供的数据库连接池，速度快。
- Druid 是阿里提供的数据库连接池，据说是集
DBCP 、C3P0 、Proxool优点于一身的数据库连接池，但是速度不确定是否有BoneCP快。
- DBCP 是
DataSource通常被称为数据源，它包含连接池和连接池管理两个部分，习惯上也经常把DataSource称为连接池。- DataSource用来取代DriverManager来获取Connection，获取速度快，同时可以大幅度提高数据库访问速度。
- 特别注意：
- 数据源和数据库连接不同，数据源无需创建多个，它是产生数据库连接的工厂，因此整个应用只需要一个数据源即可。
- 当数据库访问结束后，程序还是像以前一样关闭数据库连接：
conn.close();但conn.close()并没有关闭数据库的物理连接，它仅仅把数据库连接释放，归还给了数据库连接池。
C3P0：
- 配置文件信息（
c3p0-config.xml）：
<?xml version="1.0" encoding="UTF-8" ?>
<c3p0-config>
<named-config name="helloc3p0">
<!-- 提供获取连接的4个基本信息 -->
<property name="driverClass">com.mysql.jdbc.Driver</property>
<property name="jdbcUrl">jdbc:mysql://localhost:3306/test?rewriteBatchedStatements=true</property>
<property name="user">root</property>
<property name="password">123456</property>
<!-- 进行数据库连接池管理的基本信息 -->
<!-- 当数据库连接池中的连接数不够时，c3p0一次性向数据库服务器申请的连接数 -->
<property name="acquireIncrement">5</property>
<!-- c3p0数据库连接池中初始化时的连接数 -->
<property name="initialPoolSize">10</property>
<!-- c3p0数据库连接池维护的最少连接数 -->
<property name="minPoolSize">10</property>
<!-- c3p0数据库连接池维护的最多的连接数 -->
<property name="maxPoolSize">100</property>
<!-- c3p0数据库连接池最多维护的Statement的个数 -->
<property name="maxStatements">50</property>
<!-- 每个连接中可以最多使用的Statement的个数 -->
<property name="maxStatementsPerConnection">2</property>
</named-config>
</c3p0-config>
- 测试代码：
public class C3P0Test {
// 方式一：
@Test
public void testGetConnection() throws Exception {
// 获取c3p0数据库连接池
ComboPooledDataSource cpds = new ComboPooledDataSource();
cpds.setDriverClass("com.mysql.jdbc.Driver"); // loads the jdbc driver
cpds.setJdbcUrl("jdbc:mysql://localhost:3306/test?rewriteBatchedStatements=true");
cpds.setUser("root");
cpds.setPassword("123456");
// 通过设置相关的参数，对数据库连接池进行管理：
// 设置初始时数据库连接池中的连接数
cpds.setInitialPoolSize(10);
Connection conn = cpds.getConnection();
System.out.println(conn);
// // 销毁c3p0数据库连接池
// DataSources.destroy(cpds);
}
// 方式二：使用配置文件
@Test
public void testGetConnection1() throws SQLException {
// 配置文件 c3p0-config.xml 在 idea 中必须位于 resource 中（Resource Root）
ComboPooledDataSource cpds = new ComboPooledDataSource("helloc3p0");
Connection conn = cpds.getConnection();
System.out.println(conn);
}
}
DBCP
- 配置文件信息（
dbcp.properties）：
username=root
password=123456
url=jdbc:mysql://localhost:3306/test?rewriteBatchedStatements=true
driverClassName=com.mysql.jdbc.Driver
initialSize=10
- 测试代码：
/**
* Content: 测试DBCP的数据库连接池技术
*/
public class DBCPTest {
@Test
public void testGetConnection() throws SQLException {
// 创建了DBCP的数据库连接池
BasicDataSource source = new BasicDataSource();
// 设置基本信息
source.setDriverClassName("com.mysql.jdbc.Driver");
source.setUrl("jdbc:mysql://localhost:3306/test?rewriteBatchedStatements=true");
source.setUsername("root");
source.setPassword("123456");
// 还可以设置其他涉及数据库连接池管理的相关属性：
source.setInitialSize(10);
source.setMaxActive(10);
// ......
Connection conn = source.getConnection();
System.out.println(conn);
}
// 方式二：推荐：使用配置文件
@Test
public void testGetConnection1() throws Exception {
Properties pros = new Properties();
// // 方式1：
// InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream(JDBCUtils.PORPERTYPATHSRC + "dbcp.properties");
// 方式2：
FileInputStream is = new FileInputStream(new File(JDBCUtils.PORPERTYPATHSRC + "dbcp.properties"));
pros.load(is);
DataSource source = BasicDataSourceFactory.createDataSource(pros);
Connection conn = source.getConnection();
System.out.println(conn);
}
}
DBCP
- 配置文件信息（
druid.properties）：
username=root
password=123456
url=jdbc:mysql://localhost:3306/test?rewriteBatchedStatements=true
driverClassName=com.mysql.jdbc.Driver
initialSize=10
maxActive=10
- 测试代码：
public class DruidTest {
@Test
public void getConnection() throws Exception {
Properties pros = new Properties();
InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream(JDBCUtils.PORPERTYPATH + "druid.properties");
pros.load(is);
DataSource source = DruidDataSourceFactory.createDataSource(pros);
Connection conn = source.getConnection();
System.out.println(conn);
}
}
9 Apache-DBUtils实现CRUD操作
commons-dbutils是Apache组织提供的一个开源JDBC工具类库，它是对JDBC的简单封装，学习成本极低，并且使用dbutils能极大简化jdbc编码的工作量，同时也不会影响程序的性能。- 使用：
/**
* Content: 此 utils 使用已经提供好的包
*/
public class DataBaseUtils {
// 配置文件路径, DBCP连接池需要 src\\
public static final String PORPERTYPATH = "_0000_study\\_db\\_jdbc\\util\\";
public static final String PORPERTYPATHSRC = "src\\" + PORPERTYPATH;
/*
* 使用 数据库连接池 建立连接
*/
// 使用数据库连接池 C3P0 获取数据库的连接
private static ComboPooledDataSource C3P0source = new ComboPooledDataSource("helloc3p0");
public static Connection getConnectionUsingC3P0() throws Exception {
return C3P0source.getConnection();
}
// 使用数据库连接池 DBCP 获取数据库的连接
private static DataSource DBCPsource;
static {
try {
Properties pros = new Properties();
FileInputStream is = new FileInputStream(new File(DataBaseUtils.PORPERTYPATHSRC + "dbcp.properties"));
pros.load(is);
DBCPsource = BasicDataSourceFactory.createDataSource(pros);
} catch (Exception e) {
e.printStackTrace();
}
}
public static Connection getConnectionUsingDBCP() throws Exception {
return DBCPsource.getConnection();
}
// 使用数据库连接池 Druid 获取数据库的连接
private static DataSource Druidsource;
static {
try {
Properties pros = new Properties();
InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream(DataBaseUtils.PORPERTYPATH + "druid.properties");
pros.load(is);
Druidsource = DruidDataSourceFactory.createDataSource(pros);
} catch (Exception e) {
e.printStackTrace();
}
}
public static Connection getConnectionUsingDruid() throws Exception {
return Druidsource.getConnection();
}
/*
* 关闭连接
*/
public static void closeResource(Connection conn) {
DbUtils.closeQuietly(conn, null, null);
}
public static void closeResource(Connection conn, Statement ps) {
DbUtils.closeQuietly(conn, ps, null);
}
public static void closeResource(Connection conn, Statement ps, ResultSet rs) {
DbUtils.closeQuietly(conn, ps, rs);
}
/*
* 通用的增删改查操作，使用 dbutils 提供的现有类
*/
private static QueryRunner queryRunner = new QueryRunner();
// 通用的增删改操作
public static int updateRowWithTx(Connection conn, String sql, Object... args) {
int count = 0;
try {
count = queryRunner.update(conn, sql, args);
} catch (SQLException throwables) {
throwables.printStackTrace();
}
return count;
}
// 获取一个对象
public static <T> T getInstanceWithTx(Connection conn, Class<T> clazz, String sql, Object... args) {
T t = null;
try {
t = queryRunner.query(conn, sql, new BeanHandler<T>(clazz), args);
} catch (SQLException e) {
e.printStackTrace();
}
return t;
}
// 获取所有对象
public static <T> List<T> getForListWithTx(Connection conn, Class<T> clazz, String sql, Object... args) {
List<T> list = null;
try {
list = queryRunner.query(conn, sql, new BeanListHandler<T>(clazz), args);
} catch (SQLException e) {
e.printStackTrace();
}
return list;
}
// 获取一个查询特殊值方法，专门用来执行像 select count(*)...这样的sql语句
public static Object getValue(Connection conn, String sql, Object... args) {
Object count = 0;
try {
count = queryRunner.query(conn, sql, new ScalarHandler(), args);
} catch (SQLException throwables) {
throwables.printStackTrace();
}
return count;
}
}
补充：创建演示用表对应sql语句
CREATE DATABASE `test`;
USE `test`;
/*Table structure for table `customers` */
DROP TABLE IF EXISTS `customers`;
CREATE TABLE `customers` (
`id` int(10) NOT NULL AUTO_INCREMENT,
`name` varchar(15) DEFAULT NULL,
`email` varchar(20) DEFAULT NULL,
`birth` date DEFAULT NULL,
`photo` mediumblob,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=19 DEFAULT CHARSET=utf8;
/*Data for the table `customers` */
insert into `customers`(`id`,`name`,`email`,`birth`,`photo`) values (1,'汪峰','wf@126.com','2010-02-02',NULL),(2,'王菲','wangf@163.com','1988-12-26',NULL),(3,'林志玲','linzl@gmail.com','1984-06-12',NULL),(4,'汤唯','tangw@sina.com','1986-06-13',NULL),(5,'成龙','Jackey@gmai.com','1955-07-14',NULL),(6,'迪丽热巴','reba@163.com','1983-05-17',NULL),(7,'刘亦菲','liuyifei@qq.com','1991-11-14',NULL),(8,'陈道明','bdf@126.com','2014-01-17',NULL),(10,'周杰伦','zhoujl@sina.com','1979-11-15',NULL),(12,'黎明','LiM@126.com','1998-09-08',NULL),(13,'张学友','zhangxy@126.com','1998-12-21',NULL),(16,'朱茵','zhuyin@126.com','2014-01-16',NULL),(18,'贝多芬','beidf@126.com','2014-01-17',NULL);
/*Table structure for table `examstudent` */
DROP TABLE IF EXISTS `examstudent`;
CREATE TABLE `examstudent` (
`FlowID` int(20) NOT NULL AUTO_INCREMENT,
`Type` int(20) DEFAULT NULL,
`IDCard` varchar(18) DEFAULT NULL,
`ExamCard` varchar(15) DEFAULT NULL,
`StudentName` varchar(20) DEFAULT NULL,
`Location` varchar(20) DEFAULT NULL,
`Grade` int(10) DEFAULT NULL,
PRIMARY KEY (`FlowID`)
) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8;
/*Data for the table `examstudent` */
insert into `examstudent`(`FlowID`,`Type`,`IDCard`,`ExamCard`,`StudentName`,`Location`,`Grade`) values (1,4,'412824195263214584','200523164754000','张锋','郑州',85),(2,4,'222224195263214584','200523164754001','孙朋','大连',56),(3,6,'342824195263214584','200523164754002','刘明','沈阳',72),(4,6,'100824195263214584','200523164754003','赵虎','哈尔滨\r\n',95),(5,4,'454524195263214584','200523164754004','杨丽','北京',64),(6,4,'854524195263214584','200523164754005','王小红','太原',60);
/*Table structure for table `order` */
DROP TABLE IF EXISTS `order`;
CREATE TABLE `order` (
`order_id` int(10) NOT NULL AUTO_INCREMENT,
`order_name` varchar(20) DEFAULT NULL,
`order_date` date DEFAULT NULL,
PRIMARY KEY (`order_id`)
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8;
/*Data for the table `order` */
insert into `order`(`order_id`,`order_name`,`order_date`) values (1,'AA','2010-03-04'),(2,'BB','2000-02-01'),(4,'GG','1994-06-28');
/*Table structure for table `user` */
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(10) NOT NULL,
`password` varchar(15) NOT NULL DEFAULT '123456',
`address` varchar(25) DEFAULT NULL,
`phone` varchar(15) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;
/*Data for the table `user` */
insert into `user`(`id`,`name`,`password`,`address`,`phone`) values (1,'章子怡','qwerty','Beijing','13788658672'),(2,'郭富城','abc123','HongKong','15678909898'),(3,'林志颖','654321','Taiwan','18612124565'),(4,'梁静茹','987654367','malaixiya','18912340998'),(5,'LadyGaGa','123456','America','13012386565');
/*Table structure for table `user_table` */
DROP TABLE IF EXISTS `user_table`;
CREATE TABLE `user_table` (
`user` varchar(20) DEFAULT NULL,
`password` varchar(20) DEFAULT NULL,
`balance` int(20) DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
/*Data for the table `user_table` */
insert into `user_table`(`user`,`password`,`balance`) values ('AA','123456',1000),('BB','654321',1000),('CC','abcd',2000),('DD','abcder',3000);
扫一扫
740
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
