DButils工具類和連接池的使用

1. DButils工具類的介紹個三個核心類

   A: DButils工具類的介紹個三個核心類
   a: 概述
      DBUtils是java編程中的數據庫操作實用工具，小巧簡單實用。
      DBUtils封裝了對JDBC的操作，簡化了JDBC操作，可以少寫代碼。
      DBUtils就是JDBC的簡化開發工具包。需要項目導入commons-dbutils-1.6.jar才能夠正常使用DBUtils工具。
   b: Dbutils三個核心功能介紹
     QueryRunner中提供對sql語句操作的API.
     update(Connection conn, String sql, Object... params) ，用來完成表數據的增加、刪除、更新操作
     query(Connection conn, String sql, ResultSetHandler<T> rsh, Object... params) ，用來完成表數據的查詢操作
     ResultSetHandler接口，用於定義select操作后，怎樣封裝結果集.
     DbUtils類，它就是一個工具類,定義了關閉資源與事務處理的方法

2. QueryRunner類的update方法介紹

     a: 方法介紹

     update(Connection conn, String sql, Object... params) ，用來完成表數據的增加、刪除、更新操作
     使用QueryRunner類,實現對數據表的insert delete update
     調用QueryRunner類的方法 update (Connection con,String sql,Object...param)
     Object...param 可變參數,Object類型,SQL語句會出現?占位符
     數據庫連接對象,自定義的工具類傳遞

   b. 代碼實現  

/**
 * QueryRunner類
 * update(Connection conn, String sql, Object... params)
 * 實現表中數據的增、刪、改
 * @author vanguard
 *
 */
public class QueryRunnerDemo {
    //獲取數據庫連接
    private static Connection conn = JDBCUtils.getConnection();
    
    public static void main(String[] args) throws SQLException {
        //insert();
        //delete();
        //update();
    }
    /**
     * 使用QueryRunner類中的update方法，實現更新數據
     * @throws SQLException
     */
    private static void update() throws SQLException {
        //創建QueryRunner類對象
        QueryRunner qr = new QueryRunner();
        //定義更新的sql語句
        String sql = "UPDATE sort SET sname=?,sprice=?,sdesc=? WHERE sid=?";
        ////將四個?占位符的實際參數寫在數組中
        Object[] params = {"家居產品", 9000, "漲價了", 2};
        ////調用QueryRunner類的方法update執行SQL語句
        int row = qr.update(conn, sql, params);
        System.out.println(row);
        DbUtils.closeQuietly(conn);
    }
    /**
     *  使用QueryRunner類中的update方法，實現添加數據
     * @throws SQLException
     */
    private static void delete() throws SQLException {
        //創建QueryRunner類對象
        QueryRunner qr = new QueryRunner();
        String sql = "DELETE FROM sort WHERE sid=?";
        //調用QueryRunner類的方法update執行SQL語句
        int row = qr.update(conn, sql, 7);
        System.out.println(row);
        DbUtils.closeQuietly(conn);
    }
    
    /**
     * 使用Q    ueryRunner類中的update方法，實現添加數據
     * @throws SQLException
     */
    private static void insert() throws SQLException {
        //創建QueryRunner類對象
        QueryRunner qr = new QueryRunner();
        String sql = "INSERT INTO sort(sname,sprice,sdesc) VALUES(?,?,?)";
        //將三個?占位符的實際參數寫在數組中
        Object[] params = {"體育用品", 200.98, "購買體育用品"};
        //調用QueryRunner類的方法update執行SQL語句
        int row = qr.update(conn, sql, params);
        System.out.println(row);
        DbUtils.closeQuietly(conn);
    }
}

3. DBUtils工具類結果集處理的方式

   a: QueryRunner實現查詢操作
     query(Connection conn, String sql, ResultSetHandler<T> rsh, Object... params) ，用來完成表數據的查詢操作
   b: ResultSetHandler結果集處理類
    ArrayHandler 將結果集中的第一條記錄封裝到一個Object[]數組中，數組中的每一個元素就是這條記錄中的每一個字段的值
    ArrayListHandler 將結果集中的每一條記錄都封裝到一個Object[]數組中，將這些數組在封裝到List集合中。
    BeanHandler 將結果集中第一條記錄封裝到一個指定的javaBean中。
    BeanListHandler 將結果集中每一條記錄封裝到指定的javaBean中，將這些javaBean在封裝到List集合中
    ColumnListHandler 將結果集中指定的列的字段值，封裝到一個List集合中
    ScalarHandler 它是用於單數據。例如select count(*) from 表操作。
    MapHandler 將結果集第一行封裝到Map集合中,Key 列名, Value 該列數據
    MapListHandler 將結果集第一行封裝到Map集合中,Key 列名, Value 該列數據,Map集合存儲到List集合

4. QueryRunner類的方法query
  a: QueryRunner類的方法query數據查詢操作
    調用QueryRunner類方法query(Connection con,String sql,ResultSetHandler r, Object..params)
    ResultSetHandler r 結果集的處理方式,傳遞ResultSetHandler接口實現類
    Object..params SQL語句中的?占位符
    注意: query方法返回值,返回的是T 泛型, 具體返回值類型,跟隨結果集處理方式變化

  b:代碼實現：   

/**
 * 使用QueryRunner類中的
 * query(Connection conn, String sql, ResultSetHandler<T> rsh, 
 *                         Object... params)
 * 完成對數據的查詢操作
 * ResultSetHandler結果集處理類 8中處理結果集的方式
 *  ArrayHandler    將結果集中的第一條記錄封裝到一個Object[]數組中，數組中的每一個元素就是這條記錄中的每一個字段的值
 *  ArrayListHandler    將結果集中的每一條記錄都封裝到一個Object[]數組中，將這些數組在封裝到List集合中。
 *  BeanHandler    將結果集中第一條記錄封裝到一個指定的javaBean中。
 *  BeanListHandler    將結果集中每一條記錄封裝到指定的javaBean中，將這些javaBean在封裝到List集合中
 *  ColumnListHandler    將結果集中指定的列的字段值，封裝到一個List集合中
 *  ScalarHandler    它是用於單數據。例如select count(*) from 表操作。
 *  MapHandler    將結果集第一行封裝到Map集合中,Key 列名, Value 該列數據
 *  MapListHandler    將結果集第一行封裝到Map集合中,Key 列名, Value 該列數據,Map集合存儲到List集合
 * @author vanguard
 *
 */
public class QueryRunnerDmoe01 {
    private static Connection conn = JDBCUtils.getConnection();
    
    public static void main(String[] args) throws SQLException {
        //arrayHandler();
        //arrayListHandler();
        //beanHandler();
        //beanListHandler();
        //columnListHandler();
        //scalarHandler();
        //mapHandler();
        mapListHandler();
    }
    
    /**
     * 結果集處理的第八種方式MapListHandler
     * 將結果集的每一行結果封裝到Map集合中，Key 列名，Value 該列的數據
     * 將Map集合放到List集合中
     * @throws SQLException
     */
    private static void mapListHandler() throws SQLException {
        //創建QueryRunner類對象
        QueryRunner qr = new QueryRunner();
        //定義查詢的sql語句
        String sql = "SELECT * FROM sort";
        //調用query()執行查詢操作，傳遞連接對象，SQL語句，結果處理類方式的實現類
        List<Map<String, Object>> list = qr.query(conn, sql, new MapListHandler());
        //遍歷List集合
        for(Map<String, Object> map : list) {
            for(String row : map.keySet()) {
                System.out.print(row + ":" + map.get(row) + "\t");
            }
            System.out.println();
        }
    }

    /**
     * 結果集處理的第七種方式MapHandler
     * 將結果集的第一行數據封裝到Map集合中 Key 列名 Value 該列數據
     * @throws SQLException
     */
    private static void mapHandler() throws SQLException {
        //創建QueryRunner類對象
        QueryRunner qr = new QueryRunner();
        //定義查詢的sql語句
        String sql = "SELECT * FROM sort";
        //調用query()執行查詢操作，傳遞連接對象，SQL語句，結果處理類方式的實現類
        Map<String, Object> map = qr.query(conn, sql, new MapHandler());
        for(String row : map.keySet()) {
            System.out.print(row + ":" + map.get(row) + "  ");
        }
    }

    /**
     * 結果集處理的第六種方式ScalarHandler
     * 它用於單數據，對於查詢后只有一個結果
     * @throws SQLException
     */
    private static void scalarHandler() throws SQLException {
        //創建QueryRunner類對象
        QueryRunner qr = new QueryRunner();
        //定義查詢的sql語句
        String sql = "SELECT COUNT(*) FROM sort";
        //調用query()執行查詢操作，傳遞連接對象，SQL語句，結果處理類方式的實現類
        long count = qr.query(conn, sql, new ScalarHandler<Long>());
        System.out.println(count);
    }
    
    /**
     * 結果集處理的第五種方式ColumnListHandler
     * 將結果集中指定列的字段值封裝到list集合中
     * @throws SQLException
     */
    private static void columnListHandler() throws SQLException {
        //創建QueryRunner類對象
        QueryRunner qr = new QueryRunner();
        //定義查詢的sql語句
        String sql = "SELECT * FROM sort";
        //調用query()執行查詢操作，傳遞連接對象，SQL語句，結果處理類方式的實現類
        List<String> list = qr.query(conn, sql, new ColumnListHandler<String>("sname"));
        for(String name : list) {
            System.out.println(name);
        } 
    }

    /**
     * 結果集處理的第四種方式BeanListHandler
     * 將結果集中每一條數據封裝到JavaBean對象中
     * 將這些JavaBean對象放到list集合中
     * @throws SQLException
     */
    private static void beanListHandler() throws SQLException {
        //創建QueryRunner類對象
        QueryRunner qr = new QueryRunner();
        //定義查詢的sql語句
        String sql = "SELECT * FROM sort";
        //調用query()執行查詢操作，傳遞連接對象，SQL語句，結果處理類方式的實現類
        List<Sort> list = qr.query(conn, sql, new BeanListHandler<Sort>(Sort.class));
        //遍歷list集合
        for(Sort s : list) {
            System.out.println(s);
        }
    }

    /**
     * 結果集處理的第三種方式BeanHandler
     * 將結果集中的第一條數據封裝到JavaBean對象中
     * 注意：被封裝成數據到JavaBean對象，Sort類中必須有空參構造
     * @throws SQLException
     */
    private static void beanHandler() throws SQLException {
        //創建QueryRunner類對象
        QueryRunner qr = new QueryRunner();
        //定義查詢的sql語句
        String sql = "SELECT * FROM sort";
        //調用query()執行查詢操作，傳遞連接對象，SQL語句，結果處理類方式的實現類
        Sort s = qr.query(conn, sql, new BeanHandler<Sort>(Sort.class));
        System.out.println(s);
    }

    /**
     * 結果集處理的第二種方式ArrayListHandler
     * 將結果集的每一行封裝到Object[]數組中
     * 將這些數組放到list集合中
     * @throws SQLException
     */
    private static void arrayListHandler() throws SQLException {
        //創建QueryRunner類對象
        QueryRunner qr = new QueryRunner();
        //定義查詢的sql語句
        String sql = "SELECT * FROM sort";
        //調用query()執行查詢操作，傳遞連接對象，SQL語句，結果處理類方式的實現類
        List<Object[]> list = qr.query(conn, sql, new ArrayListHandler());
        for(Object[] objs : list) {
            for(Object obj : objs) {
                System.out.print(obj + "\t\t");
            }
            System.out.println();
        }
    }

    /**
     * 結果集處理的第一種方式ArrayHandler
     * 將結果集的第一行封裝到Object[]數組中
     * @throws SQLException 
     */
    private static void arrayHandler() throws SQLException {
        //創建QueryRunner類對象
        QueryRunner qr = new QueryRunner();
        //定義查詢的sql語句
        String sql = "SELECT * FROM sort";
        //調用query()執行查詢操作，傳遞連接對象，SQL語句，結果處理類方式的實現類
        Object[] objects = qr.query(conn, sql, new ArrayHandler());
        //遍歷數組
        for(Object obj : objects) {
            System.out.print(obj + "  ");
        }
    }
}

public class Sort {
    private int sid;
    private String sname;
    private int sprice;
    private String sdesc;
    
    public Sort() {}
    
    public Sort(int sid, String sname, int sprice, String sdesc) {
        super();
        this.sid = sid;
        this.sname = sname;
        this.sprice = sprice;
        this.sdesc = 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 int getSprice() {
        return sprice;
    }

    public void setSprice(int sprice) {
        this.sprice = sprice;
    }

    public String getSdesc() {
        return sdesc;
    }

    public void setSdesc(String sdesc) {
        this.sdesc = sdesc;
    }

    @Override
    public String toString() {
        return "Sort [sid=" + sid + ", sname=" + sname + ", sprice=" + sprice
                + ", sdesc=" + sdesc + "]";
    }
    
    
}

5. 連接池介紹
  1）: 連接池介紹
    a: 連接池介紹
      實際上就是存放連接的池子(容器)
     在開發中“獲得連接”或“釋放資源”是非常消耗系統資源的兩個過程
     為了解決此類性能問題，通常情況我們采用連接池技術，來共享連接Connection。
     這樣我們就不需要每次都創建連接、釋放連接了，這些操作都交給了連接池

 2）: 連接池概念規范和DataSource接口
   a: 連接池概念規范
     用池來管理Connection，這樣可以重復使用Connection。
     不用自己來創建Connection，而是通過池來獲取Connection對象
     使用完Connection后，調用Connection的close()方法也不會真的關閉Connection，而是把Connection“歸還”給池
     連接池技術可以完成Connection對象的再次利用
   b: DataSource接口
     Java為數據庫連接池提供了公共的接口：javax.sql.DataSource
     各個廠商需要讓自己的連接池實現這個接口。這樣應用程序可以方便的切換不同廠商的連接池
     常見的連接池：DBCP、C3P0

 3）: DBCP連接池介紹
   a: DBCP連接池介紹
     DBCP也是一個開源的連接池，是Apache Common成員之一，在企業開發中也比較常見，tomcat內置的連接池

 4）: 導入jar包
   a: jar包介紹
    mysql-connector-java-5.1.37-bin.jar：數據庫驅動
    commons-dbutils-1.6.jar：提供QueryRunner類方便進行增刪改查操作
    commons-dbcp-1.4.jar：
    commons-pool-1.5.6.jar：提供高效的數據庫連接池技術
  b: 導入jar包
    在項目根路徑下建立文件夾lib
    拷貝以上jar包，選定拷貝的jar包/右鍵/Build Path/Add to Build Path

 5）: BasicDataSource類的使用
   a: 案例代碼

      

/**
 * 連接池
 * 連接池jar包中定義好了一個類DataSource
 * 實現該類數據源的規范接口 javax.sql.DataSource
 * @author vanguard
 *
 */
public class DataSourceDemo {
    public static void main(String[] args) {
        //創建DataSource類接口的實現類對象
        BasicDataSource datasource = new BasicDataSource();
        //連接數據庫的四個基本信息可以通過setXXX方法設置
        datasource.setDriverClassName("com.mysql.jdbc.Driver");
        datasource.setUrl("jdbc:mysql://localhost:3306/mybase");
        datasource.setUsername("root");
        datasource.setPassword("root");
        
        //調用對象的方法獲取數據庫連接
        try {
            Connection conn = datasource.getConnection();
            System.out.println(conn);
        } catch (SQLException e) {
            e.printStackTrace();
            throw new RuntimeException("數據庫連接失敗");
        }
    }
}

 

 6）: BasicDataSource類的常見配置
   a: 常見配置
     分類 屬性 描述
     必須項
      driverClassName 數據庫驅動名稱
      url 數據庫的地址
      username 用戶名
      password 密碼
   基本項（擴展）
      maxActive 最大連接數量
      minIdle 最小空閑連接
      maxIdle 最大空閑連接
      initialSize 初始化連接

 7）: 實現數據庫連接池工具類
    a: 案例代碼
      

/**
 *  使用DBCP實現數據庫的連接池
 *  連接池配置,自定義類,
 *  最基本四項完整
 *  對於數據庫連接池其他配置,自定義
 * @author vanguard
 *
 */
public class JDBCPoolUtils {
    //創建出BasicDataSource類對象
    private static BasicDataSource datasource = new BasicDataSource();
    
    //靜態代碼塊，對BasicDataSource類進行配置
    static {
        //數據庫連接信息，必須的
        datasource.setDriverClassName("com.mysql.jdbc.Driver");
        datasource.setUrl("jdbc:mysql://localhost:3306/stdb");
        datasource.setUsername("root");
        datasource.setPassword("root");
        //對象連接池中的連接數量配置，可選
        datasource.setInitialSize(10);//初始化的連接數
        datasource.setMaxActive(8);//最大的連接數
        datasource.setMaxIdle(5);//最大空閑數
        datasource.setMinIdle(2);//最小空閑數
    }
    /**
     * 返回BasicDataSource類對象
     * @return
     */
    public static DataSource getDataSource() {
        return datasource;
    }
}

 8）: 工具類的測試
   a: 案例代碼

/**
 * 測試寫好的工具類
 * 提供的是一個DataSource接口的數據源
 *  QueryRunner類構造方法,接收DataSource接口的實現類
 *  后面,調用方法update,query,無需傳遞他們Connection連接對象
 * @author vanguard
 *
 */
public class QueryRunnerDemo {
    private static QueryRunner qr = new QueryRunner(JDBCPoolUtils.getDataSource());
    
    public static void main(String[] args) {
        //insert();
        select();
    }
    /**
     * 定義查詢數據的方法
     */
    private static void select() {
        String sql = "SELECT * FROM sort";
        try {
            List<Object[]> list = qr.query(sql, new ArrayListHandler());
            for(Object[] objs : list) {
                for(Object obj : objs) {
                    System.out.print(obj + "\t");
                }
                System.out.println();
            }
        } catch (SQLException e) {
            
            e.printStackTrace();
            throw new RuntimeException("數據庫查詢失敗");
        }
    }

    /**
     * 定義添加數據的方法
     */
    private static void insert() {
        String sql = "INSERT INTO sort(sname,sprice,sdesc) VALUES(?,?,?)";
        Object[] params = {"水果", 20.5, "桃子便宜了"};
        try {
            int row = qr.update(sql, params);
            System.out.println(row);
        } catch (SQLException e) {
            
            e.printStackTrace();
            throw new RuntimeException("數據添加失敗");
        }
    }
}