JDBC核心技术(下)

短命女 2023-02-25 07:19 6阅读 0赞

### 文章目录 ###

*  JDBC核心技术
 *   *  第6章： 数据库事务
     *   *  6.1 数据库事务介绍
         *  6.2 JDBC事务处理
         *  6.3 事务的ACID属性
         *   *  6.3.1 数据库的并发问题
             *  6.3.2 四种隔离级别
             *  6.3.3 在MySql中设置隔离级别
     *  第7章：DAO及相关实现类
     *   *  【BaseDAO.java】
         *  【CustomerDAO.java】
         *  【CustomerDAOImpl.java】
         *  【Customer.java】
         *  【CustomerDAOImplTest.java】
     *  第8章：数据库连接池
     *   *  8.1 JDBC数据库连接池的必要性
         *  8.2 数据库连接池技术
         *  8.3 多种开源的数据库连接池
         *   *  8.3.1 C3P0数据库连接池
             *  8.3.2 DBCP数据库连接池
             *  8.3.3 Druid（德鲁伊）数据库连接池
     *  第9章：Apache-DBUtils实现CRUD操作
     *   *  9.1 Apache-DBUtils简介
         *  9.2 主要API的使用
         *   *  9.2.1 DbUtils
             *  9.2.2 QueryRunner类
             *  9.2.3 ResultSetHandler接口及实现类
     *  JDBC总结
     *  感谢查阅！！！

# JDBC核心技术 #

## 第6章： 数据库事务 ##

### 6.1 数据库事务介绍 ###

*  **事务：一组逻辑操作单元,使数据从一种状态变换到另一种状态。**
 *  **事务处理（事务操作）：保证所有事务都作为一个工作单元来执行，即使出现了故障，都不能改变这种执行方式。当在一个事务中执行多个操作时，要么所有的事务都被提交(commit)**，那么这些修改就永久地保存下来；要么数据库管理系统将放弃所作的所有修改，整个事务\*\*回滚(rollback)\*\*到最初状态。
 *  为确保数据库中数据的**一致性**，数据的操纵应当是离散的成组的逻辑单元：当它全部完成时，数据的一致性可以保持，而当这个单元中的一部分操作失败，整个事务应全部视为错误，所有从起始点以后的操作应全部回退到开始状态。

### 6.2 JDBC事务处理 ###

*  数据一旦提交，就不可回滚。
 *  数据什么时候意味着提交？
    
     *  **当一个连接对象被创建时，默认情况下是自动提交事务**：每次执行一个 SQL 语句时，如果执行成功，就会向数据库自动提交，而不能回滚。
     *  \*\*关闭数据库连接，数据就会自动的提交。\*\*如果多个操作，每个操作使用的是自己单独的连接，则无法保证事务。即同一个事务的多个操作必须在同一个连接下。
 *  **JDBC程序中为了让多个 SQL 语句作为一个事务执行：**
    
     *  调用 Connection 对象的 **setAutoCommit(false);** 以取消自动提交事务
     *  在所有的 SQL 语句都成功执行后，调用 **commit();** 方法提交事务
     *  在出现异常时，调用 **rollback();** 方法回滚事务
    
    > 若此时 Connection 没有被关闭，还可能被重复使用，则需要恢复其自动提交状态 setAutoCommit(true)。尤其是在使用数据库连接池技术时，执行close()方法前，建议恢复自动提交状态。

【案例：用户AA向用户BB转账100】

![在这里插入图片描述][20200710230918848.png_pic_center]

import java.sql.Connection;
    import java.sql.PreparedStatement;
    import java.sql.SQLException;
    
    import org.junit.Test;
    
    import github.util.JDBCUtil;
    /* * 1.什么叫数据库事务? * 事务:一组逻辑操作单元,使数据从一种状态变换到另一种状态。 * > 一组逻辑操作单元:一个或多个DML操作。 * * 2.事务处理的原则:保证所有事务都作为一个工作单元来执行,即使出现了故障,都不能改变这种执行方式。 * 当在一个事务中执行多个操作时,要么所有的事务都被提交(commit),那么这些修改就永久地保存 * 下来;要么数据库管理系统将放弃所作的所有修改,整个事务回滚(rollback)到最初状态。 * * 3.数据一旦提交,就不可回滚 * * 4.哪些操作会导致数据的自动提交？ * >DDL操作一旦执行,都会自动提交。 * >set autocommit = false 对DDL操作失效 * >DML默认情况下,一旦执行,就会自动提交。 * >我们可以通过set autocommit = false的方式取消DML操作的自动提交。 * >默认在关闭连接时,会自动的提交数据 */
    public class TranTest { 
    	public void update(String sql, Object... args) { // sql中占位符的个数与可变形参的长度相同！
    		Connection conn = null;
    		PreparedStatement ps = null;
    		try { 
    			// 1.获取数据库的连接
    			conn = JDBCUtil.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 { 
    			//修改其为自动提交数据
    			//主要针对于使用数据库连接池的使用
    			try { 
    				conn.setAutoCommit(true);
    			} catch (SQLException e) { 
    				e.printStackTrace();
    			}			
    			// 5.资源的关闭
    			JDBCUtil.closeResource(conn, ps);
    		}
    	}
    
    	/* * 未考虑数据库事务情况下的转账操作 针对于数据表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 testUpdate() { 
    		String sql = "update user_table set balance = balance - 100 where user = ?";
    		update(sql, "AA");
    		
    		// 模拟网络异常
    // System.out.println(10 / 0);
    
    		String sql2 = "update user_table set balance = balance + 100 where user = ?";
    		update(sql2, "BB");
    
    		System.out.println("转账成功!");
    	}
    	
    	//考虑数据库事务后的转账操作
    	public int update(Connection conn,String sql, Object... args) { // sql中占位符的个数与可变形参的长度相同！
    		PreparedStatement ps = null;
    		try { 
    			// 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.资源的关闭
    			JDBCUtil.closeResource(null, ps);
    		}
    		return 0;
    	}
    	
    	@Test
    	public void testUpdateWithTx() { 
    		Connection conn = null;
    		try { 
    			conn = JDBCUtil.getConnection();
    			System.out.println(conn.getAutoCommit());//true
    			//1.取消数据的自动提交
    			conn.setAutoCommit(false);
    			
    			String sql = "update user_table set balance = balance - 100 where user = ?";
    			update(conn,sql, "AA");
    			
    			//模拟网络异常
    // System.out.println(10 / 0);
    			
    			String sql2 = "update user_table set balance = balance + 100 where user = ?";
    			update(conn,sql2, "BB");
    			System.out.println("转账成功!");
    			//2.提交数据
    			conn.commit();
    		} catch (Exception e) { 
    			e.printStackTrace();
    			//3.回滚数据
    			try { 
    				conn.rollback();
    			} catch (SQLException e2) { 
    				e2.printStackTrace();
    			}
    		}finally{ 
    			JDBCUtil.closeResource(conn, null);
    		}
    	}
    }

其中，对数据库操作的方法为：

//考虑数据库事务后的转账操作
    	public int update(Connection conn,String sql, Object... args) { // sql中占位符的个数与可变形参的长度相同！
    		PreparedStatement ps = null;
    		try { 
    			// 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.资源的关闭
    			JDBCUtil.closeResource(null, ps);
    		}
    		return 0;
    	}

### 6.3 事务的ACID属性 ###

1.  **原子性（Atomicity）**  
    原子性是指事务是一个不可分割的工作单位，事务中的操作要么都发生，要么都不发生。
2.  **一致性（Consistency）**  
    事务必须使数据库从一个一致性状态变换到另外一个一致性状态。
3.  **隔离性（Isolation）**  
    事务的隔离性是指一个事务的执行不能被其他事务干扰，即一个事务内部的操作及使用的数据对并发的其他事务是隔离的，并发执行的各个事务之间不能互相干扰。
4.  **持久性（Durability）**  
    持久性是指一个事务一旦被提交，它对数据库中数据的改变就是永久性的，接下来的其他操作和数据库故障不应该对其有任何影响。

#### 6.3.1 数据库的并发问题 ####

*  对于同时运行的多个事务, 当这些事务访问数据库中相同的数据时, 如果没有采取必要的隔离机制, 就会导致各种并发问题:
    
     *  **脏读**: 对于两个事务 T1, T2, T1 读取了已经被 T2 更新但还**没有被提交**的字段。之后, 若 T2 回滚, T1读取的内容就是临时且无效的。
     *  **不可重复读**: 对于两个事务T1, T2, T1 读取了一个字段, 然后 T2 **更新**了该字段。之后, T1再次读取同一个字段, 值就不同了。
     *  **幻读**: 对于两个事务T1, T2, T1 从一个表中读取了一个字段, 然后 T2 在该表中**插入**了一些新的行。之后, 如果 T1 再次读取同一个表, 就会多出几行。
 *  **数据库事务的隔离性**: 数据库系统必须具有隔离并发运行各个事务的能力, 使它们不会相互影响, 避免各种并发问题。
 *  一个事务与其他事务隔离的程度称为隔离级别。数据库规定了多种事务隔离级别, 不同隔离级别对应不同的干扰程度, **隔离级别越高, 数据一致性就越好, 但并发性越弱。**

#### 6.3.2 四种隔离级别 ####

*  数据库提供的4种事务隔离级别：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center]

*  Oracle 支持的 2 种事务隔离级别：**READ COMMITED**, SERIALIZABLE。 Oracle 默认的事务隔离级别为: **READ COMMITED** 。
 *  Mysql 支持 4 种事务隔离级别。Mysql 默认的事务隔离级别为: **REPEATABLE READ。**

#### 6.3.3 在MySql中设置隔离级别 ####

*  每启动一个 mysql 程序, 就会获得一个单独的数据库连接. 每个数据库连接都有一个全局变量 @@tx\_isolation, 表示当前的事务隔离级别。
 *  查看当前的隔离级别:
    
        SELECT @@tx_isolation;
 *  设置当前 mySQL 连接的隔离级别:
    
        set  transaction isolation level read committed;
 *  设置数据库系统的全局的隔离级别:
    
        set global transaction isolation level read committed;
 *  补充操作：
    
     *  创建mysql数据库用户：
        
            create user tom identified by 'abc123';
 *  授予权限
    
        #授予通过网络方式登录的tom用户，对所有库所有表的全部权限，密码设为abc123.
          grant all privileges on *.* to tom@'%'  identified by 'abc123'; 
          
           #给tom用户使用本地命令行方式，授予atguigudb这个库下的所有表的插删改查的权限。
          grant select,insert,delete,update on atguigudb.* to tom@localhost identified by 'abc123';
 *  厉害的mysql自动补全工具

在cmd命令行输入如下命令:
    pip install mycli
        
    等待一会~~~~
        
    进入mysql命令行:
    mycli -uroot -proot;
    
    使用效果如图:

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 1]

*  Java代码演示并设置数据库的隔离级别
 *  User类

public class User { 
    	private String user;
    	private String password;
    	private int balance;
    	public User() { 
    		super();
    	}
    	public User(String user, String password, int balance) { 
    		super();
    		this.user = user;
    		this.password = password;
    		this.balance = balance;
    	}
    	@Override
    	public String toString() { 
    		return "User [user=" + user + ", password=" + password + ", balance=" + balance + "]";
    	}
    	public String getUser() { 
    		return user;
    	}
    	public void setUser(String user) { 
    		this.user = user;
    	}
    	public String getPassword() { 
    		return password;
    	}
    	public void setPassword(String password) { 
    		this.password = password;
    	}
    	public int getBalance() { 
    		return balance;
    	}
    	public void setBalance(int balance) { 
    		this.balance = balance;
    	}
    }

*  方法代码：

import java.lang.reflect.Field;
    import java.sql.Connection;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.ResultSetMetaData;
    
    import org.junit.Test;
    
    import github.util.JDBCUtil;
    
    public class TranTest { 
    	//考虑数据库事务后的转账操作
    	public int update(Connection conn,String sql, Object... args) { // sql中占位符的个数与可变形参的长度相同！
    		PreparedStatement ps = null;
    		try { 
    			// 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.资源的关闭
    			JDBCUtil.closeResource(null, ps);
    		}
    		return 0;
    	}
    	
    	//通用的查询操作,用于返回数据表中的一条记录
    	public <T> T getInstance(Connection conn, Class<T> clazz,String sql, Object... args) { 
    		PreparedStatement ps = null;
    		//执行,结果集
    		ResultSet rs = null;
    		try { 
    			// 2.预编译sql语句,得到PreparedStatement对象
    			ps = conn.prepareStatement(sql);
    			// 3.填充占位符
    			for (int i = 0; i < args.length; i++) { 
    				ps.setObject(i + 1, args[i]);
    			}
    			// 4.执行executeQuery(),得到结果集：ResultSet
    			rs = ps.executeQuery();
    			// 5.得到结果集的元数据:ResultSetMetaData
    			ResultSetMetaData rsmd = rs.getMetaData();
    			// 6.1通过ResultSetMetaData得到columnCount,columnLabel;通过ResultSet得到列值
    			int count = rsmd.getColumnCount();
    			if (rs.next()) { 
    				T t = clazz.newInstance();
    				for (int i = 0; i < count; i++) { 
    					//获取每个列值:通过ResultSet
    					Object value = rs.getObject(i + 1);
    					//获取列的别名:getColumnLabel()
    					String columnLabel = rsmd.getColumnLabel(i + 1);
    					
    					// 6.2通过反射,将t对象指定名className的属性赋值为指定的值value
    					Field field = clazz.getDeclaredField(columnLabel);
    					field.setAccessible(true);
    					field.set(t, value);
    				}
    				return t;
    			} 
    		} catch (Exception e) { 
    			e.printStackTrace();
    		} finally { 	
    			JDBCUtil.closeResource(null, ps, rs);
    		}
    		return null;
    	}
    	
    	@Test
    	public void testTransactionSelect() throws Exception{ 
    		
    		Connection conn = JDBCUtil.getConnection();
    		//获取当前连接的隔离级别
    		System.out.println(conn.getTransactionIsolation());
    		//设置数据库的隔离级别：
    		conn.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);
    		//取消自动提交数据
    		conn.setAutoCommit(false);
    		
    		String sql = "select user,password,balance from user_table where user = ?";
    		User user = getInstance(conn, User.class, sql, "CC");
    		
    		System.out.println(user);
    	}
    	
    	@Test
    	public void testTransactionUpdate() throws Exception{ 
    		Connection conn = JDBCUtil.getConnection();
    		
    		//取消自动提交数据
    		conn.setAutoCommit(false);
    		String sql = "update user_table set balance = ? where user = ?";
    		update(conn, sql, 5000,"CC");
    		
    		Thread.sleep(15000);
    		System.out.println("修改结束");
    	}
    }

## 第7章：DAO及相关实现类 ##

*  DAO：Data Access Object访问数据信息的类和接口，包括了对数据的CRUD（Create、Retrival、Update、Delete），而不包含任何业务相关的信息。有时也称作：BaseDAO
 *  作用：为了实现功能的模块化，更有利于代码的维护和升级。
 *  下面是DAO使用的体现：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 2]

*  层次结构：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 3]

### 【BaseDAO.java】 ###

import java.lang.reflect.Field;
    import java.sql.Connection;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.ResultSetMetaData;
    import java.util.ArrayList;
    import java.util.List;
    
    import github.util.JDBCUtil;
    
    /* * DAO: data(base) access object * 封装了针对于数据表的通用的操作 */
    public class BaseDAO<T> { 
    	private Class<T> clazz = null;
    	
    	// 考虑数据库事务后的转账操作
    	public int update(Connection conn, String sql, Object... args) { // sql中占位符的个数与可变形参的长度相同！
    		PreparedStatement ps = null;
    		try { 
    			// 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.资源的关闭
    			JDBCUtil.closeResource(null, ps);
    		}
    		return 0;
    	}
    
    	// 通用的查询操作,用于返回数据表中的一条记录
    	public T getInstance(Connection conn, String sql, Object... args) { 
    		PreparedStatement ps = null;
    		// 执行,结果集
    		ResultSet rs = null;
    		try { 
    			// 2.预编译sql语句,得到PreparedStatement对象
    			ps = conn.prepareStatement(sql);
    			// 3.填充占位符
    			for (int i = 0; i < args.length; i++) { 
    				ps.setObject(i + 1, args[i]);
    			}
    			// 4.执行executeQuery(),得到结果集：ResultSet
    			rs = ps.executeQuery();
    			// 5.得到结果集的元数据:ResultSetMetaData
    			ResultSetMetaData rsmd = rs.getMetaData();
    			// 6.1通过ResultSetMetaData得到columnCount,columnLabel;通过ResultSet得到列值
    			int count = rsmd.getColumnCount();
    			if (rs.next()) { 
    				T t = clazz.newInstance();
    				for (int i = 0; i < count; i++) { 
    					// 获取每个列值:通过ResultSet
    					Object value = rs.getObject(i + 1);
    					// 获取列的别名:getColumnLabel()
    					String columnLabel = rsmd.getColumnLabel(i + 1);
    
    					// 6.2通过反射,将t对象指定名className的属性赋值为指定的值value
    					Field field = clazz.getDeclaredField(columnLabel);
    					field.setAccessible(true);
    					field.set(t, value);
    				}
    				return t;
    			}
    		} catch (Exception e) { 
    			e.printStackTrace();
    		} finally { 
    			JDBCUtil.closeResource(null, ps, rs);
    		}
    		return null;
    	}
    
    	//返回多条记录
    	public List<T> getForList(Connection conn, String sql, Object... args) { 
    		PreparedStatement ps = null;
    		// 执行,结果集
    		ResultSet rs = null;
    		try { 
    			// 2.预编译sql语句,得到PreparedStatement对象
    			ps = conn.prepareStatement(sql);
    			// 3.填充占位符
    			for (int i = 0; i < args.length; i++) { 
    				ps.setObject(i + 1, args[i]);
    			}
    			// 4.执行executeQuery(),得到结果集：ResultSet
    			rs = ps.executeQuery();
    			// 5.得到结果集的元数据：ResultSetMetaData
    			ResultSetMetaData rsmd = rs.getMetaData();
    			// 6.1通过ResultSetMetaData得到columnCount,columnLabel;通过ResultSet得到列值
    			int count = rsmd.getColumnCount();
    			// 创建集合对象
    			ArrayList<T> list = new ArrayList<T>();
    			while (rs.next()) { 
    				T t = clazz.newInstance();
    				// 处理结果集一行数据中的每一个列:给t对象指定的属性赋值
    				for (int i = 0; i < count; i++) { 
    					// 获取每个列值:通过ResultSet
    					Object value = rs.getObject(i + 1);
    					// 获取列的别名:getColumnLabel()
    					String columnLabel = rsmd.getColumnLabel(i + 1);
    
    					// 6.2通过反射,将t对象指定名className的属性赋值为指定的值value
    					Field field = clazz.getDeclaredField(columnLabel);
    					field.setAccessible(true);
    					field.set(t, value);
    				}
    				list.add(t);
    			}
    			return list;
    		} catch (Exception e) { 
    			e.printStackTrace();
    		} finally { 
    			// 7.关闭资源
    			JDBCUtil.closeResource(null, ps, rs);
    		}
    		return null;
    	}
    	
    	@SuppressWarnings("unchecked")
    	public <E> E getValue(Connection conn,String sql,Object ...args){ 
    		PreparedStatement ps = null;
    		ResultSet rs = null;
    		try { 
    			ps = conn.prepareStatement(sql);
    			for (int i = 0; i < args.length; i++) { 
    				ps.setObject(i + 1, args[i]);
    			}
    			rs = ps.executeQuery();
    			if (rs.next()) { 
    				return (E) rs.getObject(1);
    			} 
    		} catch (Exception e) { 
    			e.printStackTrace();
    		} finally { 			
    			JDBCUtil.closeResource(null, ps,rs);
    		}
    		return null;
    	}
    }

### 【CustomerDAO.java】 ###

import java.sql.Connection;
    import java.util.Date;
    import java.util.List;
    
    import github2.bean.Customer;
    
    //此接口用于规范针对于customers表的常用操作
    public interface CustomerDAO { 
    	//将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);
    }

### 【CustomerDAOImpl.java】 ###

import java.sql.Connection;
    import java.util.Date;
    import java.util.List;
    
    import github2.bean.Customer;
    import github3.dao.BaseDAO;
    import github3.dao.CustomerDAO;
    
    public class CustomerDAOImpl extends BaseDAO<Customer> implements CustomerDAO { 
    
    	@Override
    	public void insert(Connection conn, Customer cust) { 
    		String sql = "insert into customers(name,email,birth)values(?,?,?)";
    		update(conn, sql,cust.getName(),cust.getEmail(),cust.getBirth());
    	}
    
    	@Override
    	public void deleteById(Connection conn, int id) { 
    		String sql = "delete from customers where id = ?";
    		update(conn, sql, id);
    	}
    
    	@Override
    	public void update(Connection conn, Customer cust) { 
    		String sql = "update customers set name = ?,email = ?,birth = ? where id = ?";
    		update(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 = getInstance(conn, sql,id);
    		return customer;
    	}
    
    	@Override
    	public List<Customer> getAll(Connection conn) { 
    		String sql = "select id,name,email,birth from customers";
    		List<Customer> list = getForList(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);
    	}
    }

### 【Customer.java】 ###

import java.util.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 + "]";
    	}
    }

### 【CustomerDAOImplTest.java】 ###

import java.sql.Connection;
    import java.util.Date;
    import java.util.List;
    
    import org.junit.Test;
    
    import github.util.JDBCUtil;
    import github2.bean.Customer;
    import github2.dao.impl.CustomerDAOImpl;
    
    public class CustomerDAOImplTest { 
    	private CustomerDAOImpl dao = new CustomerDAOImpl();
    
    	@Test
    	public void testInsert() { 
    		Connection conn = null;
    		try { 
    			conn = JDBCUtil.getConnection();
    			Customer cust = new Customer(1, "马里奥", "maliao@126.com", new Date(43534646435L));
    			dao.insert(conn, cust);
    			System.out.println("添加成功!");
    		} catch (Exception e) { 
    			e.printStackTrace();
    		} finally { 
    			JDBCUtil.closeResource(conn, null);
    		}
    	}
    
    	@Test
    	public void testDeleteById() { 
    		Connection conn = null;
    		try { 
    			conn = JDBCUtil.getConnection();
    			dao.deleteById(conn, 13);
    
    			System.out.println("删除成功!");
    		} catch (Exception e) { 
    			e.printStackTrace();
    		} finally { 
    			JDBCUtil.closeResource(conn, null);
    		}
    	}
    
    	@Test
    	public void testUpdateConnectionCustomer() { 
    		Connection conn = null;
    		try { 
    			conn = JDBCUtil.getConnection();
    			Customer cust = new Customer(18, "火金", "huojin@126.com", new Date(453465656L));
    			dao.update(conn, cust);
    
    			System.out.println("修改成功!");
    		} catch (Exception e) { 
    			e.printStackTrace();
    		} finally { 
    			JDBCUtil.closeResource(conn, null);
    		}
    	}
    
    	@Test
    	public void testGetCustomerById() { 
    		Connection conn = null;
    		try { 
    			conn = JDBCUtil.getConnection();
    			Customer cust = dao.getCustomerById(conn, 19);
    			System.out.println(cust);
    
    		} catch (Exception e) { 
    			e.printStackTrace();
    		} finally { 
    			JDBCUtil.closeResource(conn, null);
    		}
    	}
    
    	@Test
    	public void testGetAll() { 
    		Connection conn = null;
    		try { 
    			conn = JDBCUtil.getConnection();
    
    			List<Customer> list = dao.getAll(conn);
    			list.forEach(System.out::println);
    
    			System.out.println("");
    		} catch (Exception e) { 
    			e.printStackTrace();
    		} finally { 
    			JDBCUtil.closeResource(conn, null);
    		}
    	}
    
    	@Test
    	public void testGetCount() { 
    		Connection conn = null;
    		try { 
    			conn = JDBCUtil.getConnection();
    			Long count = dao.getCount(conn);
    
    			System.out.println("表中的记录数为:" + count);
    		} catch (Exception e) { 
    			e.printStackTrace();
    		} finally { 
    			JDBCUtil.closeResource(conn, null);
    		}
    	}
    
    	@Test
    	public void testGetMaxBirth() { 
    		Connection conn = null;
    		try { 
    			conn = JDBCUtil.getConnection();
    			Date maxBirth = dao.getMaxBirth(conn);
    
    			System.out.println("最大的生日为:" + maxBirth);
    		} catch (Exception e) { 
    			e.printStackTrace();
    		} finally { 
    			JDBCUtil.closeResource(conn, null);
    		}
    	}
    }

## 第8章：数据库连接池 ##

### 8.1 JDBC数据库连接池的必要性 ###

*  在使用开发基于数据库的web程序时，传统的模式基本是按以下步骤：
    
     *  **在主程序（如servlet、beans）中建立数据库连接**
     *  **进行sql操作**
     *  **断开数据库连接**
 *  这种模式开发，存在的问题:
    
     *  普通的JDBC数据库连接使用 DriverManager 来获取，每次向数据库建立连接的时候都要将 Connection 加载到内存中，再验证用户名和密码(得花费0.05s～1s的时间)。需要数据库连接的时候，就向数据库要求一个，执行完成后再断开连接。这样的方式将会消耗大量的资源和时间。**数据库的连接资源并没有得到很好的重复利用**。若同时有几百人甚至几千人在线，频繁的进行数据库连接操作将占用很多的系统资源，严重的甚至会造成服务器的崩溃。
     *  **对于每一次数据库连接，使用完后都得断开**。否则，如果程序出现异常而未能关闭，将会导致数据库系统中的内存泄漏，最终将导致重启数据库。（回忆：何为Java的内存泄漏？）
     *  **这种开发不能控制被创建的连接对象数**，系统资源会被毫无顾及的分配出去，如连接过多，也可能导致内存泄漏，服务器崩溃。

### 8.2 数据库连接池技术 ###

*  为解决传统开发中的数据库连接问题，可以采用数据库连接池技术。
 *  **数据库连接池的基本思想**：就是为数据库连接建立一个“缓冲池”。预先在缓冲池中放入一定数量的连接，当需要建立数据库连接时，只需从“缓冲池”中取出一个，使用完毕之后再放回去。
 *  **数据库连接池**负责分配、管理和释放数据库连接，它**允许应用程序重复使用一个现有的数据库连接，而不是重新建立一个**。
 *  数据库连接池在初始化时将创建一定数量的数据库连接放到连接池中，这些数据库连接的数量是由**最小数据库连接数来设定**的。无论这些数据库连接是否被使用，连接池都将一直保证至少拥有这么多的连接数量。连接池的**最大数据库连接数量**限定了这个连接池能占有的最大连接数，当应用程序向连接池请求的连接数超过最大连接数量时，这些请求将被加入到等待队列中。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 4]

*  **工作原理：**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 5]

*  **数据库连接池技术的优点**
    
    **1. 资源重用**
    
    由于数据库连接得以重用，避免了频繁创建，释放连接引起的大量性能开销。在减少系统消耗的基础上，另一方面也增加了系统运行环境的平稳性。
    
    **2. 更快的系统反应速度**
    
    数据库连接池在初始化过程中，往往已经创建了若干数据库连接置于连接池中备用。此时连接的初始化工作均已完成。对于业务请求处理而言，直接利用现有可用连接，避免了数据库连接初始化和释放过程的时间开销，从而减少了系统的响应时间
    
    **3. 新的资源分配手段**
    
    对于多应用共享同一数据库的系统而言，可在应用层通过数据库连接池的配置，实现某一应用最大可用数据库连接数的限制，避免某一应用独占所有的数据库资源
    
    **4. 统一的连接管理，避免数据库连接泄漏**
    
    在较为完善的数据库连接池实现中，可根据预先的占用超时设定，强制回收被占用连接，从而避免了常规数据库连接操作中可能出现的资源泄露

### 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快
 *  DataSource 通常被称为数据源，它包含连接池和连接池管理两个部分，习惯上也经常把 DataSource 称为连接池
 *  **DataSource用来取代DriverManager来获取Connection，获取速度快，同时可以大幅度提高数据库访问速度。**
 *  特别注意：
    
     *  数据源和数据库连接不同，数据源无需创建多个，它是产生数据库连接的工厂，因此**整个应用只需要一个数据源即可。**
     *  当数据库访问结束后，程序还是像以前一样关闭数据库连接：conn.close(); 但conn.close()并没有关闭数据库的物理连接，它仅仅把数据库连接释放，归还给了数据库连接池。

#### 8.3.1 C3P0数据库连接池 ####

*  获取连接方式一

import java.sql.Connection;
    
    import org.junit.Test;
    
    import com.mchange.v2.c3p0.ComboPooledDataSource;
    
    public class C3P0 { 
    	@Test
    	public void testGCtion() throws Exception { 
    		// 获取c3p0数据库连接池
    		ComboPooledDataSource cpds = new ComboPooledDataSource();
    		cpds.setDriverClass("com.mysql.jdbc.Driver");
    		cpds.setJdbcUrl("jdbc:mysql://localhost:3306/test");
    		cpds.setUser("root");
    		cpds.setPassword("root");
    		// 通过设置相关的参数,对数据库连接池进行管理：
    		// 设置初始时数据库连接池中的连接数
    		cpds.setInitialPoolSize(10);
    
    		Connection conn = cpds.getConnection();
    		System.out.println(conn);
    
    		// 销毁c3p0数据库连接池
    		// DataSources.destroy( cpds );
    	}
    }

*  获取连接方式二

import java.sql.Connection;
    
    import org.junit.Test;
    
    import com.mchange.v2.c3p0.ComboPooledDataSource;
    
    public class C3P0 { 
    
    	// 方式二:使用配置文件
    	@Test
    	public void testGCtion2() throws Exception { 
    		ComboPooledDataSource cpds = new ComboPooledDataSource("subei");
    		Connection conn = cpds.getConnection();
    		System.out.println(conn);
    	}
    }

其中，src下的配置文件为：【c3p0-config.xml】

<?xml version="1.0" encoding="UTF-8"?>
    <c3p0-config>
    	<named-config name="subei">
    		
    		<property name="user">root</property>
    		<property name="password">root</property>
    		<property name="jdbcUrl">jdbc:mysql:///test</property>
    		<property name="driverClass">com.mysql.jdbc.Driver</property>
    		
    		
    		
    		<property name="acquireIncrement">5</property>
    		
    		<property name="initialPoolSize">5</property>
    		
    		<property name="minPoolSize">5</property>
    		
    		<property name="maxPoolSize">10</property>
    		
    		<property name="maxStatements">20</property>
    		
    		<property name="maxStatementsPerConnection">5</property>
    		
    	</named-config>
    </c3p0-config>

#### 8.3.2 DBCP数据库连接池 ####

*  DBCP 是 Apache 软件基金组织下的开源连接池实现，该连接池依赖该组织下的另一个开源系统：Common-pool。如需使用该连接池实现，应在系统中增加如下两个 jar 文件：
    
     *  Commons-dbcp.jar：连接池的实现
     *  Commons-pool.jar：连接池实现的依赖库
 *  \*\*Tomcat 的连接池正是采用该连接池来实现的。\*\*该数据库连接池既可以与应用服务器整合使用，也可由应用程序独立使用。
 *  数据源和数据库连接不同，数据源无需创建多个，它是产生数据库连接的工厂，因此整个应用只需要一个数据源即可。
 *  当数据库访问结束后，程序还是像以前一样关闭数据库连接：conn.close(); 但上面的代码并没有关闭数据库的物理连接，它仅仅把数据库连接释放，归还给了数据库连接池。
 *  配置属性说明

<table> 
 <thead> 
  <tr> 
   <th>属性</th> 
   <th>默认值</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>initialSize</td> 
   <td>0</td> 
   <td>连接池启动时创建的初始化连接数量</td> 
  </tr> 
  <tr> 
   <td>maxActive</td> 
   <td>8</td> 
   <td>连接池中可同时连接的最大的连接数</td> 
  </tr> 
  <tr> 
   <td>maxIdle</td> 
   <td>8</td> 
   <td>连接池中最大的空闲的连接数，超过的空闲连接将被释放，如果设置为负数表示不限制</td> 
  </tr> 
  <tr> 
   <td>minIdle</td> 
   <td>0</td> 
   <td>连接池中最小的空闲的连接数，低于这个数量会被创建新的连接。该参数越接近maxIdle，性能越好，因为连接的创建和销毁，都是需要消耗资源的；但是不能太大。</td> 
  </tr> 
  <tr> 
   <td>maxWait</td> 
   <td>无限制</td> 
   <td>最大等待时间，当没有可用连接时，连接池等待连接释放的最大时间，超过该时间限制会抛出异常，如果设置-1表示无限等待</td> 
  </tr> 
  <tr> 
   <td>poolPreparedStatements</td> 
   <td>false</td> 
   <td>开启池的Statement是否prepared</td> 
  </tr> 
  <tr> 
   <td>maxOpenPreparedStatements</td> 
   <td>无限制</td> 
   <td>开启池的prepared 后的同时最大连接数</td> 
  </tr> 
  <tr> 
   <td>minEvictableIdleTimeMillis</td> 
   <td></td> 
   <td>连接池中连接，在时间段内一直空闲， 被逐出连接池的时间</td> 
  </tr> 
  <tr> 
   <td>removeAbandonedTimeout</td> 
   <td>300</td> 
   <td>超过时间限制，回收没有用(废弃)的连接</td> 
  </tr> 
  <tr> 
   <td>removeAbandoned</td> 
   <td>false</td> 
   <td>超过removeAbandonedTimeout时间后，是否进 行没用连接（废弃）的回收</td> 
  </tr> 
 </tbody> 
</table>

*  获取连接方式一：

import java.sql.Connection;
    
    import org.apache.commons.dbcp.BasicDataSource;
    import org.junit.Test;
    
    public class DBCPTest { 
    	/** * //方式一:不推荐 * @Description 测试DBCP的数据库连接池技术 * @author subei * @throws Exception * @date 2020年7月10日下午8:06:07 */
    	@Test
    	public void testGCtion() throws Exception { 
    		// 创建了DBCP的数据库连接池
    		BasicDataSource source = new BasicDataSource();
    
    		// 设置基本信息
    		source.setDriverClassName("com.mysql.jdbc.Driver");
    		source.setUrl("jdbc:mysql:///test");
    		source.setUsername("root");
    		source.setPassword("root");
    
    		// 还可以设置其他涉及数据库连接池管理的相关属性:
    		source.setInitialSize(10);
    		source.setMaxActive(10);
    
    		Connection conn = source.getConnection();
    		System.out.println(conn);
    	}
    }

*  获取连接方式二：

// 创建一个DBCP数据库连接池,使用dbcp数据库连接池的配置文件方式，获取数据库的连接
    	private static DataSource source;
    	static { 
    		try { 
    			Properties pros = new Properties();
    			FileInputStream is = new FileInputStream(new File("src/dbcp.properties"));
    			pros.load(is);
    			source = BasicDataSourceFactory.createDataSource(pros);
    		} catch (Exception e) { 
    			e.printStackTrace();
    		}
    	}
    
    	public static Connection getConnection2() throws Exception { 
    
    		Connection conn = source.getConnection();
    
    		return conn;
    	}

*  其中，src下的配置文件为：【dbcp.properties】

driverClassName=com.mysql.jdbc.Driver
    url=jdbc:mysql:///test
    username=root
    password=root
    
    initialSize=10

*  测试类

import java.io.File;
    import java.io.FileInputStream;
    import java.sql.Connection;
    import java.util.Properties;
    
    import javax.sql.DataSource;
    
    import org.apache.commons.dbcp.BasicDataSourceFactory;
    import org.junit.Test;
    
    public class DBCPTest { 
    
    	// 方式二:推荐:使用配置文件
    	@Test
    	public void testGCtion2() throws Exception { 
    		Properties pros = new Properties();
    
    		// 方式1:
    		// InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("dbcp.properties");
    		// 方式2:
    		FileInputStream is = new FileInputStream(new File("src/dbcp.properties"));
    
    		pros.load(is);
    		DataSource source = BasicDataSourceFactory.createDataSource(pros);
    
    		Connection conn = source.getConnection();
    		System.out.println(conn);
    	}
    }

#### 8.3.3 Druid（德鲁伊）数据库连接池 ####

Druid是阿里巴巴开源平台上一个数据库连接池实现，它结合了C3P0、DBCP、Proxool等DB池的优点，同时加入了日志监控，可以很好的监控DB池连接和SQL的执行情况，可以说是针对监控而生的DB连接池，**可以说是目前最好的连接池之一。**

// 使用Druid数据库连接池技术
    	private static DataSource source1;
    	static{ 
    		try { 
    			Properties pros = new Properties();
    			
    			InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("druid.properties");
    			
    			pros.load(is);
    			
    			source1 = DruidDataSourceFactory.createDataSource(pros);
    		} catch (Exception e) { 
    			e.printStackTrace();
    		}
    	}
    	public static Connection getConnection3() throws SQLException{ 
    		Connection conn = source1.getConnection();
    		return conn;
    	}

*  测试类

import java.io.InputStream;
    import java.sql.Connection;
    import java.util.Properties;
    
    import javax.sql.DataSource;
    
    import org.junit.Test;
    
    import com.alibaba.druid.pool.DruidDataSourceFactory;
    
    public class DruidTest { 
    	@Test
    	public void getConnection() throws Exception{ 
    		Properties pros = new Properties();
    		InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("druid.properties");
    		pros.load(is);
    		DataSource source = DruidDataSourceFactory.createDataSource(pros);
    		Connection conn = source.getConnection();
    		System.out.println(conn);
    	}
    }

其中，src下的配置文件为：【druid.properties】

url=jdbc:mysql:///test
    username=root
    password=root
    driverClassName=com.mysql.jdbc.Driver
    
    initialSize=10
    maxActive=10

*  详细配置参数：

<table> 
 <thead> 
  <tr> 
   <th><strong>配置</strong></th> 
   <th><strong>缺省</strong></th> 
   <th><strong>说明</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>name</td> 
   <td></td> 
   <td>配置这个属性的意义在于，如果存在多个数据源，监控的时候可以通过名字来区分开来。 如果没有配置，将会生成一个名字，格式是：”DataSource-” + System.identityHashCode(this)</td> 
  </tr> 
  <tr> 
   <td>url</td> 
   <td></td> 
   <td>连接数据库的url，不同数据库不一样。例如：mysql : jdbc:mysql://10.20.153.104:3306/druid2 oracle : jdbc:oracle:thin:@10.20.149.85:1521:ocnauto</td> 
  </tr> 
  <tr> 
   <td>username</td> 
   <td></td> 
   <td>连接数据库的用户名</td> 
  </tr> 
  <tr> 
   <td>password</td> 
   <td></td> 
   <td>连接数据库的密码。如果你不希望密码直接写在配置文件中，可以使用ConfigFilter。详细看这里：<a href="https://github.com/alibaba/druid/wiki/%E4%BD%BF%E7%94%A8ConfigFilter" rel="nofollow">https://github.com/alibaba/druid/wiki/使用ConfigFilter</a></td> 
  </tr> 
  <tr> 
   <td>driverClassName</td> 
   <td></td> 
   <td>根据url自动识别 这一项可配可不配，如果不配置druid会根据url自动识别dbType，然后选择相应的driverClassName(建议配置下)</td> 
  </tr> 
  <tr> 
   <td>initialSize</td> 
   <td>0</td> 
   <td>初始化时建立物理连接的个数。初始化发生在显示调用init方法，或者第一次getConnection时</td> 
  </tr> 
  <tr> 
   <td>maxActive</td> 
   <td>8</td> 
   <td>最大连接池数量</td> 
  </tr> 
  <tr> 
   <td>maxIdle</td> 
   <td>8</td> 
   <td>已经不再使用，配置了也没效果</td> 
  </tr> 
  <tr> 
   <td>minIdle</td> 
   <td></td> 
   <td>最小连接池数量</td> 
  </tr> 
  <tr> 
   <td>maxWait</td> 
   <td></td> 
   <td>获取连接时最大等待时间，单位毫秒。配置了maxWait之后，缺省启用公平锁，并发效率会有所下降，如果需要可以通过配置useUnfairLock属性为true使用非公平锁。</td> 
  </tr> 
  <tr> 
   <td>poolPreparedStatements</td> 
   <td>false</td> 
   <td>是否缓存preparedStatement，也就是PSCache。PSCache对支持游标的数据库性能提升巨大，比如说oracle。在mysql下建议关闭。</td> 
  </tr> 
  <tr> 
   <td>maxOpenPreparedStatements</td> 
   <td>-1</td> 
   <td>要启用PSCache，必须配置大于0，当大于0时，poolPreparedStatements自动触发修改为true。在Druid中，不会存在Oracle下PSCache占用内存过多的问题，可以把这个数值配置大一些，比如说100</td> 
  </tr> 
  <tr> 
   <td>validationQuery</td> 
   <td></td> 
   <td>用来检测连接是否有效的sql，要求是一个查询语句。如果validationQuery为null，testOnBorrow、testOnReturn、testWhileIdle都不会其作用。</td> 
  </tr> 
  <tr> 
   <td>testOnBorrow</td> 
   <td>true</td> 
   <td>申请连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。</td> 
  </tr> 
  <tr> 
   <td>testOnReturn</td> 
   <td>false</td> 
   <td>归还连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能</td> 
  </tr> 
  <tr> 
   <td>testWhileIdle</td> 
   <td>false</td> 
   <td>建议配置为true，不影响性能，并且保证安全性。申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。</td> 
  </tr> 
  <tr> 
   <td>timeBetweenEvictionRunsMillis</td> 
   <td></td> 
   <td>有两个含义： 1)Destroy线程会检测连接的间隔时间2)testWhileIdle的判断依据，详细看testWhileIdle属性的说明</td> 
  </tr> 
  <tr> 
   <td>numTestsPerEvictionRun</td> 
   <td></td> 
   <td>不再使用，一个DruidDataSource只支持一个EvictionRun</td> 
  </tr> 
  <tr> 
   <td>minEvictableIdleTimeMillis</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>connectionInitSqls</td> 
   <td></td> 
   <td>物理连接初始化的时候执行的sql</td> 
  </tr> 
  <tr> 
   <td>exceptionSorter</td> 
   <td></td> 
   <td>根据dbType自动识别 当数据库抛出一些不可恢复的异常时，抛弃连接</td> 
  </tr> 
  <tr> 
   <td>filters</td> 
   <td></td> 
   <td>属性类型是字符串，通过别名的方式配置扩展插件，常用的插件有： 监控统计用的filter:stat日志用的filter:log4j防御sql注入的filter:wall</td> 
  </tr> 
  <tr> 
   <td>proxyFilters</td> 
   <td></td> 
   <td>类型是List，如果同时配置了filters和proxyFilters，是组合关系，并非替换关系</td> 
  </tr> 
 </tbody> 
</table>

## 第9章：Apache-DBUtils实现CRUD操作 ##

### 9.1 Apache-DBUtils简介 ###

*  commons-dbutils 是 Apache 组织提供的一个开源 JDBC工具类库，它是对JDBC的简单封装，学习成本极低，并且使用dbutils能极大简化jdbc编码的工作量，同时也不会影响程序的性能。
 *  API介绍：
    
     *  org.apache.commons.dbutils.QueryRunner
     *  org.apache.commons.dbutils.ResultSetHandler
     *  工具类：org.apache.commons.dbutils.DbUtils
 *  API包说明：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 6]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 7]

### 9.2 主要API的使用 ###

#### 9.2.1 DbUtils ####

*  DbUtils ：提供如关闭连接、装载JDBC驱动程序等常规工作的工具类，里面的所有方法都是静态的。主要方法如下：
    
     *  **public static void close(…) throws java.sql.SQLException**：　DbUtils类提供了三个重载的关闭方法。这些方法检查所提供的参数是不是NULL，如果不是的话，它们就关闭Connection、Statement和ResultSet。
     *  public static void closeQuietly(…): 这一类方法不仅能在Connection、Statement和ResultSet为NULL情况下避免关闭，还能隐藏一些在程序中抛出的SQLEeception。
     *  public static void commitAndClose(Connection conn)throws SQLException： 用来提交连接的事务，然后关闭连接
     *  public static void commitAndCloseQuietly(Connection conn)： 用来提交连接，然后关闭连接，并且在关闭连接时不抛出SQL异常。
     *  public static void rollback(Connection conn)throws SQLException：允许conn为null，因为方法内部做了判断
     *  public static void rollbackAndClose(Connection conn)throws SQLException
     *  rollbackAndCloseQuietly(Connection)
     *  public static boolean loadDriver(java.lang.String driverClassName)：这一方装载并注册JDBC驱动程序，如果成功就返回true。使用该方法，你不需要捕捉这个异常ClassNotFoundException。

#### 9.2.2 QueryRunner类 ####

*  **该类简单化了SQL查询，它与ResultSetHandler组合在一起使用可以完成大部分的数据库操作，能够大大减少编码量。**
 *  QueryRunner类提供了两个构造器：
    
     *  默认的构造器
     *  需要一个 javax.sql.DataSource 来作参数的构造器
 *  QueryRunner类的主要方法：
    
     *  **更新**
        
         *  public int update(Connection conn, String sql, Object… params) throws SQLException:用来执行一个更新（插入、更新或删除）操作。
         *  …
     *  **插入**
        
         *  public T insert(Connection conn,String sql,ResultSetHandler rsh, Object… params) throws SQLException：只支持INSERT语句，其中 rsh - The handler used to create the result object from the ResultSet of auto-generated keys. 返回值: An object generated by the handler.即自动生成的键值
         *  …
     *  **批处理**
        
         *  public int\[\] batch(Connection conn,String sql,Object\[\]\[\] params)throws SQLException： INSERT, UPDATE, or DELETE语句
         *  public T insertBatch(Connection conn,String sql,ResultSetHandler rsh,Object\[\]\[\] params)throws SQLException：只支持INSERT语句
         *  …
     *  **查询**
        
         *  public Object query(Connection conn, String sql, ResultSetHandler rsh,Object… params) throws SQLException：执行一个查询操作，在这个查询中，对象数组中的每个元素值被用来作为查询语句的置换参数。该方法会自行处理 PreparedStatement 和 ResultSet 的创建和关闭。
         *  …
 *  测试

import java.sql.Connection;
    import java.sql.SQLException;
    
    import org.apache.commons.dbutils.QueryRunner;
    import org.junit.Test;
    
    import github4.util.JDBCUtil;
    
    //commons-dbutils 是 Apache 组织提供的一个开源 JDBC工具类库,封装了针对于数据库的增删改查操作
    public class QueryRunnerTest { 
    	// 测试插入
    	@Test
    	public void testInsert() { 
    		Connection conn = null;
    		try { 
    			QueryRunner runner = new QueryRunner();
    			conn = JDBCUtil.getConnection3();
    			String sql = "insert into customers(name,email,birth)values(?,?,?)";
    			int insertCount = runner.update(conn, sql, "李明", "liming@163.com", "1998-07-08");
    			System.out.println("添加了" + insertCount + "条记录");
    		} catch (SQLException e) { 
    			e.printStackTrace();
    		} finally { 
    			JDBCUtil.closeResource(conn, null);
    		}
    	}
    }

// 测试删除
    @Test
    public void testDelete() throws Exception { 
    	QueryRunner runner = new QueryRunner();
    	Connection conn = JDBCUtil.getConnection3();
    	String sql = "delete from customers where id < ?";
    	int count = runner.update(conn, sql,3);
    
    	System.out.println("删除了" + count + "条记录");
    		
    	JDBCUtil.closeResource(conn, null);
    }

#### 9.2.3 ResultSetHandler接口及实现类 ####

*  该接口用于处理 java.sql.ResultSet，将数据按要求转换为另一种形式。
 *  ResultSetHandler 接口提供了一个单独的方法：Object handle (java.sql.ResultSet .rs)。
 *  接口的主要实现类：
    
     *  ArrayHandler：把结果集中的第一行数据转成对象数组。
     *  ArrayListHandler：把结果集中的每一行数据都转成一个数组，再存放到List中。
     *  \*\*BeanHandler：\*\*将结果集中的第一行数据封装到一个对应的JavaBean实例中。
     *  \*\*BeanListHandler：\*\*将结果集中的每一行数据都封装到一个对应的JavaBean实例中，存放到List里。
     *  ColumnListHandler：将结果集中某一列的数据存放到List中。
     *  KeyedHandler(name)：将结果集中的每一行数据都封装到一个Map里，再把这些map再存到一个map里，其key为指定的key。
     *  \*\*MapHandler：\*\*将结果集中的第一行数据封装到一个Map里，key是列名，value就是对应的值。
     *  \*\*MapListHandler：\*\*将结果集中的每一行数据都封装到一个Map里，然后再存放到List
     *  \*\*ScalarHandler：\*\*查询单个值对象
 *  测试

import java.sql.Connection;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    import java.util.Date;
    import java.util.List;
    import java.util.Map;
    
    import org.apache.commons.dbutils.QueryRunner;
    import org.apache.commons.dbutils.ResultSetHandler;
    import org.apache.commons.dbutils.handlers.BeanHandler;
    import org.apache.commons.dbutils.handlers.BeanListHandler;
    import org.apache.commons.dbutils.handlers.MapHandler;
    import org.apache.commons.dbutils.handlers.MapListHandler;
    import org.apache.commons.dbutils.handlers.ScalarHandler;
    import org.junit.Test;
    
    import github2.bean.Customer;
    import github4.util.JDBCUtil;
    
    //commons-dbutils 是 Apache 组织提供的一个开源 JDBC工具类库,封装了针对于数据库的增删改查操作
    public class QueryRunnerTest { 
    
    	// 测试查询
    	// BeanHander:是ResultSetHandler接口的实现类,用于封装表中的一条记录。
    	@Test
    	public void QueryTest() { 
    		Connection conn = null;
    		try { 
    			QueryRunner runner = new QueryRunner();
    			conn = JDBCUtil.getConnection3();
    			String sql = "select id,name,email,birth from customers where id = ?";
    			BeanHandler<Customer> handler = new BeanHandler<>(Customer.class);
    			Customer customer = runner.query(conn, sql, handler, 25);
    			System.out.println(customer);
    		} catch (Exception e) { 
    			e.printStackTrace();
    		} finally { 
    			JDBCUtil.closeResource(conn, null);
    		}
    	}
    
    	// BeanListHandler:是ResultSetHandler接口的实现类,用于封装表中的多条记录构成的集合。
    	@Test
    	public void QueryTest2() { 
    		Connection conn = null;
    		try { 
    			QueryRunner runner = new QueryRunner();
    			conn = JDBCUtil.getConnection3();
    			String sql = "select id,name,email,birth from customers where id < ?";
    
    			BeanListHandler<Customer> handler = new BeanListHandler<>(Customer.class);
    
    			List<Customer> list = runner.query(conn, sql, handler, 25);
    			list.forEach(System.out::println);
    		} catch (SQLException e) { 
    			e.printStackTrace();
    		} finally { 
    			JDBCUtil.closeResource(conn, null);
    		}
    	}
    
    	// MapHander:是ResultSetHandler接口的实现类，对应表中的一条记录。
    	// 将字段及相应字段的值作为map中的key和value
    	@Test
    	public void QueryTest3() { 
    		Connection conn = null;
    		try { 
    			QueryRunner runner = new QueryRunner();
    			conn = JDBCUtil.getConnection3();
    			String sql = "select id,name,email,birth from customers where id = ?";
    			MapHandler handler = new MapHandler();
    			Map<String, Object> map = runner.query(conn, sql, handler, 25);
    			System.out.println(map);
    		} catch (SQLException e) { 
    			e.printStackTrace();
    		} finally { 
    			JDBCUtil.closeResource(conn, null);
    		}
    	}
    
    	// MapListHander:是ResultSetHandler接口的实现类,对应表中的多条记录。
    	// 将字段及相应字段的值作为map中的key和value。将这些map添加到List中
    	@Test
    	public void QueryTest4() { 
    		Connection conn = null;
    		try { 
    			QueryRunner runner = new QueryRunner();
    			conn = JDBCUtil.getConnection3();
    			String sql = "select id,name,email,birth from customers where id < ?";
    
    			MapListHandler handler = new MapListHandler();
    			List<Map<String, Object>> list = runner.query(conn, sql, handler, 23);
    			list.forEach(System.out::println);
    		} catch (SQLException e) { 
    			e.printStackTrace();
    		} finally { 
    			JDBCUtil.closeResource(conn, null);
    		}
    	}
    
    	// ScalarHandler:用于查询特殊值
    	@Test
    	public void QueryTest5() { 
    		Connection conn = null;
    		try { 
    			QueryRunner runner = new QueryRunner();
    			conn = JDBCUtil.getConnection3();
    			String sql = "select count(*) from customers";
    
    			ScalarHandler handler = new ScalarHandler();
    
    			Long count = (Long) runner.query(conn, sql, handler);
    			System.out.println(count);
    		} catch (SQLException e) { 
    			e.printStackTrace();
    		} finally { 
    			JDBCUtil.closeResource(conn, null);
    		}
    	}
    
    	@Test
    	public void QueryTest6() { 
    		Connection conn = null;
    		try { 
    			QueryRunner runner = new QueryRunner();
    			conn = JDBCUtil.getConnection3();
    			String sql = "select max(birth) from customers";
    
    			ScalarHandler handler = new ScalarHandler();
    			Date maxBirth = (Date) runner.query(conn, sql, handler);
    			System.out.println(maxBirth);
    		} catch (SQLException e) { 
    			e.printStackTrace();
    		} finally { 
    			JDBCUtil.closeResource(conn, null);
    		}
    	}
    
    	// 自定义ResultSetHandler的实现类
    	@Test
    	public void QueryTest7() { 
    		Connection conn = null;
    		try { 
    			QueryRunner runner = new QueryRunner();
    			conn = JDBCUtil.getConnection3();
    
    			String sql = "select id,name,email,birth from customers where id = ?";
    			ResultSetHandler<Customer> handler = new ResultSetHandler<Customer>() { 
    
    				@Override
    				public Customer handle(ResultSet rs) throws SQLException { 
    					// System.out.println("handle");
    					// return null;
    
    					// return new Customer(12, "勾芒", "goumang@163.com", new
    					// Date(234324234324L));
    
    					if (rs.next()) { 
    						int id = rs.getInt("id");
    						String name = rs.getString("name");
    						String email = rs.getString("email");
    						Date birth = rs.getDate("birth");
    						Customer customer = new Customer(id, name, email, birth);
    						return customer;
    					}
    					return null;
    				}
    			};
    			Customer customer = runner.query(conn, sql, handler, 25);
    			System.out.println(customer);
    		} catch (SQLException e) { 
    			e.printStackTrace();
    		} finally { 
    			JDBCUtil.closeResource(conn, null);
    		}
    	}
    }

## JDBC总结 ##

总结
    @Test
    public void testUpdateWithTx() { 
    		
    	Connection conn = null;
    	try { 
    		//1.获取连接的操作（
    		//① 手写的连接：JDBCUtils.getConnection();
    		//② 使用数据库连接池：C3P0;DBCP;Druid
    		//2.对数据表进行一系列CRUD操作
    		//① 使用PreparedStatement实现通用的增删改、查询操作（version 1.0 \ version 2.0)
    //version2.0的增删改public void update(Connection conn,String sql,Object ... args){}
    //version2.0的查询 public <T> T getInstance(Connection conn,Class<T> clazz,String sql,Object ... args){}
    		//② 使用dbutils提供的jar包中提供的QueryRunner类
    			
    		//提交数据
    		conn.commit();	
    	
    	} catch (Exception e) { 
    		e.printStackTrace();
    			
    		try { 
    			//回滚数据
    			conn.rollback();
    		} catch (SQLException e1) { 
    			e1.printStackTrace();
    		}
    
    	}finally{ 
    		//3.关闭连接等操作
    		//① JDBCUtils.closeResource();
    		//② 使用dbutils提供的jar包中提供的DbUtils类提供了关闭的相关操作 
    	}
    }

--------------------

## 感谢查阅！！！ ##

[20200710230918848.png_pic_center]: /images/20230209/0078099252534aeb932cdac867ce43e8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center]: /images/20230209/2e12b59a73c84565ae362e9fe2c01006.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20230209/49a6884652854a50ab0f162318097734.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20230209/78445ca4f6f84804aa14bf0657876ab4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20230209/3f6a1afbbea84f25b0560dc7008c5622.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20230209/f5b18b261ca04a6887d811c8e88b9168.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20230209/167e0ce39ec846a28d6ae02d587c7094.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20230209/406c4db2bb714e6ea599e959b9a3811d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20230209/cea4ce64962a459884d35e6f388e2044.png