JDBC小工具--TxQueryRunner及其单元测试

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】

 package com.lxf.myCommonUtils;

 import java.sql.Connection;
 import java.sql.SQLException;

 import org.apache.commons.dbutils.QueryRunner;
 import org.apache.commons.dbutils.ResultSetHandler;

 public class TxQueryRunner extends QueryRunner
 {
     /**
      * 1.批处理
      */
     @Override
     public int[]batch(String sql,Object[][] params)throws SQLException
     {
         //获取连接
         Connection con = JdbcUtils.getConnection();
         //操作
         int[] result = super.batch(con, sql, params);
         //释放连接
         JdbcUtils.releaseConnection(con);
         return result;
     }

     /**
      * 2.带有查询条件的query()方法。
      *  单行查询
      */
     @Override
     public <T> T query(String sql,ResultSetHandler<T> rsh,Object... params)
     throws SQLException
     {
         //获取连接
         Connection con = JdbcUtils.getConnection();
         //操作
         T  result = super.query(con, sql, rsh, params);
         //释放连接
         JdbcUtils.releaseConnection(con);
         return result;
     }

     /**
      * 3.多行查询
      */
     @Override
     public <T> T query(String sql,ResultSetHandler<T> rsh)
             throws SQLException
             {
                 //获取连接
                 Connection con = JdbcUtils.getConnection();
                 //操作
                 T  result = super.query(con, sql, rsh);
                 //释放连接
                 JdbcUtils.releaseConnection(con);
                 return result;
             }

     /**
      * 4.不带参数的update()
      */
     @Override
     public int update(String sql)throws SQLException
     {
         //获取连接
         Connection con = JdbcUtils.getConnection();
         //操作
         int result = super.update(con, sql);
         //释放连接
         JdbcUtils.releaseConnection(con);
         return result;
     }

     /**
      * 带有一个参数的uodate()
      */
     @Override
     public int update(String sql,Object param)throws SQLException
     {
         //获取连接
         Connection con = JdbcUtils.getConnection();
         //操作
         int result = super.update(con, sql, param);
         //释放连接
         JdbcUtils.releaseConnection(con);
         return result;
     }

     @Override
     public int update(String sql,Object... params)throws SQLException
     {
         //获取连接
         Connection con = JdbcUtils.getConnection();
         //操作
         int result = super.update(con, sql, params);
         //释放连接
         JdbcUtils.releaseConnection(con);
         return result;
     }

 }

3.TxQueryRunner的单元测试

3.1--准备工作　

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

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

　- 数据库表的建立

       

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

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

3.2单元测试

这里主要测试的方法有：

- 测试update的相关方法

- 测试查询的相关方法

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

 package com.lxf.test;

 import java.sql.SQLException;
 import java.util.List;
 import java.util.Map;

 import org.apache.commons.dbutils.QueryRunner;
 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.ScalarHandler;
 import org.junit.Test;

 import com.lxf.bean.Person;
 import com.lxf.myCommonUtils.JdbcUtils;

 import cn.itcast.jdbc.TxQueryRunner;

 /**
  * TxQueryRunner类是common-dbutils下QueryRunner的子类，是用来简化JDBC操作的。
  * 所以要导入common-dbutils的jar包
  * TxQueryRunner底层是使用了JdbcUtils的。
  * 它里面主要涉及3个方法：
  *     1.update  -->insert、delete、update
  *  2.query   -->select
  *  3.批处理
  * @author Administrator
  *
  */
 public class TxQueryRunnerTest
 {
     /**
      * 测试update方法，用来执行insert、delete、update语句。
      * @throws SQLException
      */
     @Test
     public void testUpdate() throws SQLException
     {
         String sql = "insert into person(pid,pname,page,sex)values(?,?,?,?)";
         //给sql中对应的参数赋值
         Object[] params = {"3","p3","3","男"};
         QueryRunner qr = new TxQueryRunner();
         qr.update(sql, params);
     }

     /**
      * 使用事务
      * @throws SQLException
      */
     @Test
     public void testUpdate2() throws Exception
     {

         try
         {
             //1.开启事务
             JdbcUtils.beginTransaction();

             //2.多次操作
             String sql = "insert into person(pid,pname,page,sex)values(?,?,?,?)";
             //给sql中对应的参数赋值
             Object[] params = {"4","p4","4","women"};
             QueryRunner qr = new TxQueryRunner();
             //执行
             qr.update(sql, params);

             if(false)
             {
                 throw new Exception();
             }

             params = new Object[]{"5","p5","5","women"};
             //执行
             qr.update(sql,params);

             //3.提交事务
             JdbcUtils.commitTransaction();

         }catch(Exception e)
         {
             try
             {
                 //4.回滚事务
                 JdbcUtils.rollbackTransaction();
             }
             catch (SQLException e1)
             {
                 e1.printStackTrace();
             }
             throw e;
         }
     }

     /**
      *测试查询方法
      *JDBC查询的结果是ResultSet;
      *而QueryRunner查询的结果是通过 ResultSet映射后的数据。
      *转换结果：
      *    1.javaBean:把结果集封装到javaBean中；
      *    2.Map:把结果集封装到Map中。
      *    3.把结果集封装到Object中(结果集是单行单列)
      * @throws SQLException
      */

     /**
      * 单行结果集映射到javaBean中
      * @throws SQLException
      */
     @Test
     public void testQuery1() throws SQLException
     {
         String sql = "select * from person where pid = ?";
         QueryRunner qr = new TxQueryRunner();
         /*
          *第二个参数类型为ResultSetHandler，他是一个接口，表示映射的结果类型。
          *BeanHandler ,它是 ResultSetHandler的实现类，他的作用是把结果集封装到Person对象中。
          */
         Person p = qr.query(sql, new BeanHandler<Person>(Person.class),"1");
         System.out.println(p);
     }

     /**
      * 使用BeanListHandler
      * 把多行结果集映射到List<Bean>中，即多个javaBean对象
      * 一行结果映射到一个javaBean对象中，多行结果映射到List<Bean>中。
      * @throws SQLException
      */
     @Test
     public void testQuery2() throws SQLException
     {
         //相比单行映射名只需要把条件去掉即可
         String sql = "select * from person ";
         QueryRunner qr = new TxQueryRunner();
         /*
          *第二个参数类型为ResultSetHandler，他是一个接口，表示映射的结果类型。
          *BeanListHandler ,它是 ResultSetHandler的实现类，他的作用是把结果集封装到Person对象中。
          */
         List<Person> list = qr.query(sql, new BeanListHandler<Person>(Person.class));
         System.out.println(list);
     }

     /**
      * Map
      * 使用MapHandler将单行结果集映射到Map中
      * @throws SQLException
      */
     @Test
     public void testQuery3() throws SQLException
     {
         //相比单行映射名只需要把条件去掉即可
         String sql = "select * from person where pid = ?";
         QueryRunner qr = new TxQueryRunner();
         /*
          *第二个参数类型为ResultSetHandler，他是一个接口，表示映射的结果类型。
          *MapHandler ,它是 ResultSetHandler的实现类，他的作用是把结果集封装到Person对象中。
          */
         Map map = qr.query(sql, new MapHandler(),"1");
         System.out.println(map);
     }

     /**
      * 使用MapListHandler将多行结果集映射到MapList中，
      * 即一行结果集映射到Map中，多行结果集映射到MapList中。
      * @throws SQLException
      */
     @Test
     public void testQuery4() throws SQLException
     {
         //相比单行映射名只需要把条件去掉即可
         String sql = "select * from person";
         QueryRunner qr = new TxQueryRunner();
         /*
          *第二个参数类型为ResultSetHandler，他是一个接口，表示映射的结果类型。
          *MapHandler ,它是 ResultSetHandler的实现类，他的作用是把结果集封装到Person对象中。
          */
         List<Map<String,Object>> mapList = qr.query(sql, new MapListHandler());
         System.out.println(mapList);
     }

     /**
      * 使用ScalarHandler将单行单列的结果集映射到Object中
      * @throws SQLException
      */
     @Test
     public void testQuery5() throws SQLException
     {
         //相比单行映射名只需要把条件去掉即可
         String sql = "select count(*) from person";
         QueryRunner qr = new TxQueryRunner();
         /*
          *第二个参数类型为ResultSetHandler，他是一个接口，表示映射的结果类型。
          *MapHandler ,它是 ResultSetHandler的实现类，他的作用是把结果集封装到Person对象中。
          */
         Object obj = qr.query(sql, new ScalarHandler());
         Number number = (Number)obj;
         long count = number.longValue();
         System.out.println(count);
     }

 }

4.后期补充

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

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

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

【Address实体类】

 package com.lxf.bean;

 /**
  * 地址类
  * @author Administrator
  *
  */
 public class Address
 {
     //编号，省份，城市，街道
     private String aid;

     private String province;

     private String city;

     private String street;

     public String getAid() {
         return aid;
     }

     public void setAid(String aid) {
         this.aid = aid;
     }

     public String getProvince() {
         return province;
     }

     public void setProvince(String province) {
         this.province = province;
     }

     public String getCity() {
         return city;
     }

     public void setCity(String city) {
         this.city = city;
     }

     public String getStreet() {
         return street;
     }

     public void setStreet(String street) {
         this.street = street;
     }

     @Override
     public String toString() {
         return "Address [aid=" + aid + ", province=" + province + ", city="
                 + city + ", street=" + street + "]";
     }

 }

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