数据库连接池

小鱼儿 2021-11-29 10:36 492阅读 0赞

## 今日知识 ##

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

转载于:https://www.cnblogs.com/rqy0526/p/11067285.html