TxQueryRunner类是common-dbutils下QueryRunner的子类，是用来简化JDBC操作的，所以要导入common-dbutils的jar包。
TxQueryRunner底层是使用了JdbcUtils。可以使用JdbcUtils.getConnection()来获取连接。使用JdbcUtils.releaseConnection()来关闭连接。
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 }
为了进行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 }
这里主要测试的方法有：
- 测试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】
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表。如图：
原文：http://www.cnblogs.com/hoobey/p/7466210.html