DButils工具类和连接池的使用

1. DButils工具类的介绍个三个核心类

   A: DButils工具类的介绍个三个核心类
   a: 概述
      DBUtils是java编程中的数据库操作实用工具，小巧简单实用。
      DBUtils封装了对JDBC的操作，简化了JDBC操作，可以少写代码。
      DBUtils就是JDBC的简化开发工具包。需要项目导入commons-dbutils-1.6.jar才能够正常使用DBUtils工具。
   b: Dbutils三个核心功能介绍
     QueryRunner中提供对sql语句操作的API.
     update(Connection conn, String sql, Object... params) ，用来完成表数据的增加、删除、更新操作
     query(Connection conn, String sql, ResultSetHandler rsh, Object... params) ，用来完成表数据的查询操作
     ResultSetHandler接口，用于定义select操作后，怎样封装结果集.
     DbUtils类，它就是一个工具类,定义了关闭资源与事务处理的方法

2. QueryRunner类的update方法介绍

     a: 方法介绍

     update(Connection conn, String sql, Object... params) ，用来完成表数据的增加、删除、更新操作
     使用QueryRunner类,实现对数据表的insert delete update
     调用QueryRunner类的方法 update (Connection con,String sql,Object...param)
     Object...param 可变参数,Object类型,SQL语句会出现?占位符
     数据库连接对象,自定义的工具类传递

   b. 代码实现  

 1 /**
 2  * QueryRunner类
 3  * update(Connection conn, String sql, Object... params)
 4  * 实现表中数据的增、删、改
 5  * @author vanguard
 6  *
 7  */
 8 public class QueryRunnerDemo {
 9     //获取数据库连接
10     private static Connection conn = JDBCUtils.getConnection();
11     
12     public static void main(String[] args) throws SQLException {
13         //insert();
14         //delete();
15         //update();
16     }
17     /**
18      * 使用QueryRunner类中的update方法，实现更新数据
19      * @throws SQLException
20      */
21     private static void update() throws SQLException {
22         //创建QueryRunner类对象
23         QueryRunner qr = new QueryRunner();
24         //定义更新的sql语句
25         String sql = "UPDATE sort SET sname=?,sprice=?,sdesc=? WHERE sid=?";
26         将四个?占位符的实际参数写在数组中
27         Object[] params = {"家居产品", 9000, "涨价了", 2};
28         调用QueryRunner类的方法update执行SQL语句
29         int row = qr.update(conn, sql, params);
30         System.out.println(row);
31         DbUtils.closeQuietly(conn);
32     }
33     /**
34      *  使用QueryRunner类中的update方法，实现添加数据
35      * @throws SQLException
36      */
37     private static void delete() throws SQLException {
38         //创建QueryRunner类对象
39         QueryRunner qr = new QueryRunner();
40         String sql = "DELETE FROM sort WHERE sid=?";
41         //调用QueryRunner类的方法update执行SQL语句
42         int row = qr.update(conn, sql, 7);
43         System.out.println(row);
44         DbUtils.closeQuietly(conn);
45     }
46     
47     /**
48      * 使用Q    ueryRunner类中的update方法，实现添加数据
49      * @throws SQLException
50      */
51     private static void insert() throws SQLException {
52         //创建QueryRunner类对象
53         QueryRunner qr = new QueryRunner();
54         String sql = "INSERT INTO sort(sname,sprice,sdesc) VALUES(?,?,?)";
55         //将三个?占位符的实际参数写在数组中
56         Object[] params = {"体育用品", 200.98, "购买体育用品"};
57         //调用QueryRunner类的方法update执行SQL语句
58         int row = qr.update(conn, sql, params);
59         System.out.println(row);
60         DbUtils.closeQuietly(conn);
61     }
62 }

3. DBUtils工具类结果集处理的方式

   a: QueryRunner实现查询操作
     query(Connection conn, String sql, ResultSetHandler rsh, Object... params) ，用来完成表数据的查询操作
   b: 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集合

4. QueryRunner类的方法query
  a: QueryRunner类的方法query数据查询操作
    调用QueryRunner类方法query(Connection con,String sql,ResultSetHandler r, Object..params)
    ResultSetHandler r 结果集的处理方式,传递ResultSetHandler接口实现类
    Object..params SQL语句中的?占位符
    注意: query方法返回值,返回的是T 泛型, 具体返回值类型,跟随结果集处理方式变化

  b:代码实现：   

  1 /**
  2  * 使用QueryRunner类中的
  3  * query(Connection conn, String sql, ResultSetHandler rsh, 
  4  *                         Object... params)
  5  * 完成对数据的查询操作
  6  * ResultSetHandler结果集处理类 8中处理结果集的方式
  7  *  ArrayHandler    将结果集中的第一条记录封装到一个Object[]数组中，数组中的每一个元素就是这条记录中的每一个字段的值
  8  *  ArrayListHandler    将结果集中的每一条记录都封装到一个Object[]数组中，将这些数组在封装到List集合中。
  9  *  BeanHandler    将结果集中第一条记录封装到一个指定的javaBean中。
 10  *  BeanListHandler    将结果集中每一条记录封装到指定的javaBean中，将这些javaBean在封装到List集合中
 11  *  ColumnListHandler    将结果集中指定的列的字段值，封装到一个List集合中
 12  *  ScalarHandler    它是用于单数据。例如select count(*) from 表操作。
 13  *  MapHandler    将结果集第一行封装到Map集合中,Key 列名, Value 该列数据
 14  *  MapListHandler    将结果集第一行封装到Map集合中,Key 列名, Value 该列数据,Map集合存储到List集合
 15  * @author vanguard
 16  *
 17  */
 18 public class QueryRunnerDmoe01 {
 19     private static Connection conn = JDBCUtils.getConnection();
 20     
 21     public static void main(String[] args) throws SQLException {
 22         //arrayHandler();
 23         //arrayListHandler();
 24         //beanHandler();
 25         //beanListHandler();
 26         //columnListHandler();
 27         //scalarHandler();
 28         //mapHandler();
 29         mapListHandler();
 30     }
 31     
 32     /**
 33      * 结果集处理的第八种方式MapListHandler
 34      * 将结果集的每一行结果封装到Map集合中，Key 列名，Value 该列的数据
 35      * 将Map集合放到List集合中
 36      * @throws SQLException
 37      */
 38     private static void mapListHandler() throws SQLException {
 39         //创建QueryRunner类对象
 40         QueryRunner qr = new QueryRunner();
 41         //定义查询的sql语句
 42         String sql = "SELECT * FROM sort";
 43         //调用query()执行查询操作，传递连接对象，SQL语句，结果处理类方式的实现类
 44         List> list = qr.query(conn, sql, new MapListHandler());
 45         //遍历List集合
 46         for(Map map : list) {
 47             for(String row : map.keySet()) {
 48                 System.out.print(row + ":" + map.get(row) + "\t");
 49             }
 50             System.out.println();
 51         }
 52     }
 53 
 54     /**
 55      * 结果集处理的第七种方式MapHandler
 56      * 将结果集的第一行数据封装到Map集合中 Key 列名 Value 该列数据
 57      * @throws SQLException
 58      */
 59     private static void mapHandler() throws SQLException {
 60         //创建QueryRunner类对象
 61         QueryRunner qr = new QueryRunner();
 62         //定义查询的sql语句
 63         String sql = "SELECT * FROM sort";
 64         //调用query()执行查询操作，传递连接对象，SQL语句，结果处理类方式的实现类
 65         Map map = qr.query(conn, sql, new MapHandler());
 66         for(String row : map.keySet()) {
 67             System.out.print(row + ":" + map.get(row) + "  ");
 68         }
 69     }
 70 
 71     /**
 72      * 结果集处理的第六种方式ScalarHandler
 73      * 它用于单数据，对于查询后只有一个结果
 74      * @throws SQLException
 75      */
 76     private static void scalarHandler() throws SQLException {
 77         //创建QueryRunner类对象
 78         QueryRunner qr = new QueryRunner();
 79         //定义查询的sql语句
 80         String sql = "SELECT COUNT(*) FROM sort";
 81         //调用query()执行查询操作，传递连接对象，SQL语句，结果处理类方式的实现类
 82         long count = qr.query(conn, sql, new ScalarHandler());
 83         System.out.println(count);
 84     }
 85     
 86     /**
 87      * 结果集处理的第五种方式ColumnListHandler
 88      * 将结果集中指定列的字段值封装到list集合中
 89      * @throws SQLException
 90      */
 91     private static void columnListHandler() throws SQLException {
 92         //创建QueryRunner类对象
 93         QueryRunner qr = new QueryRunner();
 94         //定义查询的sql语句
 95         String sql = "SELECT * FROM sort";
 96         //调用query()执行查询操作，传递连接对象，SQL语句，结果处理类方式的实现类
 97         List list = qr.query(conn, sql, new ColumnListHandler("sname"));
 98         for(String name : list) {
 99             System.out.println(name);
100         } 
101     }
102 
103     /**
104      * 结果集处理的第四种方式BeanListHandler
105      * 将结果集中每一条数据封装到JavaBean对象中
106      * 将这些JavaBean对象放到list集合中
107      * @throws SQLException
108      */
109     private static void beanListHandler() throws SQLException {
110         //创建QueryRunner类对象
111         QueryRunner qr = new QueryRunner();
112         //定义查询的sql语句
113         String sql = "SELECT * FROM sort";
114         //调用query()执行查询操作，传递连接对象，SQL语句，结果处理类方式的实现类
115         List list = qr.query(conn, sql, new BeanListHandler(Sort.class));
116         //遍历list集合
117         for(Sort s : list) {
118             System.out.println(s);
119         }
120     }
121 
122     /**
123      * 结果集处理的第三种方式BeanHandler
124      * 将结果集中的第一条数据封装到JavaBean对象中
125      * 注意：被封装成数据到JavaBean对象，Sort类中必须有空参构造
126      * @throws SQLException
127      */
128     private static void beanHandler() throws SQLException {
129         //创建QueryRunner类对象
130         QueryRunner qr = new QueryRunner();
131         //定义查询的sql语句
132         String sql = "SELECT * FROM sort";
133         //调用query()执行查询操作，传递连接对象，SQL语句，结果处理类方式的实现类
134         Sort s = qr.query(conn, sql, new BeanHandler(Sort.class));
135         System.out.println(s);
136     }
137 
138     /**
139      * 结果集处理的第二种方式ArrayListHandler
140      * 将结果集的每一行封装到Object[]数组中
141      * 将这些数组放到list集合中
142      * @throws SQLException
143      */
144     private static void arrayListHandler() throws SQLException {
145         //创建QueryRunner类对象
146         QueryRunner qr = new QueryRunner();
147         //定义查询的sql语句
148         String sql = "SELECT * FROM sort";
149         //调用query()执行查询操作，传递连接对象，SQL语句，结果处理类方式的实现类
150         List list = qr.query(conn, sql, new ArrayListHandler());
151         for(Object[] objs : list) {
152             for(Object obj : objs) {
153                 System.out.print(obj + "\t\t");
154             }
155             System.out.println();
156         }
157     }
158 
159     /**
160      * 结果集处理的第一种方式ArrayHandler
161      * 将结果集的第一行封装到Object[]数组中
162      * @throws SQLException 
163      */
164     private static void arrayHandler() throws SQLException {
165         //创建QueryRunner类对象
166         QueryRunner qr = new QueryRunner();
167         //定义查询的sql语句
168         String sql = "SELECT * FROM sort";
169         //调用query()执行查询操作，传递连接对象，SQL语句，结果处理类方式的实现类
170         Object[] objects = qr.query(conn, sql, new ArrayHandler());
171         //遍历数组
172         for(Object obj : objects) {
173             System.out.print(obj + "  ");
174         }
175     }
176 }

 1 public class Sort {
 2     private int sid;
 3     private String sname;
 4     private int sprice;
 5     private String sdesc;
 6     
 7     public Sort() {}
 8     
 9     public Sort(int sid, String sname, int sprice, String sdesc) {
10         super();
11         this.sid = sid;
12         this.sname = sname;
13         this.sprice = sprice;
14         this.sdesc = sdesc;
15     }
16 
17     public int getSid() {
18         return sid;
19     }
20 
21     public void setSid(int sid) {
22         this.sid = sid;
23     }
24 
25     public String getSname() {
26         return sname;
27     }
28 
29     public void setSname(String sname) {
30         this.sname = sname;
31     }
32 
33     public int getSprice() {
34         return sprice;
35     }
36 
37     public void setSprice(int sprice) {
38         this.sprice = sprice;
39     }
40 
41     public String getSdesc() {
42         return sdesc;
43     }
44 
45     public void setSdesc(String sdesc) {
46         this.sdesc = sdesc;
47     }
48 
49     @Override
50     public String toString() {
51         return "Sort [sid=" + sid + ", sname=" + sname + ", sprice=" + sprice
52                 + ", sdesc=" + sdesc + "]";
53     }
54     
55     
56 }

5. 连接池介绍
  1）: 连接池介绍
    a: 连接池介绍
      实际上就是存放连接的池子(容器)
     在开发中“获得连接”或“释放资源”是非常消耗系统资源的两个过程
     为了解决此类性能问题，通常情况我们采用连接池技术，来共享连接Connection。
     这样我们就不需要每次都创建连接、释放连接了，这些操作都交给了连接池

 2）: 连接池概念规范和DataSource接口
   a: 连接池概念规范
     用池来管理Connection，这样可以重复使用Connection。
     不用自己来创建Connection，而是通过池来获取Connection对象
     使用完Connection后，调用Connection的close()方法也不会真的关闭Connection，而是把Connection“归还”给池
     连接池技术可以完成Connection对象的再次利用
   b: DataSource接口
     Java为数据库连接池提供了公共的接口：javax.sql.DataSource
     各个厂商需要让自己的连接池实现这个接口。这样应用程序可以方便的切换不同厂商的连接池
     常见的连接池：DBCP、C3P0

 3）: DBCP连接池介绍
   a: DBCP连接池介绍
     DBCP也是一个开源的连接池，是Apache Common成员之一，在企业开发中也比较常见，tomcat内置的连接池

 4）: 导入jar包
   a: jar包介绍
    mysql-connector-java-5.1.37-bin.jar：数据库驱动
    commons-dbutils-1.6.jar：提供QueryRunner类方便进行增删改查操作
    commons-dbcp-1.4.jar：
    commons-pool-1.5.6.jar：提供高效的数据库连接池技术
  b: 导入jar包
    在项目根路径下建立文件夹lib
    拷贝以上jar包，选定拷贝的jar包/右键/Build Path/Add to Build Path

 5）: BasicDataSource类的使用
   a: 案例代码

      

 1 /**
 2  * 连接池
 3  * 连接池jar包中定义好了一个类DataSource
 4  * 实现该类数据源的规范接口 javax.sql.DataSource
 5  * @author vanguard
 6  *
 7  */
 8 public class DataSourceDemo {
 9     public static void main(String[] args) {
10         //创建DataSource类接口的实现类对象
11         BasicDataSource datasource = new BasicDataSource();
12         //连接数据库的四个基本信息可以通过setXXX方法设置
13         datasource.setDriverClassName("com.mysql.jdbc.Driver");
14         datasource.setUrl("jdbc:mysql://localhost:3306/mybase");
15         datasource.setUsername("root");
16         datasource.setPassword("root");
17         
18         //调用对象的方法获取数据库连接
19         try {
20             Connection conn = datasource.getConnection();
21             System.out.println(conn);
22         } catch (SQLException e) {
23             e.printStackTrace();
24             throw new RuntimeException("数据库连接失败");
25         }
26     }
27 }

 

 6）: BasicDataSource类的常见配置
   a: 常见配置
     分类 属性 描述
     必须项
      driverClassName 数据库驱动名称
      url 数据库的地址
      username 用户名
      password 密码
   基本项（扩展）
      maxActive 最大连接数量
      minIdle 最小空闲连接
      maxIdle 最大空闲连接
      initialSize 初始化连接

 7）: 实现数据库连接池工具类
    a: 案例代码
      

 1 /**
 2  *  使用DBCP实现数据库的连接池
 3  *  连接池配置,自定义类,
 4  *  最基本四项完整
 5  *  对于数据库连接池其他配置,自定义
 6  * @author vanguard
 7  *
 8  */
 9 public class JDBCPoolUtils {
10     //创建出BasicDataSource类对象
11     private static BasicDataSource datasource = new BasicDataSource();
12     
13     //静态代码块，对BasicDataSource类进行配置
14     static {
15         //数据库连接信息，必须的
16         datasource.setDriverClassName("com.mysql.jdbc.Driver");
17         datasource.setUrl("jdbc:mysql://localhost:3306/stdb");
18         datasource.setUsername("root");
19         datasource.setPassword("root");
20         //对象连接池中的连接数量配置，可选
21         datasource.setInitialSize(10);//初始化的连接数
22         datasource.setMaxActive(8);//最大的连接数
23         datasource.setMaxIdle(5);//最大空闲数
24         datasource.setMinIdle(2);//最小空闲数
25     }
26     /**
27      * 返回BasicDataSource类对象
28      * @return
29      */
30     public static DataSource getDataSource() {
31         return datasource;
32     }
33 }

 8）: 工具类的测试
   a: 案例代码

 1 /**
 2  * 测试写好的工具类
 3  * 提供的是一个DataSource接口的数据源
 4  *  QueryRunner类构造方法,接收DataSource接口的实现类
 5  *  后面,调用方法update,query,无需传递他们Connection连接对象
 6  * @author vanguard
 7  *
 8  */
 9 public class QueryRunnerDemo {
10     private static QueryRunner qr = new QueryRunner(JDBCPoolUtils.getDataSource());
11     
12     public static void main(String[] args) {
13         //insert();
14         select();
15     }
16     /**
17      * 定义查询数据的方法
18      */
19     private static void select() {
20         String sql = "SELECT * FROM sort";
21         try {
22             List list = qr.query(sql, new ArrayListHandler());
23             for(Object[] objs : list) {
24                 for(Object obj : objs) {
25                     System.out.print(obj + "\t");
26                 }
27                 System.out.println();
28             }
29         } catch (SQLException e) {
30             
31             e.printStackTrace();
32             throw new RuntimeException("数据库查询失败");
33         }
34     }
35 
36     /**
37      * 定义添加数据的方法
38      */
39     private static void insert() {
40         String sql = "INSERT INTO sort(sname,sprice,sdesc) VALUES(?,?,?)";
41         Object[] params = {"水果", 20.5, "桃子便宜了"};
42         try {
43             int row = qr.update(sql, params);
44             System.out.println(row);
45         } catch (SQLException e) {
46             
47             e.printStackTrace();
48             throw new RuntimeException("数据添加失败");
49         }
50     }
51 }

 

转载于:https://www.cnblogs.com/guodong-wang/p/7240646.html