澳门新萄京官方网站-www.8455.com-澳门新萄京赌场网址

澳门新萄京官方网站:学习应用

2019-11-24 作者:数据库网络   |   浏览(105)

DBUtils 学习使用

本文包括:

1、DBUtils简介

2、DbUtils类

3、QueryRunner类

4、ResultSetHandler接口

5、使用步骤

JAVAWEB dbutils执行sql命令并遍历结果集时不能查到内容的原因及处理方法如下所示:

Apache的DBUtils框架:commons-dbutils是Apache组织提供的一个开源JDBC工具类库,它是对JDBC的简单封装,学习成本极低,并且使用dbutils能极大简化jdbc编码的工作量,同时也不会影响程序的性能。因此dbutils成为很多不喜欢hibernate的公司的首选。

commons-dbutils 是 Apache 组织提供的一个开源 JDBC工具类库,它是对JDBC的简单封装,学习成本极低,并且使用dbutils能极大简化jdbc编码的工作量,同时也不会影响程序的性能。

commons-dbutils简介

commons-dbutils是Apache组织提供的一个开源JDBC工具类库,它是对JDBC的简单封装,学习成本极低,并且使用dbutils能极大简化jdbc编码的工作量,同时也不会影响程序的性能。因此dbutils成为很多不喜欢hibernate的公司的首选。 dbutils的官方网站

澳门新萄京官方网站 1

1、DbUtils简介

  • commons-dbutils 是 Apache 组织提供的一个开源 JDBC工具类库,它是对JDBC的简单封装,学习成本极低,并且使用dbutils能极大简化jdbc编码的工作量,创建连接、结果集封装、释放资源,同时也不会影响程序的性能。创建连接、结果集封装、释放资源因此dbutils成为很多不喜欢hibernate的公司的首选。

  • API介绍:

    • org.apache.commons.dbutils.QueryRunner --- 核心
    • org.apache.commons.dbutils.ResultSetHandler --- 结果集封装器
    • org.apache.commons.dbutils.DbUtils --- 工具类
  • 地址:http://commons.apache.org/proper/commons-dbutils/

  • 学习重点:多看看API,多看看官网的example!

遍历结果集时只遍历bean对象才会只输出第一行那种内容(第一行是输出了UserEntity类实例化的对象),所以这里需要 re.getRepoTableName() 才能通过对象调用相对应的内容

commons-dbutils API介绍:

API介绍:

dbutils 优点

  1. 对于数据表的读操作,他可以把结果转换成List,Array,Set等java集合,便于程序员操作;
  2. 对于数据表的写操作,也变得很简单(只需写sql语句)
  3. 可以使用数据源,使用JNDI,数据库连接池(dbcp,c3p0)等技术来优化性能--重用已经构建好的数据库连接对象,而不像php,asp那样,费时费力的不断重复的构建和析构这样的对象。

2、DbUtils类

DbUtils :提供如加载驱动、关闭连接、事务提交、回滚等常规工作的工具类,里面的所有方法都是静态的。主要方法如下:

  • DbUtils类提供了三个重载的关闭方法。这些方法检查所提供的参数是不是NULL,如果不是的话,它们就关闭Connection、Statement和ResultSet。

      public static void close(…) throws java.sql.SQLException
    
  • 这一类"quietly"方法不仅能在Connection、Statement和ResultSet为NULL情况下避免关闭,还能隐藏一些在程序中抛出的SQLException。

      public static void closeQuietly(…)
    
  • 用来提交连接,然后关闭连接,并且在关闭连接时不抛出SQL异常。

      public static void commitAndCloseQuietly(Connection conn)
    
  • 装载并注册JDBC驱动程序,如果成功就返回true。使用该方法,你不需要捕捉这个异常ClassNotFoundException。

      public static boolean loadDriver(java.lang.String driverClassName)
    

这样一来,就可以取到值了

org.apache.commons.dbutils.QueryRunner QueryRunner中有update()和query()方法 org.apache.commons.dbutils.ResultSetHandler

org.apache.commons.dbutils.QueryRunner

commons-dbutils API介绍

  • org.apache.commons.dbutils.QueryRunner QueryRunner (insert、update、delete使用)
  • org.apache.commons.dbutils.ResultSetHandler (用于查询结果处理使用)
  • org.apache.commons.dbutils.DbUtils (工具类)

3、QueryRunner类

  • 该类简单化了SQL查询,它与ResultSetHandler组合在一起使用可以完成大部分的数据库操作,能够大大减少编码量。

  • QueryRunner类提供了两个构造方法:

    • 默认的构造方法:QueryRunner()

    • 需要一个 javax.sql.DataSource 来作参数的构造方法:QueryRunner(DataSource ds)

      注意:构造器需要传入DataSource参数,所以必须要用到连接池,关于JDBC连接池可参考我之前的一篇文章:《JDBC进阶——连接池》。在那篇文章中的JDBCUtils类中没有相应的方法来获得DataSource对象,所以应该在JDBCUtils类中加入如下代码:

      // 返回数据库连接池
      public static DataSource getDataSource() {
          return dataSource;
      }
      
  • 常用方法(分为两种情况):

    • 批处理

        batch(Connection conn, String sql, Object[][] params)  // 传递连接批处理
        batch(String sql, Object[][] params)  // 不传递连接批处理
      
    • 查询操作

        public Object query(Connection conn, String sql, ResultSetHandler<T> rsh, Object... params)
        public Object query(String sql, ResultSetHandler<T> rsh, Object... params) 
      
    • 更新操作

        public int update(Connection conn, String sql, Object... params)
        public int update(String sql, Object... params)
      

澳门新萄京官方网站 2

工具类:

org.apache.commons.dbutils.ResultSetHandler

QueryRunner 类的主要方法

  • public Object query(Connection conn, String sql, Object[] params, ResultSetHandler rsh) throws SQLException

执行一个查询操作,在这个查询中,对象数组中的每个元素值被用来作为查询语句的置换参数。该方法会自行处理PreparedStatement和ResultSet的创建和关闭。

  • public Object query(String sql, Object[] params, ResultSetHandler rsh) throws SQLException

澳门新萄京官方网站:学习应用。几乎与第一种方法一样;唯一的不同在于它不将数据库连接提供给方法,并且它是从提供给构造方法的数据源(DataSource)或使用的setDataSource方法中重新获得Connection。

  • public Object query(Connection conn, String sql, ResultSetHandler rsh) throws SQLException

执行一个不需要置换参数的查询操作。

  • public int update(Connection conn, String sql, Object[] params) throws SQLException

用来执行一个更新(插入、更新或删除)操作。

  • public int update(Connection conn, String sql) throws SQLException

用来执行一个不需要置换参数的更新操作。

  • public int[] batch(Connection conn, String sql, Object[][] params) throws SQLException

这个方法对应着批处理,经常用于在同一个表中批量插入数据,或批量更新表的数据。 该方法为何会接收二维数组Object[][] params呢? 答:例如现在要想在同一个表中批量插入数据,编写的SQL语句为:

  String sql = "insert into users(id,name) values(?,?)";

该方法接收二维数组Object[][] params,那么调用其的时候就要传递一个诸如这样的实参[[1,aa],[2,bb],[3,cc]],即用二维数组里面的每一个一维数组生成一条sql语句。 那为何又会返回int[]呢? 答:该方法的返回值是int[],所以会返回诸如这样的结果:[1,1,1],意思是生成的第一条sql语句影响数据库几行、生成的第二条sql语句影响数据库几行、生成的第三条sql语句影响数据库几行。

4、ResultSetHandler接口

  • 该接口用于处理 java.sql.ResultSet,将数据按要求转换为另一种形式。

  • ResultSetHandler 接口提供了一个单独的方法:

      Object handle(ResultSet rs){}
    
  • ResultSetHandler 接口的实现类(构造方法不唯一,在这里只用最常见的构造方法):

    • ArrayHandler():把结果集中的第一行数据转成对象数组(存入Object[])。

    • ArrayListHandler():把结果集中的每一行数据都转成一个对象数组,再存放到List中。

    • BeanHandler(Class<T> type):将结果集中的第一行数据封装到一个对应的JavaBean实例中。

    • BeanListHandler(Class<T> type):将结果集中的每一行数据都封装到一个对应的JavaBean实例中,存放到List里。

      Parameters:

      type - The Class that objects returned from handle() are created from.

    • ColumnListHandler(String columnName/int columnIndex):将结果集中某一列的数据存放到List中。

    • MapHandler():将结果集中的第一行数据封装到一个Map里,key是列名,value就是对应的值。

    • 澳门新萄京官方网站:学习应用。MapListHandler():将结果集中的每一行数据都封装到一个Map里,然后再将所有的Map存放到List中。

    • KeyedHandler(String columnName):将结果集每一行数据保存到一个“小”map中,key为列名,value该列的值,再将所有“小”map对象保存到一个“大”map中 , “大”map中的key为指定列,value为“小”map对象

    • ScalarHandler(int columnIndex):通常用来保存只有一行一列的结果集。

    注意:DBUtils-1.4版本中的 ScalarHandler, ColumnHandler, and KeyedHandler没有泛型!要使用1.5以上的版本。

    Release Notes Address : http://commons.apache.org/proper/commons-dbutils/changes-report.html

澳门新萄京官方网站 3

org.apache.commons.dbutils.DbUtils

工具类

ResultSetHandler接口使用讲解

该接口用于处理java.sql.ResultSet,将数据按要求转换为另一种形式。ResultSetHandler接口提供了一个单独的方法:Object handle (java.sql.ResultSet .rs)

ResultSetHandler接口的实现类

  • ArrayHandler:把结果集中的第一行数据转成对象数组。
  • ArrayListHandler:把结果集中的每一行数据都转成一个数组,再存放到List中。
  • BeanHandler:将结果集中的第一行数据封装到一个对应的JavaBean实例中。
  • BeanListHandler:将结果集中的每一行数据都封装到一个对应的JavaBean实例中,存放到List里。
  • ColumnListHandler:将结果集中某一列的数据存放到List中。
  • KeyedHandler(name):将结果集中的每一行数据都封装到一个Map里,再把这些map再存到一个map里,其key为指定的key。
  • MapHandler:将结果集中的第一行数据封装到一个Map里,key是列名,value就是对应的值。
  • MapListHandler:将结果集中的每一行数据都封装到一个Map里,然后再存放到List。

5、使用步骤

  1. 将DBUtils的jar包加入到项目工程的build path中。

  2. 对于CUD,有两种不同的情况:

    • 情况一:

      如果使用 QueryRunner(DataSource ds) 构造器创建QueryRunner对象,需要使用连接池,如DBCP、C3P0等等,数据库事务交给DBUtils框架进行管理 ---- 默认情况下每条SQL语句单独一个事务

      • 在这种情况下,使用如下方法:

          batch(String sql, Object[][] params)
        
          query(String sql, ResultSetHandler<T> rsh, Object... params) 
        
          update(String sql, Object... params) 
        
      • demo:

          @Test
          public void testDelete() throws SQLException {
              QueryRunner queryRunner = new QueryRunner(JDBCUtils.getDataSource());
              String sql = "delete from users where id = ?";
              queryRunner.update(sql, 3);
          }
        
          @Test
          public void testUpdate() throws SQLException {
              QueryRunner queryRunner = new QueryRunner(JDBCUtils.getDataSource());
              String sql = "update users set password = ? where username = ?";
              Object[] param = { "nihao", "小明" };
              queryRunner.update(sql, param);
          }
        
          @Test
          public void testInsert() throws SQLException {
              // 第一步 创建QueryRunner对象
              QueryRunner queryRunner = new QueryRunner(JDBCUtils.getDataSource());
        
              // 第二步 准备方法参数
              String sql = "insert into users values(null,?,?,?)";
              Object[] param = { "小丽", "qwe", "xiaoli@itcast.cn" };
        
              // 第三步 调用 query / update
              queryRunner.update(sql, param);
          }
        
    • 情况二:

      如果使用 QueryRunner() 构造器创建QueryRunner对象 ,需要自己管理事务,因为框架没有连接池无法获得数据库连接。

      • 在这种情况下,要使用传入Connection对象参数的方法:

          query(Connection conn, String sql, ResultSetHandler<T> rsh, Object... params)
        
          update(Connection conn, String sql, Object... params) 
        
      • demo:

          // 事务控制
          @Test
          public void testTransfer() throws SQLException {
              double money = 100;
              String outAccount = "aaa";
              String inAccount = "bbb";
              String sql1 = "update account set money = money - ? where name= ?";
              String sql2 = "update account set money = money   ? where name= ?";
        
              // 传入DataSource的构造器,默认每条SQL语句一个单独事务,而在这里要自己管理业务,所以不合适!
              // QueryRunner queryRunner = new QueryRunner(JDBCUtils.getDataSource());
        
              QueryRunner queryRunner = new QueryRunner();// 不要传递连接池 --- 手动事务管理
              Connection conn = JDBCUtils.getConnection();
              conn.setAutoCommit(false);
              try {
                  queryRunner.update(conn, sql1, money, outAccount); // 注意要传入Connection对象的方法
                  // int d = 1 / 0;
                  queryRunner.update(conn, sql2, money, inAccount);
        
                  System.out.println("事务提交!");
                  DbUtils.commitAndCloseQuietly(conn);
              } catch (Exception e) {
                  System.out.println("事务回滚!");
                  DbUtils.rollbackAndCloseQuietly(conn);
                  e.printStackTrace();
              }
          }
        
  3. 对于R,需要用到ResultSetHandler接口,该接口有9大实现类,

     public class ResultSetHandlerTest {
         // ScalarHandler 通常用于保存只有一行一列的结果集,例如分组函数
         @Test
         public void demo9() throws SQLException {
             QueryRunner queryRunner = new QueryRunner(JDBCUtils.getDataSource());
             String sql = "select count(*) from account";
    
             long count = (Long) queryRunner.query(sql, new ScalarHandler(1)); // 得到结果集的第1列
             System.out.println(count);
         }
    
         // KeyedHandler 将结果集每一行数据保存到一个“小”map中,key为列名,value该列的值,再将所有“小”map对象保存到一个“大”map中 , “大”map中的key为指定列,value为“小”map对象
         @Test
         public void demo8() throws SQLException {
             QueryRunner queryRunner = new QueryRunner(JDBCUtils.getDataSource());
             String sql = "select * from account";
    
             Map<Object, Map<String, Object>> map = queryRunner.query(sql,
                     new KeyedHandler("id"));
             System.out.println(map);
         }
    
         // MapListHandler 将结果集每一行数据保存到map中,key列名 value该列的值 ---- 再将所有map对象保存到List集合中
         @Test
         public void demo7() throws SQLException {
             QueryRunner queryRunner = new QueryRunner(JDBCUtils.getDataSource());
             String sql = "select * from account";
             List<Map<String, Object>> list = queryRunner.query(sql,
                     new MapListHandler());
             for (Map<String, Object> map : list) {
                 System.out.println(map);
             }
         }
    
         // MapHander 将结果集第一行数据封装到Map集合中,key是列名,value为该列的值
         @Test
         public void demo6() throws SQLException {
             QueryRunner queryRunner = new QueryRunner(JDBCUtils.getDataSource());
             String sql = "select * from account";
             Map<String, Object> map = queryRunner.query(sql, new MapHandler()); // 列名为String类型,该列的值为Object类型
             System.out.println(map);
         }
    
         // ColumnListHandler 获得结果集的某一列,将该列的所有值存入List<Object>中
         @Test
         public void demo5() throws SQLException {
             QueryRunner queryRunner = new QueryRunner(JDBCUtils.getDataSource());
             String sql = "select * from account";
    
             // 因为每列类型都不一样,所以用List<Object>存储
             // List<Object> list = queryRunner.query(sql,
             // new ColumnListHandler("name")); // 得到表列名为name的列
             List<Object> list = queryRunner.query(sql, new ColumnListHandler(2)); // 得到结果集的第2列
             System.out.println(list);
         }
    
         // BeanListHander 将结果集每一条数据,转为JavaBean对象,再保存到list集合中
         @Test
         public void demo4() throws SQLException {
             QueryRunner queryRunner = new QueryRunner(JDBCUtils.getDataSource());
             String sql = "select * from account";
             List<Account> accounts = queryRunner.query(sql,
                     new BeanListHandler<Account>(Account.class));
    
             for (Account account : accounts) {
                 System.out.println(account.getId());
                 System.out.println(account.getName());
                 System.out.println(account.getMoney());
                 System.out.println("----------------");
             }
         }
    
         // BeanHandler 将结果集第一行数据封装到JavaBean对象中
         @Test
         public void demo3() throws SQLException {
             QueryRunner queryRunner = new QueryRunner(JDBCUtils.getDataSource());
             String sql = "select * from account";
    
             // 传入 Account.class字节码文件:为了在方法中 通过反射构造Account对象
             // 使用BeanHandler注意事项 :数据库中的表列名 与 Bean类中属性 名称一致!!!
             Account account = queryRunner.query(sql, new BeanHandler<Account>(
                     Account.class));
             System.out.println(account.getId());
             System.out.println(account.getName());
             System.out.println(account.getMoney());
         }
    
         // ArrayListHandler 将结果集每一行数据保存到List<Object[]>中
         @Test
         public void demo2() throws SQLException {
             QueryRunner queryRunner = new QueryRunner(JDBCUtils.getDataSource());
             String sql = "select * from account";
             List<Object[]> list = queryRunner.query(sql, new ArrayListHandler());
    
             for (Object[] objects : list) {
                 System.out.println(Arrays.toString(objects));
             }
         }
    
         // ArrayHandler 将结果集第一行数据保存到Object[]中
         @Test
         public void demo1() throws SQLException {
             // 使用DBUtils
             QueryRunner queryRunner = new QueryRunner(JDBCUtils.getDataSource());
             String sql = "select * from account";
    
             // 对象数组存储rs第一行数据的所有列
             Object[] values = queryRunner.query(sql, new ArrayHandler());
             System.out.println(Arrays.toString(values));
         }
     }
    

JDBC文集:

  1. Java 与数据库的桥梁——JDBC:http://www.jianshu.com/p/c0acbd18794c

  2. JDBC 进阶——连接池:http://www.jianshu.com/p/ad0ff2961597

  3. JDBC 进阶——元数据:http://www.jianshu.com/p/36d5d76342f1

  4. JDBC框架——DBUtils:http://www.jianshu.com/p/10241754cdd7

PS:JavaWeb之DBUtils详细介绍如下所示:

QueryRunner类使用讲解

该类简单化了SQL查询,它与ResultSetHandler组合在一起使用可以完成大部分的数据库操作,能够大大减少编码量。
QueryRunner类提供了两个构造方法:

默认的构造方法。 需要一个javax.sql.DataSource来作参数的构造方法。

org.apache.commons.dbutils.DbUtils。

DbUtils类使用讲解

DbUtils:提供如关闭连接、装载JDBC驱动程序等常规工作的工具类,里面的所有方法都是静态的。主要方法如下:

  • public static void close(…) throws java.sql.SQLException DbUtils类提供了三个重载的关闭方法。这些方法检查所提供的参数是不是NULL,如果不是的话,它们就关闭Connection、Statement和ResultSet。
  • public static void closeQuietly(…) 这一类方法不仅能在Connection、Statement和ResultSet为NULL情况下避免关闭,还能隐藏一些在程序中抛出的SQLException。
  • public static void commitAndCloseQuietly(Connection conn) 用来提交连接,然后关闭连接,并且在关闭连接时不抛出SQL异常。
  • public static boolean loadDriver(java.lang.String driverClassName) 这一方法装载并注册JDBC驱动程序,如果成功就返回true。使用该方法,你不需要捕捉这个异常ClassNotFoundException。

一、什么是DBUtils及作用

QueryRunner类的主要方法

public Object query(Connection conn, String sql, Object[] params, ResultSetHandler rsh) throws SQLException
执行一个查询操作,在这个查询中,对象数组中的每个元素值被用来作为查询语句的置换参数。该方法会自行处理PreparedStatement和ResultSet的创建和关闭。 public Object query(String sql, Object[] params, ResultSetHandler rsh) throws SQLException
几乎与第一种方法一样;唯一的不同在于它不将数据库连接提供给方法,并且它是从提供给构造方法的数据源(DataSource)或使用的setDataSource方法中重新获得Connection。 public Object query(Connection conn, String sql, ResultSetHandler rsh) throws SQLException
执行一个不需要置换参数的查询操作。 public int update(Connection conn, String sql, Object[] params) throws SQLException
用来执行一个更新(插入、更新或删除)操作。 public int update(Connection conn, String sql) throws SQLException
用来执行一个不需要置换参数的更新操作。

public int[] batch(Connection conn, String sql, Object[][] params) throws SQLException
这个方法对应着批处理,经常用于在同一个表中批量插入数据,或批量更新表的数据。
该方法为何会接收二维数组Object[][] params呢?
答:例如现在要想在同一个表中批量插入数据,编写的SQL语句为:

String sql = "insert into users(id,name) values(?,?)";

该方法接收二维数组Object[][] params,那么调用其的时候就要传递一个诸如这样的实参[[1,aa],[2,bb],[3,cc]],即用二维数组里面的每一个一维数组生成一条sql语句。
那为何又会返回int[]呢?
答:该方法的返回值是int[],所以会返回诸如这样的结果:[1,1,1],意思是生成的第一条sql语句影响数据库几行、生成的第二条sql语句影响数据库几行、生成的第三条sql语句影响数据库几行。

澳门新萄京官方网站 4

使用DBUtils完成数据库的CRUD

在使用DBUtils完成数据库的CRUD之前,我们先编写测试用的SQL脚本:

CREATE TABLE `user` (
  `id` int(11) NOT NULL auto_increment,
  `name` varchar(50) NOT NULL,
  `age` tinyint(10) NOT NULL,
  PRIMARY KEY  (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

澳门新萄京官方网站,使用dbutils遵从以下步骤

  1. 加载JDBC驱动程序类,并用DriverManager来得到一个数据库连接conn。
  2. 实例化 QueryRunner,得到实例化对象qRunner。
  3. qRunner.update()方法,执行增改删的sql命令,qRunner.query()方法,得到结果集。

  DBUtils是apache公司写的。DBUtils是java编程中的数据库操作实用工具,小巧简单实用。

ResultSetHandler接口使用讲解

该接口用于处理java.sql.ResultSet,将数据按要求转换为另一种形式。ResultSetHandler接口提供了一个单独的方法:Object handle (java.sql.ResultSet .rs)。

DbUtils :提供如关闭连接、装载JDBC驱动程序等常规工作的工具类,里面的所有方法都是静态的。主要方法如下:

获取连接对象

private static final String url = "jdbc:mysql://192.168.1.15:3306/test?useUnicode=true&characterEncoding=utf8";
private static final String driver = "com.mysql.jdbc.Driver";
private static final String user = "znsd_test";
private static final String password = "123456";

public static Connection getConnect() {
    Connection conn = null;
    try {
        Class.forName(driver);
        conn = DriverManager.getConnection(url, user, password);
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } catch (SQLException e) {
        e.printStackTrace();
    }
    return conn;
}

  DBUtils封装了对JDBC的操作,简化了JDBC操作。可以少写代码。

ResultSetHandler接口的实现类

ArrayHandler:把结果集中的第一行数据转成对象数组。 ArrayListHandler:把结果集中的每一行数据都转成一个数组,再存放到List中。 BeanHandler:将结果集中的第一行数据封装到一个对应的JavaBean实例中。 BeanListHandler:将结果集中的每一行数据都封装到一个对应的JavaBean实例中,存放到List里。 ColumnListHandler:将结果集中某一列的数据存放到List中。 KeyedHandler(name):将结果集中的每一行数据都封装到一个Map里,再把这些map再存到一个map里,其key为指定的key。 MapHandler:将结果集中的第一行数据封装到一个Map里,key是列名,value就是对应的值。 MapListHandler:将结果集中的每一行数据都封装到一个Map里,然后再存放到List。

public static void close throws java.sql.SQLException: DbUtils类提供了三个重载的关闭方法。这些方法检查所提供的参数是不是NULL,如果不是的话,它们就关闭Connection、Statement和ResultSet。

创建bean对象关联数据库

public class User implements Serializable {
    private Integer id; // 用户ID
    private String name; // 用户姓名
    private Integer age;  // 用户年龄
    // ...忽略set、get方法
}

  1.对于数据表的读操作,他可以把结果转换成List,Array,Set等java集合,便于程序员操作;

DbUtils类使用讲解

DbUtils:提供如关闭连接、装载JDBC驱动程序等常规工作的工具类,里面的所有方法都是静态的。主要方法如下:

public static void close(…) throws java.sql.SQLException
DbUtils类提供了三个重载的关闭方法。这些方法检查所提供的参数是不是NULL,如果不是的话,它们就关闭Connection、Statement和ResultSet。 public static void closeQuietly(…)
这一类方法不仅能在Connection、Statement和ResultSet为NULL情况下避免关闭,还能隐藏一些在程序中抛出的SQLException。 public static void commitAndCloseQuietly(Connection conn)
用来提交连接,然后关闭连接,并且在关闭连接时不抛出SQL异常。 public static boolean loadDriver(java.lang.String driverClassName)
这一方法装载并注册JDBC驱动程序,如果成功就返回true。使用该方法,你不需要捕捉这个异常ClassNotFoundException。

public static void closeQuietly: 这一类方法不仅能在Connection、Statement和ResultSet为NULL情况下避免关闭,还能隐藏一些在程序中抛出的SQLEeception。

添加

public Integer add(User user) {
        QueryRunner queryRunner = new QueryRunner();
        Connection connect = ConnectionUtil.getConnect();
        try {
            return queryRunner.update(connect, "insert into user(name, age) values(?, ?)", user.getName(), user.getAge());
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            DbUtils.closeQuietly(connect);
        }
        return 0;
}

  2.对于数据表的写操作,也变得很简单(只需写sql语句)

使用DBUtils完成数据库的CRUD

在使用DBUtils完成数据库的CRUD之前,我们先编写测试用的SQL脚本:

create database day17;
use day17;
create table users 
(
    id int primary key,
    name varchar(40),
    password varchar(40),
    email varchar(60),
    birthday date
);

public static void commitAndCloseQuietly(Connection conn): 用来提交连接,然后关闭连接,并且在关闭连接时不抛出SQL异常。

修改

public Integer update(User user) {

        QueryRunner queryRunner = new QueryRunner();
        Connection conn = ConnectionUtil.getConnect();
        try {
            return queryRunner.update(conn , "update user set name = ?, age = ? where id = ?", user.getName(), user.getAge(), user.getId());
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            DbUtils.closeQuietly(conn);
        }
        return 0;
}

  3.可以使用数据源,使用JNDI,数据库连接池等技术来优化性能--重用已经构建好的数据库连接对象

在应用程序中加入dbcp连接池

导入相关jar包:

commons-dbcp-1.4.jar commons-pool-1.6.jar

在类目录下加入dbcp的配置文件:dbcpconfig.properties。dbcpconfig.properties的配置信息如下:

#连接设置
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/day17
username=root
password=yezi

#
initialSize=10

#最大连接数量
maxActive=50

#
maxIdle=20

#
minIdle=5

#
maxWait=60000


#JDBC驱动建立连接时附带的连接属性属性的格式必须为这样:[属性名=property;] 
#注意:"user" 与 "password" 两个属性会被明确地传递,因此这里不需要包含他们。
connectionProperties=useUnicode=true;characterEncoding=utf8

#指定由连接池所创建的连接的自动提交(auto-commit)状态。
defaultAutoCommit=true

#driver default 指定由连接池所创建的连接的只读(read-only)状态。
#如果没有设置该值,则“setReadOnly”方法将不被调用。(某些驱动并不支持只读模式,如:Informix)
defaultReadOnly=

#driver default 指定由连接池所创建的连接的事务级别(TransactionIsolation)。
#可用值为下列之一:(详情可见javadoc。)NONE,READ_UNCOMMITTED, READ_COMMITTED, REPEATABLE_READ, SERIALIZABLE
defaultTransactionIsolation=READ_COMMITTED

如下图所示:
澳门新萄京官方网站 5

public static boolean loadDriver(java.lang.String driverClassName):这一方装载并注册JDBC驱动程序,如果成功就返回true。使用该方法,你不需要捕捉这个异常ClassNotFoundException。

删除

public Integer delete(Integer id) {

        QueryRunner queryRunner = new QueryRunner();
        Connection conn = ConnectionUtil.getConnect();
        try {
            return queryRunner.update(conn , "delete from user where id = ?", id);
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            DbUtils.closeQuietly(conn);
        }
        return 0;
}

二、DBUtils的三个核心对象

使用QueryRunner类实现CRUD

在cn.itcast.domain包下创建一个封装数据的实体——User.java,对应数据库中的users表。User类的具体代码如下:

public class User {
    private int id;
    private String name;
    private String password;
    private String email;
    private Date birthday;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    public String getEmail() {
        return email;
    }
    public void setEmail(String email) {
        this.email = email;
    }
    public Date getBirthday() {
        return birthday;
    }
    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

}

在cn.itcast.utils包下创建一个获取数据库连接的工具类(JdbcUtils),该工具类(JdbcUtils)的代码为:

public class JdbcUtils {
    private static DataSource ds = null;

    static {
        try {
            Properties prop = new Properties();
            InputStream in = JdbcUtils2.class.getClassLoader().getResourceAsStream("dbcpconfig.properties");
            prop.load(in);
            BasicDataSourceFactory factory = new BasicDataSourceFactory();
            ds = factory.createDataSource(prop);
        } catch (Exception e) {
            throw new ExceptionInInitializerError(e);
        }
    }

    public static DataSource getDataSource() {
        return ds;
    }

    public static Connection getConnection() throws SQLException {
        return ds.getConnection();
    }

    /*
     * 工具类里面现在没有必要提供release()方法,因为我们是使用dbutils操作数据库,
     * 即调用dbutils的update()和query()方法操作数据库,他操作完数据库之后,会自动释放掉连接。
     */
}

提示:工具类里面现在没有必要提供release()方法,因为我们是使用DBUtils操作数据库,即调用DBUtils的update()和query()方法操作数据库,它操作完数据库之后,会自动释放掉连接。
现在在cn.itcast.dbutils.demo包下新建一个测试类Demo1.java,Demo1类的具体代码如下:

public class Demo1 {    
    // 使用dbutils完成数据库的CRUD
    @Test
    public void insert() throws SQLException {
        QueryRunner runner = new QueryRunner(JdbcUtils.getDataSource());
        String sql = "insert into users(id,name,password,email,birthday) values(?,?,?,?,?)";
        Object[] params = {2, "bbb", "123", "bbb@163.com", new Date()};
        runner.update(sql, params);
    }

    @Test
    public void update() throws SQLException {
        QueryRunner runner = new QueryRunner(JdbcUtils.getDataSource());
        String sql = "update users set email=? where id=?";
        Object[] params = {"yeyiyi@126.com", 1};
        runner.update(sql, params);
    }

    @Test
    public void delete() throws SQLException {
        QueryRunner runner = new QueryRunner(JdbcUtils.getDataSource());
        String sql = "delete from users where id=?";
        runner.update(sql, 2);
    }

    @Test
    public void find() throws SQLException {
        QueryRunner runner = new QueryRunner(JdbcUtils.getDataSource());
        String sql = "select * from users where id=?";
        User user = (User) runner.query(sql, 1, new BeanHandler(User.class));
        System.out.println(user.getEmail());
    }

    @Test
    public void getAll() throws SQLException {
        QueryRunner runner = new QueryRunner(JdbcUtils.getDataSource());
        String sql = "select * from users";
        List list = (List) runner.query(sql, new BeanListHandler(User.class));
        System.out.println(list);
    }

    @Test
    public void batch() throws SQLException {
        QueryRunner runner = new QueryRunner(JdbcUtils.getDataSource());
        String sql = "insert into users(id,name,password,email,birthday) values(?,?,?,?,?)";
        Object[][] params = new Object[3][5];
        for (int i = 0; i < params.length; i  ) {
            params[i] = new Object[]{i 1, "aa" i, "123", i "@sian.com", new Date()};
        }
        runner.batch(sql, params);
    }
}

该类简单化了SQL查询,它与ResultSetHandler组合在一起使用可以完成大部分的数据库操作,能够大大减少编码量。

批量添加

public int[] batch(Object[][] values) {

        QueryRunner queryRunner = new QueryRunner();
        Connection conn = ConnectionUtil.getConnect();
        try {
            return queryRunner.batch(conn, "insert into user(name, age) values(?, ?)", values);
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            DbUtils.closeQuietly(conn);
        }
        return null;
}

  2.1、QueryRunner类

测试dbutils各种类型的处理器

在使用DBUtils完成数据库的CRUD中,我们就已经测试过BeanHandler和BeanListHandler处理器,现在我们来一个个测试其余的处理器。

ArrayHandler:把结果集中的第一行数据转成对象数组。测试代码如下:

// 测试dbutils的各个结果集处理器
public class Demo2 {
    @Test
    public void test1() throws SQLException {
        QueryRunner runner = new QueryRunner(JdbcUtils.getDataSource());
        String sql = "select * from users";
        Object[] result = runner.query(sql, new ArrayHandler());
        System.out.println(result[0]);
        System.out.println(result[1]);
    }
}

ArrayListHandler:把结果集中的每一行数据都转成一个数组,再存放到List中。测试代码如下:

// 测试dbutils的各个结果集处理器
public class Demo2 {
    @Test
    public void test2() throws SQLException {
        QueryRunner runner = new QueryRunner(JdbcUtils.getDataSource());
        String sql = "select * from users";
        List list = runner.query(sql, new ArrayListHandler());
        System.out.println(list);
    }
}

ColumnListHandler:将结果集中某一列的数据存放到List中。测试代码如下:

// 测试dbutils的各个结果集处理器
public class Demo2 {
    @Test
    public void test3() throws SQLException {
        QueryRunner runner = new QueryRunner(JdbcUtils.getDataSource());
        String sql = "select * from users";
        List list = (List) runner.query(sql, new ColumnListHandler("name"));
        System.out.println(list);
    }
}

我们也可以自己重新写出这样一个ColumnListHandler处理器,如:

class ColumnListHandler1 implements ResultSetHandler {

    private String columnName;

    public ColumnListHandler1(String columnName) {
        this.columnName = columnName;
    }

    @Override
    public Object handle(ResultSet rs) throws SQLException {
        List list = new ArrayList();
        while (rs.next()) {
            list.add(rs.getObject(columnName));
        }
        return list;
    }

}

用我们自己编写的ColumnListHandler1处理器来测试,代码为:

// 测试dbutils的各个结果集处理器
public class Demo2 {
    @Test
    public void test3() throws SQLException {
        QueryRunner runner = new QueryRunner(JdbcUtils.getDataSource());
        String sql = "select * from users";
        List list = (List) runner.query(sql, new ColumnListHandler1("name"));
        System.out.println(list);
    }
}

KeyedHandler(name):将结果集中的每一行数据都封装到一个Map里,再把这些map再存到一个map里,其key为指定的key。
这话听起来有些绕口,但我用一张图来解释就很明白了。
澳门新萄京官方网站 6
明白原理之后,就很容易写测试代码了,测试代码为:

// 测试dbutils的各个结果集处理器
public class Demo2 {
    @Test
    public void test4() throws SQLException {
        QueryRunner runner = new QueryRunner(JdbcUtils.getDataSource());
        String sql = "select * from users";
        Map> map = (Map>) runner.query(sql, new KeyedHandler("id"));
        for (Map.Entry> me : map.entrySet()) {
            int id = me.getKey();
            for (Map.Entry entry : me.getValue().entrySet()) {
                String name = entry.getKey();
                Object value = entry.getValue();
                System.out.println(name "=" value);
            }
        }
    }
}

当想要查询某张表中的总记录数时,我们可以用ArrayHandler处理器来处理。作为一个新手,第一次写代码时,可能会这样写:

// 测试dbutils的各个结果集处理器
public class Demo2 {
    @Test
    public void test5() throws SQLException {
        QueryRunner runner = new QueryRunner(JdbcUtils.getDataSource());
        String sql = "select count(*) from users";
        Object[] result = runner.query(sql, new ArrayHandler());
        int totalrecord = (int) result[0];
        System.out.println(totalrecord);
    }
}

JUnit测试可发现报如下异常:

java.lang.ClassCastException: java.lang.Long cannot be cast to java.lang.Integer

原因是:查询结果——总记录数是作为java.lang.Long类型返回的。所以我们应该把代码修改为:

// 测试dbutils的各个结果集处理器
public class Demo2 {
    @Test
    public void test5() throws SQLException {
        QueryRunner runner = new QueryRunner(JdbcUtils.getDataSource());
        String sql = "select count(*) from users";
        Object[] result = runner.query(sql, new ArrayHandler());
        long totalrecord = (Long) result[0]; // 查询结果——总记录数是作为java.lang.Long类型返回的
        int num = (int) totalrecord;
        System.out.println(num);
    }
}

除此之外,我们又可写为:

// 测试dbutils的各个结果集处理器
public class Demo2 {
    @Test
    public void test5() throws SQLException {
        QueryRunner runner = new QueryRunner(JdbcUtils.getDataSource());
        String sql = "select count(*) from users";
        Object[] result = runner.query(sql, new ArrayHandler());
        int totalrecord =  ((Long) result[0]).intValue();
        System.out.println(totalrecord);
    }
}

更加专业一点的方法是使用ScalarHandler处理器,测试代码如下:

// 测试dbutils的各个结果集处理器
public class Demo2 {
    @Test
    public void test5() throws SQLException {
        QueryRunner runner = new QueryRunner(JdbcUtils.getDataSource());
        String sql = "select count(*) from users";
        int totalrecord = ((Long)runner.query(sql, new ScalarHandler(1))).intValue();
        System.out.println(totalrecord);
    }
}

QueryRunner类提供了两个构造方法:

查询所有

public List<User> select() {

        QueryRunner queryRunner = new QueryRunner();
        Connection conn = ConnectionUtil.getConnect();
        try {
            return queryRunner.query(conn, "select id id1, name, age from user", new UserBeanListHandler(User.class));
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            DbUtils.closeQuietly(conn);
        }
        return null;
}

    QueryRunner中提供对sql语句操作的API.它主要有三个方法:query() 用于执行select,update() 用于执行insert update delete,batch() 批处理。等下下面的会详细的介绍这几种方法的用法。

①、默认的构造方法

查询返回map

public List<Map<String, Object>> selectAsMap() {

        QueryRunner queryRunner = new QueryRunner();
        Connection conn = ConnectionUtil.getConnect();
        try {
            List<Map<String, Object>> userMaps = queryRunner.query(conn, "select id id1, name, age from user", new MapListHandler());
            return userMaps;
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            DbUtils.closeQuietly(conn);
        }
        return null;
}

  2.2、ResultSetHandler接口

②、需要一个 javax.sql.DataSource 来作参数的构造方法。

查询单个对象

public User selectOne(Integer id) {

        QueryRunner queryRunner = new QueryRunner();
        Connection conn = ConnectionUtil.getConnect();
        try {
            return queryRunner.query(conn, "select id id1, name, age from user where id = ? limit 1", new BeanHandler<User>(User.class) {
                @Override
                public User handle(ResultSet rs) throws SQLException {
                    if (rs.next()) {
                        return new User(rs.getInt("id1"), rs.getString("name"), rs.getInt("age"));
                    }
                    return null;
                }
            }, id);
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            DbUtils.closeQuietly(conn);
        }
        return null;
}

    用于定义select操作后,怎样封装结果集.它总共有9个常用的实现类,下面我会详细的为大家介绍怎么去使用。

public Object query(Connection conn, String sql, Object[] params, ResultSetHandler rsh) throws SQLException:执行一个查询操作,在这个查询中,对象数组中的每个元素值被用来作为查询语句的置换参数。该方法会自行处理 PreparedStatement 和 ResultSet 的创建和关闭。

结合c3p0数据源使用dbutils

  2.3、DbUtils类

public Object query(String sql, Object[] params, ResultSetHandler rsh) throws SQLException: 几乎与第一种方法一样;唯一的不同在于它不将数据库连接提供给方法,并且它是从提供给构造方法的数据源(DataSource) 或使用的setDataSource 方法中重新获得 Connection。

c3p0简介

C3P0是一个开源的JDBC连接池,它实现了数据源和JNDI绑定,支持JDBC3规范和JDBC2的标准扩展。目前使用它的开源项目有Hibernate,Spring等

    它就是一个工具类,定义了关闭资源与事务处理的方法

public Object query(Connection conn, String sql, ResultSetHandler rsh) throws SQLException : 执行一个不需要置换参数的查询操作。

数据库连接池简介

数据库连接池负责分配、管理和释放数据库连接,它允许应用程序重复使用一个现有的数据库连接,而不是再重新建立一个;连接池允许多个客户端使用缓存起来的连接对象,这些对象可以连接数据库,它们是共享的、可被重复使用的。

打开/关闭数据库连接开销很大,连接池技术允许我们在连接池里维护连接对象,这样可以提高数据库的执行命令的性能。多个客户端请求可以重复使用相同的连接对象,当每次收到一个客户端请求时,就会搜索连接池,看看有没有闲置的连接对象。如果没有闲置对象的话,要么所有的客户端请求都进入队列排队,要么在池中创建一个新的连接对象(这取决于池里已经有多少个连接存在以及配置支持多少连接)。一旦某个请求使用完连接对象之后,这个对象会被重新放入池中,然后会被重新分派给排队等待的请求(分派给哪个请求要看使用什么调度算法)。因为大部分请求都是使用现存的连接对象,所以连接池技术大大减少了等待创建数据库连接的时间,从而减少了平均连接时间。

澳门新萄京官方网站 7

三、怎么去使用DBUtils框架

public int update(Connection conn, String sql, Object[] params) throws SQLException:用来执行一个更新操作。

使用连接池的优点

  • 资源重用:

由于数据库连接得以重用,避免了频繁创建,释放连接引起的大量性能开销。在减少系统消耗的基础上,另一方面也增加了系统运行环境的平稳性。

  • 更快的系统反应速度:

数据库连接池在初始化过程中,往往已经创建了若干数据库连接置于连接池中备用。此时连接的初始化工作均已完成。对于业务请求处理而言,直接利用现有可用连接,避免了数据库连接初始化和释放过程的时间开销,从而减少了系统的响应时间。

  • 统一的连接管理,避免数据库连接泄露:

在较为完善的数据库连接池实现中,可根据预先的占用超时设定,强制回收被占用连接,从而避免了常规数据库连接操作中可能出现的资源泄露。

  3.1、使用步骤

public int update(Connection conn, String sql) throws SQLException:用来执行一个不需要置换参数的更新操作。

使用步骤

  1. 首先要导入c3p0和dbutils以及mysql的jar包
  • c3p0-0.9.5.2.jar
  • commons-dbutils-1.7.jar
  • mchange-commons-java-0.2.11.jar
  • mysql-connector-java-5.1.22.jar
  1. 编写c3p0的配置文件c3p0-config.xml

在src目录下存放c3p0的配置文件,配置文件是c3p0自己去识别并读入的,我们不需要在代码中做任何的操作,但是配置文件一定要命名为c3p0-config.xml

   <?xml version="1.0" encoding="UTF-8"?>
   <c3p0-config>
    <!-- 这是默认配置信息 -->
    <default-config>
        <!-- jdbc连接四大参数配置 -->
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://192.168.1.15:3306/test</property>
        <property name="user">znsd_test</property>
        <property name="password">123456</property>

        <!-- 池参数配置 -->
        <!--JDBC的标准参数,用以控制数据源内加载的PreparedStatements数量。但由于预缓存的statements
            属于单个connection而不是整个连接池。所以设置这个参数需要考虑到多方面的因素。
            如果maxStatements与maxStatementsPerConnection均为0,则缓存被关闭。Default: 0
        -->
        <property name="acquireIncrement">3</property>
        <!--初始化时获取的连接数,取值应在minPoolSize与maxPoolSize之间。Default: 3 -->
        <property name="initialPoolSize">10</property>
        <!--连接池中保留的最小连接数。-->
        <property name="minPoolSize">2</property>
        <!--连接池中保留的最大连接数。Default: 15 -->
        <property name="maxPoolSize">10</property>
    </default-config>
   </c3p0-config>
  1. 使用c3p0获取获取数据库连接对象
   public class C3p0ConnectionUtil {

    // 配置文件的默认配置!要求你必须给出c3p0-config.xml
    private static ComboPooledDataSource c3p0DataSource = new ComboPooledDataSource();

    /**
     * 获取连接对象
     * @return
     */
    public static Connection getConnection() {
        try {
            // 得到连接器
            return c3p0DataSource.getConnection();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 获取数据源
     * 
     * @return
     */
    public static DataSource getDataSource() {
        return c3p0DataSource;
    }
   }
  1. dbutils 使用c3p0
   public Integer add(User user) {
        QueryRunner queryRunner = new QueryRunner(C3p0ConnectionUtil.getDataSource());
        try {
            return queryRunner.update("insert into user(name, age) values(?, ?)", user.getName(), user.getAge());
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return 0;
   }
  1. 返回主键例子
   public Integer add(User user) {
        DataSource dataSource = C3p0ConnectionUtil.getDataSource();
        QueryRunner queryRunner = new QueryRunner(dataSource);
        try {
            String sql = "insert into user(name, age) values(?, ?)";
                // 需要条用insert方法,指定MapHandler参数
            Map<String, Object> idMap = queryRunner.insert(sql, new MapHandler() {

                @Override
                public Map<String, Object> handle(ResultSet rs) throws SQLException {

                    //rs = rs.getStatement().getGeneratedKeys();
                        // 获取主键
                    int id = rs.next() ? rs.getInt(1) : -1;
                    // 将数据库返回主键放入map中
                    Map<String, Object> idMap = new HashMap<String, Object>();
                    idMap.put("id", id);

                    return idMap;
                }
            }, user.getName(), user.getAge());

            return (Integer) idMap.get("id");
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return 0;
   }

    导入相对应的jar包

该接口用于处理 java.sql.ResultSet,将数据按要求转换为另一种形式。

    创建QueryRunner对象

ResultSetHandler 接口提供了一个单独的方法:Object handle (java.sql.ResultSet .rs)。

      使用query方法执行select语句

ArrayHandler:把结果集中的第一行数据转成对象数组。

      使用ResultSetHandler封装结果集

ArrayListHandler:把结果集中的每一行数据都转成一个数组,再存放到List中。

      使用DbUtils类释放资源

BeanHandler:将结果集中的第一行数据封装到一个对应的JavaBean实例中。

  3.2、实例

BeanListHandler:将结果集中的每一行数据都封装到一个对应的JavaBean实例中,存放到List里。

    注:本人使用的是C3P0连接池

ColumnListHandler:将结果集中某一列的数据存放到List中。

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.ResultSetHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.junit.Test;
import com.jxlg.domain.User;
public class TestSelect {
 @Test
 public void testSelect(){
 //创建一个QueryRunner对象
 QueryRunner qr = new QueryRunner(C3P0Util.getDataSource());
 try {
  // new ResultSetHandler<List<User>>告诉我们如何封装结果集
  List<User> list = qr.query("select * from user", new ResultSetHandler<List<User>>(){
  @Override
  //query语句执行select语句后,结果一返回值的形式传递过来
  public List<User> handle(ResultSet rs) throws SQLException {
   List<User> list = new ArrayList<User>();
   while(rs.next()){
   User u = new User();
   u.setId(rs.getInt(1));
   u.setUsername(rs.getString(2));
   u.setPassword(rs.getString(3));
   u.setEmail(rs.getString(4));
   u.setBirthday(rs.getDate(5));
   list.add(u);
   }
   return list;
  }
  });
  for (User user : list) {
  System.out.println(user);
  }
 } catch (SQLException e) {
  e.printStackTrace();
 }
}
 @Test
 public void testSelect2(){
 //创建一个QueryRunner对象
 QueryRunner qr = new QueryRunner(C3P0Util.getDataSource());
 try {
  //执行sql语句,返回结果
  List<User> list = qr.query("select * from user where id=? and username=?", new BeanListHandler<User>(User.class),1,"tom");
  for (User user : list) {
  System.out.println(user);
  }
 } catch (SQLException e) {
  e.printStackTrace();
 }
 }
}

KeyedHandler:将结果集中的每一行数据都封装到一个Map里,再把这些map再存到一个map里,其key为指定的key。

四、DBUtils三个核心对象详解

MapHandler:将结果集中的第一行数据封装到一个Map里,key是列名,value就是对应的值。

  4.1、QueryRunner对象

MapListHandler:将结果集中的每一行数据都封装到一个Map里,然后再存放到List

    4.1.1、构造函数

ResultSetHandler

         new QueryRunner(); 它的事务可以手动控制。                    

澳门新萄京官方网站 8

也就是说此对象调用的方法(如:query、update、batch)参数中要有Connection对象。

BeanListHandler

           new QueryRunner(DataSource ds); 它的事务是自动控制的。一个sql一个事务。                           

澳门新萄京官方网站 9

此对象调用的方法(如:query、update、batrch)参数中无需Connection对象。

MapHandler

    4.1.2、常用方法 

澳门新萄京官方网站 10

澳门新萄京官方网站 11

MapListHandler

   澳门新萄京官方网站 12

澳门新萄京官方网站 13

        澳门新萄京官方网站 14

ScalarHandler

        澳门新萄京官方网站 15

澳门新萄京官方网站 16

        澳门新萄京官方网站 17

  4.2、ResultSetHandler接口

    4.2.1、它有9个结果处理器

      ArrayHandler:适合取1条记录。把该条记录的每列值封装到一个数组中Object[]
      ArrayListHandler:适合取多条记录。把每条记录的每列值封装到一个数组中Object[],把数组封装到一个List中
      ColumnListHandler:取某一列的数据。封装到List中。
      KeyedHandler:取多条记录,每一条记录封装到一个Map中,再把这个Map封装到另外一个Map中,key为指定的字段值。
      MapHandler:适合取1条记录。把当前记录的列名和列值放到一个Map中
      MapListHandler:适合取多条记录。把每条记录封装到一个Map中,再把Map封装到List中
      ScalarHandler:适合取单行单列数据
      BeanHandler
      BeanListHandler

    4.2.2、实例       

import static org.junit.Assert.*;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
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.ColumnListHandler;
import org.apache.commons.dbutils.handlers.KeyedHandler;
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.jxlg.domain.User;
public class TestResultSetHandler {
 @Test
 public void test1() {
 //ArrayHandler:适合取1条记录。把该条记录的每列值封装到一个数组中Object[]
 QueryRunner qr = new QueryRunner(C3P0Util.getDataSource());
 try {
  Object[] o = qr.query("select * from user where id=?", new ArrayHandler(),5);
  for (Object object : o) {
  System.out.println(object);
  }
 } catch (SQLException e) {
  e.printStackTrace();
 }
 }
 @Test
 public void test2() throws SQLException {
 //ArrayListHandler:适合取多条记录。把每条记录的每列值封装到一个数组中Object[],把数组封装到一个List中
 QueryRunner qr = new QueryRunner(C3P0Util.getDataSource());
 List<Object[]> list = qr.query("select * from user", new ArrayListHandler());
 for (Object[] objects : list) {
  for (Object object : objects) {
  System.out.println(object);
  }
  System.out.println("----------------------");
 }
 }
 @Test
 public void test3() throws SQLException {
 //ColumnListHandler:取某一列的数据。封装到List中
 QueryRunner qr = new QueryRunner(C3P0Util.getDataSource());
 List<Object> list = qr.query("select username,password from user ", new ColumnListHandler(1));
 for (Object object : list) {
  System.out.println(object);
 } 
 }
 @Test
 public void test4() throws SQLException {
 //KeyedHandler:取多条记录,每一条记录封装到一个Map中,
 //再把这个Map封装到另外一个Map中,key为指定的字段值。
 QueryRunner qr = new QueryRunner(C3P0Util.getDataSource());
 //大的Map的key是表中的某列数据,小的Map的key是表的列名,所以大的map的key用的是Object类型,小的是String。
 Map<Object, Map<String, Object>> map = qr.query("select * from user", new KeyedHandler(1));
 for (Map.Entry<Object, Map<String,Object>> m : map.entrySet()) {
  System.out.println(m);//就是id至,因为设置了“1”.
  for (Map.Entry<String, Object> mm : m.getValue().entrySet()) {
  System.out.println(mm);//取出小map中的key和value
  }
  System.out.println("--------------------");
 }
 }
 @Test
 public void test5() throws SQLException {
 //MapHandler:适合取1条记录。把当前记录的列名和列值放到一个Map中
 QueryRunner qr = new QueryRunner(C3P0Util.getDataSource());
 Map<String, Object> map = qr.query("select * from user", new MapHandler());
 for (Map.Entry<String, Object> m : map.entrySet()) {
  System.out.println(m.getKey() "t" m.getValue());
  //默认取第一行数据,需要去其它行用where加条件
 }
 }
 @Test
 public void test6() throws SQLException {
 //MapListHandler:适合取多条记录。把每条记录封装到一个Map中,再把Map封装到List中
 QueryRunner qr = new QueryRunner(C3P0Util.getDataSource());
 List<Map<String, Object>> list = qr.query("select * from user", new MapListHandler());
 for (Map<String, Object> map : list) {
  for (Map.Entry<String, Object> m : map.entrySet()) {
  System.out.println(m); 
  }
  System.out.println("-----------");
 }
 }
 @Test
 public void test7() throws SQLException {
 //ScalarHandler:适合取单行单列数据
 QueryRunner qr = new QueryRunner(C3P0Util.getDataSource());
 Object o = qr.query("select * from user", new ScalarHandler(2));
 System.out.println(o);
 } 
 @Test
 public void test8() throws SQLException {
 //BeanHandler:适合取单行单列数据
 QueryRunner qr = new QueryRunner(C3P0Util.getDataSource());
 User user = qr.query("select * from user", new BeanHandler<User>(User.class));
 System.out.println(user);
 } 
}

五、使用DBUtils做一个增删改查的例子  

import static org.junit.Assert.*;
import java.sql.SQLException;
import java.util.Date;
import javax.crypto.spec.OAEPParameterSpec;
import org.apache.commons.dbutils.QueryRunner;
import org.junit.Test;
public class TestInCURD {
 @Test
 public void testInsert() {
 //创建一个QueryRunner对象
 QueryRunner qr = new QueryRunner(C3P0Util.getDataSource());
 try {
  qr.update("insert into user (username,password,email,birthday)values(?,?,?,?)", "guapi","4646","guapi@163.com",new Date());
 } catch (SQLException e) {
  e.printStackTrace();
 }
 }
 @Test
 public void testUpdate() {
 //创建一个QueryRunner对象
 QueryRunner qr = new QueryRunner(C3P0Util.getDataSource());
 try {
  qr.update("update user set username=?,password=? where id=4 ", "meizimeizi","520520");
 } catch (SQLException e) {
  e.printStackTrace();
 }
 }
 @Test
 public void testDelete() {
 //创建一个QueryRunner对象
 QueryRunner qr = new QueryRunner(C3P0Util.getDataSource());
 try {
  qr.update("delete from user where id=? ",4);
 } catch (SQLException e) {
  e.printStackTrace();
 }
 }
 @Test
 public void testBatch() {
 //创建一个QueryRunner对象
 QueryRunner qr = new QueryRunner(C3P0Util.getDataSource());
 try {
  Object[][] params = new Object[10][]; //高维代表执行多少次sql语句
  for(int i =0;i<params.length;i  ){
  params[i] =new Object[]{"guapi" i,"4646","guapi@163.com",new Date()}; 
  }
  qr.batch("insert into user (username,password,email,birthday)values(?,?,?,?)", params );
 } catch (SQLException e) {
  e.printStackTrace();
 }
 }
}

总结

以上所述是小编给大家介绍的JavaWeb dbutils执行sql命令并遍历结果集时不能查到内容的原因分析,希望对大家有所帮助,如果大家有任何疑问请给我留言,小编会及时回复大家的。在此也非常感谢大家对脚本之家的支持!

您可能感兴趣的文章:

  • Java数据库连接PreparedStatement的使用详解
  • 详解Java的JDBC中Statement与PreparedStatement对象
  • java实现jdbc查询结果集result转换成对应list集合
  • java实现将结果集封装到List中的方法
  • Java使用jdbc连接MySQL数据库实例分析
  • Java基于JDBC连接数据库及显示数据操作示例
  • java jdbc连接mysql数据库实现增删改查操作
  • java遍历读取整个redis数据库实例
  • java配置dbcp连接池(数据库连接池)示例分享
  • Java使用PreparedStatement接口及ResultSet结果集的方法示例

本文由澳门新萄京官方网站发布于数据库网络,转载请注明出处:澳门新萄京官方网站:学习应用

关键词: