JDBC核心技术总结

01 JDBC概述

1. 数据的持久化:

持久化(persistence)：把数据保存到可掉电式存储设备中以供之后使用。

2. JDBC的理解：

JDBC(Java Database Connectivity)是一个独立于特定数据库管理系统、通用的SQL数据库存取和操作的公共接口（一组API）

简单理解为：JDBC，是SUN提供的一套 API，使用这套API可以实现对具体数据库的操作（获取连接、关闭连接、DML、DDL、DCL)

3.图示理解：

好处：

从开发程序员的角度：不需要关注具体的数据库的细节
数据库厂商：只需要提供标准的具体实现。

4. 数据库的驱动：

数据库厂商针对于JDBC这套接口，提供的具体实现类的集合。
类似：

5.面向接口编程的思想：

JDBC是sun公司提供一套用于数据库操作的接口，java程序员只需要面向这套接口编程即可。
不同的数据库厂商，需要针对这套接口，提供不同实现。不同的实现的集合，即为不同数据库的驱动。

02 数据库的连接

方式一、方式二、方式三、方式四：作为过程存在，了解即可。

方式五：最终版

/**
 * 
 * @Description 获取数据库的连接
 * @author 
 * @date 上午9:11:23
 * @return
 * @throws Exception
 */
public static Connection getConnection() throws Exception {
	// 1.读取配置文件中的4个基本信息
	InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("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;
}

其中，配置文件【jdbc.properties】：此配置文件声明在工程的src下

user=root
password=abc123
url=jdbc:mysql://localhost:3306/test?rewriteBatchedStatements=true
driverClass=com.mysql.jdbc.Driver

JDBCUtils.java

package com.atguigu3.util;


/**
 * 
 * @Description 操作数据库的工具类
 * @author 
 * @version
 * @date 上午9:10:02
 *
 */
public class JDBCUtils {

/**
 * 
 * @Description 获取数据库的连接
 * @author shkstart
 * @date 上午9:11:23
 * @return
 * @throws Exception
 */
public static Connection getConnection() throws Exception {
	// 1.读取配置文件中的4个基本信息
	InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("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;
}
/**
 * 
 * @Description 关闭连接和Statement的操作
 * @author shkstart
 * @date 上午9:12:40
 * @param conn
 * @param ps
 */
public static void closeResource(Connection conn,Statement ps){
	try {
		if(ps != null)
			ps.close();
	} catch (SQLException e) {
		e.printStackTrace();
	}
	try {
		if(conn != null)
			conn.close();
	} catch (SQLException e) {
		e.printStackTrace();
	}
}
/**
 * 
 * @Description 关闭资源操作
 * @author shkstart
 * @date 上午10:21:15
 * @param conn
 * @param ps
 * @param rs
 */
public static void closeResource(Connection conn,Statement ps,ResultSet rs){
	try {
		if(ps != null)
			ps.close();
	} catch (SQLException e) {
		e.printStackTrace();
	}
	try {
		if(conn != null)
			conn.close();
	} catch (SQLException e) {
		e.printStackTrace();
	}
	try {
		if(rs != null)
			rs.close();
	} catch (SQLException e) {
		e.printStackTrace();
	}
}

}

03 Statement接口实现CRUD操作（了解）

增、删、改； 查询

/** 实现对数据表中数据的增删改操作
*/

		public void update(String sql){
			Connection conn = null;
			Statement st = null;
			try {
				//1.获取数据库的连接
				conn = JDBCUtils.getConnection();
		
		//2.创建一个Statement的实例
		st = conn.createStatement();
		
		//3.根据提供的sql语句，执行
		st.execute(sql);
		
	} catch (Exception e) {
		e.printStackTrace();
	}finally{
		//4.资源的关闭
		JDBCUtils.close(conn, st);
	}
}

/*

• 实现对数据表的查询操作。需要使用结果集：ResultSet

*/

public <T> T get(String sql, Class<T> clazz) {// (sql, Customer.class)
		T t = null;

	Connection conn = null;
	Statement st = null;
	ResultSet rs = null;
	try {
		conn = JDBCUtils.getConnection();

		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. 将数据表中得到的数据，封装进对象
				// 注意：反射根据Java中类的属性获取Field对象
				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;
}

04 PreparedStatement替换Statement实现CRUD操作

1.PreparedStatement的理解：

① PreparedStatement 是Statement的子接口
② An object that represents a precompiled SQL statement.
③ 可以解决Statement的sql注入问题，拼串问题

2.使用PreparedStatement实现通用的增、删、改的方法：version 1.0

//通用的增删改操作

public 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);
		
	}
	
	
}

3.使用PreparedStatement实现通用的查询操作：version 1.0
/**

 * 
 * @Description 针对于不同的表的通用的查询操作，返回表中的一条记录
 * @author 
 * @date 上午11:42:23
 * @param clazz
 * @param sql
 * @param args
 * @return
 */
public <T> T getInstance(Class<T> clazz,String sql, Object... args) {
	Connection conn = null;
	PreparedStatement ps = null;
	ResultSet rs = null;
	try {
		conn = JDBCUtils.getConnection();

		ps = conn.prepareStatement(sql);
		for (int i = 0; i < args.length; i++) {
			ps.setObject(i + 1, args[i]);
		}

		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 {
		JDBCUtils.closeResource(conn, ps, rs);

	}

	return null;
}
public <T> List<T> getForList(Class<T> clazz,String sql, Object... args){
	Connection conn = null;
	PreparedStatement ps = null;
	ResultSet rs = null;
	try {
		conn = JDBCUtils.getConnection();

		ps = conn.prepareStatement(sql);
		for (int i = 0; i < args.length; i++) {
			ps.setObject(i + 1, args[i]);
		}

		rs = ps.executeQuery();
		// 获取结果集的元数据 :ResultSetMetaData
		ResultSetMetaData rsmd = rs.getMetaData();
		// 通过ResultSetMetaData获取结果集中的列数
		int columnCount = rsmd.getColumnCount();
		//创建集合对象
		ArrayList<T> list = new ArrayList<T>();
		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 {
		JDBCUtils.closeResource(conn, ps, rs);

	}

	return null;
}

【总结】

两种思想：
面向接口编程的思想

ORM编程思想：（object relational mapping）

• 一个数据表对应一个java类
• 表中的一条记录对应java类的一个对象
• 表中的一个字段对应java类的一个属性

两种技术：

1.使用结果集的元数据：

ResultSetMetaData
getColumnCount():获取列数
getColumnLabel():获取列的别名
说明：如果sql中没给字段其别名，getColumnLabel()获取的就是列名

2. 反射的使用（①创建对应的运行时类的对象 ② 在运行时，动态的调用指定的运行时类的属性、方法）

查询的图示：

05 PreparedStatement操作Blob类型的变量PreparedStatement可以操作Blob类型的变量。

写入操作的方法：setBlob(InputStream is);
读取操作的方法：
Blob blob = getBlob(int index);
InputStream is = blob.getBinaryStream();

具体的insert:
//向数据表customers中插入Blob类型的字段
	@Test
	public void testInsert() throws Exception{
		Connection conn = JDBCUtils.getConnection();
		String sql = "insert into customers(name,email,birth,photo)values(?,?,?,?)";
	
	PreparedStatement ps = conn.prepareStatement(sql);
	
	ps.setObject(1,"袁浩");
	ps.setObject(2, "yuan@qq.com");
	ps.setObject(3,"1992-09-08");
	FileInputStream is = new FileInputStream(new File("girl.jpg"));
	ps.setBlob(4, is);
	
	ps.execute();
	
	JDBCUtils.closeResource(conn, ps);
	
}
具体的query:
//查询数据表customers中Blob类型的字段
	@Test
	public void testQuery(){
		Connection conn = null;
		PreparedStatement ps = null;
		InputStream is = null;
		FileOutputStream fos = null;
		ResultSet rs = null;
		try {
			conn = JDBCUtils.getConnection();
			String sql = "select id,name,email,birth,photo from customers where id = ?";
			ps = conn.prepareStatement(sql);
			ps.setInt(1, 21);
			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();
			fos = new FileOutputStream("zhangyuhao.jpg");
			byte[] buffer = new byte[1024];
			int len;
			while((len = is.read(buffer)) != -1){
				fos.write(buffer, 0, len);
			}
			
		}
	} catch (Exception e) {
		e.printStackTrace();
	}finally{
		
		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);
	}
	
	
}

注意：

06 PreparedStatement实现高效的批量插入

测试使用PreparedStatement实现批量操作：

层次一：使用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);
 }

层次二：使用PreparedStatement替换Statement
略。
层次三：

1.addBatch()、executeBatch()、clearBatch()
2.mysql服务器默认是关闭批处理的，我们需要通过一个参数，让mysql开启批处理的支持。?rewriteBatchedStatements=true 写在配置文件的url后面
3.使用更新的mysql 驱动：mysql-connector-java-5.1.37-bin.jar

层次四：设置连接不允许自动提交数据

最终版的代码体现：
@Test
public void testInsert3() {
Connection conn = null;
PreparedStatement ps = null;
try {

		long start = System.currentTimeMillis();
		
		conn = JDBCUtils.getConnection();
		
		//设置不允许自动提交数据
		conn.setAutoCommit(false);
		
		String sql = "insert into goods(name)values(?)";
		ps = conn.prepareStatement(sql);
		for(int i = 1;i <= 1000000;i++){
			ps.setObject(1, "name_" + i);
			
			//1."攒"sql
			ps.addBatch();
			
			if(i % 500 == 0){
				//2.执行batch
				ps.executeBatch();
				
				//3.清空batch
				ps.clearBatch();
			}
			
		}
		
		//提交数据
		conn.commit();
		
		long end = System.currentTimeMillis();
		
		System.out.println("花费的时间为：" + (end - start));      //20000:83065 -- 565
	} catch (Exception e) {								//1000000:16086 -- 5114
		e.printStackTrace();
	}finally{
		JDBCUtils.closeResource(conn, ps);
		
	}
	
}

总结：PreparedStatement与Statement的异同？
① 指出二者的关系？ 接口 与 子接口的关系
② 开发中，PreparedStatement替换Statement
③ An object that represents a precompiled SQL statement.

07 数据库的事务

1.事务：一组逻辑操作单元,使数据从一种状态变换到另一种状态。

•  > 一组逻辑操作单元：一个或多个DML操作。
  

2.事务处理的原则：

保证所事务都作为一个工作单元来执行，即使出现了故障，都不能改变这种执行方式。当在一个事务中执行多个操作时，要么所有的事务都被提交(commit)，那么这些修改就永久地保存下来；要么数据库管理系统将放弃所作的所有修改，整个事务回滚(rollback)到最初状态。

说明：
1.数据一旦提交，就不可回滚

2.哪些操作会导致数据的自动提交？

•  >DDL操作一旦执行，都会自动提交。
  

•  >set autocommit = false 对DDL操作失效
  

•  >DML默认情况下，一旦执行，就会自动提交。
  

•  >我们可以通过set autocommit = false的方式取消DML操作的自动提交。
  

•  >默认在关闭连接时，会自动的提交数据
  

3.代码的体现：

     @Test
	public void testUpdateWithTx() {
		Connection conn = null;
		try {
			conn = JDBCUtils.getConnection();
			System.out.println(conn.getAutoCommit());//true
			//1.取消数据的自动提交
			conn.setAutoCommit(false);
		
		String sql1 = "update user_table set balance = balance - 100 where user = ?";
		update(conn,sql1, "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 e1) {
			e1.printStackTrace();
		}
	}finally{
		//修改其为自动提交数据
		//主要针对于使用数据库连接池的使用
		try {
			conn.setAutoCommit(true);
		} catch (SQLException e) {
			e.printStackTrace();
		}
		
		JDBCUtils.closeResource(conn, null);
	}
	
}

4.考虑到事务以后，实现的通用的增删改操作： version 2.0

// 通用的增删改操作---version 2.0 （考虑上事务
	public int update(Connection conn,String sql, Object... args) {// sql中占位符的个数与可变形参的长度相同！
		PreparedStatement ps = null;
		try {
			// 1.预编译sql语句，返回PreparedStatement的实例
			ps = conn.prepareStatement(sql);
			// 2.填充占位符
			for (int i = 0; i < args.length; i++) {
				ps.setObject(i + 1, args[i]);// 小心参数声明错误！！
			}
			// 3.执行
			return ps.executeUpdate();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			// 4.资源的关闭
			JDBCUtils.closeResource(null, ps);

		}
		return 0;

	}

考虑到事务以后，实现的通用的查询： version 2.0
//通用的查询操作，用于返回数据表中的一条记录（version 2.0：考虑上事务）
	public <T> T getInstance(Connection conn,Class<T> clazz,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();
		// 获取结果集的元数据 :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 {
		JDBCUtils.closeResource(null, ps, rs);

	}

	return null;
}

08 DAO及其子类

/*
 DAO: data(base) access object
封装了针对于数据表的通用的操作
 */
public abstract class BaseDAO<T> {

private Class<T> clazz = null;

//	public BaseDAO(){
//		
//	}

{	
	//获取当前BaseDAO的子类继承的父类中的泛型
	Type genericSuperclass = this.getClass().getGenericSuperclass();
	ParameterizedType paramType = (ParameterizedType) genericSuperclass;
	
	Type[] typeArguments = paramType.getActualTypeArguments();//获取了父类的泛型参数
	clazz = (Class<T>) typeArguments[0];//泛型的第一个参数
	
}


// 通用的增删改操作---version 2.0 （考虑上事务
public int update(Connection conn, String sql, Object... args) {// sql中占位符的个数与可变形参的长度相同！
	PreparedStatement ps = null;
	try {
		// 1.预编译sql语句，返回PreparedStatement的实例
		ps = conn.prepareStatement(sql);
		// 2.填充占位符
		for (int i = 0; i < args.length; i++) {
			ps.setObject(i + 1, args[i]);// 小心参数声明错误！！
		}
		// 3.执行
		return ps.executeUpdate();
	} catch (Exception e) {
		e.printStackTrace();
	} finally {
		// 4.资源的关闭
		JDBCUtils.closeResource(null, ps);

	}
	return 0;

}

// 通用的查询操作，用于返回数据表中的一条记录（version 2.0：考虑上事务
public T getInstance(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();
		// 获取结果集的元数据 :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 {
		JDBCUtils.closeResource(null, ps, rs);

	}

	return null;
}
// 通用的查询操作，用于返回数据表中的多条记录构成的集合（version 2.0：考虑上事务
public List<T> getForList(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();
		// 获取结果集的元数据 :ResultSetMetaData
		ResultSetMetaData rsmd = rs.getMetaData();
		// 通过ResultSetMetaData获取结果集中的列数
		int columnCount = rsmd.getColumnCount();
		// 创建集合对象
		ArrayList<T> list = new ArrayList<T>();
		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 {
		JDBCUtils.closeResource(null, ps, rs);

	}

	return null;
}
//用于查询特殊值的通用的方法
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 (SQLException e) {
		e.printStackTrace();
	}finally{
		JDBCUtils.closeResource(null, ps, rs);
		
	}
	return null;
	
}	

}

09 数据库连接池

1.传统连接的问题：

2.如何解决传统开发中的数据库连接问题:使用数据库连接池
3.使用数据库连接池的好处：

或自己组织语言：
1.提高程序的响应速度(减少了创建连接相应的时间)
2.降低资源的消耗(可以重复使用已经提供好的连接)
3.便于连接的管理

4.实现的方式：

10 DBUtils提供的jar包实现CRUD操作

导入jar包：

使用现成的jar中的QueryRunner测试增、删、改的操作:
//测试插入
	@Test
	public void testInsert() {
		Connection conn = null;
		try {
			QueryRunner runner = new QueryRunner();
			conn = JDBCUtils.getConnection3();
			String sql = "insert into customers(name,email,birth)values(?,?,?)";
			int insertCount = runner.update(conn, sql, "蔡徐坤","caixukun@126.com","1997-09-08");
			System.out.println("添加了" + insertCount + "条记录");
		} catch (SQLException e) {
			e.printStackTrace();
		}finally{
		
		JDBCUtils.closeResource(conn, null);
	}
	
}

使用现成的jar中的QueryRunner测试查询的操作:

//测试查询
	/*
	 * BeanHander:是ResultSetHandler接口的实现类，用于封装表中的一条记录。
	 */
	@Test
	public void testQuery1(){
		Connection conn = null;
		try {
			QueryRunner runner = new QueryRunner();
			conn = JDBCUtils.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, 23);
			System.out.println(customer);
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally{
			JDBCUtils.closeResource(conn, null);
			
		}
	
}

/*
 * BeanListHandler:是ResultSetHandler接口的实现类，用于封装表中的多条记录构成的集合。
 */
@Test
public void testQuery2() {
	Connection conn = null;
	try {
		QueryRunner runner = new QueryRunner();
		conn = JDBCUtils.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, 23);
		list.forEach(System.out::println);
	} catch (SQLException e) {
		e.printStackTrace();
	}finally{
		
		JDBCUtils.closeResource(conn, null);
	}
	
}

/*
 * MapHander:是ResultSetHandler接口的实现类，对应表中的一条记录。
 * 将字段及相应字段的值作为map中的key和value
 */
@Test
public void testQuery3(){
	Connection conn = null;
	try {
		QueryRunner runner = new QueryRunner();
		conn = JDBCUtils.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, 23);
		System.out.println(map);
	} catch (SQLException e) {
		e.printStackTrace();
	}finally{
		JDBCUtils.closeResource(conn, null);
		
	}
	
}

/*
 * MapListHander:是ResultSetHandler接口的实现类，对应表中的多条记录。
 * 将字段及相应字段的值作为map中的key和value。将这些map添加到List中
 */
@Test
public void testQuery4(){
	Connection conn = null;
	try {
		QueryRunner runner = new QueryRunner();
		conn = JDBCUtils.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{
		JDBCUtils.closeResource(conn, null);
		
	}
	
}
/*
 * ScalarHandler:用于查询特殊值
 */
@Test
public void testQuery5(){
	Connection conn = null;
	try {
		QueryRunner runner = new QueryRunner();
		conn = JDBCUtils.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{
		JDBCUtils.closeResource(conn, null);
		
	}
	
}
@Test
public void testQuery6(){
	Connection conn = null;
	try {
		QueryRunner runner = new QueryRunner();
		conn = JDBCUtils.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{
		JDBCUtils.closeResource(conn, null);
		
	}
	
}

/*
 * 自定义ResultSetHandler的实现类
 */
@Test
public void testQuery7(){
	Connection conn = null;
	try {
		QueryRunner runner = new QueryRunner();
		conn = JDBCUtils.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, "成龙", "Jacky@126.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,23);
		System.out.println(customer);
	} catch (SQLException e) {
		e.printStackTrace();
	}finally{
		JDBCUtils.closeResource(conn, null);
		
	}
	
}

使用dbutils.jar包中的DbUtils工具类实现连接等资源的关闭：
/**
	 * 
	 * @Description 使用dbutils.jar中提供的DbUtils工具类，实现资源的关闭
	 * @author shkstart
	 * @date 下午4:53:09
	 * @param conn
	 * @param ps
	 * @param rs
	 */
	public static void closeResource1(Connection conn,Statement ps,ResultSet rs){
//		try {
//			DbUtils.close(conn);
//		} catch (SQLException e) {
//			e.printStackTrace();
//		}
//		try {
//			DbUtils.close(ps);
//		} catch (SQLException e) {
//			e.printStackTrace();
//		}
//		try {
//			DbUtils.close(rs);
//		} catch (SQLException e) {
//			e.printStackTrace();
//		}
	
	DbUtils.closeQuietly(conn);
	DbUtils.closeQuietly(ps);
	DbUtils.closeQuietly(rs);
}