数据库连接池

今日知识

1. c3p0和Druid使用
2. DBUtils使用
3. SpringJDBC轻量级框架
4. 总结

c3p0和Druid使用

1. *概念：其实是一个容器(集合)，存放数据库的容器。用户访问完在放回池子中
2. *好处：
    1.节约资源
    2. 用户访问高效
    
3. 实现：
    1. 标准接口：DataSource  javax.sql包下的
        1.方法：
            *获取连接 Connection()
            *归还连接：Connection.close()如果连接对象connection是连接池获取的，此时应该是归还连接，不是直接关闭连接。
    2.
    * c3p0连接池技术
    * Druid连接技术，由阿里巴巴实现的。      
4. C3P0的使用：
    *步骤：
        1. 导入jar(两个)，c3p0的包，和mchange-commons-java-0.2.12 jar包,+数据库连接的包
        2. 定义配置文件：
            *名称：c3p0.properties 或者 c3p0-config.xml
            *路径：直接放在src目录下即可
        3. 创建核心对象 获取数据库连接池对象 ：combopooledDataSource(mchange-commons-java-0.2.12 jar包)
        4. 获取连接：getConnection
    *核心代码：
        //获取dataSource,使用的默认配置
        1.DataSource ds=new ComboPooledDataSource();//自动获取配置文件c3p0-config.xml
          //使用其他配置,带参的使用
        2.DataSource ds=new ComboPooledDataSource("otherc3p0");
        3. 通过DataSource调用getConnection方法
        4. 剩下的操作和原来一样
        
        * 注意：C3p0只是一个管理连接池的一个容器，其他操作还和原来一样，先获取sql执行对象，在执行sql,最后处理结果。
        
5.  Druid连接池
    * 步骤
        1.导入 druid-1.0.9jar包和数据库连接jar包
        2. 定义配置文件：druid.properties
            *可以叫任意名称，放在任意目录下
        3. 获取数据库连接池对象 ：DruidDataSourceFactory.createDataSource(pro);
        4. 获取连接：getConnection
    * 创建Utils工具使用:
        1. 创建成员变量DataSource 
        2. 用静态代码块获取DataSource对象，
        3. 创建getConnection方法
        4.创建释放资源的方法
        例如：
            public class DruidUtils {
            private static  DataSource ds;
            //获取连接池对象
            static {
                Properties pro=new Properties();
                //获取配置文件，并返回流
                InputStream is = DruidUtils.class.getClassLoader().getResourceAsStream("druid.properties");
                try {
                    pro.load(is);
                    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(Connection con,Statement statement){
               close(con,statement,null);
            }
            public static void close(Connection con, Statement statement, ResultSet rs){
                if (rs!=null){
                    try {
                        rs.close();
                    } catch (SQLException e) {
                        e.printStackTrace();
                    }
                }
                if (con!=null){
                    try {
                        con.close();
                    } catch (SQLException e) {
                        e.printStackTrace();
                    }
                }
                if (statement!=null){
                    try {
                        statement.close();
                    } catch (SQLException e) {
                        e.printStackTrace();
                    }
                }
            }
            //获取连接池的方法
            public static DataSource getDatasource(){
                return ds;
            }
        }

DBUtils使用

* DBUtils框架 它是对JDBC的简单封装，学习成本极低，并且使用dbutils能极大简化jdbc编码的工作量
* 步骤：
    1. 导包：commons-dbutils-jar
    2. 创建QueryRunner对象，依赖数据源DataSource
        *QueryRunner runner=new QueryRunner(DruidUtils.getDatasource());
    3. 调用QueryRunner的方法来完成数据库操
        1. update：用来执行一个更新（插入、更新或删除）操作。
        2. batch：用来执行批量更新（插入、更新或删除）操作。
        3. query(sql,new ArrayHandler()):把结果集中的第一行数据转成对象数组。
        4. query(sql,new ArrayListHandler()):把结果集中的每一行数据都转成一个数组，再存放到List中。
        5. query(sql,new BeanHandler()):将结果集中的第一行数据封装到一个对应的JavaBean实例中。
        6. query(sql,new BeanListHandler()):将结果集中的每一行数据都封装到一个对应的JavaBean实例中，存放到List里。
        7. query(sql,new ColumnListHandler("name")):将结果集中某一列的数据存放到List中
        8. query(sql,new KeyedHandler("name")):将结果集中的每一行数据都封装到一个Map<列名,列值>里,再把这些map再存到一个map里，其key为指定的key。
        9. query(sql,new MapHandler()):将结果集中的第一行数据封装到一个Map里，key是列名，value就是对应的值。
        10. query(sql,new MapListHandler()):将结果集中的每一行数据都封装到一个Map里，然后再存放到List.
        11. query(sql,new ScalarHandler()):将单个值封装，用来统计聚合函数返回值.如count，avg，max,min
    
    *代码：
         package com.rqy.datasource.dbutils;

        import com.rqy.datasource.Utils.DruidUtils;
        import com.rqy.datasource.bean.Account;
        import org.apache.commons.dbutils.QueryRunner;
        import org.apache.commons.dbutils.handlers.*;
        import org.junit.Test;
        import java.sql.SQLException;
        import java.util.*;
        
        /**
         * @author 任清阳
         * @Email 1277409109@qq.com
         * @date 2019/6/18 21:16
         */
        public class DButilsDemo2 {
            //1.导入jar包
                private QueryRunner runner=new QueryRunner(DruidUtils.getDatasource());
              //使用单元测试
        
            /**
             * batch：用来执行批量更新（插入、更新或删除）操作。
             */
            @Test
            public void testBatch() throws SQLException {
                String sql="delete from account where name=? and balance=? ";
                Object[] [] params=new Object[10][];
                for (int i = 0; i < 10; i++) {
                    //为每一行给两列值，第一列对应第一个问号，第二列对应第二个问号
                    params[i]=new Object[]{i+"",3};
                }
                int[] query = runner.batch(sql,params);
                System.out.println(Arrays.toString(query));
        
            }
            /**
             * update：用来执行一个更新（插入、更新或删除）操作。
             */
            @Test
            public void test() throws SQLException {
                String sql="insert into account values(null,?,?) ";
                int query = runner.update(sql,"ren",5200);
                System.out.println(query);
        
            }
        
            /**
             *query: ArrayHandler：把结果集中的第一行数据转成对象数组。
             */
            @Test
            public void test1() throws SQLException {
                String sql="select * from account ";
                Object[] query = runner.query(sql, new ArrayHandler());
                System.out.println(Arrays.toString(query));
        
            }
            /**
             * query:ArrayListHandler：把结果集中的每一行数据都转成一个数组，再存放到List中。
             */
            @Test
            public void test2() throws SQLException {
                String sql="select * from account ";
                List<Object[]> query = runner.query(sql, new ArrayListHandler());
                for (Object[] objects:query) {
                    System.out.println(Arrays.toString(objects));
                }
            }
            /**
             * BeanHandler：将结果集中的第一行数据封装到一个对应的JavaBean实例中。
             */
            @Test
            public void test3() throws SQLException {
                String sql="select * from account ";
                Account query = runner.query(sql, new BeanHandler<Account>(Account.class));
                    System.out.println(query);
            }
            /**
             * BeanListHandler：将结果集中的每一行数据都封装到一个对应的JavaBean实例中，存放到List里。
             */
            @Test
            public void test4() throws SQLException {
                String sql="select * from account ";
                List<Account> query = runner.query(sql, new BeanListHandler<Account>(Account.class));
                for(Account account:query) {
                    System.out.println(account);
                }
            }
            /**
             * ColumnListHandler：将结果集中某一列的数据存放到List中
             */
            @Test
            public void test5() throws SQLException {
                String sql="select * from account ";
                List<Object> query = runner.query(sql, new ColumnListHandler("name"));
                for(Object obj:query) {
                    System.out.println(obj);
                }
            }
            /**
             * KeyedHandler(name)：将结果集中的每一行数据都封装到一个Map<列名,列值>里
             * 再把这些map再存到一个map里，其key为指定的key。
             */
            @Test
            public void test6() throws SQLException {
                String sql="select * from account ";
                Map<Object, Map<String, Object>> name = runner.query(sql, new KeyedHandler("name"));
                Set<Object> objects=name.keySet();
                for(Object key:objects) {
                    Map<String, Object> value=name.get(key);
                    System.out.println(value);
                }
            }
            /**
             * MapHandler：将结果集中的第一行数据封装到一个Map里，key是列名，value就是对应的值。
             */
            @Test
            public void test7() throws SQLException {
                String sql="select * from account ";
                Map<String, Object> query = runner.query(sql, new MapHandler());
                    System.out.println(query);
            }
            /**
             * MapListHandler：将结果集中的每一行数据都封装到一个Map里，然后再存放到List
             */
            @Test
            public void test8() throws SQLException {
                String sql="select * from emp ";
                List<Map<String, Object>> list = runner.query(sql, new MapListHandler());
                for (Map<String,Object> s:list ){
                    System.out.println(s);
                }
            }
            /**
             * 测试ScalarHandler:将单个值封装，用来统计聚合函数返回值
             *
             * */
            @Test
            public void test9() throws SQLException {
                Object query = runner.query("select count(*) from account",
                        new ScalarHandler());
                System.out.println(query);
        
            }
        }

Spring JDBC

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

	3. 调用JdbcTemplate的方法来完成CRUD的操作
		1. update():执行DML语句。增、删、改语句
		2.  queryForMap():查询结果将结果集封装为map集合，将列名作为key，将值作为value 将这条记录封装为一个map集合
			* 注意：这个方法查询的结果集长度只能是1
		3.  queryForList():查询结果将结果集封装为list集合
			* 注意：将每一条记录封装为一个Map集合，再将Map集合装载到List集合中
		4. query():查询结果，将结果封装为JavaBean对象
			* query的参数：RowMapper
				* 一般我们使用BeanPropertyRowMapper实现类。可以完成数据到JavaBean的自动封装
				* new BeanPropertyRowMapper<类型>(类型.class)
		5.  queryForObject：查询结果，将结果封装为对象
			* 一般用于聚合函数的查询
		
    4. 练习：
		* 需求：
			1. 修改1号数据的 salary 为 10000
			2. 添加一条记录
			3. 删除刚才添加的记录
			4. 查询id为1的记录，将其封装为Map集合
			5. 查询所有记录，将其封装为List
			6. 查询所有记录，将其封装为Emp对象的List集合
			7. 查询总记录数
	
        *代码：
            package com.rqy.datasource.jdbctemplate;
            import com.rqy.datasource.Utils.DruidUtils;
            import com.rqy.datasource.bean.Account;
            import org.junit.Test;
            import org.springframework.jdbc.core.BeanPropertyRowMapper;
            import org.springframework.jdbc.core.JdbcTemplate;
            import java.util.List;
            import java.util.Map;
            
            /**
             * @author 任清阳
             * @Email 1277409109@qq.com
             * @date 2019/6/18 15:36
            */
            public class JdbcTemplateDemo {
                //导入jar包
                //创建JDBCTemplate对象
              private  JdbcTemplate template = new JdbcTemplate(DruidUtils.getDatasource());
    
            //junit单元测试，可以让方法独立运行
            /**
             * 1.修改1号数据的 salary 为 10000
            *
            */
            @Test
            public void test1(){
                String sql="update emp set sal=5000 where empno=?";
                int i=template.update(sql,01);
                System.out.println(i);
            }
            /**
             * 2.添加一条记录
             *
             */
            @Test
            public void test2(){
                String sql="insert into emp (empno,ename,deptno)VALUES (?,?,?)";
                int i=template.update(sql,"08","nihao","3");
                System.out.println(i);
            }
            /**
             * 3.删除刚才添加的记录
             *
             */
            @Test
            public void test3(){
                String sql="delete from emp where empno=?";
                int i=template.update(sql,"08");
                System.out.println(i);
            }
            /**
             *
             * 4.查询id为1的记录，将其封装为Map集合
             *  /注意：这个方法查询的结果集长度只能是1
             */
            @Test
            public void test4(){
                String sql="select * from emp where empno=?";
                Map<String, Object> map = template.queryForMap(sql, "01");
                System.out.println(map);
            }
            /**
             * 5.查询所有记录，将其封装为List
             * 实际操作：将每一条记录封装为一个Map集合，再将Map集合装载到List集合中
             */
            @Test
            public void test5(){
                String sql="select * from emp ";
                List<Map<String, Object>> list = template.queryForList(sql);
                for (Map<String,Object> s:list ){
                    System.out.println(s);
                }
            }
            /**
             * 6.查询所有记录，将其封装为Emp对象的List集合
             */
            @Test
            public void test6(){
                String sql="select * from account ";
                List<Account> accounts = template.query(sql, new BeanPropertyRowMapper<Account>(Account.class));
                for (Account s:accounts){
                    System.out.println(s);
                }
            }
            /**
             * 7. 查询总记录数
             */
            @Test
            public void test7(){
                String sql="select count(id) from account ";
                Long i=template.queryForObject(sql,Long.class);
                System.out.println(i);
            }
        }