今日知识

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
         
           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.class)); System.out.println(query);             } /**              * BeanListHandler：将结果集中的每一行数据都封装到一个对应的JavaBean实例中，存放到List里。              */             @Test public void test4() throws SQLException {
                       String sql="select * from account ";                 List
           
             query = runner.query(sql, new BeanListHandler
            
             (Account.class)); for(Account account:query) {
       System.out.println(account);                 }             } /**              * ColumnListHandler：将结果集中某一列的数据存放到List中              */             @Test public void test5() throws SQLException {
                       String sql="select * from account ";                 List
             
            
           
          
         
        

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
         
           map = template.queryForMap(sql, "01"); System.out.println(map);             } /**              * 5.查询所有记录，将其封装为List              * 实际操作：将每一条记录封装为一个Map集合，再将Map集合装载到List集合中              */             @Test public void test5(){
                       String sql="select * from emp ";                 List