DBUtils和连接池

Dbutils

只使用JDBC进行开发冗余代码过多，

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

DBUtils就是JDBC的简化开发工具包。需要项目导入commons-dbutils-1.6.jar才能够正常使用DBUtils工具。

 

1.1 Dbutils三个核心功能

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

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

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

1.2 QueryRunner核心类

update(Connection conn, String sql, Object... params) ，用来完成表数据的增加、删除、更新操作

query(Connection conn, String sql, ResultSetHandler<T> rsh, Object... params) ，用来完成表数据的查询操作

1.2.1添加、更新、删除

例：

建java项目，导入mysql的工具包和dbutils的jar包

import java.sql.Connection;
import java.sql.SQLException;
import org.apache.commons.dbutils.DbUtils;
import org.apache.commons.dbutils.QueryRunner;
import com.shopping.tools.JDBCUtils;

public class Demo01 {
    public static void main(String[] args) throws SQLException {
        add();
    }
    
    //对sort表添加数据
    public static void add() throws SQLException{
        //获得连接对象
        Connection conn=JDBCUtils.getConn();
        //获得语句执行对象
        QueryRunner qr=new QueryRunner();
        String sql="insert into sort values(?,?,?)";
        //封装传入的实际参数
        Object[] obj={13,"水杯","喝水"};
        int row=qr.update(conn,sql,obj);
        System.out.println(row);
        //关闭资源
        DbUtils.close(conn);
    }
    
    //修改数据
    public static void update() throws SQLException{    
        Connection conn=JDBCUtils.getConn();
        QueryRunner qr=new QueryRunner();
        String sql="update sort set sname=?,sdesc=? where sid=?";
        int row=qr.update(conn, sql, "遥控器","开电视",13);
        System.out.println(row);    
        DbUtils.close(conn);        
    }
    
    //删除数据
    public static void delete() throws SQLException{
        Connection conn=JDBCUtils.getConn();
        QueryRunner qr=new QueryRunner();
        String sql="DELETE FROM sort WHERE sid=?";
        qr.update(conn,sql,13);
        DbUtils.close(conn);
    }    
}

 add()方法结果：

update()方法结果：

delete()方法结果：

1.查询

ResultSetHandler结果集处理类：

ArrayHandler	将结果集中的第一条记录封装到一个Object[]数组中，数组中的每一个元素就是这条记录中的每一个字段的值
ArrayListHandler	将结果集中的每一条记录都封装到一个Object[]数组中，将这些数组在封装到List集合中。
BeanHandler	将结果集中第一条记录封装到一个指定的javaBean中。
BeanListHandler	将结果集中每一条记录封装到指定的javaBean中，将这些javaBean在封装到List集合中
ColumnListHandler	将结果集中指定的列的字段值，封装到一个List集合中
ScalarHandler	它是用于单数据。例如select count(*) from 表操作。
MapHandler	将结果集第一行封装到Map<String,Object>集合中,Key 列名, Value 该列数据
MapListHandler	将结果集每一行封装到List<Map<String,Object>>集合中,Key 列名, Value 该列数据,Map集合存储到List集合

 

实体类：

JavaBean是一个类，在开发中常用封装数据

1）需要实现接口：java.io.Serializable ，通常实现接口这步骤省略了，不会影响程序。

2）提供私有字段：private 类型 字段名;

3）提供getter/setter方法：

4）提供无参构造

例：

 

Sort实体类：

public class Sort {
    private int sid;
    private String sname;
    private String sdesc;
    public int getSid() {
        return sid;
    }
    public void setSid(int sid) {
        this.sid = sid;
    }
    public String getSname() {
        return sname;
    }
    public void setSname(String sname) {
        this.sname = sname;
    }
    public String getSdesc() {
        return sdesc;
    }
    public void setSdesc(String sdesc) {
        this.sdesc = sdesc;
    }
    @Override
    public String toString() {
        return "Sort [sid=" + sid + ", sname=" + sname + ", sdesc=" + sdesc + "]";
    }    
}

 

class Demo02：

 

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

public class Demo02 {
    private static Connection conn=JDBCUtils.getConn();
    private static QueryRunner qr=new QueryRunner();    
    
    public static void main(String[] args) throws SQLException {
        get1();
    }
    
    //查询数据ArrayHandler
    public static void get1() throws SQLException{        
        String sql="select * from sort where sid>?";
        Object[] obj=qr.query(conn, sql, new ArrayHandler(),2); //取结果集的第一条记录
        for(Object o:obj){
            System.out.print(o+" ");
        }
        DbUtils.close(conn);
    }
    
    //查询数据ArrayListHandler
    public static void get2() throws SQLException{        
        String sql="SELECT * FROM sort";
        List<Object[]> list=qr.query(conn, sql, new ArrayListHandler());
        for(Object[] objs:list){
            for(Object o:objs){
                System.out.print(o+" ");
            }
            System.out.println();
        }
    }
    
    //BeanHandler
    public static void get3() throws SQLException{
        String sql="SELECT * FROM sort where sid=?";
        Sort sort=qr.query(conn,sql,new BeanHandler<Sort>(Sort.class),6);
        System.out.println(sort);
    }
    
    //BeanListHandler
    public static void get4() throws SQLException{
        String sql="SELECT * FROM sort";
        List<Sort> list=qr.query(conn,sql,new BeanListHandler<Sort>(Sort.class));
        for(Sort s:list){
            System.out.println(s);
        }
    }
    
    //ColumnListHandler只查询某一列
    public static void get5() throws SQLException{
        String sql="select sname from sort";
        List<String> list=qr.query(conn,sql,new ColumnListHandler<String>());
        for(String s:list){
            System.out.println(s);
        }
    }
    
    //ScalarHandler单数据
    public static void get6() throws SQLException{
        String sql="SELECT COUNT(*) FROM sort";
        long count=qr.query(conn,sql,new ScalarHandler<Long>()); //注意是long类型
        System.out.println(count);
    }
    
    //MapHandler
    public static void get7() throws SQLException{
        String sql="SELECT * FROM sort";
        Map<String,Object> map=qr.query(conn,sql,new MapHandler());
        Set<String> set=map.keySet();
        for(String s:set){
            System.out.println(s+"..."+map.get(s));
        }
    }
    
    //MapListHandler
    public static void get8() throws SQLException{
        String sql="SELECT * FROM sort";
        List<Map<String,Object>> list=qr.query(conn,sql,new MapListHandler());
        for(Map<String,Object> map:list){
            Set<String> s=map.keySet();
            for(String str:s){
                System.out.print(str+"..."+map.get(str)+" ");
            }
            System.out.println();            
        }
    }
}

 

 get1()方法结果：

get2()方法结果：

get3()方法结果：

get4()方法结果：

get5()方法结果：

get6()方法结果：

get7()方法结果：

get8()方法结果：

2.连接池

实际开发中“获得连接”或“释放资源”是非常消耗系统资源的两个过程，

为了解决此类性能问题，采用连接池技术，来共享连接Connection。

这样就不需要每次都创建连接、释放连接了，这些操作都交给了连接池。

 

2.1原理

用池来管理Connection，这样可以重复使用Connection。

有了池，就不用自己来创建Connection，而是通过池来获取Connection对象。

当使用完Connection后，调用Connection的close()方法也不会真的关闭Connection，而是把Connection“归还”给池。池就可以再利用这个Connection对象了。

 

 

2.2规范

Java为数据库连接池提供了公共的接口：javax.sql.DataSource，各个厂商需要让自己的连接池实现这个接口。这样应用程序可以方便的切换不同厂商的连接池。

常见的连接池：DBCP、C3P0。

 

2.3 DBCP连接池 

2.3.1导入jar包

2.3.2 编写工具类：

DBUtils：

import java.sql.Connection;
import java.sql.SQLException;
import javax.sql.DataSource;
import org.apache.commons.dbcp.BasicDataSource;

public class DBUtils {
    public static final String DRIVER = "com.mysql.jdbc.Driver";
    public static final String URL = "jdbc:mysql://localhost:3306/market0929?useUnicode=true&characterEncoding=UTF-8";
    public static final String USERNAME = "root";
    public static final String PASSWORD = "123456";
    /*
     * 创建连接池BasicDataSource
     */
    //创建连接池对象
    public static BasicDataSource dataSource = new BasicDataSource(); //导的引入的jar包
    //静态代码块（只运行一次）
    static {
        //对连接池对象 进行基本的配置
        dataSource.setDriverClassName(DRIVER); // 这是要连接的数据库的驱动
        dataSource.setUrl(URL); //指定要连接的数据库地址
        dataSource.setUsername(USERNAME); //指定要连接数据的用户名
        dataSource.setPassword(PASSWORD); //指定要连接数据的密码
    }
    /*
     * 返回连接池对象
     */
    public static DataSource getDataSource(){ //导sql包
        return dataSource;
    }    
}

测试类：

import java.sql.SQLException;
import java.util.List;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import com.shopping.tools.DBUtils;

public class Demo03 {
    public static void main(String[] args) throws SQLException {
        get4();
    }

    private static QueryRunner qr = new QueryRunner(DBUtils.getDataSource());

    // BeanHandler
    public static void get3() throws SQLException {
        String sql = "SELECT * FROM sort where sid=?";
        Sort sort = qr.query(sql, new BeanHandler<Sort>(Sort.class), 6);
        System.out.println(sort);
    }

    // BeanListHandler
    public static void get4() throws SQLException {
        String sql = "SELECT * FROM sort";
        List<Sort> list = qr.query(sql, new BeanListHandler<Sort>(Sort.class));
        for (Sort s : list) {
            System.out.println(s);
        }
    }
}