【servlet】Apache—DBUtils框架详解与案例

Tip：O-R Mapping简介

• 什么是O-R  Mapping
• 常用O-R Mapping映射工具
  • Hibernate
  • Ibatis
  • Commons DbUtils(只是对JDBC简单封装)

Apache—DBUtils框架

简介

• commons-dbutils 是 Apache 组织提供的一个开源 JDBC工具类库，它是对JDBC的简单封装，学习成本极低，并且使用dbutils能极大简化jdbc编码的工作量，同时也不会影响程序的性能。因此dbutils成为很多不喜欢hibernate的公司的首选。
• API介绍：
  • org.apache.commons.dbutils.QueryRunner --BDManager
  • org.apache.commons.dbutils.ResultSetHandler—处理结果集
  • 工具类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情况下避免关闭，还能隐藏一些在程序中抛出的SQLEeception。
  • public static void commitAndCloseQuietly(Connection conn)： 用来提交连接，然后关闭连接，并且在关闭连接时不抛出SQL异常。 
  • public static boolean loadDriver(java.lang.String driverClassName)：这一方装载并注册JDBC驱动程序，如果成功就返回true。使用该方法，你不需要捕捉这个异常ClassNotFoundException。

QueryRunner类 

• 该类简单化了SQL查询，它与ResultSetHandler组合在一起使用可以完成大部分的数据库操作，能够大大减少编码量。
• QueryRunner类提供了两个构造方法：
  • 默认的构造方法
  • 需要一个 javax.sql.DataSource 来作参数的构造方法。

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：用来执行一个不需要置换参数的更新操作。

【实例】通过DBUtils实现增删改查

整个文件结构：

倒jar包

c3p0-config.xml

1. <?xml version="1.0" encoding="UTF-8"?>  
2.   
3.   
4. <c3p0-config>  
5.     <default-config>  
6.         <property name="driverClass">com.mysql.jdbc.Driver</property>  
7.         <property name="jdbcUrl">jdbc:mysql://localhost:3306/java</property>  
8.         <property name="user">root</property>  
9.         <property name="password">123456</property>  
10.           
11.         <property name="acquireIncrement">5</property>  
12.         <property name="initialPoolSize">10</property>  
13.         <property name="minPoolSize">5</property>  
14.         <property name="maxPoolSize">20</property>  
15.           
16.           
17.     </default-config>  
18.   
19.     <named-config name="mysql">  
20.         <property name="driverClass">com.mysql.jdbc.Driver</property>  
21.         <property name="jdbcUrl">jdbc:mysql://localhost:3306/java</property>  
22.         <property name="user">root</property>  
23.         <property name="password">123456</property>  
24.         <property name="acquireIncrement">5</property>  
25.         <property name="initialPoolSize">10</property>  
26.         <property name="minPoolSize">5</property>  
27.         <property name="maxPoolSize">20</property>  
28.     </named-config>  
29.   
30. </c3p0-config>  

连接数据库，DBManager.java

1. package com.hbsi.util;  
2.   
3. import java.sql.Connection;  
4. import java.sql.PreparedStatement;  
5. import java.sql.ResultSet;  
6. import java.sql.SQLException;  
7.   
8. import javax.sql.DataSource;  
9.   
10. import com.mchange.v2.c3p0.ComboPooledDataSource;  
11. public class DBManager {  
12.     private static ComboPooledDataSource ds = null;  
13.     static{  
14.         try{  
15.             //创建连接池           
16.             ds = new ComboPooledDataSource("mysql");  
17.         }catch(Exception e){  
18.             e.printStackTrace();  
19.         }  
20.     }  
21.   
22.     //获取链接  
23.     public static DataSource getDataSource(){  
24.         return ds;  
25.     }  
26.   
27. }  

表admin映射成class类，admin.java

1. package com.hbsi.domain;  
2. import java.io.Serializable;  
3.   
4. /** 
5.  * 把一个表admin映射(mapping)成Class类 
6.  *  
7.  * @author redarmy 
8.  *  
9.  */  
10. //可序列化的接口  
11. public class Admin implements Serializable {  
12.   
13.     /** 
14.      *   id int(11) not null primary key auto_increment,---calss 成员属性 
15.      *   name varchar(40) unique, 
16.      *   pass varchar(12), 
17.      *   sex enum('男','女'), 
18.      *   role int(11) 
19.      *    
20.      *   表                                                                                                                            class 
21.      *   int                                             int,Integer 
22.      *   varchar                                         Stirng 
23.      *   enum                                            Stirng 
24.      *   role                                            int 
25.      */  
26.     private static final long serialVersionUID = 1L;  
27.     // 把admin表中的字段映射成Admin类的成员属性(字段类型的转换如下 int --int Integer,varchar--String )  
28.     private int id;  
29.     private String name;  
30.     private String pass;  
31.     private String sex;  
32.     private int role;  
33.   
34.     public Admin(int id, String name, String pass, String sex, int role) {  
35.         super();  
36.         this.id = id;  
37.         this.name = name;  
38.         this.pass = pass;  
39.         this.sex = sex;  
40.         this.role = role;  
41.     }  
42.   
43.     //构造器  
44.     public Admin() {  
45.         super();  
46.         // TODO Auto-generated constructor stub  
47.     }  
48.   
49.     public Admin(String name, String pass, String sex, int role) {  
50.         super();  
51.         this.name = name;  
52.         this.pass = pass;  
53.         this.sex = sex;  
54.         this.role = role;  
55.     }  
56.   
57.     public int getId() {  
58.         return id;  
59.     }  
60.   
61.     public void setId(int id) {  
62.         this.id = id;  
63.     }  
64.   
65.     public String getName() {  
66.         return name;  
67.     }  
68.   
69.     public void setName(String name) {  
70.         this.name = name;  
71.     }  
72.   
73.     public String getPass() {  
74.         return pass;  
75.     }  
76.   
77.     public void setPass(String pass) {  
78.         this.pass = pass;  
79.     }  
80.   
81.     public String getSex() {  
82.         return sex;  
83.     }  
84.   
85.     public void setSex(String sex) {  
86.         this.sex = sex;  
87.     }  
88.   
89.     public int getRole() {  
90.         return role;  
91.     }  
92.   
93.     public void setRole(int role) {  
94.         this.role = role;  
95.     }  
96.   
97.     @Override  
98.     public String toString() {  
99.         return "Admin [id=" + id + ", name=" + name + ", pass=" + pass  
100.                 + ", role=" + role + ", sex=" + sex + "]";  
101.     }  
102.       
103.       
104.   
105. }  

增删改查操作，ZSGC.java

1. package com.hbsi.dao;  
2. import java.sql.SQLException;  
3. import java.util.List;  
4.   
5. import org.apache.commons.dbutils.QueryRunner;  
6. import org.apache.commons.dbutils.handlers.BeanHandler;  
7. import org.apache.commons.dbutils.handlers.BeanListHandler;  
8. import org.junit.Test;  
9.   
10.   
11. import com.hbsi.domain.Admin;  
12. import com.hbsi.util.DBManager;  
13. public class ZSGC {  
14.     @Test  
15.     public void insert(){  
16.         QueryRunner runner = new QueryRunner(DBManager.getDataSource());  
17.         String sql ="insert into admin(id,name,pass,sex,role)values(?,?,?,?,?)";  
18.         Object[] params ={13,"Jarry","123","男",1};  
19.         try {  
20.             runner.update(sql,params);  
21.         } catch (SQLException e) {  
22.             // TODO Auto-generated catch block  
23.             e.printStackTrace();  
24.         }  
25.   
26.     }  
27.     @Test  
28.     public void update() throws SQLException{  
29.         QueryRunner runner = new QueryRunner(DBManager.getDataSource());  
30.         String sql ="update admin set name=?,pass=? where id=?";  
31.         Object[] params ={"xxx","xxxx",13};  
32.         runner.update(sql,params);  
33.     }  
34.     @Test  
35.     public void delete() throws SQLException{  
36.         QueryRunner runner = new QueryRunner(DBManager.getDataSource());  
37.         String sql ="delete from admin where id=?";  
38.         runner.update(sql,13);    
39.     }  
40.       
41.     @Test  
42.     public void find() throws SQLException{  
43.         QueryRunner runner = new QueryRunner(DBManager.getDataSource());  
44.         String sql ="select id,name,pass from admin where id=?";  
45.         Admin admin;  
46.         admin = (Admin)runner.query(sql, 5,new BeanHandler(Admin.class));  
47.         System.out.println(admin.getId()+"--"+admin.getName()+"--"+admin.getPass()+"--"+admin.getSex()+"--"+admin.getRole());  
48.     }  
49.       
50.   
51.       
52.       
53.     @Test  
54.     public void getAll() throws SQLException {  
55.         QueryRunner runner = new QueryRunner(DBManager.getDataSource());  
56.         String sql = "select * from admin ";  
57.           
58.         List<Admin> list = (List<Admin>) runner.query(sql, new BeanListHandler(Admin.class));  
59.         System.out.println(list.size());  
60.           
61.         for(Admin admin:list){  
62.             System.out.println(admin.getId()+"--"+admin.getName()+"---"+admin.getPass()+"---"+admin.getSex()+"---"+admin.getRole());  
63.         }  
64.     }  
65. }  

原表数据:

insert方法实现，表数据变化

update方法实现，表数据变化

delete方法实现，表数据变化

select方法实现，表数据查询显示结果

selectAll方法实现，表数据查询显示结果

ResultSetHandler接口 

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

ResultSetHandler 接口的实现类

• ArrayHandler：把结果集中的第一行数据转成对象数组。
• ArrayListHandler：把结果集中的每一行数据都转成一个数组，再存放到List中。
• BeanHandler：将结果集中的第一行数据封装到一个对应的JavaBean实例中。
• BeanListHandler：将结果集中的每一行数据都封装到一个对应的JavaBean实例中，存放到List里。

ResultSetHandler 接口的实现类

• ColumnListHandler：将结果集中某一列的数据存放到List中。
• KeyedHandler(name)：将结果集中的每一行数据都封装到一个Map里，再把这些map再存到一个map里，其key为指定的key。
• MapHandler：将结果集中的第一行数据封装到一个Map里，key是列名，value就是对应的值。
• MapListHandler：将结果集中的每一行数据都封装到一个Map里，然后再存放到List

【案例】接口实现类案例

HandlerDemo.java

1. package com.hbsi.dao;  
2.   
3. import java.sql.SQLException;  
4. import java.util.Arrays;  
5. import java.util.List;  
6. import java.util.Map;  
7.   
8. import org.apache.commons.dbutils.QueryRunner;  
9. import org.apache.commons.dbutils.handlers.ArrayHandler;  
10. import org.apache.commons.dbutils.handlers.ArrayListHandler;  
11. import org.apache.commons.dbutils.handlers.ColumnListHandler;  
12. import org.apache.commons.dbutils.handlers.KeyedHandler;  
13. import org.apache.commons.dbutils.handlers.MapListHandler;  
14. import org.junit.Test;  
15.   
16. import com.hbsi.util.DBManager;  
17.   
18. public class HandlerDemo {  
19.   
20.     @Test  
21.     public void testArrayHandler() throws SQLException{  
22.           
23.         QueryRunner runner = new QueryRunner(DBManager.getDataSource());  
24.         String sql = "select * from admin where id=?";  
25.         Object[] params ={2};  
26.         Object[] result = runner.query(sql, params, new ArrayHandler());  
27.         System.out.println(Arrays.asList(result));  
28.           
29.     }  
30.       
31.     @Test  
32.     public void testArrayListHandler() throws SQLException{  
33.           
34.         QueryRunner runner = new QueryRunner(DBManager.getDataSource());  
35.         String sql = "select * from admin ";  
36.           
37.         List<Object[]> list =(List<Object[]>) runner.query(sql, new ArrayListHandler());  
38.         System.out.println(list.size());  
39.           
40.     }  
41.       
42.     @Test  
43.     public void testColumnListHandler() throws SQLException{  
44.           
45.         QueryRunner runner = new QueryRunner(DBManager.getDataSource());  
46.         String sql = "select * from admin ";  
47.           
48.         List list = (List)runner.query(sql, new ColumnListHandler("name"));  
49.         System.out.println(list);  
50.           
51.     }  
52.       
53.     @Test  
54.     public void testKeyedHandler() throws SQLException{  
55.           
56.         QueryRunner runner = new QueryRunner(DBManager.getDataSource());  
57.         String sql = "select * from admin ";  
58.           
59.         Map<Object, Map<String, Object>> map = runner.query(sql,new KeyedHandler("id"));  
60.           
61.         for(Map.Entry<Object,Map<String,Object>> me :map.entrySet()){  
62.               Map<String,Object> innerme =me.getValue();  
63.               for(Map.Entry<String,Object> entry :innerme.entrySet()){  
64.                  System.out.println( entry.getKey()+"="+entry.getValue());  
65.               }  
66.         }  
67.           
68.     }  
69.       
70.     @Test  
71.     public void testMapListHandler() throws SQLException{  
72.         QueryRunner runner = new QueryRunner(DBManager.getDataSource());  
73.         String sql = "select * from admin ";  
74.         List list = runner.query(sql, new MapListHandler());  
75.         System.out.println(list);  
76.     }  
77.   
78. }  

testArrayHandler()方法测试结果

testArrayListHandler()方法测试结果

testColumnListHandler()方法测试结果

testKeyedHandler()方法测试结果

testMapListHandler()方法测试结果

使用Jdbc操作多个表

注意事项

• 不管java的对象存在何种关系，反映到关系型数据库中，都是使用外键表示纪录（即对象）的关联关系。
• 设计java对象如涉及到多个对象相互引用，要尽量避免使用一对多，或多对多关系，而应使用多对一描述对象之间的关系(或使用延迟加载的方式)。