TxQueryRunner-JDBC小工具

1.TxQueryRunner的简介（需要相关jar包的请留言）

TxQueryRunner类是common-dbutils下QueryRunner的子类，是用来简化JDBC操作的，所以要导入common-dbutils的jar包。

TxQueryRunner底层是使用了JdbcUtils。可以使用JdbcUtils.getConnection()来获取连接。使用JdbcUtils.releaseConnection()来关闭连接。

2.TxQueryRunner中的方法

TxQueryRunner主要涉及3个方法：
1.update() -->insert、delete、update

2.query()   -->select

3.batch()  -->批处理

TxQueryRunner的【代码清单--0】

  1 package com.lxf.myCommonUtils;
  2
  3 import java.sql.Connection;
  4 import java.sql.SQLException;
  5
  6 import org.apache.commons.dbutils.QueryRunner;
  7 import org.apache.commons.dbutils.ResultSetHandler;
  8
  9 public class TxQueryRunner extends QueryRunner
 10 {
 11     /**
 12      * 1.批处理
 13      */
 14     @Override
 15     public int[]batch(String sql,Object[][] params)throws SQLException
 16     {
 17         //获取连接
 18         Connection con = JdbcUtils.getConnection();
 19         //操作
 20         int[] result = super.batch(con, sql, params);
 21         //释放连接
 22         JdbcUtils.releaseConnection(con);
 23         return result;
 24     }
 25
 26     /**
 27      * 2.带有查询条件的query()方法。
 28      *  单行查询
 29      */
 30     @Override
 31     public <T> T query(String sql,ResultSetHandler<T> rsh,Object... params)
 32     throws SQLException
 33     {
 34         //获取连接
 35         Connection con = JdbcUtils.getConnection();
 36         //操作
 37         T  result = super.query(con, sql, rsh, params);
 38         //释放连接
 39         JdbcUtils.releaseConnection(con);
 40         return result;
 41     }
 42
 43     /**
 44      * 3.多行查询
 45      */
 46     @Override
 47     public <T> T query(String sql,ResultSetHandler<T> rsh)
 48             throws SQLException
 49             {
 50                 //获取连接
 51                 Connection con = JdbcUtils.getConnection();
 52                 //操作
 53                 T  result = super.query(con, sql, rsh);
 54                 //释放连接
 55                 JdbcUtils.releaseConnection(con);
 56                 return result;
 57             }
 58
 59     /**
 60      * 4.不带参数的update()
 61      */
 62     @Override
 63     public int update(String sql)throws SQLException
 64     {
 65         //获取连接
 66         Connection con = JdbcUtils.getConnection();
 67         //操作
 68         int result = super.update(con, sql);
 69         //释放连接
 70         JdbcUtils.releaseConnection(con);
 71         return result;
 72     }
 73
 74     /**
 75      * 带有一个参数的uodate()
 76      */
 77     @Override
 78     public int update(String sql,Object param)throws SQLException
 79     {
 80         //获取连接
 81         Connection con = JdbcUtils.getConnection();
 82         //操作
 83         int result = super.update(con, sql, param);
 84         //释放连接
 85         JdbcUtils.releaseConnection(con);
 86         return result;
 87     }
 88
 89     @Override
 90     public int update(String sql,Object... params)throws SQLException
 91     {
 92         //获取连接
 93         Connection con = JdbcUtils.getConnection();
 94         //操作
 95         int result = super.update(con, sql, params);
 96         //释放连接
 97         JdbcUtils.releaseConnection(con);
 98         return result;
 99     }
100
101 }

3.TxQueryRunner的单元测试

3.1--准备工作　

　　为了进行TxQueryRunner的单元测试，我们需要在数据库中建立一张表（此处我建立的是person表）。另外还需要创建一个Person实体类。

注意：表中的字段名必须和Person实体类的属性名保持一致。

　- 数据库表的建立

       

　　-　Person实体类【代码清单--1】

 1  1 package com.lxf.bean;
 2  2
 3  3 /**
 4  4  * Person实体类
 5  5  * @author Administrator
 6  6  *
 7  7  */
 8  8 public class Person
 9  9 {
10 10     private String pid;
11 11     private String pname;
12 12     private int page;
13 13     private String sex;
14 14
15 15     public String getPid() {
16 16         return pid;
17 17     }
18 18     public void setPid(String pid) {
19 19         this.pid = pid;
20 20     }
21 21     public String getPname() {
22 22         return pname;
23 23     }
24 24     public void setPname(String pname) {
25 25         this.pname = pname;
26 26     }
27 27     public int getPage() {
28 28         return page;
29 29     }
30 30     public void setPage(int page) {
31 31         this.page = page;
32 32     }
33 33     public String getSex() {
34 34         return sex;
35 35     }
36 36     public void setSex(String sex) {
37 37         this.sex = sex;
38 38     }
39 39     @Override
40 40     public String toString() {
41 41         return "Person [pid=" + pid + ", pname=" + pname + ", page=" + page
42 42                 + ", sex=" + sex + "]";
43 43     }
44 44
45 45 }

3.2单元测试

这里主要测试的方法有：

- 测试update的相关方法

- 测试查询的相关方法

具体见【代码清单--2】

  1 package com.lxf.test;
  2
  3 import java.sql.SQLException;
  4 import java.util.List;
  5 import java.util.Map;
  6
  7 import org.apache.commons.dbutils.QueryRunner;
  8 import org.apache.commons.dbutils.handlers.BeanHandler;
  9 import org.apache.commons.dbutils.handlers.BeanListHandler;
 10 import org.apache.commons.dbutils.handlers.MapHandler;
 11 import org.apache.commons.dbutils.handlers.MapListHandler;
 12 import org.apache.commons.dbutils.handlers.ScalarHandler;
 13 import org.junit.Test;
 14
 15 import com.lxf.bean.Person;
 16 import com.lxf.myCommonUtils.JdbcUtils;
 17
 18 import cn.itcast.jdbc.TxQueryRunner;
 19
 20 /**
 21  * TxQueryRunner类是common-dbutils下QueryRunner的子类，是用来简化JDBC操作的。
 22  * 所以要导入common-dbutils的jar包
 23  * TxQueryRunner底层是使用了JdbcUtils的。
 24  * 它里面主要涉及3个方法：
 25  *     1.update  -->insert、delete、update
 26  *  2.query   -->select
 27  *  3.批处理
 28  * @author Administrator
 29  *
 30  */
 31 public class TxQueryRunnerTest
 32 {
 33     /**
 34      * 测试update方法，用来执行insert、delete、update语句。
 35      * @throws SQLException
 36      */
 37     @Test
 38     public void testUpdate() throws SQLException
 39     {
 40         String sql = "insert into person(pid,pname,page,sex)values(?,?,?,?)";
 41         //给sql中对应的参数赋值
 42         Object[] params = {"3","p3","3","男"};
 43         QueryRunner qr = new TxQueryRunner();
 44         qr.update(sql, params);
 45     }
 46
 47     /**
 48      * 使用事务
 49      * @throws SQLException
 50      */
 51     @Test
 52     public void testUpdate2() throws Exception
 53     {
 54
 55         try
 56         {
 57             //1.开启事务
 58             JdbcUtils.beginTransaction();
 59
 60             //2.多次操作
 61             String sql = "insert into person(pid,pname,page,sex)values(?,?,?,?)";
 62             //给sql中对应的参数赋值
 63             Object[] params = {"4","p4","4","women"};
 64             QueryRunner qr = new TxQueryRunner();
 65             //执行
 66             qr.update(sql, params);
 67
 68             if(false)
 69             {
 70                 throw new Exception();
 71             }
 72
 73             params = new Object[]{"5","p5","5","women"};
 74             //执行
 75             qr.update(sql,params);
 76
 77             //3.提交事务
 78             JdbcUtils.commitTransaction();
 79
 80         }catch(Exception e)
 81         {
 82             try
 83             {
 84                 //4.回滚事务
 85                 JdbcUtils.rollbackTransaction();
 86             }
 87             catch (SQLException e1)
 88             {
 89                 e1.printStackTrace();
 90             }
 91             throw e;
 92         }
 93     }
 94
 95     /**
 96      *测试查询方法
 97      *JDBC查询的结果是ResultSet;
 98      *而QueryRunner查询的结果是通过 ResultSet映射后的数据。
 99      *转换结果：
100      *    1.javaBean:把结果集封装到javaBean中；
101      *    2.Map:把结果集封装到Map中。
102      *    3.把结果集封装到Object中(结果集是单行单列)
103      * @throws SQLException
104      */
105
106     /**
107      * 单行结果集映射到javaBean中
108      * @throws SQLException
109      */
110     @Test
111     public void testQuery1() throws SQLException
112     {
113         String sql = "select * from person where pid = ?";
114         QueryRunner qr = new TxQueryRunner();
115         /*
116          *第二个参数类型为ResultSetHandler，他是一个接口，表示映射的结果类型。
117          *BeanHandler ,它是 ResultSetHandler的实现类，他的作用是把结果集封装到Person对象中。
118          */
119         Person p = qr.query(sql, new BeanHandler<Person>(Person.class),"1");
120         System.out.println(p);
121     }
122
123     /**
124      * 使用BeanListHandler
125      * 把多行结果集映射到List<Bean>中，即多个javaBean对象
126      * 一行结果映射到一个javaBean对象中，多行结果映射到List<Bean>中。
127      * @throws SQLException
128      */
129     @Test
130     public void testQuery2() throws SQLException
131     {
132         //相比单行映射名只需要把条件去掉即可
133         String sql = "select * from person ";
134         QueryRunner qr = new TxQueryRunner();
135         /*
136          *第二个参数类型为ResultSetHandler，他是一个接口，表示映射的结果类型。
137          *BeanListHandler ,它是 ResultSetHandler的实现类，他的作用是把结果集封装到Person对象中。
138          */
139         List<Person> list = qr.query(sql, new BeanListHandler<Person>(Person.class));
140         System.out.println(list);
141     }
142
143     /**
144      * Map
145      * 使用MapHandler将单行结果集映射到Map中
146      * @throws SQLException
147      */
148     @Test
149     public void testQuery3() throws SQLException
150     {
151         //相比单行映射名只需要把条件去掉即可
152         String sql = "select * from person where pid = ?";
153         QueryRunner qr = new TxQueryRunner();
154         /*
155          *第二个参数类型为ResultSetHandler，他是一个接口，表示映射的结果类型。
156          *MapHandler ,它是 ResultSetHandler的实现类，他的作用是把结果集封装到Person对象中。
157          */
158         Map map = qr.query(sql, new MapHandler(),"1");
159         System.out.println(map);
160     }
161
162     /**
163      * 使用MapListHandler将多行结果集映射到MapList中，
164      * 即一行结果集映射到Map中，多行结果集映射到MapList中。
165      * @throws SQLException
166      */
167     @Test
168     public void testQuery4() throws SQLException
169     {
170         //相比单行映射名只需要把条件去掉即可
171         String sql = "select * from person";
172         QueryRunner qr = new TxQueryRunner();
173         /*
174          *第二个参数类型为ResultSetHandler，他是一个接口，表示映射的结果类型。
175          *MapHandler ,它是 ResultSetHandler的实现类，他的作用是把结果集封装到Person对象中。
176          */
177         List<Map<String,Object>> mapList = qr.query(sql, new MapListHandler());
178         System.out.println(mapList);
179     }
180
181     /**
182      * 使用ScalarHandler将单行单列的结果集映射到Object中
183      * @throws SQLException
184      */
185     @Test
186     public void testQuery5() throws SQLException
187     {
188         //相比单行映射名只需要把条件去掉即可
189         String sql = "select count(*) from person";
190         QueryRunner qr = new TxQueryRunner();
191         /*
192          *第二个参数类型为ResultSetHandler，他是一个接口，表示映射的结果类型。
193          *MapHandler ,它是 ResultSetHandler的实现类，他的作用是把结果集封装到Person对象中。
194          */
195         Object obj = qr.query(sql, new ScalarHandler());
196         Number number = (Number)obj;
197         long count = number.longValue();
198         System.out.println(count);
199     }
200
201
202 }

4.后期补充

新增【多表映射，代码清单--4】

 1 /**
 2      * 多表映射
 3      * 一行结果集中包含两张表的数据
 4      * 使用MapHnadler来处理数据
 5      * 把数据封装到Map中，
 6      * 使用Map分别生成Person和Address对象
 7      * 将两个对象建立联系
 8      * @throws SQLException
 9      */
10     @Test
11     public void testQuery6() throws SQLException
12     {
13         //相比单行映射名只需要把条件去掉即可
14         String sql = "select * from person t , t_address b where t.pid = b.aid and t.pid = ?";
15         QueryRunner qr = new TxQueryRunner();
16         Map map = qr.query(sql, new MapHandler(),"1");
17         //生成Person对象
18         Person p = CommonUtils.toBean(map, Person.class);
19         //生成Address对象
20         Address a = CommonUtils.toBean(map, Address.class);
21         //建立联系
22         p.setAddr(a);
23         System.out.println(p);
24     }

此时，需要在bean中新建一个Address实体类，并且在Person类中引用。以此来建立联系。

【Address实体类】

 1 package com.lxf.bean;
 2
 3 /**
 4  * 地址类
 5  * @author Administrator
 6  *
 7  */
 8 public class Address
 9 {
10     //编号，省份，城市，街道
11     private String aid;
12
13     private String province;
14
15     private String city;
16
17     private String street;
18
19     public String getAid() {
20         return aid;
21     }
22
23     public void setAid(String aid) {
24         this.aid = aid;
25     }
26
27     public String getProvince() {
28         return province;
29     }
30
31     public void setProvince(String province) {
32         this.province = province;
33     }
34
35     public String getCity() {
36         return city;
37     }
38
39     public void setCity(String city) {
40         this.city = city;
41     }
42
43     public String getStreet() {
44         return street;
45     }
46
47     public void setStreet(String street) {
48         this.street = street;
49     }
50
51     @Override
52     public String toString() {
53         return "Address [aid=" + aid + ", province=" + province + ", city="
54                 + city + ", street=" + street + "]";
55     }
56
57
58 }

在数据库中建立t_address表。如图：