DBUtil介绍以及连接池DBCP和C3P0的使用概述

小咪咪 2022-06-15 08:46 161阅读 0赞

# 1.DBUtil概述 #

DBUtil是JDBC的简化开发工具包,是apache commons的一个组件成员.  
是对JDBC简单封装的开源的工具类库,使用它能简化JDBC应用程序的开发,而且不会影响性能  
注意:使用时需要导入commons-dbutils-1.6.jar包  
DBUtils中的文件注释:  
![这里写图片描述][SouthEast]

# 2.三个核心功能: #

QueryRunner类中提供对sql语句操作的API.(增,删,改,查)  
ResultSetHandler接口，用于定义select操作后，怎样封装结果集.  
DbUtils类，它就是一个工具类,定义了关闭资源与事务处理的方法,有一个close方法,可以释放资源

在下边的介绍中会依次介绍这三个功能类和接口的使用。

# 3.事务(Transaction)处理 #

使系统摆脱不一致的状态  
![这里写图片描述][SouthEast 1]

# 4.QueryRunner类的操作(可以实现增,删,改的操作) #

核心方法:  
1.update(Connection conn,String sql, Object…params)用于完成数据的增删改操作  
第一个参数是数据库连接对象,第二个参数是数据库语句(里面的变量用?占位符替代),第三个参数就是?占位符的实际参数的数组.  
2.query(Connection conn, String sql, ResultSetHandler rsh, Object… params) ，用来完成表数据的查询操作  
ResultSetHandler rsh 是结果集的处理方式,传递ResultSetHandler接口实现类  
Object…params sql语句中的?占位符  
注意:  
query方法的返回值,返回的是T,是泛型,具体返回值类型,随着结果集处理方式变化

操作演示：
    //ExceptionInInitializerError 静态初始化异常
        //主要原因 没有导入mysql-connection这个jar包
        private static Connection conn = JDBCConfig.getConnection();
        public static void main(String[] args) throws SQLException {
                //insert();
            //update();
            delete();
    
        }
        public static void delete() throws SQLException {
            QueryRunner qr = new QueryRunner();
            String sql = "DELETE FROM sort WHERE sid=10";
            int line = qr.update(conn, sql);
            if(line > 0) {
                System.out.println("删除成功");
            }else {
                System.out.println("删除失败");
            }
            DbUtils.closeQuietly(conn);
    
        }
        //修改操作
        public static void update()throws SQLException {
            QueryRunner qr = new QueryRunner();
            String sql = "UPDATE sort SET sname=?,sprice=?,sdesc=? WHERE sid=?";
            Object[] params = {
       "足疗",3000,"呵呵呵",12};
            int line = qr.update(conn, sql, params);
            System.out.println(line);
            DbUtils.closeQuietly(conn);
        }
        //插入操作
        public static void insert() throws SQLException {
            QueryRunner qr = new QueryRunner();
            String sql = "INSERT INTO sort(sname,sprice,sdesc) VALUES(?,?,?)";
            Object[] params = {
       "外卖",30,"好吃不贵"};
            int line = qr.update(conn, sql, params);
            System.out.println(line);
            DbUtils.closeQuietly(conn);
        }
    }

# 5.ResultSetHandler(是一个接口)结果集处理 #

下面这些是实现这个接口的一些方法  
ArrayHandler 将结果集中的第一条记录封装到一个Object\[\]数组中，数组中的每一个元素就是这条记录中的每一个字段的值  
ArrayListHandler 将结果集中的每一条记录都封装到一个Object\[\]数组中，将这些数组在封装到List集合中。  
BeanHandler 将结果集中第一条记录封装到一个指定的javaBean中。  
BeanListHandler 将结果集中每一条记录封装到指定的javaBean中，将这些javaBean在封装到List集合中  
ColumnListHandler 将结果集中指定的列的字段值，封装到一个List集合中  
ScalarHandler 它是用于单数据。例如select count(\*) from 表操作。  
MapHandler 将结果集第一行封装到Map集合中,Key 列名, Value 该列数据  
MapListHandler 将结果集第一行封装到Map集合中,Key 列名, Value 该列数据,Map集合存储到List集合

# 6.JavaBean概述: #

就是一个类，在开发中常用封装数据。具有如下特性  
1.需要实现接口：java.io.Serializable ，通常实现接口这步骤省略了，不会影响程序。  
2.提供私有字段：private 类型 字段名; //对应的数据库表中的字段  
3.提供getter/setter方法：  
4.提供无参构造 //必须提供

# 7.连接池 #

为了解决”获得连接”或”释放资源”的性能问题,共享连接Connection  
概述  
用池管理连接,可以实现重复使用连接,对于多并发的时候有较好的性能  
怎么获取连接  
从连接池中获取,用完再归还给连接池  
![这里写图片描述][SouthEast 2]

规范:  
连接池必须实现接口:  
javax.sql.DataSource  
常见的连接池:**DBCP,C3P0**

# 8.DBCP(Database Connection Pool)概述: #

是数据库连接池的一种,通过连接池可以让程序自动的管理数据库的连接和释放,Tomcat当中内置了这个连接池  
Tomcat是什么?  
是JavaWeb服务器,我们需要把我们写好的class文件,放在Tomcat软件中,当开启Tomcat的时候会监听端口80.

导入jar包  
dbcp 和pool的jar包  
DBCP连接池的使用:

/* * 连接池的jar包中,定义好一个类BasicDataSource 实现了数据源的规范接口javax.sql.DataSource */
    public class DBCP_Demo {
        public static void main(String[] args) {
    
            // 创建DataSource接口的实现类对象
            // 实现类,org.apache.commons.dbcp
            BasicDataSource dataSource = new BasicDataSource();
            // 连接数据库的4个基本信息,通过对象方法SetXXX设置进来
            dataSource.setDriverClassName("com.mysql.jdbc.Driver");
            dataSource.setUrl("jdbc:mysql://127.0.0.1:3306/mybase");
            dataSource.setUsername("root");
            dataSource.setPassword("123");
            // 调用对象的方法getConnection方法获取数据库的连接
            try {
                Connection connection = dataSource.getConnection();
                System.out.println(connection);
            } catch (SQLException ex) {
                // 这些信息是给开发者使用,帮助找到错误是在哪.
                ex.printStackTrace();
                System.out.println(ex);// 错误信息较短
                // 数据库连接不上,就抛运行时异常,因为数据库都连接不上,下边的操作就没任何用.
                // throw抛出来的信息是给用户看的
                throw new RuntimeException("数据库连接失败");
            }
        }
    }

# 9.BasicDataSource类的常见配置 #

![这里写图片描述][SouthEast 3]

# 10.DBCP连接池实现数据库连接池的工具类 #

/* * 使用DBCP实现数据库连接池 连接池配置,自定义类 最基本的四项必须有 对于数据库连接池其他配置,自定义 */
    public class DBCPUtils {
        //创建出BasicDataSource
        private static BasicDataSource dataSource = new BasicDataSource();
    
        //静态代码块
        static {
            //数据库连接必须的
            dataSource.setDriverClassName("com.mysql.jdbc.Driver");
            dataSource.setUrl("jdbc:mysql://127.0.0.1:3306/mybase");
            dataSource.setUsername("root");
            dataSource.setPassword("123");
            ////对象连接池中的连接数量配置,可选择的
            dataSource.setMaxActive(10);//最大连接数量
            dataSource.setMinIdle(5);//最小空闲连接
            dataSource.setMaxIdle(8);//最大空闲连接
            dataSource.setInitialSize(3);//初始化连接
        }
        ////定义静态方法,返回BasicDataSource类的父接口DataSource
        public static DataSource getDataSource(){
            return dataSource;
        }
    }

# 11测试工具类(插入和查询操作) #

/* * 测试写好的工具类 提供的是一个DataSource接口的数据源 QueryRunner类构造方法,接收DataSource接口的实现类 后面,调用方法update,query,无需传递他们COnnection连接对象 */
    public class TestDbCPUtils {
        private static QueryRunner qr = new QueryRunner(DBCPUtils.getDataSource());
    
        public static void main(String[] args) {
            // 定义两个方法,实现数据表的添加,数据表的查询
            // QueryRunner类对象,卸载类成员位置
            //insert();
            select();
        }
        public static void select() {
            //查询语句
            String sql = "SELECT *FROM sort";
            try{
                //获得查询结果集的集合存入到ArrayList集合中
            List<Object[]> list = qr.query(sql, new ArrayListHandler());
            //两次遍历得到每一个元素
            for (Object[] objects : list) {
                for (Object object : objects) {
                    System.out.print(object+"\t");
                }
                System.out.println();
            }
            }catch(SQLException ex) {
                ex.printStackTrace();
                throw new RuntimeException("查询失败");
            }
        }
        public static void insert() {
            String sql = "INSERT INTO sort(sname,sprice,sdesc) VALUES(?,?,?)";
            Object[] params = {
       "坚果",699,"核桃碧根果"};
            try{
                int update = qr.update(sql, params);
                System.out.println(update);
            }catch(SQLException ex) {
                ex.printStackTrace();
                throw new RuntimeException("添加数据失败");
            }
        }
    }

# 12查询之后结果集中处理方法 #

import java.sql.Connection;
    import java.sql.SQLException;
    import java.util.List;
    import java.util.Map;
    import java.util.Set;
    
    import org.apache.commons.dbutils.QueryRunner;
    import org.apache.commons.dbutils.handlers.ArrayHandler;
    import org.apache.commons.dbutils.handlers.ArrayListHandler;
    import org.apache.commons.dbutils.handlers.BeanHandler;
    import org.apache.commons.dbutils.handlers.BeanListHandler;
    import org.apache.commons.dbutils.handlers.MapHandler;
    import org.apache.commons.dbutils.handlers.MapListHandler;
    import org.apache.commons.dbutils.handlers.ColumnListHandler;
    import org.apache.commons.dbutils.handlers.ScalarHandler;
    
    import com.bean.Sort;
    import com.jdbc.JDBCProperties;
    
    public class Demo2_ResultSetHandler {
        private static Connection conn = JDBCProperties.getConnection();
    
        public static void main(String[] args) throws SQLException {
            // ArrayHandler();
            // ArrayListHandler();
            //BeanHandler();
            //BeanListHandler();
            //MapHandler();
            // MapListHandler();
            //ColumnListHandler();
            ScalarHandler();
        }
    
        /* * 结果集的第一种处理方法,ArrayHandler(是ResultSetHandler的实现类) 将结果集的第一行存储到对象数组中Object[] */
        public static void ArrayHandler() throws SQLException {
            QueryRunner qr = new QueryRunner();
            String sql = "SELECT *FROM sort";
            // 这个地方导包的时候一定要注意是:org.apache.commons.dbutils.handlers.ArrayHandler;
            Object[] result = qr.query(conn, sql, new ArrayHandler());
            for (Object object : result) {
                System.out.print(object + "\t");
            }
        }

/*
     * 
     * 第二种处理方法 ArrayListHandler 将结果集的每一行,封装到对象数组中,会出现很多对象 数组, 对象数组存储到List集合
     */
    public static void ArrayListHandler() throws SQLException {
        QueryRunner qr = new QueryRunner();
        String sql = "SELECT *FROM sort";
        List<Object[]> result = qr.query(conn, sql, new ArrayListHandler());
        for (Object[] objects : result) {
            for (Object object : objects) {
                System.out.print(object + "\t");
            }
            System.out.println();
        }
    }
    
    /*
     * 第三种处理方法 BeanHandler 将结果的第一行数据,封装成JavaBean对象
     * 注意:被封装成数据到JavaBean对象,Sort类必须有空参构造
     */
    public static void BeanHandler() throws SQLException {
        QueryRunner qr = new QueryRunner();
        String sql = "SELECT *FROM sort";
    
        // 调用方法,传递结果集实现类BeanHandler
        // BeanHandler(Class<T>(type))
        /**
         * 
         BeanHandler结果集,数据表第一行,封装到JavaBean对象中,结果集第一行封装成Sort类对象 Sort s = new
         * Sort(sid ,sname,..) BeanHandler(Class c
         * )传递Sort类的class文件的对象Sort.class内部,获取到了传递的Sort.class文件对象,反射,创建对象
         */
        Sort result = qr.query(conn, sql, new BeanHandler<Sort>(Sort.class));
        // Sort [sid=1, sname=家电, sprice=3000.0, sdesc=降价了!!!!!]
        System.out.println(result);
    }
    public static void BeanListHandler() throws SQLException{
        QueryRunner qr = new QueryRunner();
        String sql = "SELECT *FROM sort";
        List<Sort> result = qr.query(conn, sql, new BeanListHandler<Sort>(Sort.class));
    
        //遍历结果集
        for (Sort sort : result) {
            System.out.println(sort);
        }
    }
    
    public static void MapHandler() throws SQLException{
        QueryRunner qr = new QueryRunner();
        String sql = "SELECT *FROM sort";
        Map<String, Object> result = qr.query(conn, sql, new MapHandler());
        //拿到的是第一列的集合,只是以键值对的形式出现,键为数据表的标题,值就是添加的数据
        Set<String> set = result.keySet();
        for (String key : set) {
    
            Object value = result.get(key);
            System.out.println(key+" = "+value);
        }
    }
    
    public static void MapListHandler() throws SQLException{
        QueryRunner qr = new QueryRunner();
        String sql = "SELECT *FROM sort";
        List<Map<String, Object>> result = qr.query(conn, sql, new MapListHandler());
        //拿到的是第一列的集合,只是以键值对的形式出现,键为数据表的标题,值就是添加的数据
    
        for (Map<String, Object> map : result) {
            Set<String> set = map.keySet();
            for (String key : set) {
                Object value = map.get(key);
                System.out.print(key+" = "+value);
            }
            System.out.println();
        }
    
    }
    
    public static void ColumnListHandler() throws SQLException{
        QueryRunner qr = new QueryRunner();
        String sql = "SELECT *FROM sort";
        //获取指定列的所有数据
        Object result = qr.query(conn, sql, new ColumnListHandler<>(2));
    
        System.out.println(result);
    
    }
    
    // ScalarHandler
    
    public static void ScalarHandler() throws SQLException{
        QueryRunner qr = new QueryRunner();
        String sql = "SELECT *FROM sort";
        //获取第一行的第几个数据,给个2就是获取第一行的第二个数据,只能获取到第一行当中的数据
        Object result = qr.query(conn, sql, new ScalarHandler<>(2));
    
        System.out.println(result);
    
    }

# 13.Scanner类中next方法和nextLine方法的区别 #

1.next()方法  
next()一定要读取到有效字符后才可以结束输入，对输入有效字符之前遇到的空格键、Tab键或Enter键等结束符，next()方法会自动将其去掉，只有在输入有效字符之后，next()方法才将其后输入的空格键、Tab键或Enter键等视为分隔符或结束符。

简单地说，next()查找并返回来自此扫描器的下一个完整标记。完整标记的前后是与分隔模式匹配的输入信息，所以next方法不能得到带空格的字符串。  
2.nextLine()方法  
而nextLine()方法的结束符只是Enter键，即nextLine()方法返回的是Enter键之前的所有字符，它是可以得到带空格的字符串的。

[SouthEast]: /images/20220615/56be9c5334e64773afc575cecdb99133.png
[SouthEast 1]: /images/20220615/13aa59f853a8453594391426432580fe.png
[SouthEast 2]: /images/20220615/d2562d3a105f46c39fd7bd1cead44c59.png
[SouthEast 3]: /images/20220615/15e91109af634a779156cc133ae14499.png