JDBC - JDBC连接池&JDBCTempleate

数据库连接池

1. 概念：其实就是一个容器(集合)，存放数据库连接的容器。
   当系统初始化好后，容器被创建，容器中会申请一些连接对象，当用户来访问数据库时，从容器中获取连接对象，用户访问完之后，会将连接对象归还给容器，而不是释放资源。

2. 好处：

   1. 节约资源（实现了连接对象的重用）
   2. 用户访问高效（申请资源是较为浪费时间的）

3. 实现：

   1. 标准接口：DataSource javax.sql包下的

      1. 方法：
         • 获取连接：getConnection()
         • 归还连接：Connection.close()。如果连接对象Connection是从连接池中获取的，那么调用Connection.close()方法，则不会再关闭连接了。而是归还连接

   2. 一般我们不去实现它，有数据库厂商来实现

      1. C3P0：数据库连接池技术
      2. Druid：数据库连接池实现技术，由阿里巴巴提供的（以后会常常使用 是非常优秀的数据库连接池实现技术）

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();
     

5. Druid：数据库连接池实现技术，由阿里巴巴提供的（被誉为最好的数据库连接池实现技术）

   1. 步骤：
      1. 导入jar包 druid-1.0.9.jar
      2. 定义配置文件：
         • 是properties形式的（好像是不能使XML形式的）
         • 可以叫任意名称，可以放在任意目录下，不能自动的导入（和c3p0不同，c3p0将配置文件放在sec目录下能够自动的导入 但是名字就只能是c3p0-config）
      3. 加载配置文件。Properties（名字可以随便起。）
      4. 获取数据库连接池对象：通过工厂类来获取 DruidDataSourceFactory.createDataSource(参数是Properties对象 通过ClassLoader 来将配置文件加载到内存中。)；
         获取类加载器的方式就是 三种获取Class对象的方式.getClass()方法、。
      5. 获取连接：getConnection
   • 代码：

      //3.加载配置文件
     Properties pro = new Properties();
     InputStream is = DruidDemo.class.getClassLoader().getResourceAsStream("druid.properties");
     pro.load(is);
     //4.获取连接池对象（需要传入一个Properties对象）
     DataSource ds = DruidDataSourceFactory.createDataSource(pro);
     //5.获取连接
     Connection conn = ds.getConnection();
     

   2. 定义工具类（工具类就是为了代码的重用 JDBC这种只需要修改配置文件的信息在不用改动代码）

      1. 定义一个类 JDBCUtils
      2. 提供静态代码块加载配置文件，初始化连接池对象
      3. 提供方法
         1. 获取连接方法：通过数据库连接池获取连接
         2. 释放资源
         3. 获取连接池的方法
      • 代码：

      	public class JDBCUtils {
               
      	
      	//1.定义成员变量 DataSource
      	private static DataSource ds ;
      	
      	static{
               //定义一个静态代码块 在类加载的时候进行加载 完成DataSource对象的创建。
      	   try {
               
      	       //1.加载配置文件
      	       Properties pro = new Properties();
      	       pro.load(JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties"));
      	       //2.获取DataSource
      	       ds = DruidDataSourceFactory.createDataSource(pro);
      	   } catch (IOException e) {
               
      	       e.printStackTrace();
      	   } catch (Exception e) {
               
      	       e.printStackTrace();
      	   }
      	}		
      	/**
      	* 获取连接
      	*/
      	public static Connection getConnection() throws SQLException {
               
      	   return ds.getConnection();
      	}
      	/**
      	* 释放资源
      	*/
      	public static void close(Statement stmt,Connection conn){
               
      	  /* if(stmt != null){
      	       try {
      	           stmt.close();
      	       } catch (SQLException e) {
      	           e.printStackTrace();
      	       }
      	   }
      	
      	   if(conn != null){
      	       try {
      	           conn.close();//数据库连接池中是归还连接而不是释放资源
      	       } catch (SQLException e) {
      	           e.printStackTrace();
      	       }
      	   }*/
      	
      	  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;
      	}
      		
      }
      

Spring JDBC

• Spring框架对JDBC的简单封装。提供了一个JDBCTemplate对象简化JDBC的开发
• 步骤：

  1. 导入jar包（相应的 需要导入数据库连接池jar包 + 数据库驱动jar包）

  2. 创建JdbcTemplate对象。依赖于数据源DataSource 使用的是哪种的数据库连接池都行 但是最好是使用Druid【德鲁伊】

     • JdbcTemplate template = new JdbcTemplate(ds);

  3. 调用JdbcTemplate的方法来完成CRUD的操作

     • update():执行DML语句。增、删、改语句
     • queryForMap():查询结果将结果集封装为map集合，将列名作为key，将值作为value 将这条记录封装为一个map集合
       • 注意：这个方法查询的结果集长度只能是1，也就是说只能将一行的数据封装成一个Map，但是0个或者是多个都会报错。
     • queryForList():查询结果将结果集封装为list集合
       • 注意：将每一条记录封装为一个Map集合，再将Map集合装载到List集合中
     • query():查询结果，将结果封装为JavaBean对象
       • query的两个参数：SQL，RowMapper对象（不需要手动实现）
         • 一般我们使用BeanPropertyRowMapper实现类。可以完成数据到JavaBean的自动封装（但是在创建javabean对象的时候：成员变量的类型需要使用相应的包装类型，char类型使用的是String类型【目的是方式在接收null的时候出现异常。】）
         • new BeanPropertyRowMapper<类型>(类型.class)
     • queryForObject：查询结果，将结果封装为对象
       • 一般用于聚合函数的查询
       • 参数：SQL语句， RowMapper对象（要是类型是int 就使用Integer.class），【参数占位符】

练习：
* 需求：
1. 修改1号数据的 salary 为 10000
2. 添加一条记录
3. 删除刚才添加的记录
4. 查询id为1的记录，将其封装为Map集合
5. 查询所有记录，将其封装为List
6. 查询所有记录，将其封装为Emp对象的List集合
7. 查询总记录数

• 代码：

  	import cn.itcast.domain.Emp;
  	import cn.itcast.utils.JDBCUtils;
  	import org.junit.Test;
  	import org.springframework.jdbc.core.BeanPropertyRowMapper;
  	import org.springframework.jdbc.core.JdbcTemplate;
  	import org.springframework.jdbc.core.RowMapper;
  	
  	import java.sql.Date;
  	import java.sql.ResultSet;
  	import java.sql.SQLException;
  	import java.util.List;
  	import java.util.Map;
  	
  	public class JdbcTemplateDemo2 {
         
  	
  	    //Junit单元测试，可以让方法独立执行
  ​		//1. 获取JDBCTemplate对象
  ​		private JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
  ​		/**
  ​		* 1. 修改1号数据的 salary 为 10000
  ​		*/
  ​		@Test
  ​		public void test1(){
         			
  	        //2. 定义sql
  	        String sql = "update emp set salary = 10000 where id = 1001";
  	        //3. 执行sql
  	        int count = template.update(sql);
  	        System.out.println(count);
  	    }
  	    /**
  	     * 2. 添加一条记录
  	     */
  	    @Test
  	    public void test2(){
         
  	        String sql = "insert into emp(id,ename,dept_id) values(?,?,?)";
  	        int count = template.update(sql, 1015, "郭靖", 10);
  	        System.out.println(count);
  	    }
  	    /**
  	     * 3.删除刚才添加的记录
  	     */
  	    @Test
  	    public void test3(){
         
  	        String sql = "delete from emp where id = ?";
  	        int count = template.update(sql, 1015);
  	        System.out.println(count);
  	    }
  	    /**
  	     * 4.查询id为1001的记录，将其封装为Map集合
  	     * 注意：这个方法查询的结果集长度只能是1
  	     */
  	    @Test
  	    public void test4(){
         
  	        String sql = "select * from emp where id = ? or id = ?";
  	        Map<String, Object> map = template.queryForMap(sql, 1001,1002);
  	        System.out.println(map);
  	        //{id=1001, ename=孙悟空, job_id=4, mgr=1004, joindate=2000-12-17, salary=10000.00, bonus=null, dept_id=20}
  	    }
  	    /**
  	     * 5. 查询所有记录，将其封装为List
  	     */
  	    @Test
  	    public void test5(){
         
  	        String sql = "select * from emp";
  	        List<Map<String, Object>> list = template.queryForList(sql);
  	
  	        for (Map<String, Object> stringObjectMap : list) {
         
  	            System.out.println(stringObjectMap);
  	        }
  	    }	
  	    /**
  	     * 6. 查询所有记录，将其封装为Emp对象的List集合
  	     */
  	    @Test
  	    public void test6(){
         
  	        String sql = "select * from emp";
  	        List<Emp> list = template.query(sql, new RowMapper<Emp>() {
         
  	            @Override
  	            public Emp mapRow(ResultSet rs, int i) throws SQLException {
         
  	                Emp emp = new Emp();
  	                int id = rs.getInt("id");
  	                String ename = rs.getString("ename");
  	                int job_id = rs.getInt("job_id");
  	                int mgr = rs.getInt("mgr");
  	                Date joindate = rs.getDate("joindate");
  	                double salary = rs.getDouble("salary");
  	                double bonus = rs.getDouble("bonus");
  	                int dept_id = rs.getInt("dept_id");
  	                emp.setId(id);
  	                emp.setEname(ename);
  	                emp.setJob_id(job_id);
  	                emp.setMgr(mgr);
  	                emp.setJoindate(joindate);
  	                emp.setSalary(salary);
  	                emp.setBonus(bonus);
  	                emp.setDept_id(dept_id);
  	                return emp;
  	            }
  	        });
  ​			        for (Emp emp : list) {
         
  ​				            System.out.println(emp);
  ​				        }
  ​				    }			
  	    /**
  	     * 6. 查询所有记录，将其封装为Emp对象的List集合
  	     */	
  	    @Test
  	    public void test6_2(){
         
  	        String sql = "select * from emp";
  	        List<Emp> list = template.query(sql, new BeanPropertyRowMapper<Emp>(Emp.class));
  	        for (Emp emp : list) {
         
  	            System.out.println(emp);
  	        }
  	    }	
  	    /**
  	     * 7. 查询总记录数
  	     */
  	    @Test
  	    public void test7(){
         
  	        String sql = "select count(id) from emp";
  	        Long total = template.queryForObject(sql, Long.class);
  	        System.out.println(total);
  	    }	
  	}