DButils学习总结

最新推荐文章于 2024-09-01 13:25:41 发布

果子狸的大果果

最新推荐文章于 2024-09-01 13:25:41 发布

阅读量853

点赞数 2

本文链接：https://blog.csdn.net/qq_40692753/article/details/81705101

版权

DButils:主要是封装了JDBC的代码，简化dao层的操作，线程安全。

作用：帮助java程序员，开发Dao层代码的简单框架。

框架的作用：帮助程序员，提高程序的开发效率。

DButils的三个核心介绍：

DButils类：构造方法： Dbutils()

这个类的作用主要是提供一些用于关闭连接关闭连接、装载JDBC驱动程序之类的常规工作的方法，它里面的所有的方法都是静态的。其中重要方法有：

1、loadDriver(StringdriveClassName): 这一方法装载并注册JDBC驱动程序，如果成功就返回TRUE,不需要去捕捉ClassNotFoundException异常。通过返回值判断驱动程序是否加载成功。

2、close（）

这些方法检查所提供的参数是不是NULL，
如果不是的话，它们就关闭连接、声明和结果集（ResultSet）。

DbUtils.close(Connection con);
DbUtils.close(ResultSet rs);
DbUtils.close(Statement st);

3、CloseQuietly:
CloseQuietly这一方法不仅能在连接、声明或者结果集（ResultSet）为NULL情况下避免关闭，
还能隐藏一些在程序中抛出的SQLEeception。如果你不想捕捉这些异常的话，这对你是非常有用的。
在重载CloseQuietly方法时，特别有用的一个方法是closeQuietly(Connection conn,Statement stmt,ResultSet rs)，
这是因为在大多数情况下，连接、声明和结果集（ResultSet）是你要用的三样东西，而且在最后的块你必须关闭它们。
使用这一方法，你最后的块就可以只需要调用这一方法即可。

4、CommitAndCloseQuietly(Connection conn)：
这一方法用来提交连接，然后关闭连接，并且在关闭连接时不向上抛出在关闭时发生的一些SQL异常。
LoadDriver(String driveClassName):这一方法装载并注册JDBC驱动程序，如果成功就返回TRUE。
使用这种方法，你不需要去捕捉这个异常ClassNotFoundException。使用loadDrive方法，编码就变得更容易理解，
你也就得到了一个很好的Boolean返回值，这个返回值会告诉你驱动类是不是已经加载成功了。

QueryRunner类:执行Sql语句的操作对象，并且可以对ResultSet结果集进行封装。

构造方法：QueryRunner():创建一个和数据库无关的对象，后期使用的时候需要手动给一个数据库连接对象。好处就是它可以手动管理事务：

Connection.setAutoCommit(false); 设置手动管理事务

Connection.commit(); 提交事务

QueryRunner(DataSource ds)创建一个与数据库关联的对象，使用的时候不需要提供数据库连接对象，自动管理事务。

提供的方法：

QueryRunner()

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

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

QueryRunner(DataSource ds)

update(String sql, Object... params)

query(String sql, ResultSetHandler<T> rsh, Object... params)

ResultSetHanler接口：将结果集中的数据转到另一个容器；封装数据到对象的方式（示例：将数据库保存在User、保存到数组、保存到集合）

方法：：handle（ResultSet rs）

如果想自己控制转换的过程，继承该接口并重写接口中的方法，即可完成。

也可以通过提供的接口实现类，完成数据转换，实现类及其作用如下：

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

ScalarHandler 封装类似count、avg、max、min、sum......函数的执行结果

示例demo代码：

1、首先创建一个数据表：

username（varchar(20)）,userage(int).

2、创建一个用户类。

public class User {
   private String username;
   private int userage;
   public String getUsername() {
       return username;
   }
   public void setUsername(String username) {
       this.username = username;
   }
   public int getUserage() {
       return userage;
   }
   public void setUserage(int userage) {
       this.userage = userage;
   }
}

3、创建一个类，用于获得数据库连接。

public class GetCon {
   static Connection con = null;
   static String url = "jdbc:mysql://127.0.0.1:3306/sxb";
   static String user = "root";
   static String pass = "pass";

public static Connection getConnection() {

       try {
           Class.forName("com.mysql.jdbc.Driver");
           System.out.println("数据库驱动加载成功");
       } catch (ClassNotFoundException e) {
           // TODO Auto-generated catch block
           e.printStackTrace();
           System.out.println("数据库驱动加载失败");
       }
       try {
           con = DriverManager.getConnection(url, user, pass);
           System.out.println("数据库连接完成");
       } catch (SQLException e) {
           // TODO Auto-generated catch block
           e.printStackTrace();
           System.out.println("数据库连接失败");
       }
       return con;
   }
}
4、创建测试类，做基本的增删改查操作。

package testwrite;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

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 Crud {
   static Connection con; // 声明一个数据库连接对象
   static User[] user; // 声明一个User对象数组，用于存放查询结果集转换后的数据
   static Map<String, Object> map;
   static List<Map<String, Object>> list;

   public static void main (String[] args) {
       // TODO Auto-generated method stub
       MethodSca();
   }

// 执行自定义的查询
static List<User> listcustom; // 声明一个List容器

   public static void MethodCustom() {
       con = GetCon.getConnection();
       QueryRunner qr = new QueryRunner();
       String sql = "select * from table2";
       try {
           listcustom = qr.query(con, sql, new MyHandle());
           // MyHandle()类是一个继承了ResultSetHandler接口的类，并在类中重写了handle方法
           // 将查询结果集封装进了一个元素为User对象的List容器

       } catch (SQLException e) {
           // TODO Auto-generated catch block
           e.printStackTrace();
       }
       int listsize = listcustom.size();
       for (int a = 0; a < listsize; a++) {
           System.out.println("用户名：" + listcustom.get(a).getUsername());
           System.out.println("年龄：" + listcustom.get(a).getUserage());
       }
       DbUtils.closeQuietly(con);
   }

   // 用ResultSetHandle接口的实现类进行查询结果的封装
   // 1、ArrayHandler：把结果集中的第一行数据保存到Object数组中。
   static Object[] arraylist;

   public static void MethodArrayHander() {
       con = GetCon.getConnection();
       QueryRunner qr = new QueryRunner();
       String sql = "select * from table2";
       try {
           arraylist = qr.query(con, sql, new ArrayHandler());
       } catch (SQLException e) {
           // TODO Auto-generated catch block
           e.printStackTrace();
       }
       for (Object ob : arraylist) {
           System.out.println(ob);
       }
       DbUtils.closeQuietly(con);

}

// 2、ArrayListHandler：将查询的结果，每一行先封装到Object数组中，然后将数据存入List集合
static List<Object[]> arraylisthandler; // 声明一个对象数组

   public static void MethodArrayListHandler() {
       con = GetCon.getConnection();
       QueryRunner qr = new QueryRunner();
       String sql = "select * from table2";
       try {
           arraylisthandler = qr.query(con, sql, new ArrayListHandler()); // 创建了MyHandle实例后query方法回去自动调类中的handle方法
           System.out.println("数据查询成功");
           System.out.println(arraylisthandler.size());
           for (Object[] objects : arraylisthandler) {
               for (Object object : objects) {
                   System.out.println(object);
               }
               System.out.println("-----------------------------");
           }
       } catch (SQLException e) {
           // TODO Auto-generated catch block
           e.printStackTrace();
       }
       DbUtils.closeQuietly(con);
   }

// 3、BeanHandler：将结果集中的第一行数据封装到一个对应的JavaBean实例中。
static User ubean;

   public static void MethodBeanHandler() {
       con = GetCon.getConnection();
       QueryRunner qr = new QueryRunner();
       String sql = "select * from table2";
       try {
           ubean = qr.query(con, sql, new BeanHandler<User>(User.class));
       } catch (SQLException e) {
           // TODO Auto-generated catch block
           e.printStackTrace();
       }
       System.out.println("用户名" + ubean.getUsername());
       System.out.println("密码" + ubean.getUserage());
   }

// 4、BeanListHandler：将结果集中的每一行数据都封装到一个对应的JavaBean实例中，存放到List里。
static List<User> listbean;

   public static void MethodBeanListHandler() {
       con = GetCon.getConnection();
       QueryRunner qr = new QueryRunner();
       String sql = "select * from table2";
       try {
           listbean = qr
                   .query(con, sql, new BeanListHandler<User>(User.class));
       } catch (SQLException e) {
           // TODO Auto-generated catch block
           e.printStackTrace();
       }
       int listsize = listbean.size();
       for (int a = 0; a < listsize; a++) {
           System.out.println("用户名：" + listbean.get(a).getUsername());
           System.out.println("年龄：" + listbean.get(a).getUserage());
       }
       try {
           DbUtils.close(con);
       } catch (SQLException e) {
           // TODO Auto-generated catch block
           e.printStackTrace();
       }
   }

// 5、ColumnListHandler：将结果集中某一列的数据存放到List中。
static List<Object> columnlist; // 声明一个存放userage的list

   public static void MethodColumListHandler() {
       con = GetCon.getConnection();
       QueryRunner qr = new QueryRunner();
       // String sql = "select username,userage from table2";
       // 如果sql语句中出现多个查询字段，默认为第一个
       String sql = "select username from table2";
       try {
           columnlist = qr.query(con, sql, new ColumnListHandler<Object>());
       } catch (SQLException e) {
           // TODO Auto-generated catch block
           e.printStackTrace();
       }
       int size = columnlist.size();
       for (Object ob : columnlist) {
           System.out.println(ob);
       }
       DbUtils.closeQuietly(con);
   }

// 6、KeyedHandler(name)：将结果集中的每一行数据都封装到一个Map<列名,列值>里(map1)，
// 再把这些map再存到一个map(map2)里，其key为指定的key。

static Map<Object, Map<String, Object>> keymap; // 声明一个容器存放username字段和值

   public static void MethodKeyedHandler() {
       con = GetCon.getConnection();
       QueryRunner qr = new QueryRunner();
       String sql = "select * from table2";
       try {
           keymap = qr.query(con, sql, new KeyedHandler<>());

       } catch (SQLException e) {
           // TODO Auto-generated catch block
           e.printStackTrace();
       }

       /*
       * Set<Object> seto=keymap.keySet(); Iterator<Object>
       * ito=seto.iterator(); while(ito.hasNext()){
       * //System.out.println("Object:"+ito.next()); }
       */

       Collection<Map<String, Object>> co = keymap.values(); // String是列名，Object是值
       Iterator<Map<String, Object>> it = co.iterator();
       while (it.hasNext()) {
           Map<String, Object> mapp = it.next();
           Set<String> set = mapp.keySet(); // 获得关于map中key的集合
           Iterator<String> itset = set.iterator();
           while (itset.hasNext()) {
               System.out.println("列名：" + itset.next());
           }
           System.out.println("---------------------------");

           Collection<Object> cobject = mapp.values(); // 获取Map中的value的集合
           Iterator<Object> it2 = cobject.iterator();
           while (it2.hasNext()) {
               System.out.println(it2.next());
           }
           System.out.println("||||||||||||||||||||");
       }

}

// 7、MapHandler：将结果集中的第一行数据(包括所有字段 )封装到一个Map里，key是列名，value就是对应的值。
static Map<String, Object> maph;

   public static void MethodMapHandler() {
       con = GetCon.getConnection();
       QueryRunner qr = new QueryRunner();
       String sql = "select * from table2";
       try {
           maph = qr.query(con, sql, new MapHandler());
       } catch (SQLException e) {
           // TODO Auto-generated catch block
           e.printStackTrace();
       }
       Set<String> set = maph.keySet();
       Iterator<String> itk = set.iterator();
       while (itk.hasNext()) {
           System.out.println(itk.next());
       }

       System.out.println("----------------");
       Collection<Object> co = maph.values();
       Iterator<Object> itv = co.iterator();
       while (itv.hasNext()) {
           System.out.println(itv.next());
       }
   }

// 8、MapListHandler：将结果集中的每一行数据都封装到一个Map里，然后再存放到List
static List<Map<String, Object>> maplist;

   public static void MethodMapListHandler() {
       con = GetCon.getConnection();
       QueryRunner qr = new QueryRunner();
       String sql = "select * from table2";
       try {
           maplist = qr.query(con, sql, new MapListHandler());
       } catch (SQLException e) {
           // TODO Auto-generated catch block
           e.printStackTrace();
       }
       for (int a = 0; a < maplist.size(); a++) {
           Map<String, Object> mapt = maplist.get(a);
           Set<String> set = mapt.keySet();
           Iterator<String> itk = set.iterator();
           while (itk.hasNext()) {
               System.out.println(itk.next());
           }

           System.out.println("----------------");
           Collection<Object> co = mapt.values();
           Iterator<Object> itv = co.iterator();
           while (itv.hasNext()) {
               System.out.println(itv.next());
           }
       }
   }

   // 9、ScalarHandler 封装类似count、avg、max、min、sum......函数的执行结果
   public static void MethodSca() {
       con = GetCon.getConnection();
       QueryRunner qr = new QueryRunner();
       String sql = "select count(*) from table2";
       try {
           //查询数据库信息总条数
           long num = qr.query(con,sql, new ScalarHandler(1));
           System.out.println(num);
       } catch (SQLException e) {
           e.printStackTrace();
       }
   }

   // 执行添加数据
   public static void MethodInsert() {
       con = GetCon.getConnection();
       QueryRunner qr = new QueryRunner();
       String sql_insert = "insert into table2 values(?,?)";
       try {
           int update = qr.update(con, sql_insert, "wang", 21);
           System.out.println(update);
       } catch (SQLException e) {
           // TODO Auto-generated catch block
           e.printStackTrace();
           System.out.println("数据添加失败");
       }
       // 关闭数据库连接

DbUtils.closeQuietly(con); // 不需要抛出异常
}

   // 执行修改数据
   public static void MethodUpdate() {
       con = GetCon.getConnection();
       QueryRunner qr = new QueryRunner();
       String sql_update = "update table2 set username=? where username=?";
       try {
           int update = qr.update(con, sql_update, "www", "wang");
           System.out.println(update);
       } catch (SQLException e) {
           // TODO Auto-generated catch block
           e.printStackTrace();
           System.out.println("数据删除失败");
       }
       DbUtils.closeQuietly(con);
   }

   // 执行删除数据
   public static void MethodDelete() {
       con = GetCon.getConnection();
       QueryRunner qr = new QueryRunner();
       String sql_delete = "delete from table2 where username=?";
       try {
           int update = qr.update(con, sql_delete, "wang");
           System.out.println(update);
       } catch (SQLException e) {
           // TODO Auto-generated catch block
           e.printStackTrace();
           System.out.println("数据删除失败");
       }
       DbUtils.closeQuietly(con);
   }

}