关于JDBC与数据库连接池，你了解多少？

---

1 JDBC

1. JAVA Database Connectivity java 数据库连接

2. 为什么会出现JDBC?

   SUN公司提供的一种数据库访问规则、规范, 由于数据库种类较多，并且java语言使用比较广泛，sun公司就提供了一种规范，让其他的数据库提供商去实现底层的访问规则。 我们的java程序只要使用sun公司提供的jdbc驱动即可。

1.1 使用JDBC的基本步骤

1. 注册驱动

   DriverManager.registerDriver(new com.mysql.jdbc.Driver());
   

2. 建立连接

   //第一种
   DriverManager.getConnection("jdbc:mysql://localhost/test?user=root&password=root");
   //参数一：协议 + 访问的数据库，参数二：用户名，参数三：密码。
   //第二种
   conn = DriverManager.getConnection("jdbc:mysql://localhost/test", "root", "root");
   

3. 创建statement

   //创建statement，跟数据库打交道，一定需要这个对象
   st = conn.createStatement();
   

4. 执行sql，得到ResultSet

   //执行查询，得到结果集
   String sql = "select * from stu";
   rs = st.executeQuery(sql);
   

5. 遍历结果集

   //遍历查询每一条记录
   while (rs.next()) {
   	int id = rs.getInt("id");
   	String name = rs.getString("name");
   	int age = rs.getInt("age");
   	System.out.println("id=" + id + "==name==" + name + "==age==" + age);
   }
   

6. 释放资源

   if (rs != null) {
   	try {
   		rs.close();
   	} catch (SQLException sqlEx) { } // ignore 
   	rs = null;
   }
   ...
   

1.2 JDBC工具类构建

1. 资源释放工作的整合
2. 驱动防二次注册

   DriverManager.registerDriver(new com.mysql.jdbc.Driver());
   // Driver 这个类里面有静态代码块，一上来就执行了，所以等同于我们注册了两次驱动。 其实没这个必要的。
   // 静态代码块 ---> 类加载了，就执行。 java.sql.DriverManager.registerDriver(new Driver());
   // 最后形成以下代码即可。
   Class.forName("com.mysql.jdbc.Driver");	
   

3. 使用properties配置文件
   1. 在src下面声明一个文件 xxx.properties，里面的内容如下：

   driverClass=com.mysql.jdbc.Driver
   url=jdbc:mysql://localhost/student
   name=root
   password=root
   

   2. 在工具类里面，使用静态代码块，读取属性。

   // JDBC代码
   public class JDBCUtil {
   	static String driverClass = null;
   	static String url = null;
   	static String name = null;
   	static String password= null;
   	static {
   		try {
   			//1. 创建一个属性配置对象
   			Properties properties = new Properties();
   			InputStream is = new FileInputStream("jdbc.properties");
   			
   			// 使用类加载器，去读取src底下的资源文件
   			// InputStream is = JDBCUtil.class.getClassLoader().getResourceAsStream("jdbc.properties");
   			// 导入输入流。
   			properties.load(is);
   			
   			//读取属性
   			driverClass = properties.getProperty("driverClass");
   			url = properties.getProperty("url");
   			name = properties.getProperty("name");
   			password = properties.getProperty("password");
   		} catch (Exception e) {
   			e.printStackTrace();
   		}
   	}
   	/**
   	* 获取连接对象
   	* @return
   	*/
   	public static Connection getConn() {
   		Connection conn = null;
   		try {
   			Class.forName(driverClass);
   			conn = DriverManager.getConnection(url, name, password);
   		} catch (Exception e) {
   			e.printStackTrace();
   		}
   		return conn;
   	}
   	/**
   	* 释放资源
   	* @param conn
   	* @param st
   	* @param rs
   	*/
   	public static void release(Connection conn , Statement st , ResultSet rs){
   		closeRs(rs);
   		closeSt(st);
   		closeConn(conn);
   	}
   	private static void closeRs(ResultSet rs) {
   		try {
   			if (rs != null) {
   				rs.close();
   			}
   		} catch (SQLException e) {
   			e.printStackTrace();
   		} finally {
   			rs = null;
   		}
   	}
   	private static void closeSt(Statement st) {
   		try {
   			if (st != null) {
   				st.close();
   			}
   		} catch (SQLException e) {
   			e.printStackTrace();
   		} finally {
   			st = null;
   		}
   	}
   	private static void closeConn(Connection conn) {
   		try {
   			if (conn != null) {
   				conn.close();
   			}
   		} catch (SQLException e) {
   			e.printStackTrace();
   		} finally {
   			conn = null;
   		}
   	}
   }
   

1.3 数据库的CRUD

1. insert

   INSERT INTO t_stu (name, age) VALUES ('wangqiang', 28);
   INSERT INTO t_stu VALUES (NULL, 'wangqiang2', 28);
   

   // 1. 获取连接对象
   conn = JDBCUtil.getConn();
   // 2. 根据连接对象，得到statement
   st = conn.createStatement();
   // 3. 执行添加
   String sql = "insert into t_stu values(null , 'aobama' , 59)";
   //影响的行数，如果大于0表明操作成功，否则失败
   int result = st.executeUpdate(sql);
   if (result > 0) {
   	System.out.println("添加成功");
   } else {
   	System.out.println("添加失败");
   }
   

2. delete

   DELETE FROM t_stu WHERE id = 6;
   

   // 1. 获取连接对象
   conn = JDBCUtil.getConn();
   // 2. 根据连接对象，得到statement
   st = conn.createStatement();
   
   // 3. 执行添加
   String sql = "delete from t_stu where name='aobama'";
   // 影响的行数，如果大于0表明操作成功，否则失败
   int result = st.executeUpdate(sql);
   if (result > 0) {
   	System.out.println("删除成功");
   } else {
   	System.out.println("删除失败");
   }
   

3. query

   SELECT * FROM t_stu;
   

   // 1. 获取连接对象
   conn = JDBCUtil.getConn();
   // 2. 根据连接对象，得到statement
   st = conn.createStatement();
   // 3. 执行sql语句，返回ResultSet
   String sql = "select * from t_stu";
   rs = st.executeQuery(sql);
   
   // 4. 遍历结果集
   while (rs.next()) {
   	String name = rs.getString("name");
   	int age = rs.getInt("age");
   	System.out.println(name + "   " + age);
   }
   

4. update

   UPDATE t_stu SET age = 38 WHERE id = 1;
   

   // 1. 获取连接对象
   conn = JDBCUtil.getConn();
   // 2. 根据连接对象，得到statement
   st = conn.createStatement();
   // 3. 执行添加
   String sql = "update t_stu set age = 26 where name ='qyq'";
   // 影响的行数，如果大于0表明操作成功，否则失败
   int result = st.executeUpdate(sql);
   
   if (result > 0) {
   	System.out.println("更新成功");
   } else {
   	System.out.println("更新失败");
   }
   

1.4 Dao模式

1. Data Access Object 数据访问对象

2. 新建一个dao的接口，里面声明数据库访问规则

   /**
   * 定义操作数据库的方法
   */
   public interface UserDao {
   	/**
   	* 查询所有
   	*/
   	void findAll();
   }
   

3. 新建一个dao的实现类，具体实现早前定义的规则

   public class UserDaoImpl implements UserDao{
   	@Override
   	public void findAll() {
   		Connection conn = null;
   		Statement st = null;
   		ResultSet rs = null;
   		try {
   			//1. 获取连接对象
   			conn = JDBCUtil.getConn();
   			//2. 创建statement对象
   			st = conn.createStatement();
   			String sql = "select * from t_user";
   			rs = st.executeQuery(sql);
   			while(rs.next()){
   				String userName = rs.getString("username");
   				String password = rs.getString("password");
   				
   				System.out.println(userName+"="+password);
   			}
   			
   		} catch (Exception e) {
   			e.printStackTrace();
   		}finally {
   			JDBCUtil.release(conn, st, rs);
   		}
   	}
   }
   

4. 直接使用实现

   @Test
   public void testFindAll(){
   	UserDao dao = new UserDaoImpl();
   	dao.findAll();
   }
   

1.5 Statement安全问题

1. Statement执行，其实是拼接sql语句的。先拼接sql语句，然后再一起执行。

   String sql = "select * from t_user where username='"+ username  +"' and password='"+ password +"'";
   
   UserDao dao = new UserDaoImpl();
   dao.login("admin", "100234khsdf88' or '1=1"); // 一定可以登录成功
   // SELECT * FROM t_user WHERE username='admin' AND PASSWORD='100234khsdf88' or '1=1' 
   // 前面先拼接sql语句，如果变量里面带有了数据库的关键字，那么一并认为是关键字。不认为是普通的字符串。 
   rs = st.executeQuery(sql);
   

1.6 PrepareStatement

1. 该对象就是替换前面的statement对象。

2. 相比较以前的statement， 预先处理给定的sql语句，对其执行语法检查。在sql语句里面使用 ? 占位符来替代后续要传递进来的变量。后面进来的变量值，将会被看成是字符串，不会产生任何的关键字。

   String sql = "insert into t_user values(null , ? , ?)";
   ps = conn.prepareStatement(sql);
   //给占位符赋值 从左到右数过来，1 代表第一个问号，从1开始。
   ps.setString(1, userName);
   ps.setString(2, password);
   

2 数据库连接池

1. 数据库的连接对象创建工作，比较消耗性能。

2. 一开始先在内存中开辟一块空间(集合)，一开先往池子里面放置多个连接对象。后面需要连接的话，直接从池子里面取。不要去自己创建连接了。使用完毕，要记得归还连接。确保连接对象能循环利用。

2.1 自定义数据库连接池

1. 代码实现

   /*
   * 	1. 开始创建10个连接。
   * 	2. 来的程序通过getConnection获取连接
   * 	3. 用完之后，使用addBack归还连接。
   * 	4. 扩容。
   */
   public class MyDataSource implements DataSource {
   	
   	List <Connection> list = new ArrayList<Connection>();
   	
   	public  MyDataSource() {
   		for (int i = 0; i < 10; i++) {
   			Connection conn = JDBCUtil.getConn();
   			list.add(conn);
   		}
   	}
   	
   	// 该连接池对外公布的获取连接的方法
   	@Override
   	public Connection getConnection() throws SQLException {
   		//来拿连接的时候，先看看，池子里面还有没有。
   		if(list.size() == 0 ){
   			for (int i = 0; i < 5; i++) {
   				Connection conn = JDBCUtil.getConn();
   				list.add(conn);
   			}
   		}
   		
   		//remove(0) ---> 移除第一个。移除的是集合中的第一个。移除的是开始的那个元素
   		Connection conn = list.remove(0);
   		return conn;
   	}
   	/**
   	* 用完之后，记得归还。
   	* @param conn
   	*/
   	public void addBack(Connection conn){
   		list.add(conn);
   	}
   	......
   }
   

2. 出现的问题：
   1. 需要额外记住 addBack方法
   2. 无法面向接口编程。

      UserDao dao = new UserDaoImpl();
      dao.insert();
      DataSource dataSource = new MyDataSource();
      // 因为接口里面没有定义addBack方法。
      

   3. 怎么解决? 以addBack 为切入点。

2.2 解决自定义数据库连接池出现的问题。

由于多了一个addBack方法，所以使用这个连接池的地方，需要额外记住这个方法，并且还不能面向接口编程。

我们打算修改接口中的那个close方法。原来的Connection对象的close方法，是真的关闭连接。
打算修改这个close方法，以后在调用close，并不是真的关闭，而是归还连接对象。

2.3 如何扩展某一个方法?

原有的方法逻辑，不是我们想要的。想修改自己的逻辑

1. 直接改源码 -> 无法实现。
2. 继承 -> 必须得知道这个接口的具体实现是谁。
3. 使用装饰者模式。

3 开源连接池

3.1 DBCP

1. 导入jar文件
2. 不使用配置文件：

   public void testDBCP01() {
   	Connection conn = null;
   	PreparedStatement ps = null;
   	try {
   		// 1. 构建数据源对象
   		BasicDataSource dataSource = new BasicDataSource();
   		// 连的是什么类型的数据库， 访问的是哪个数据库，用户名，密码。。
   		// jdbc:mysql://localhost/bank 主协议：子协议 ://本地/数据库
   		dataSource.setDriverClassName("com.mysql.jdbc.Driver");
   		dataSource.setUrl("jdbc:mysql://localhost/bank");
   		dataSource.setUsername("root");
   		dataSource.setPassword("root");
   		
   		// 2. 得到连接对象
   		conn = dataSource.getConnection();
   		String sql = "insert into account values(null , ? , ?)";
   		ps = conn.prepareStatement(sql);
   		ps.setString(1, "admin");
   		ps.setInt(2, 1000);
   		ps.executeUpdate();
   	} catch (SQLException e) {
   		e.printStackTrace();
   	} finally {
   		JDBCUtil.release(conn, ps);
   	}
   }
   

3. 使用配置文件方式：
   1. 声明一个文件 xxx.properties，里面的内容如下：

   # 连接设置
   driverClassName=com.mysql.jdbc.Driver
   url=jdbc:mysql://localhost:3306/bank
   username=root
   password=root
   
   #
   initialSize=10
   
   #最大连接数量
   maxActive=50
   
   #
   maxIdle=20
   
   #
   minIdle=5
   
   #
   maxWait=60000
   
   
   #JDBC驱动建立连接时附带的连接属性属性的格式必须为这样：[属性名=property;] 
   #注意："user" 与 "password" 两个属性会被明确地传递，因此这里不需要包含他们。
   connectionProperties=useUnicode=true;characterEncoding=gbk
   
   #指定由连接池所创建的连接的自动提交（auto-commit）状态。
   defaultAutoCommit=true
   
   #driver default 指定由连接池所创建的连接的事务级别（TransactionIsolation）。
   #可用值为下列之一：（详情可见javadoc。）NONE,READ_UNCOMMITTED, READ_COMMITTED, REPEATABLE_READ, SERIALIZABLE
   defaultTransactionIsolation=READ_UNCOMMITTED
   

   Connection conn = null;
   PreparedStatement ps = null;
   try {
   	BasicDataSourceFactory factory = new BasicDataSourceFactory();
   	Properties properties = new Properties();
   	InputStream is = new FileInputStream("src//dbcpconfig.properties");
   	properties.load(is);
   	DataSource dataSource = factory.createDataSource(properties);
   	
   	//2. 得到连接对象
   	conn = dataSource.getConnection();
   	String sql = "insert into account values(null, ? , ?)";
   	ps = conn.prepareStatement(sql);
   	ps.setString(1, "liangchaowei");
   	ps.setInt(2, 100);
   	ps.executeUpdate();
   	
   } catch (Exception e) {
   	e.printStackTrace();
   } finally {
   	JDBCUtil.release(conn, ps);
   }
   

3.2 C3P0

1. 导入jar文件

2. 不使用配置文件方式

   Connection conn = null;
   PreparedStatement ps = null;
   try {
   	// 1. 创建datasource
   	ComboPooledDataSource dataSource = new ComboPooledDataSource();
   	// 2. 设置连接数据的信息
   	dataSource.setDriverClass("com.mysql.jdbc.Driver");
   	dataSource.setJdbcUrl("jdbc:mysql://localhost/bank");
   	dataSource.setUser("root");
   	dataSource.setPassword("root");
   	
   	// 2. 得到连接对象
   	conn = dataSource.getConnection();
   	String sql = "insert into account values(null , ? , ?)";
   	ps = conn.prepareStatement(sql);
   	ps.setString(1, "admi234n");
   	ps.setInt(2, 103200);
   	ps.executeUpdate();
   } catch (Exception e) {
   	e.printStackTrace();
   } finally {
   	JDBCUtil.release(conn, ps);
   }
   

3. 使用配置文件方式

   // 默认会找 xml 中的 default-config 分支。 
   ComboPooledDataSource dataSource = new ComboPooledDataSource();
   // 1. 设置连接数据的信息
   dataSource.setDriverClass("com.mysql.jdbc.Driver");
   dataSource.setJdbcUrl("jdbc:mysql://localhost/bank");
   dataSource.setUser("root");
   dataSource.setPassword("root");
   
   // 2. 得到连接对象
   conn = dataSource.getConnection();
   String sql = "insert into account values(null , ? , ?)";
   ps = conn.prepareStatement(sql);
   ps.setString(1, "admi234n");
   ps.setInt(2, 103200);
   

3.3 DBUtils

3.3.1 增删改

1. //dbutils 只是帮我们简化了CRUD 的代码， 但是连接的创建以及获取工作。 不在它的考虑范围
   QueryRunner queryRunner = new QueryRunner(new ComboPooledDataSource());
   
   //增加
   queryRunner.update("insert into account values (null , ? , ? )", "aa" ,1000);
   
   //删除
   queryRunner.update("delete from account where id = ?", 5);
   
   //更新
   queryRunner.update("update account set money = ? where id = ?", 10000000 , 6);
   

3.3.2 查询

1. 直接new接口的匿名实现类

   QueryRunner queryRunner = new QueryRunner(new ComboPooledDataSource());
   
   Account  account =  queryRunner.query("select * from account where id = ?", new ResultSetHandler<Account>(){
   	@Override
   	public Account handle(ResultSet rs) throws SQLException {
   		Account account  =  new Account();
   		while(rs.next()){
   			String name = rs.getString("name");
   			int money = rs.getInt("money");
   			
   			account.setName(name);
   			account.setMoney(money);
   		}
   		return account;
   	}	
   }, 6);
   System.out.println(account.toString());
   

2. 直接使用框架已经写好的实现类。

• 查询单个对象

  QueryRunner queryRunner = new QueryRunner(new ComboPooledDataSource());
  //查询单个对象
  Account account = queryRunner.query("select * from account where id = ?", new BeanHandler<Account>(Account.class), 8);
  

• 查询多个对象

  QueryRunner queryRunner = new QueryRunner(new ComboPooledDataSource());
  
  List<Account> list = queryRunner.query("select * from account ",new BeanListHandler<Account>(Account.class));
  

3.3.3 ResultSetHandler 常用的实现类

1. // 以下两个是使用频率最高的
   BeanHandler,        // 查询到的单个数据封装成一个对象 
   BeanListHandler,    // 查询到的多个数据封装 成一个List<对象>
   // -------------------------------------------------
   ArrayHandler,       // 查询到的单个数据封装成一个数组
   ArrayListHandler,   // 查询到的多个数据封装成一个集合 ，集合里面的元素是数组。 
   MapHandler,         // 查询到的单个数据封装成一个map
   MapListHandler,     // 查询到的多个数据封装成一个集合 ，集合里面的元素是map。