`
ssxxjjii
  • 浏览: 938234 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

Apache DBUtils使用总结 【转】

    博客分类：
  • ORM
 
阅读更多
DBUtils是个小巧的JDBC轻量级封装的工具包，其最核心的特性是结果集的封装，可以直接将查询出来的结果集封装成JavaBean，这就为我们做了最枯燥乏味、最容易出错的一大部分工作。
 
在使用DBUtils之前，应该注意一些问题：
 
1、DBUtils是JDBC的简单封装，可以和JDBC混合使用。
 
2、DBUtils对结果集自动封装为JavaBean是有着苛刻要求的：必须满足JavaBean的规范，其次Bean的getter与setter方法的名字与结果集的列名一一对应，而不要求JavaBean的私有成员与表结果集列名一一对应。
比如：
person表中有个字段叫：address，那么对应的JavaBean的Person类中必须有getAddress和setAddress两个方法，而Person类中可以将address属性命名为add，这是没问题的。
 
3、DBUtils可以将结果集封装为各种类型，主要有：Bean/List<Bean>，Map/List<Map>/Map<Map>，数组/List<数组>，列/List<列>，这些类型。
对于Map<Map>的类型使用KeyedHandler作为结果集处理器，内层的Map是“列名-值"对，外层的Map是“主键-内层Map的引用”，但此处的主键不一定就是数据库的主键，可以随意指定，比如：
ResultSetHandler h = new KeyedHandler("id");
Map found = (Map) queryRunner.query("select id, name, age from person", h);
Map jane = (Map) found.get(new Long(1)); // jane's id is 1
String janesName = (String) jane.get("name");
Integer janesAge = (Integer) jane.get("age");
 
4、DBUtils执行插入操作的时候，无法返回自增主键，这是一个很严重的问题，当然不能怪DBUtils，可以通过变通的方法来实现，比如 在MySQL中，执行完了一个插入SQL后，接着执行SELECT LAST_INSERT_ID()语句，就可以获取到自增主键。
 
5、DBUtils的性能和JDBC性能是一样，测试过程中没发现性能损失，拥有了很高性能的同时，而不失JDBC的灵活性。
 
6、对于JavaBean的成员类型定义，有一条原则那就是：尽可能使用包装类型，而不要使用基本类型。很多人不理解为什么，包括我见到一些傻B（，我提出让改为包装类型，他还信誓旦旦的说他的代码多牛多叼），都干好多年了，这个简单的道理还不知道:
        //错误
        int a1 = (Integer) null;
        boolean x1 = (Boolean)null;
        //正确
        Integer a2 = (Integer) null;
        Boolean x2 = (Boolean)null;
 
实际上就是为了保证在查询结果为null的时候，也不会因为给基本类型赋null值而发生错误。
 
下面给出一个简单例子，作为以后写代码时候有点参考：
 
环境：
MySQL5.4
JDK1.5
CREATE TABLE person (
     id bigint(20) NOT NULL AUTO_INCREMENT,
     name varchar(24) DEFAULT NULL,
     age int(11) DEFAULT NULL,
     address varchar(120) DEFAULT NULL,
     PRIMARY KEY (id)
) ENGINE=MyISAM AUTO_INCREMENT=1 DEFAULT CHARSET=gbk
 
public class Person {
        private Long id;
        private String sdf;
        private String address2;
        private Integer age;

        public Person() {
        }

        public Person(String sdf) {
                this.sdf = sdf;
        }

        public Person(String sdf, Integer age, String address) {
                this.sdf = sdf;
                this.age = age;
                this.address2 = address;
        }

        public Long getId() {
                return id;
        }

        public void setId(Long id) {
                this.id = id;
        }

        public String getSdf() {
                return sdf;
        }

        public void setSdf(String sdf) {
                this.sdf = sdf;
        }

        public Integer getAge() {
                return age;
        }

        public void setAge(Integer age) {
                this.age = age;
        }

        public String getAddress() {
                return address2;
        }

        public void setAddress(String address2) {
                this.address2 = address2;
        }
}
  
package com.lavasoft.dbstu;

import com.lavasoft.common.DBToolkit;
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.ScalarHandler;

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

/**
* Created by IntelliJ IDEA.
*
* @author leizhimin 2010-1-25 21:00:29
*/
public class PersonDAOImpl implements PersonDAO {
        private static PersonDAOImpl instance = new PersonDAOImpl();

        public static PersonDAOImpl getInstance() {
                return instance;
        }

        public static void main(String[] args) {
                //错误
                int a1 = (Integer) null;
                boolean x1 = (Boolean) null;
                //正确
                Integer a2 = (Integer) null;
                Boolean x2 = (Boolean) null;

                getInstance().save(null);
//                getInstance().save(null);
//                getInstance().save(null);
//                getInstance().save(null);
//                getInstance().save(null);
                getInstance().update(null);
                getInstance().load(null);
                getInstance().load4Map(null);
        }

        @Override
        public Long save(String sql) {
                Long id = null;
                String ins_sql = "INSERT INTO person (NAME, age, address) VALUES ('aaa', 21, 'address001')";
                Connection conn = DBToolkit.getConnection();
                QueryRunner qr = new QueryRunner();
                try {
                        qr.update(conn, ins_sql);
                        //获取新增记录的自增主键
                        id = (Long) qr.query(conn, "SELECT LAST_INSERT_ID()", new ScalarHandler(1));
                } catch (SQLException e) {
                        e.printStackTrace();
                } finally {
                        DBToolkit.closeConnection(conn);
                }
                return id;
        }

        @Override
        public int delete(Long id) {
                int x = 0;
                Connection conn = DBToolkit.getConnection();
                QueryRunner qr = new QueryRunner();
                try {
                        x = qr.update(conn, "DELETE FROM person WHERE id = ?", id);
                } catch (SQLException e) {
                        e.printStackTrace();
                } finally {
                        DBToolkit.closeConnection(conn);
                }
                return x;
        }

        @Override
        public int update(Person person) {
                int x = 0;
                Connection conn = DBToolkit.getConnection();
                QueryRunner qr = new QueryRunner();
                try {
                        x = qr.update(conn, "UPDATE person SET NAME = ?, age = ?, address = ? WHERE id = ?", "xxx", 23, "ttt", 5);
                } catch (SQLException e) {
                        e.printStackTrace();
                } finally {
                        DBToolkit.closeConnection(conn);
                }
                return x;

        }

        @Override
        public Person load(Long id) {
                Connection conn = DBToolkit.getConnection();
                QueryRunner qr = new QueryRunner();
                try {
                        Person person = (Person) qr.query(conn, "SELECT * FROM person where id = ?", new BeanHandler(Person.class), 3L);
                        System.out.println(person.getId() + "\t" + person.getSdf() + "\t" + person.getAge() + "\t" + person.getAddress());
                } catch (SQLException e) {
                        e.printStackTrace();
                }
                return null;
        }

        @Override
        public List<Person> findPerson(String sql) {
                Connection conn = DBToolkit.getConnection();
                QueryRunner qr = new QueryRunner();
                try {
                        List<Person> pset = (List) qr.query(conn, "SELECT * FROM person", new BeanListHandler(Person.class));
                        for (Person person : pset) {
                                System.out.println(person.getId() + "\t" + person.getSdf() + "\t" + person.getAge() + "\t" + person.getAddress());
                        }
                } catch (SQLException e) {
                        e.printStackTrace();
                }
                return null;
        }

        public Person load4Map(Long id) {
                Connection conn = DBToolkit.getConnection();
                QueryRunner qr = new QueryRunner();
                try {
                        //先将两个字段置为null
                        qr.update(conn, "update person set age = null,address =null where id =1");
                        Map<String, Object> map = qr.query(conn, "SELECT * FROM person where id = ?", new MapHandler(), 1L);
                        Person person = new Person();
                        person.setId((Long) map.get("id"));
                        person.setSdf((String) map.get("name"));
                        person.setAge((Integer) map.get("age"));
                        person.setAddress((String) map.get("address"));
                        System.out.println(person.getId() + "\t" + person.getSdf() + "\t" + person.getAge() + "\t" + person.getAddress());
                } catch (SQLException e) {
                        e.printStackTrace();
                }
                return null;
        }
}
 
注意：
从上面的过程看，每个SQL的执行都需要用到QueryRunner，这其实是一个普通的类，非线程安全。在创建这个QueryRunner对象的时候，每次都要new。
 
QueryRunner对象的创建方式很多，可以通过DateSource，也可以通过Connection来创建。从QueryRunner对象上，可以直接获取到DataSource或者Connection对象。
 
 
Dbutil 的使用示例 
package cn.lining.test;

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

import org.apache.commons.dbutils.DbUtils;
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.BeanListHandler;
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;

public class test {
 @SuppressWarnings("unchecked")
 public static void main(String[] args) throws ClassNotFoundException {

  UserField userField = new UserField();

  Connection conn = null;
  String jdbcURL = "jdbc:mysql://localhost:3306/macaw4";
  String jdbcDriver = "com.mysql.jdbc.Driver";
  try {
   DbUtils.loadDriver(jdbcDriver);
   conn = DriverManager.getConnection(jdbcURL, "root", "root");
   conn.setAutoCommit(false);//关闭自动提交
   QueryRunner qRunner = new QueryRunner();

   // 以下部分代码采用MapHandler存储方式查询
   System.out.println("***Using MapHandler***");
   Map map = (Map) qRunner.query(conn,
     "select * from mc_user_field where id = ?",
     new MapHandler(), new Object[] { "5" });

   System.out.println("id ------------- name ");
   System.out.println(map.get("id") + "  ------------- "
     + map.get("name"));

   // 以下部分代码采用MapListHandler存储方式查询
   System.out.println("***Using MapListHandler***");
   List lMap = (List) qRunner.query(conn,
     "select * from mc_user_field", new MapListHandler());

   System.out.println("id ------------- name ");
   for (int i = 0; i < lMap.size(); i++) {
    Map vals = (Map) lMap.get(i);
    System.out.println(vals.get("id") + "  ------------- "
      + vals.get("name"));
   }

   // 以下部分代码采用BeanHandler存储方式查询
   System.out.println("***Using BeanHandler***");
   userField = (UserField) qRunner.query(conn,
     "select * from mc_user_field where id = ?",
     new BeanHandler(Class.forName("cn.lining.test.UserField")),
     new Object[] { "5" });
   System.out.println("id ------------- name ");
   System.out.println(userField.getId() + "  ------------- "
     + userField.getName());

   // 以下部分代码采用BeanListHandler存储方式查询
   System.out.println("***Using BeanListHandler***");
   List lBean = (List) qRunner.query(conn,
     "select * from mc_user_field", new BeanListHandler(Class
       .forName("cn.lining.test.UserField")));
   System.out.println("id ------------- name ");
   for (int i = 0; i < lBean.size(); i++) {
    userField = (UserField) lBean.get(i);
    System.out.println(userField.getId() + "  ------------- "
      + userField.getName());
   }

   // 以下部分代码采用ArrayHandler存储方式查询
   System.out.println("***Using ArrayHandler***");
   Object[] array = (Object[]) qRunner.query(conn,
     "select * from mc_user_field where id = ?",
     new ArrayHandler(), new Object[] { "5" });

   System.out.println("id ------------- name ");
   System.out.println(array[0].toString() + "  ------------- "
     + array[1].toString());

   // 以下部分代码采用ArrayListHandler存储方式查询
   System.out.println("***Using ArrayListHandler***");
   List lArray = (List) qRunner.query(conn,
     "select * from mc_user_field", new ArrayListHandler());
   System.out.println("id ------------- name ");
   for (int i = 0; i < lArray.size(); i++) {
    Object[] var = (Object[]) lArray.get(i);
    System.out.println(var[0].toString() + "  ------------- "
      + var[1].toString());
   }

   // 以下部分代码采用ColumnListHandler存储方式查询指定列
   System.out.println("***Using ColumnListHandler***");
   List lName = (List) qRunner.query(conn,
     "select * from mc_user_field where id = ?",
     new ColumnListHandler("name"), new Object[] { "5" });
   System.out.println("name ");
   for (int i = 0; i < lName.size(); i++) {
    String name = (String) lName.get(i);
    System.out.println(name);
   }

   // 以下部分代码采用ScalarHandler存储方式查询
   System.out.println("***Using ScalarHandler***");
   String name = (String) qRunner.query(conn,
     "select * from mc_user_field where id = ?",
     new ScalarHandler("name"), new Object[] { "5" });

   System.out.println("name ");
   System.out.println(name);

   // 以下部分代码采用KeyedHandler存储方式查询
   System.out.println("***Using KeyedHandler***");
   Map<String, Map> map2 = (Map<String, Map>) qRunner.query(conn,
     "select * from mc_user_field", new KeyedHandler("name"));

   System.out.println("name: field_name2");
   Map vals = (Map) map2.get("field_name2");
   System.out.println(vals.get("id") + "  " + vals.get("name") + "  "
     + vals.get("type"));

   // 以下部分代码插入一条数据
   System.out.println("***Insert begin***");
   userField = new UserField();
   qRunner.update(conn, "insert into mc_user_field ("
     + "id,name,type,sort_order,required,visible)"
     + "values (?,?,?,?,?,?)", new Object[] { userField.getId(),
     userField.getName(), userField.getType(),
     userField.getSort_order(), userField.getRequired(),
     userField.getVisible() });
   System.out.println("***update end***");

   // 以下部分代码更新一条数据
   System.out.println("***update begin***");
   userField = new UserField();
   qRunner.update(conn, "update mc_user_field set "
     + "name = ?,type = ?,sort_order = ?,"
     + "required = ?,visible = ?" + "where id = ?",
     new Object[] { userField.getName(), userField.getType(),
       userField.getSort_order(), userField.getRequired(),
       userField.getVisible(), userField.getId() });
   System.out.println("***update end***");

   // 以下部分代码删除一条数据
   System.out.println("***delete begin***");
   userField = new UserField();
   qRunner.update(conn, "delete from mc_user_field where id2 = ?",
     new Object[] { userField.getId() });
   System.out.println("***delete end***");

  } catch (SQLException ex) {
   ex.printStackTrace();
   try {
    System.out.println("***rollback begin***");
    DbUtils.rollback(conn);
    System.out.println("***rollback end***");
   } catch (SQLException e) {
    e.printStackTrace();
   }
  } finally {
   DbUtils.closeQuietly(conn);
  }

 }
}
 
  • ArrayHandler：把结果集中的第一行数据转成对象数组。
  • ArrayListHandler：把结果集中的每一行数据都转成一个对象数组，再存放到List中。
  • BeanHandler：将结果集中的第一行数据封装到一个对应的JavaBean实例中。
  • BeanListHandler：将结果集中的每一行数据都封装到一个对应的JavaBean实例中，存放到List里。
  • ColumnListHandler：将结果集中某一列的数据存放到List中。
  •  KeyedHandler：将结果集中的每一行数据都封装到一个Map里，然后再根据指定的key把每个Map再存放到一个Map里。
  •  MapHandler：将结果集中的第一行数据封装到一个Map里，key是列名，value就是对应的值。
  •  MapListHandler：将结果集中的每一行数据都封装到一个Map里，然后再存放到List。
  •  ScalarHandler：将结果集中某一条记录的其中某一列的数据存成Object。


    • 分享到：
    | Apache DBUtils:使用Bean(ORM)例子
    评论
    发表评论

    您还没有登录,请您登录后再发表评论

    相关推荐

      Apache DBUtils使用总结

      DBUtils是个小巧的JDBC轻量级封装的工具包，其最核心的特性是结果集的封装，可以直接将查询出来的结果集封装成JavaBean，这就为我们做了最枯燥乏味、最容易出错的一大部分工作。

      Apache DbUtils Demo示例

      总结起来，Apache DbUtils是JDBC编程的利器，它通过提供便捷的API，大大减少了开发人员处理数据库操作时的工作量，提高了代码的可读性和维护性。在实际项目中，结合DAO层的设计模式，DbUtils能有效地提高开发效率，...

      apache dbutils ..............................

      总结来说，Apache DBUtils是Java开发中一个强大且实用的工具，它简化了数据库操作，提高了代码的可读性和安全性，同时也方便了开发者集成到现有的数据库管理框架中。对于需要频繁进行数据库交互的Java应用，DBUtils...

      commons-dbutils使用简单范例--简化jdbc编程

      1. **引入依赖**：在项目中引入Apache Commons DBUtils的jar包或Maven依赖，确保项目可以使用其提供的类和方法。 2. **配置数据源**：创建一个DataSource对象，这通常是通过连接池实现的，如Apache DBCP、C3P0或...

      dbutils1.6

      Apache Commons DBUtils是Java开发中的一个实用工具库，主要用于简化JDBC（Java Database Connectivity）的使用。这个资源包"commons-dbutils-1.6-bin.zip"包含了DBUtils 1.6版本的源代码和相关文档，是理解并使用...

      DButils使用实例

      DButils是Apache的一个开源项目，它是Java编程语言中用于数据库操作的一个实用工具库。这个库主要是为了解决JDBC（Java Database Connectivity）编程时的一些繁琐工作，如连接管理、异常处理以及结果集的处理等，...

      Dbutils学习源码总结

      apache下面有很多值得学习的开源项目，尤其是commons系列，在此，特封装了其组织下的dbutils根据，方便了喜欢使用sql开发的java朋友，里面有各种实用的封装类和对数据库操作的接口，欢迎下载！

      commons-dbutils-1.7.jar

      总结，Apache Commons DBUtils作为Java中的数据库操作利器，以其简洁、安全、高效的特点，极大地简化了开发人员与数据库交互的工作。它在处理日常的CRUD操作时表现出色，是Java开发者不可或缺的工具之一。了解并熟练...

      dbutils框架

      总结，Apache DBUtils是一个强大的数据库操作助手，它的设计原则是简洁、高效，旨在降低数据库操作的复杂度。通过使用DBUtils，开发人员可以更加专注于业务逻辑，提高开发效率，同时得益于其良好的异常处理和资源...

      -dbutils使用说明.docx

      总结起来，这些知识点展示了如何使用Apache Commons DBUtils库进行数据库操作，包括连接管理、查询执行、结果处理以及基本的DAO设计模式。在实际项目中，这样的工具和设计可以大大提高开发效率和代码的健壮性。

      dbutils

      3. **异常处理**：`dbutils` 使用统一的异常处理机制，将JDBC的检查异常转化为运行时异常，简化了异常处理流程。 4. **连接池集成**：虽然`dbutils` 不自带连接池，但它可以很好地与第三方连接池（如C3P0、DBCP、...

      -dbutils使用说明.pdf

      总结起来，Apache Commons dbutils是Java开发中一个强大的工具，它简化了JDBC操作，提高了开发效率，减少了出错的可能性。无论是在大型互联网项目还是小型应用中，dbutils都能作为一个可靠的助手，帮助开发者高效地...

      dbutils-1.7 bin和src

      标题"dbutils-1.7 bin和src"指的是Apache Commons DBUtils的1.7版本，它包含两个部分：bin和src。bin通常是指编译后的二进制版本，包括已编译的Java类和其他可执行文件，用户可以直接在项目中使用。src则是源代码...

      dbutils jar包及使用介绍

      **dbutils jar包及使用介绍** Apache Commons DBUtils是一个轻量级的Java数据库连接工具库，它是Apache软件基金会的一个开源项目。它简化了数据库操作，为开发者提供了简单易用的API，使得处理JDBC（Java Database ...

      DBUtils jar包 官方原版的

      DBUtils是Apache软件基金会开发的一个Java库，它提供了一套高效、简单易用的数据库连接管理工具，使得Java开发者在处理数据库操作时可以更加便捷。这个"DBUtils jar包 官方原版的"指的是从官方渠道获取的未经修改的...

      java web中的commons-dbutils-1.3-bin.zip

      总结起来，Apache Commons DBUtils是Java Web开发中的重要工具，它通过提供异常安全的数据库操作方法，简化了数据访问层的实现，提高了代码质量。结合Commons Logging，我们可以轻松管理和调试应用程序的日志，...

      数据库连接池和DBUtils使用1

      `DBUtils`是Apache的另一个开源项目，它简化了JDBC的使用，提供了一套简洁的API来处理数据库连接、执行SQL等任务。它可以在任何连接池之上运行，使得数据库操作更加便捷且易于管理。使用DBUtils，我们可以方便地进行...

      Commons DbUtils源码阅读之实例及测试应用

      总结来说，Apache Commons DbUtils是一个强大的数据库操作助手，它的源码阅读有助于我们更好地理解和掌握数据库操作的最佳实践。通过实例应用和测试，我们可以深入理解DbUtils的工作原理，并将其有效地应用到实际...

      dbutils工具包和源文件

      `dbutils` 由Apache软件基金会开发并维护，是许多Java项目中的常用组件，尤其对于进行数据处理和数据访问的程序设计者来说，它极大地提高了开发效率。 **一、dbutils的核心功能** 1. **快速查询**: `QueryRunner` ...

      dbutils工具类的使用

      dbutils是Apache的一个开源项目，它基于Java设计，主要提供了一套简洁的API来处理JDBC操作。dbutils的核心理念是减少数据库访问的繁琐代码，通过预编译的SQL语句和批处理，提高程序的性能和安全性。其主要包含两个...

    Magicbox
    Global site tag (gtag.js) - Google Analytics