JDBC知識點總結

一：JDBC 概述

    一、簡介

       1. JDBC（Java DataBase Connection，Java 數據庫連接）是Java語言中用來規范客戶端程序如何來訪問數據庫的應用程序接口，提供了諸如查詢和更新數據庫中數據的方法。

       2. JDBC 是一個標准 SQL（Structured Query Language，結構化查詢語言）數據庫訪問接口，可以為多種關系數據庫提供統一訪問。也提供一種基准，據此可以構建更高級的工具和接口。

       3. JDK（Java Development Kit，Java 開發工具包）軟件捆綁包括 JDBC 和 JDBC-ODBC（Open DataBase Connection，開放式數據庫連接）橋。

          

 

    二、API

     

 

二：JDBC 開發步驟

    一、配置依賴 jar 包

       1. 下載

           1. MySQL

              

 

           2. Oracle

              

 

       2. 配置

           1. 導入 jar 包

              

 

           2. Maven 配置

<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.20</version>
</dependency>

<!-- https://mvnrepository.com/artifact/com.oracle.database.jdbc/ojdbc10 -->
<dependency>
    <groupId>com.oracle.database.jdbc</groupId>
    <artifactId>ojdbc10</artifactId>
    <version>19.3.0.0</version>
</dependency>

 

    二、注冊驅動

public class DriverTest {
    /**
     * 通過反射機制，加載數據庫驅動，類初始化的時候執行靜態代碼塊
     *   優點1：此方式由於參數為字符串，因此很容易修改，移植性強。
     *   優點2：不依賴特定的Driver庫，很容易改造成從配置文件讀取JDBC配置，從而可以在運行時動態更換數據庫連接驅動。
     */
    static {
        try {
            /**
             * MySQL：8.0版本，5.0版本為：com.mysql.jdbc.Driver
             */
            Class.forName("com.mysql.cj.jdbc.Driver");
            
            /**
             * Oracle
             */
            Class.forName("oracle.jdbc.driver.OracleDriver");
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } // 8版本
    }
}

 

    三、獲取連接

public class ConnectionTest {
    /**
     * MySQL
     */
    public Connection getMysqlConnection() {
        // 本地連接URL：jdbc:mysql:///student?useUnicode=true&characterEnocding=utf-8&useSSL=false&serverTimezone=UTC
        // 遠程連接URL：jdbc:mysql://<host>:<port>/<database>?useUnicode=true&characterEnocding=utf-8&useSSL=false&serverTimezone=UTC
        final String url = "jdbc:mysql:///student?useUnicode=true&characterEnocding=utf-8&useSSL=false&serverTimezone=UTC";
        // 連接用戶名
        final String user = "root";
        // 連接密碼
        final String password = "000000";
        Connection conn = null;
        if (conn == null) {
            try {
                conn = DriverManager.getConnection(url, user, password);
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                System.err.println("Oracle數據庫連接出錯");
                e.printStackTrace();
            }
        }
        return conn;
    }

    /**
     * Oracle
     */
    public Connection getOracleConnection() {
        /**
         * 1. 使用thin連接：jdbc:oracle:thin:@<host>:<port>:<database>
         *    優點：thin完全由Java代碼編寫，與平台無關，不需要Oracle客戶端。
         *    缺點：thin性能一般，達不到如OCI方式的企業級的要求，一般適合一台主機連接。
         * 
         * 2. 使用oci連接：jdbc:oracle:oci:@<host>:<port>:<database>
         *    優點：用OCI連接數據庫是企業級的做法，適應於單個數據庫和集群數據庫，性能優越，尤其是連接池功能大大提高了應用程序的性能和並發量。
         *    缺點：若想使用OCI必須要安裝Oracle客戶端。
         */
        final String url = "jdbc:oracle:thin:@127.0.0.1:1521:orcl";
        // 連接用戶名
        final String user = "scott";
        // 連接密碼
        final String password = "tiger";
        // 連接對象
        Connection conn = null;
        if (conn == null) {
            try {
                conn = DriverManager.getConnection(url, user, password);
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                System.err.println("Oracle數據庫連接出錯");
                e.printStackTrace();
            }
        }
        return conn;
    }
}

 

    四、創建Statement、PreparedStatement、CallableStatement接口，執行SQL語句

package pers.mj.test;

import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.Types;

public class MysqJDBClTest {
    /**
     * Statement 的作用：用於執行靜態 SQL 語句並返回它所生成結果的對象，完成對數據庫的增刪改查。
     * Statement 的優點：語法簡單，對於只執行一次的 SQL 語句，使用 Statement 比 PreparedStatement 對象的開銷更小。
     * Statement 的缺點：每次執行時相似SQL都會進行編譯  ，采用硬編碼效率低，安全性較差，字符串拼接方式的 SQL 語句是非常繁瑣的，中間有很多的單引號和雙引號的混用，極易出錯。
     * Statement 的適用場景：普通的不帶參的查詢SQL 
     */
    public void testStatement() {
        try {
            // 獲取數據庫連接
            Connection conn = DBUtil.getMysqlConnection();
            // 創建 Statement 對象
            Statement st = conn.createStatement();
            // 定義SQL語句
            String sql = "insert into student(stu_id, stu_name) values(20200626, " + " '張三')"; // 字符串拼接麻煩
            /**
             * 演示SQL注入問題：如果此時傳遞給字段的值為：or 1 = 1，那么不論如何條件都成立，導致結果都成功，這就是SQL注入
             */
            String SQL = "select * from student where stu_name="+"'張三' and stu_id= "+"'or 1 = 1' ";
            // 執行SQL語句
            if (st.execute(sql)) {
                System.out.println("信息插入成功");
            }
        } catch (SQLException e) {
            System.err.println("插入語句執行失敗");
            e.printStackTrace();
        }
    }
    
    /**
     * PreparedStatement 的作用：用於執行動態 SQL 語句並返回它所生成結果的對象，完成對數據庫的增刪改查。繼承Statement
     * PreparedStatement 的優點：相似SQL只編譯一次，減少編譯次數，代碼的可讀性和可維護性更高，提高了安全性（阻止了SQL注入）。
     * PreparedStatement 的缺點：執行非相似SQL語句時，速度較慢。
     * PreparedStatement 的適用場景：支持可變參數的SQL 
     */
    public void testPreparedStatement() {
        try {
            // 獲取數據庫連接
            Connection conn = DBUtil.getMysqlConnection();
            // 定義SQL語句
            String sql = "insert into student(stu_id, stu_name) values(?, ?)"; 
            /**
             * 解決SQL注入問題：PreparedStatement不是將參數簡單拼湊成sql，而是做了一些預處理，將參數轉換為string，兩端加單引號，將參數內的一些特殊字符（換行，單雙引號，斜杠等）做轉義處理，這樣就很大限度的避免了sql注入。
             */
            String SQL = "select * from student where stu_name=? and stu_id= ? ";
            // 預編譯SQL語句，防止SQL注入
            PreparedStatement ps = conn.prepareStatement(sql);
            // 給占位符(?)賦值：索引從1開始，數據類型需要相對應
            ps.setInt(1, 20180627);
            ps.setString(2, "李四");
            // 執行SQL語句
            if (ps.execute()) {
                System.out.println("信息插入成功");
            }
        } catch (SQLException e) {
            System.err.println("插入語句執行失敗");
            e.printStackTrace();
        }
    }
    
    /**
     * CallableStatement 的作用：實現了存儲過程函數調用的方法以及對於輸出的處理。繼承PreparedStatement
     * CallableStatement 的使用場景：支持調用存儲過程,提供了對輸出和輸入/輸出參數(INOUT)的支持
     */
    public void testCallableStatement(){
        try {
            // 獲取數據庫連接
            Connection conn = DBUtil.getMysqlConnection();
            // 定義SQL語句
            String sql = "call p3(?,?)";
            // 預編譯SQL
            CallableStatement cs = conn.prepareCall(sql);
            // 給站位符賦值
            cs.setString(1, "王五"); 
            cs.registerOutParameter(2, Types.INTEGER);  // 注冊一個輸入參數
            // 執行SQL
            cs.execute();
            // 獲取結果集對象
            ResultSet resultSet = cs.getResultSet();
            while (resultSet.next()) {
                System.out.println(resultSet.getString("name")+" ");                
            }
            // 獲取輸出參數
            System.out.println(cs.getInt(2));
        } catch (Exception e) {
            // TODO: handle exception
        }
    }
}

 

    五、execute、executeQuery和executeUpdate詳解

public class ExecuteTest {
    // 數據庫連接對象
    Connection conn = null;
    // 預處理對象
    PreparedStatement ps = null;
    // 結果集對象
    ResultSet rs = null;
    
    /**
     * executeQuery()
     *   作用：只能執行DQL(SELECT語句)，是使用最多的查詢語句。
     *   返回值：單個結果及對象(ResultSet)
     */
    public void testExecuteQuery() {
        try {
            // 獲取數據庫連接
            conn = DBUtil.getMysqlConnection();
            // 定義SQL語句
            String sql = "SELECT stu_id,stu_name FROM student WHERE stu_id=? ";
            // 預編譯SQL
            ps = conn.prepareStatement(sql);
            // 給占位符賦值
            ps.setInt(1, 20200626);
            // 執行SQL語句
            rs = ps.executeQuery();
            while (rs.next()) {
                System.out.println("學號：" + rs.getInt("stu_id") + " 姓名：" + rs.getString("stu_name"));
            }
        } catch (Exception e) {
            // TODO: handle exception
        }
    }

    /**
     * executeUpdate()
     *   作用：執行DML(除去SELECT語句)和DDL，修改表中零行或多行中的一列或多列。
     *   返回值：受影響的行數(整數)
     */
    @Test
    public void testExecuteUpdate() {
        try {
            // 獲取數據庫連接
            conn = DBUtil.getMysqlConnection();
            // 定義SQL語句
            String sql = "UPDATE student SET stu_name=? WHERE stu_id=?";
            // 預編譯SQL
            ps = conn.prepareStatement(sql);
            // 給占位符賦值
            ps.setString(1, "王五");
            ps.setInt(2, 20200626);
            // 執行SQL語句
            if (ps.executeUpdate() != 0) {
                System.out.println("信息修改成功");
            }
        } catch (Exception e) {
            // TODO: handle exception
        }
    }

    /**
     * execute()
     *   作用：用於執行返回多個結果集、多個更新計數或二者組合的語句。例如：執行某個已存儲過程或動態執行未知 SQL 字符串。
     *   返回值：多個ResultSet對象、多個更新計數或ResultSet對象與更新計數。
     *   使用
     *    多個結果集
     *      1. 執行完execute()方法后，使用CallableStatement對象調用getResultSet()方法獲取第一個結果集，調用適當的getXXX方法獲取值
     *      2. 如果存在第二個結果集，則必須調用getMoreResults()方法，然后再調用getResultSet()方法來獲取結果集，依次類推。
     *    多個更新計數
     *      1. 執行完execute()方法后，則首先調用方法 getUpdateCount，然后調用 getMoreResults，並再次調用 getUpdateCount，依次類推。
     *   
     */
    public void testExecute() {
        List<List<Map<String, Object>>> resultList = new ArrayList<>();
        try {
            // 獲取數據庫連接
            conn = DBUtil.getMysqlConnection();
            // 定義SQL語句
            String sql = "sp_help 'test.student'";
            // 預編譯SQL
            CallableStatement cs = conn.prepareCall(sql);
             // 外循環獲取結果集的個數
            boolean oprFlg  = cs.execute(sql);
            while (oprFlg) {
                List<Map<String, Object>> result = new ArrayList<>();
                // 獲取第一個結果集
                rs = cs.getResultSet();
                // 內循環獲取每個結果集的記錄
                while (rs.next()) {
                    ResultSetMetaData rsmd = rs.getMetaData();
                    int columnCount = rsmd.getColumnCount();
                    Map<String, Object> map = new HashMap<String, Object>();
                    for (int i = 0; i < columnCount; i++) {
                        map.put(rsmd.getColumnName(i + 1).toLowerCase(), rs.getObject(i + 1));
                    }
                    result.add(map);
                }
                resultList.add(result);
                // 獲取更多的結果集
                oprFlg = cs.getMoreResults();
            }
        } catch (Exception e) {
            // TODO: handle exception
        }
    }

 

    六、處理結果集

      1. ResultSet：在線

public class ResultSetTest {
    // 數據庫連接對象
    Connection conn = null;
    // 預處理對象
    PreparedStatement ps = null;
    // 結果集對象
    ResultSet rs = null;

    /**
     * 可滾動，可更新
     *    ResultSet.TYPE_FORWARD_ONLY：該常量控制ResultSet記錄指針只能向前移動(默認)。
     *    ResultSet.TYPE_SCROLL_INSENSITIVE：該常量控制ResultSet記錄指針可以自由移動(可滾動結果集)，但底層數據的改變不會受ResultSet的內容。
     *    ResultSet.TYPE_SCROLL_SENSITIVE：該常量控制ResultSet記錄指針可以自由移動(可滾動結果集)，並且底層數據的改變會影響ResultSet的內容。
     *    ResultSet.CONCUR_READ_ONLY：該常量指示ResultSet是只讀的並發模式(默認)。
     *    ResultSet.CONCUR_UPDATABLE: 該常量指示ResultSet是可更新的並發默認。
     *   
     */
    public void testScrollAndUpdate() {
        try {
            // 獲取數據庫連接
            conn = DBUtil.getMysqlConnection();
            // 定義SQL語句
            String sql = "SELECT stu_id,stu_name FROM student";
            // 預編譯SQL
            ps = conn.prepareStatement(sql, ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE);
            // 執行SQL語句
            rs = ps.executeQuery();
            // 處理結果集
            while (rs.next()) {
                System.out.println("學號：" + rs.getInt("stu_id") + " 姓名：" + rs.getString("stu_name"));
            }
        } catch (Exception e) {
            // TODO: handle exception
        }
    }
    
    /**
     * ResultSetMetaData：分析結果集，當不清楚該ResultSet里包含哪些數據列，以及每個數據列的數據類型，那么可以通過ResultSetMetaData來獲取關於ResultSet的描述信息。
     *   getMetaData()：獲取ResultSetMetaData對象。
     *   int getColumnCount():返回該ResultSet的列數量。
     *   String getColumnName(int columnIndex):返回對應列的名稱。
     *   int getColumnType(int columnIdex):返回對應列的數據類型。
     */
    public void testResultSetMetaData() {
        try {
            // 獲取數據庫連接
            conn = DBUtil.getMysqlConnection();
            // 定義SQL語句
            String sql = "SELECT stu_id,stu_name FROM student";
            // 預編譯SQL
            ps = conn.prepareStatement(sql);
            // 執行SQL語句
            rs = ps.executeQuery();
            // 處理結果集
            while (rs.next()) {
                // 獲取結果集元數據對象
                ResultSetMetaData rsmd = rs.getMetaData();
                // 獲取結果集列數
                int columnCount = rsmd.getColumnCount();
                for (int i = 0; i < columnCount; i++) {
                    // 獲取結果集對應列名稱
                    System.out.println(rsmd.getColumnName(i + 1));
                    // 獲取結果集對應數據類型
                    System.out.println(rsmd.getColumnType(i + 1));
                }
            }
        } catch (Exception e) {
            // TODO: handle exception
        }
    }
}

 

      2. RowSet：離線

public class RowSetTest {
    // 數據庫連接對象
    Connection conn = null;
    // 預處理對象
    PreparedStatement ps = null;
    // 結果集對象
    ResultSet rs = null;

    /**
     * RowSet：實現了ResultSet接口，並且有子接口CachedRowSet(離線查詢)
     *   概念：離線查詢：在本地搞一個結果集的副本，關閉結果集、數據庫連接，使用本地的這個副本。
     *   作用：RowSet默認是可滾動，可更新，可序列化的結果集，並且作為對JavaBean使用，因此能方便地在網絡上傳輸，用於同步兩端的數據。
     *   優點：程序在創建RowSet時已把底層數據讀取到了內存中，因此可以充分利用計算機的內存，從而減低數據庫的負載，提高程序的性能。
     */
    @Test
    public void testRowSetOffline() {
        try {
            // 獲取數據庫連接
            conn = DBUtil.getMysqlConnection();
            // 定義SQL語句
            String sql = "SELECT stu_id,stu_name FROM student";
            // 預編譯SQL
            ps = conn.prepareStatement(sql);
            // 執行SQL語句
            rs = ps.executeQuery();
            /**
             * 離線查詢
             */
            // 通過RowSetProvider的靜態方法創建RowSetFactory對象
            RowSetFactory rsf = RowSetProvider.newFactory();
            // 創建CachedRowSet對象
            CachedRowSet crs = rsf.createCachedRowSet(); 
            // 使用結果集填充CachedRowSet
            crs.populate(rs); //  使用給定的ResultSet裝填RowSet，從ResultSet的第startRow條記錄開始裝填。
            /**
             * 關閉數據庫資源
             */
            rs.close();
            ps.close();
            conn.close();
            // 離線處理結果集：CachedRowSet是ResultSet的孫接口，使用的方法都相同。
            while (crs.next()) {
                System.out.println("學號：" + crs.getInt("stu_id") + " 姓名：" + crs.getString("stu_name"));
            }
        } catch (Exception e) {
            // TODO: handle exception
        }
    }
    
    /**
     * 分頁：不推薦使用每個數據庫特有的分頁，追求跨數據庫，代碼可用性更高
     *   1. 使用游標實現
     *   2. 使用離線查詢實現
     */
    public void pagination() {
        try {
            /**
             * 使用游標實現
             */
            // 獲取數據庫連接
            conn = DBUtil.getMysqlConnection();
            // 定義SQL語句
            String sql = "SELECT stu_id,stu_name FROM student";
            // 預編譯SQL
            ps = conn.prepareStatement(sql, ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE);
            // 執行SQL語句
            rs = ps.executeQuery();
            // 定義分頁
            int start = 0;  // 起始頁
            int pageSize = 10;  // 分頁大小
            // 定義游標
            rs.absolute(start);  // 游標指向起始位
            while (rs.next()) {
                // ......
                if (rs.getRow() == pageSize) { // getRow()是獲取當前記錄是結果集中的第幾條記錄，第一條就是1。也可以設置計數器來判斷
                    break;
                }
            }
            
            /**
             * 使用離線查詢實現
             */
            // 創建RowSetFactory對象
            RowSetFactory rsf = RowSetProvider.newFactory();
            // 創建CachedRowSet對象
            CachedRowSet crs = rsf.createCachedRowSet(); 
            // 設置分頁大小
            crs.setPageSize(10);
            // 使用結果集填充CachedRowSet
            crs.populate(rs);
            // 釋放資源
            rs.close();
            ps.close();
            conn.close();
            while (crs.next()) {
                // ......
            }
        } catch (Exception e) {
            // TODO: handle exception
        }
    }
}

   

    七、釋放資源

public class CloseTest {
    // 數據庫連接對象
    Connection conn = null;
    // 預處理對象
    PreparedStatement ps = null;
    // 結果集對象
    ResultSet rs = null;

    /**
     * 手動釋放
     */
    public void handMovement() {
        try {
            // 獲取數據庫連接
            conn = DBUtil.getMysqlConnection();
            // 定義SQL語句
            String sql = "SELECT stu_id,stu_name FROM student ";
            // 預編譯SQL
            ps = conn.prepareStatement(sql);
            // 執行SQL語句
            rs = ps.executeQuery();
            // 處理結果集
            while (rs.next()) {
                System.out.println("學號：" + rs.getInt("stu_id") + " 姓名：" + rs.getString("stu_name"));
            }
        } catch (Exception e) {
            // TODO: handle exception
        } finally {
            if (rs != null) {
                try {
                    rs.close();
                } catch (SQLException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            if (ps != null) {
                try {
                    ps.close();
                } catch (SQLException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 自動釋放
     */
    public void autoregula() {
        try(
            // 獲取數據庫連接
            conn = DBUtil.getMysqlConnection();
            // 定義SQL語句
            String sql = "SELECT stu_id,stu_name FROM student ";
            // 預編譯SQL
            ps = conn.prepareStatement(sql);
            // 執行SQL語句
            rs = ps.executeQuery();
            // 處理結果集
            while (rs.next()) {
                System.out.println("學號：" + rs.getInt("stu_id") + " 姓名：" + rs.getString("stu_name"));
            }    
          ){
        }catch (Exception e) {
            // TODO: handle exception
        }
    }
}

 

三：封裝

    一、封裝配置文件

# MySQL
mysql.jdbc.driver=com.mysql.cj.jdbc.Driver
mysql.jdbc.url=jdbc:mysql://<host>:<port>/<database>?useUnicode=true&characterEncoding=utf8&characterSetResults=utf8&useSSL=false&serverTimezone=UTC
mysql.jdbc.username=<user>
mysql.jdbc.password=<password>
# Oracle
oracle.jdbc.driver=oracle.jdbc.driver.OracleDriver
oracle.jdbc.url=jdbc:oracle:thin:@<host>:<port>:<database>
oracle.jdbc.username=<user>
oracle.jdbc.password=<password>

 

    二、封裝工具類

public class DBUtil {
    /**
     * MySQL和Oracle連接屬性
     */
    private static String mysqlDriver;
    private static String mysqlUrl;
    private static String mysqlUser;
    private static String mysqlPassword;
    private static String oracleDriver;
    private static String oracleUrl;
    private static String oracleUser;
    private static String oraclePassword;

    /**
     * 讀取配置文件並加載驅動
     */
    private static Properties pros = new Properties();
    static {
        try {
            // 加載配置文件
            pros.load(Thread.currentThread().getContextClassLoader().getResourceAsStream("db.properties"));
            // 屬性賦值
            mysqlDriver = pros.getProperty("mysql.jdbc.driver");
            mysqlUrl = pros.getProperty("mysql.jdbc.url");
            mysqlUser = pros.getProperty("mysql.jdbc.username");
            mysqlPassword = pros.getProperty("mysql.jdbc.password");
            oracleDriver = pros.getProperty("oracle.jdbc.driver");
            oracleUrl = pros.getProperty("oracle.jdbc.url");
            oracleUser = pros.getProperty("oracle.jdbc.username");
            oraclePassword = pros.getProperty("oracle.jdbc.password");
            // 注冊驅動
            try {
                Class.forName(mysqlDriver);
            } catch (ClassNotFoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    /**
     * 數據庫連接
     */
    public static Connection getConnection(String dbManufacturer) {
        Connection conn = null;
        if (conn == null) {
            try {
                if (dbManufacturer.startsWith("mysql")) {
                    conn = DriverManager.getConnection(mysqlUrl, mysqlUser, mysqlPassword);
                } else {
                    conn = DriverManager.getConnection(oracleUrl, oracleUser, oraclePassword);
                }
            } catch (Exception e) {
                System.err.println("數據庫連接出錯，請檢查");
            }
        }
        return conn;
    }

    /**
     * 釋放資源
     */
    public static void release(Connection conn, PreparedStatement ps, ResultSet rs) {
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (ps != null) {
            try {
                ps.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

 

    三、封裝查詢和更新

public class BaseDao<T> {
    /**
     * 封裝增、刪、改功能
     * 
     * @param sql  需要執行的sql語句
     * @param args 不定參數，是對sql語句中的占位符“？”傳入的參數
     * @return 返回操作所影響的行數
     */
    public int executeUpdate(String sql, Object... args) {
        Connection conn = null;
        PreparedStatement ps = null;
        int rows = 0;
        try {
            conn = DBUtil.getConnection("mysql");
            ps = conn.prepareStatement(sql);
            for (int i = 0; i < args.length; i++) {
                ps.setObject(i + 1, args[i]);
            }
            rows = ps.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            DBUtil.release(conn, ps, null);
        }
        return rows;
    }

    /**
     * 查詢一條記錄
     * 
     * @param sql  需要執行的sql語句
     * @param cls  實體類對象類型，例如Student.class，如果類未知，則使用 Class<?>
     * @param args 不定參數，是對sql語句中的占位符“？”傳入的參數
     * @return 返回操作所影響的行數
     */
    public T selectOne(String sql, Class<T> cls, Object... args) {
        List<T> list = this.selectMany(sql, cls, args);
        return list.isEmpty() ? null : list.get(0);
    }

    /**
     * 查詢所有記錄
     * 
     * @param sql  需要執行的sql語句
     * @param cls  實體類對象類型，例如Student.class，如果類未知，則使用 Class<?>
     * @param args 不定參數，是對sql語句中的占位符“？”傳入的參數
     * @return 返回結果集
     */
    public List<T> selectMany(String sql, Class<T> cls, Object... args) {
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        List<T> list = new ArrayList<T>();
        try {
            conn = DBUtil.getConnection("mysql");
            ps = conn.prepareStatement(sql);
            for (int i = 0; i < args.length; i++) {
                ps.setObject(i + 1, args[i]);
                rs = ps.executeQuery();
                // 分析結果集對象
                ResultSetMetaData metaData = rs.getMetaData();
                while (rs.next()) {
                    T obj = cls.getDeclaredConstructor().newInstance();
                    // 獲取結果集列數
                    for (int j = 1; j <= metaData.getColumnCount(); j++) {
                        // 獲取結果集列名
                        String columnLabel = metaData.getColumnLabel(j);
                        // 動態拼接成該屬性對應實體中的setter方法的方法名
                        String name = "set" + StringUtil.toUpper(columnLabel);
                        // 獲取實體中所有聲明的屬性
                        Field field = cls.getDeclaredField(columnLabel);
                        // 獲取實體中所有聲明的方法，形參為field.getType()類型
                        Method method = cls.getDeclaredMethod(name, field.getType());
                        // 通過結果集獲取字段值名
                        Object realParam = rs.getObject(columnLabel);
                        // 執行obj對象中的method方法，傳入的實參為realParam
                        method.invoke(obj, realParam);
                    }
                    list.add(obj);
                }
            }
        } catch (SQLException | InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } finally {
            DBUtil.release(conn, ps, rs);
        }
        return list;
    }

    /**
     * 查詢總記錄數
     * 
     * @param sql  需要執行的sql語句
     * @param args 需要對sql語句中的占位符“？”傳入的參數數組
     * @return 返回操作所影響的行數
     */
    public int selectCount(String sql, Object... args) {
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        int count = 0;
        try {
            conn = DBUtil.getConnection("mysql");
            ps = conn.prepareStatement(sql);
            for (int i = 0; i < args.length; i++) {
                ps.setObject(i + 1, args[i]);
                rs = ps.executeQuery();
                if (rs.next()) {
                    count = rs.getInt(1);
                }
            }
        } catch (SecurityException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            DBUtil.release(conn, ps, rs);
        }
        return count;
    }
}