数据库连接池知识点

数据库连接池

1. 概念：其实就是一个容器(集合)，存放数据库连接的容器。
	 当系统初始化好后，容器被创建，容器中会申请一些连接对象，当用户来访问数据库时，从容器中获取连接对象，
	 用户访问完之后，会将连接对象归还给容器。
2. 好处：
	1. 节约资源
	2. 用户访问高效
3. 实现：
	1. 标准接口：DataSource   javax.sql包下的
		1. 方法：
			* 获取连接：getConnection()
			* 归还连接：Connection.close()。如果连接对象Connection是从连接池中获取的，那么调用Connection.close()方法，则不会再关闭连接了。而是归还连接
	2. 一般我们不去实现它，有数据库厂商来实现
		1. C3P0：数据库连接池技术
		2. Druid：数据库连接池实现技术，由阿里巴巴提供的
		3. DBCP : Apache公司

4. C3P0：数据库连接池技术

	* 步骤：
		1. 导入jar包 (两个) c3p0-0.9.5.2.jar  mchange-commons-java-0.2.12.jar ，
			* 不要忘记导入数据库驱动jar包
		2. 定义配置文件：
			* 名称： c3p0.properties 或者 c3p0-config.xml
			* 路径：直接将文件放在src目录下即可。

		3. 创建核心对象 数据库连接池对象 ComboPooledDataSource
		4. 获取连接： getConnection
	* 代码：
		 //1.创建数据库连接池对象 ()为空时,使用默认配置文件
        DataSource ds  = new ComboPooledDataSource(["采用自定义的配置文件"]);
        //2. 获取连接对象
        Connection conn = ds.getConnection();
    * 工具类
	    public class C3p0Utils {
	    	//获取默认的配置文件
			private static ComboPooledDataSource dataSource = new ComboPooledDataSource();
			
			//创建一个获取连接对象的方法
			public static Connection getConnection() {
				Connection conn = null;
				try {
					conn = dataSource.getConnection();
				} catch (Exception e) {
					e.printStackTrace();
				}
				return conn;
			}
			
			//从连接池获取连接池的方法
			public static DataSource getDataSources() {
				return dataSource;
			}
			
			public static void close(ResultSet rs,Statement stmt,Connection conn) {
				if (rs != null) {
					try {
						rs.close();
					} catch (Exception e) {
						e.printStackTrace();
					}
					rs = null;
				}
				
				if (stmt != null) {
					try {
						stmt.close();
					} catch (Exception e) {
						e.printStackTrace();
					}
					stmt = null;
				}
				
				if (conn != null) {
					try {
						conn.close();
					} catch (Exception e) {
						e.printStackTrace();
					}
				}
			}
		}

5. Druid：数据库连接池实现技术，由阿里巴巴提供的

	1. 步骤：
		1. 导入jar包 druid-1.0.9.jar
		2. 定义配置文件：
			* 是properties形式的
			* 可以叫任意名称，可以放在任意目录下
		3. 加载配置文件。Properties
		4. 获取数据库连接池对象：通过工厂来来获取  DruidDataSourceFactory
		5. 获取连接：getConnection
	* 代码：
		 //3.加载配置文件
        Properties pro = new Properties();
        InputStream is = DruidDemo.class.getClassLoader().getResourceAsStream("druid.properties");
        pro.load(is);
        //4.获取连接池对象
        DataSource ds = DruidDataSourceFactory.createDataSource(pro);
        //5.获取连接
        Connection conn = ds.getConnection();
    2. 定义工具类
		1. 定义一个类 JDBCUtils
		2. 提供静态代码块加载配置文件，初始化连接池对象
		3. 提供方法
			1. 获取连接方法：通过数据库连接池获取连接
			2. 释放资源
			3. 获取连接池的方法
		* 代码实现
			public class DruidUtil {
				private static DataSource ds;
				
				static {
					try {
						//加载配置文件
						Properties pro = new Properties();
						pro.load(DruidUtil.class.getClassLoader().getResourceAsStream("druid.properties"));
						//获取DataSource
						ds = DruidDataSourceFactory.createDataSource(pro);
					} catch (IOException e) {
						e.printStackTrace();
					} catch (Exception e) {
						e.printStackTrace();
					}
				}
				/**
				 * 获取连接
				 * @throws SQLException 
				 */
				public static Connection getConnection() throws SQLException {
					return ds.getConnection();
				}
				/**
				 * 释放资源
				 */
				public static void close(Statement stmt,Connection conn){
					close(null, stmt, conn);
				}
				public static void close(ResultSet rs,Statement stmt,Connection conn) {
					if (rs != null) {
						try {
							rs.close();
						} catch (SQLException e) {
							e.printStackTrace();
						}
					}
					if (stmt != null) {
						try {
							stmt.close();
						} catch (SQLException e) {
							e.printStackTrace();
						}
					}
					if (conn != null) {
						try {
							conn.close();
						} catch (SQLException e) {
							e.printStackTrace();
						}
					}
				}
				
				public static DataSource getDataSource() {
					return ds;
				}
			}

6. DBCP:数据库连接池技术

	* 核心对象：
		BasicDataSource 
		BasicDataSourceFactory
	1、导入jar文件
		commons-dbcp-1.4.jar
		commons-pool-1.5.6.jar
	2、创建核心对象
		BasicDataSource 
	3、设置连接参数
		* 不使用配置文件
			BasicDataSource dataSource = new BasicDataSource();
			//============必须设置===================
			dataSource.setDriverClassName("com.mysql.jdbc.Driver");
			dataSource.setUrl("jdbc:mysql:///nihaobj");
			dataSource.setUsername("root");
			dataSource.setPassword("root");
			//===============================	
			Connection conn = dataSource.getConnection();
		* 使用配置文件放在 src 下面
			Properties pro = new Properties();
			pro.load(new FileInputStream("src/dbcp.properties"));
			
			DataSource ds = BasicDataSourceFactory.createDataSource(pro);
			Connection conn = ds.getConnection();

7. Spring JDBC

	* Spring框架对JDBC的简单封装。提供了一个JDBCTemplate对象简化JDBC的开发
	* 步骤：
		1. 导入jar包
		2. 创建JdbcTemplate对象。依赖于数据源DataSource
			* JdbcTemplate template = new JdbcTemplate(ds);

		3. 调用JdbcTemplate的方法来完成CRUD的操作
			* update():执行DML语句。增、删、改语句
			* queryForMap():查询结果将结果集封装为map集合，将列名作为key，将值作为value 将这条记录封装为一个map集合
				* 注意：这个方法查询的结果集长度只能是1
			* queryForList():查询结果将结果集封装为list集合
				* 注意：将每一条记录封装为一个Map集合，再将Map集合装载到List集合中
			* query():查询结果，将结果封装为JavaBean对象
				* query的参数：RowMapper
					* 一般我们使用BeanPropertyRowMapper实现类。可以完成数据到JavaBean的自动封装
					* new BeanPropertyRowMapper<类型>(类型.class)
				List<Emp> list = template.query(sql, new BeanPropertyRowMapper<Emp>(Emp.class));
			* queryForObject：查询结果，将结果封装为对象
				* 一般用于聚合函数的查询
				queryForObject(sql, new BeanPropertyRowMapper<User>(User.class), username, password);

8. DBUtils工具

	* 作用：封装了JDBC的所有操作步骤---（基于连接池）
	* QueryRunner 
		Query(sql,返回值类型，参数1，参数2) ------DQL
		Update(sql,参数1，参数2)------ DML
	* 返回值:
		ArrayHandler, ArrayListHandler: 返回值是Object[] 或 List<Object[]> 
		MapHandler, MapListHandler:     返回值是Map<String, Object> 或 List<Map<String, Object>> 
		BeanHandler, BeanListHandler:   返回值是User对象 或 List<user>
		ScalarHandler					返回值是Long 一般用于聚合函数查询
	* eg:
		//1. 新增
			@Test
			public void addUser() throws Exception {
				QueryRunner qr = new QueryRunner(C3p0Utils.getDataSource());
				int i = qr.update(" insert into user values(null,?,?) ","张三","123");
				System.out.println(i);
			}
		//2. 查询张三的信息,返回值类型 ArrayHandler  数组
			@Test
			public void findUserByUname() throws Exception {
				QueryRunner qr = new QueryRunner(C3p0Utils.getDataSource());
				Object[] ar = qr.query(" select * from user where uname=? ",newArrayHandler(),"张三");
				System.out.println(Arrays.toString(arr));
			}
		//3. 查询张三的信息,返回值类型 ArrayListHandler  集合中装有数组
			@Test
			public void findUsers() throws Exception {
				QueryRunner qr = new QueryRunner(C3p0Utils.getDataSource());
				List<Object[]> list = qr.query(" select * from user ",new ArrayListHandler());
				for(Object[] arr:list) {
					System.out.println(Arrays.toString(arr));
				}
			}
		//4. 查询张三的信息,返回值类型 MapHandler  map返回记录
			@Test
			public void findUsersByName() throws Exception {
				QueryRunner qr = new QueryRunner(C3p0Utils.getDataSource());
				Map<String, Object> map = qr.query(" select * from user where uname=? ",new MapHandler(),"张三");
				for(String key:map.keySet()) {
					Object value = map.get(key);
					System.out.println(key+":"+value);
				}
			}	
	//5. 查询张三的信息,返回值类型 MapListHandler  list中存储多个map   返回记录
		@Test
		public void findUser() throws Exception {
			QueryRunner qr = new QueryRunner(C3p0Utils.getDataSource());
			 List<Map<String, Object>> maps = qr.query(" select * from user ",new MapListHandler());
			for(Map<String, Object> map:maps) {
				for(String key:map.keySet()) {
					Object value = map.get(key);
					System.out.println(key+":"+value);
				}
			}	
		}
	//6. 查询张三的信息,返回值类型 BeanHandler  user对象返回记录
		@Test
		public void findUsersByName3() throws Exception {
			QueryRunner qr = new QueryRunner(C3p0Utils.getDataSource());
			User user = qr.query(" select * from user where uname=? ",new BeanHandler<User>(User.class),"张三");
			System.out.println(user);			
		}	
	//7. 查询所有用户信息,返回值类型 BeanListHandler  List<user> 返回记录
		@Test
		public void findUsers3() throws Exception {
			QueryRunner qr = new QueryRunner(C3p0Utils.getDataSource());
			List<User> users = qr.query(" select * from user ",new BeanListHandler<User>(User.class));
			for(User user:users) {
				System.out.println(user);
			}
		}
	//8. 查询拥所有用户的数量，返回值 ScalarHandler
		@Test
		public void findUserNum() throws Exception {
			QueryRunner qr = new QueryRunner(C3p0Utils.getDataSource());
			Long count = (Long)qr.query(" select count(*) from user ",new ScalarHandler());
			System.out.println(count.intValue());
		}