DBUtils工具类的三大核心功能以及DBCP连接池介绍

DBUtils工具类：

1.QueryRunner中提供对sql语句的操作的API；

2.ResultSetHandler 接口，用于定义select操作后，怎样封装结果集；

3.DbUtils,工具类，定义了关闭资源和事务处理的方法。

QueryRunner类:调用QueryRunner类的方法update(Connection con,String sql,object...param)(object...param为可变参数类型，用于替代占位符的出现）；实现对数据库表的insert,delete,update。

实例：

1.准备：在新建工程中导入以下jar包：

commons-dbcp-1.4.jar

commons-dbutils-1.6.jar

commons-pool-1.5.6.jar

mysql-connector-java-5.1.37-bin.jar（需要以上jar包的可自行联系）

建立JDBCUtilsconfig类对数据库建立连接：

package QueryRunnerDemo;

   import java.io.InputStream;
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.util.Properties;

    /*
     *  编写数据库连接的工具类,JDBC工具类
     *  获取连接对象采用读取配置文件方式
     *  读取文件获取连接,执行一次,static{}
     */
    public class JDBCUtilsconfig {
        private static Connection con ;
        private static String driverClass;
        private static String url;
        private static String username;
        private static String password;
        
        static{
            try{
                readConfig();
                Class.forName(driverClass);
                con = DriverManager.getConnection(url, username, password);
            }catch(Exception ex){
                throw new RuntimeException("数据库连接失败");
            }
        }
        
        private static void readConfig()throws Exception{
            InputStream in = JDBCUtilsconfig.class.getClassLoader().getResourceAsStream("database.properties");
             Properties pro = new Properties();
             pro.load(in);
             driverClass=pro.getProperty("driverClass");
             url = pro.getProperty("url");
             username = pro.getProperty("username");
             password = pro.getProperty("password");
        }
        
        
        public static Connection getConnection(){
            return con;
        }
        
    }

 

 

 

 

 

 

package QueryRunnerDemo;

import java.sql.Connection;
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.MapHandler;
import org.apache.commons.dbutils.handlers.MapListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;

public class QueryRunnerDemo {
private static Connection con = JDBCUtilsconfig.getConnection();
public static void insert() {  
    QueryRunner qr = new QueryRunner();
    String sql = "INSERT INTO sort(sname,sprice,sdesc) VALUES(?,?,?)";
    Object[] params = {"体育用品",298.33,"购买体育用品"};
    try {
        int row = qr.update(con, sql, params);
        System.out.println(row);
    } catch (SQLException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    DbUtils.closeQuietly(con);
}
public static void delete()
{  
    QueryRunner qr = new QueryRunner();
    String sql = "DELETE FROM sort WHERE sid = ?";
    try {
        int row = qr.update(con, sql, 1);
        System.out.println(row);
        
    } catch (SQLException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    
}
public static void update()
{  
    QueryRunner qr = new  QueryRunner();
    String sql = "UPDATE sort SET sname = ?,sprice = ?,sdesc = ? WHERE sid = ?";
//    Object[] params = {"洗发水",58.9,"生活用品",1};
    Object[] params = {"水果",100.12,"刚刚上市的核桃",2};
    int row;
    try {
        row = qr.update(con, sql, params);
        System.out.println(row);
    } catch (SQLException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}
//数据库查询结果集的第一种处理方式：(ArrayHandler:将结果集中的第一行数据封装到Object中。）
public static void arrayHandler()
{  
    QueryRunner qr = new QueryRunner();
    String sql = "SELECT * FROM  sort";
    Object[] result = null;
    try {
        result = qr.query(con, sql,new ArrayHandler());
    } catch (SQLException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    for(Object obj :result)
    {  
        System.out.println(obj);
    }
}
//数据结果集的第二种处理方式：ArrayListHandler：将结果集先封装到Object[]数组中，在把Object数组封装到list集合里面。
public static void arrayListHandler()
{  
    QueryRunner qr = new QueryRunner();
    String sql = "SELECT * FROM  sort";
    try {
        List<Object[]> result = qr.query(con, sql,new ArrayListHandler());
        for(Object[] obj :result)
        {  
            for(Object objs:obj)
            {  
                System.out.print(objs + "  ");
            }
            System.out.println();
        }
        
    } catch (SQLException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}
/*数据结果集的第三种处理方式：BeanHeadler:将查询的第一行数据封装到指定javabean中，
（JavaBean:JavaBean就是一个类，在开发中常用封装数据。具有如下特性
1.需要实现接口：java.io.Serializable ，通常实现接口这步骤省略了，不会影响程序。
2.提供私有字段：private 类型 字段名;
3.提供getter/setter方法：
4.提供无参构造)
*/
public static void beanHandler()
{  
    QueryRunner qr = new QueryRunner();
    String sql = "SELECT * FROM  sort";
    try {
        sort s = qr.query(con, sql, new BeanHandler<sort>(sort.class));
        System.out.println(s);
    } catch (SQLException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}
/*  
 数据结果集的第四种处理方式：BeanListHandler:
 先将数据集封装到JavaBean中，再将其封装到List集合中。
 * */
public static  void beanListHandler()
{  
    QueryRunner qr = new QueryRunner();
    String sql = "SELECT * FROM  sort";
    try {
        List<sort> list = qr.query(con, sql, new BeanListHandler<sort>(sort.class));
        for(sort s:list)
        {  
            System.out.println(s+"\t");
            System.out.println();
        }
    } catch (SQLException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}
//数据结果集的第五种处理方式：ColumnListHandler:指定列数据存到List集合。
public static void columnListHandler()
{  
    QueryRunner qr = new QueryRunner();
    String sql = "SELECT * FROM  sort";
    try {
        List<Object> list = qr.query(con, sql, new ColumnListHandler<Object>("sdesc"));
        for(Object obj: list)
        {  
            System.out.print(obj+"\t");
            System.out.println();
        }
    } catch (SQLException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}
//数据处理的第六种方式：ScarlarHandler:用于查询只用一个结果集的
public static void scarlarHandler()
{  
    QueryRunner qr = new QueryRunner();
    String sql = "SELECT COUNT(sid) FROM  sort ";
    try {
        long count = qr.query(con,sql, new ScalarHandler<Long>());
     System.out.println(count); 
    } catch (SQLException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}
//数据处理集的第七种方式：MapHandler:将结果集的第一行数据封装到map集合中 Map<键，值> 键：列名，值：列的数据。
public static void mapHandler()
{  
    QueryRunner qr = new QueryRunner();
    String sql = "SELECT * FROM  sort";
try {
    Map<String,Object> map =     qr.query(con, sql, new MapHandler());
    for(String key:map.keySet())
    {   
        System.out.println(key+ "   " +map.get(key));
    }
} catch (SQLException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
}
}
//数据处理集的第八种方式：MapListHandler:将结果集的每一行存储到Map集合中，再将map集合封装到List集合中
public static void mapListHandler()
{  
    QueryRunner qr = new QueryRunner();
    String sql = "SELECT * FROM  sort";
    try {
        List<Map<String,Object>> list = qr.query(con, sql,new MapListHandler());
        for(Map<String,Object> map:list)
        {  
            for(String key:map.keySet()) {  
                System.out.print(key+"******"+"  "+map.get(key));
            }
            System.out.println();
        }
    } catch (SQLException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}
 public static void main(String[] args) {
//    insert();
//     delete();
//     update();

/ /以上三种方法是使用QueryRunner类来对数据库进行insert,delete,update.:

//     arrayHandler();
//     arrayListHandler();
 // beanHandler();
//     beanListHandler();
//     columnListHandler();
//     scarlarHandler();
//     mapHandler();

     mapListHandler() ;

//以上八种方法是使用ResultSetHandler 结果集处理类，对查询结果进行处理。
     }
}

DBCP连接池：解决系统消耗的性能问题，用来管理connection，这样可以重复使用connection连接。

DBCP连接池的实例：

//以下代码为连接池工具类

package QueryRunnerDemo;

import javax.activation.DataSource;

import org.apache.commons.dbcp.BasicDataSource;

public class JDBCUtils {
private static BasicDataSource dataSource = new BasicDataSource();
static{  
    dataSource.setDriverClassName("com.mysql.jdbc.Driver");
    dataSource.setUrl("jdbc:mysql://localhost:3306/mybase");
    dataSource.setUsername("root");
    dataSource.setPassword("123");
    //以上为连接池必须配置的功能
    dataSource.setInitialSize(10);//初始化连接数
    dataSource.setMaxActive(8);//最大连接数
    dataSource.setMaxIdle(5);//最大空闲数
    dataSource.setMinIdle(1);//最小空闲数
}
    public static  BasicDataSource getDataSource()
    {  
        return  dataSource;
    }
}

//以下代码为连接池的测试类；测试了数据库的insert和select

package 连接池;

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

import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.ArrayListHandler;

import QueryRunnerDemo.JDBCUtils;

public class TestJDBCUtils {

    public static void main(String[] args){
        //insert();
        select();
    }
    private static QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
    public static void insert()
    {   
        String sql = "INSERT INTO sort(sname,sprice,sdesc)VALUES(?,?,?)";
        Object[] params = {"香蕉",25.03,"刚刚摘下的香蕉"};
        try {
            int row = qr.update( sql, params);
            System.out.println(row);
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    public static void select() {  
        String sql = "SELECT *FROM sort";
        try {
            List<Object[]> list = qr.query(sql, new ArrayListHandler());
            for(Object[] obj:list) {  
                for(Object objs:obj)
                {  
                    System.out.println(objs);
                }
            }
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}