JDBC核心技術

以下為本人的學習筆記

第1章：JDBC概述

1.1 數據的持久化

• 持久化(persistence)：把數據保存到可掉電式存儲設備中以供之後使用。大多數情況下，特別是企業級應用，數據持久化意味著將記憶體中的數據保存到硬碟上加以”固化”，而持久化的實現過程大多通過各種關係資料庫來完成。

• 持久化的主要應用是將記憶體中的數據存儲在關係型資料庫中，當然也可以存儲在磁碟文件、XML數據文件中。

   

1.2 Java中的數據存儲技術

• 在Java中，資料庫存取技術可分為如下幾類：

  • JDBC直接訪問資料庫

  • JDO (Java Data Object )技術

  • 第三方O/R工具，如Hibernate, Mybatis 等

• JDBC是java訪問資料庫的基石，JDO、Hibernate、MyBatis等只是更好的封裝了JDBC。

   

1.3 JDBC介紹

• JDBC(Java Database Connectivity)是一個獨立於特定資料庫管理系統、通用的SQL資料庫存取和操作的公共介面（一組API），定義了用來訪問資料庫的標準Java類庫，（java.sql,javax.sql）使用這些類庫可以以一種標準的方法、方便地訪問資料庫資源。

• JDBC為訪問不同的資料庫提供了一種統一的途徑，為開發者屏蔽了一些細節問題。

• JDBC的目標是使Java程式員使用JDBC可以連接任何提供了JDBC驅動程式的資料庫系統，這樣就使得程式員無需對特定的資料庫系統的特點有過多的瞭解，從而大大簡化和加快了開發過程。

   

1.4 JDBC體繫結構

• JDBC介面（API）包括兩個層次：

  • 面嚮應用的API：Java API，抽象介面，供應用程式開發人員使用（連接資料庫，執行SQL語句，獲得結果）。

  • 面向資料庫的API：Java Driver API，供開發商開發資料庫驅動程式用。

JDBC是sun公司提供一套用於資料庫操作的介面，java程式員只需要面向這套介面編程即可。

不同的資料庫廠商，需要針對這套介面，提供不同實現。不同的實現的集合，即為不同資料庫的驅動。 ————面向介面編程

面向介面編程的思想：

JDBC是sun公司提供一套用於資料庫操作的介面，java程式員只需要面向這套介面編程即可。

不同的資料庫廠商，需要針對這套介面，提供不同實現。不同的實現的集合，即為不同資料庫的驅動。

面向介面編程，import那裡都是介面，沒有第三方導入

1.5 JDBC程式編寫步驟

第2章：獲取資料庫連接

2.1 要素一：Driver介面實現類

2.1.1 Driver介面介紹

• java.sql.Driver 介面是所有 JDBC 驅動程式需要實現的介面。這個介面是提供給資料庫廠商使用的，不同資料庫廠商提供不同的實現。

• 在程式中不需要直接去訪問實現了 Driver 介面的類，而是由驅動程式管理器類(java.sql.DriverManager)去調用這些Driver實現。

  • Oracle的驅動：oracle.jdbc.driver.OracleDriver

  • mySql的驅動： com.mysql.jdbc.Driver

導入mysql-connector-java-5.1.37-bin.jar

2.1.2 載入與註冊JDBC驅動

• 載入驅動：載入 JDBC 驅動需調用 Class 類的靜態方法 forName()，向其傳遞要載入的 JDBC 驅動的類名

  • Class.forName(“com.mysql.jdbc.Driver”);

• 註冊驅動：DriverManager 類是驅動程式管理器類，負責管理驅動程式

  • 使用DriverManager.registerDriver(com.mysql.jdbc.Driver)來註冊驅動

  • 通常不用顯式調用 DriverManager 類的 registerDriver() 方法來註冊驅動程式類的實例，因為 Driver 介面的驅動程式類都包含了靜態代碼塊，在這個靜態代碼塊中，會調用 DriverManager.registerDriver() 方法來註冊自身的一個實例。下圖是MySQL的Driver實現類的源碼：

    

2.2 要素二：URL

• JDBC URL 用於標識一個被註冊的驅動程式，驅動程式管理器通過這個 URL 選擇正確的驅動程式，從而建立到資料庫的連接。

• JDBC URL的標準由三部分組成，各部分間用冒號分隔。

  • jdbc:子協議:子名稱

  • 協議：JDBC URL中的協議總是jdbc

  • 子協議：子協議用於標識一個資料庫驅動程式

  • 子名稱：一種標識資料庫的方法。子名稱可以依不同的子協議而變化，用子名稱的目的是為了定位資料庫提供足夠的信息。包含主機名(對應服務端的ip地址)，埠號，資料庫名

• 舉例：

  

  URL相當於一個要去的路線，即連接的資料庫 test是資料庫名

• 幾種常用資料庫的 JDBC URL

  • MySQL的連接URL編寫方式：

    • jdbc:mysql://主機名稱:mysql服務埠號/資料庫名稱?參數=值&參數=值

    • jdbc:mysql://localhost:3306/atguigu

    • jdbc:mysql://localhost:3306/atguigu?useUnicode=true&characterEncoding=utf8（如果JDBC程式與伺服器端的字元集不一致，會導致亂碼，那麼可以通過參數指定伺服器端的字元集）

    • jdbc:mysql://localhost:3306/atguigu?user=root&password=123456

  • Oracle 9i的連接URL編寫方式：

    • jdbc:oracle:thin:@主機名稱:oracle服務埠號:資料庫名稱

    • jdbc:oracle:thin:@localhost:1521:atguigu

  • SQLServer的連接URL編寫方式：

    • jdbc:sqlserver://主機名稱:sqlserver服務埠號:DatabaseName=資料庫名稱

    • jdbc:sqlserver://localhost:1433:DatabaseName=atguigu

2.3 要素三：用戶名和密碼

• user,password可以用“屬性名=屬性值”方式告訴資料庫

• 可以調用 DriverManager 類的 getConnection() 方法建立到資料庫的連接

2.4 資料庫連接方式舉例

2.4.1 連接方式一

    @Test
    public void testConnection1() {
        try {
            //1.提供java.sql.Driver介面實現類的對象
            Driver driver = null;
            driver = new com.mysql.jdbc.Driver();
​
            //2.提供url，指明具體操作的數據
            String url = "jdbc:mysql://localhost:3306/test";
​
            //3.提供Properties的對象，指明用戶名和密碼
            Properties info = new Properties();
            info.setProperty("user", "root");
            info.setProperty("password", "abc123");
​
            //4.調用driver的connect()，獲取連接
            Connection conn = driver.connect(url, info);
            System.out.println(conn);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

說明：上述代碼中顯式出現了第三方資料庫的API

2.4.2 連接方式二

    @Test
    public void testConnection2() {
        try {
            //1.實例化Driver
            String className = "com.mysql.jdbc.Driver";
            Class clazz = Class.forName(className);
            Driver driver = (Driver) clazz.newInstance();
​
            //2.提供url，指明具體操作的數據
            String url = "jdbc:mysql://localhost:3306/test";
​
            //3.提供Properties的對象，指明用戶名和密碼
            Properties info = new Properties();
            info.setProperty("user", "root");
            info.setProperty("password", "abc123");
​
            //4.調用driver的connect()，獲取連接
            Connection conn = driver.connect(url, info);
            System.out.println(conn);
​
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

說明：相較於方式一，這裡使用反射實例化Driver，不在代碼中體現第三方資料庫的API。體現了面向介面編程思想。

2.4.3 連接方式三

    @Test
    public void testConnection3() {
        try {
            //1.資料庫連接的4個基本要素：
            String url = "jdbc:mysql://localhost:3306/test";
            String user = "root";
            String password = "abc123";
            String driverName = "com.mysql.jdbc.Driver";
​
            //2.實例化Driver
            Class clazz = Class.forName(driverName);
            Driver driver = (Driver) clazz.newInstance();
            //3.註冊驅動
            DriverManager.registerDriver(driver);
            //4.獲取連接
            Connection conn = DriverManager.getConnection(url, user, password);
            System.out.println(conn);
        } catch (Exception e) {
            e.printStackTrace();
        }
​
    }

說明：使用DriverManager實現資料庫的連接。體會獲取連接必要的4個基本要素。

2.4.4 連接方式四

    @Test
    public void testConnection4() {
        try {
            //1.資料庫連接的4個基本要素：
            String url = "jdbc:mysql://localhost:3306/test";
            String user = "root";
            String password = "abc123";
            String driverName = "com.mysql.jdbc.Driver";
​
            //2.載入驅動 （①實例化Driver ②註冊驅動）
            Class.forName(driverName);
​
​
            //Driver driver = (Driver) clazz.newInstance();
            //3.註冊驅動
            //DriverManager.registerDriver(driver);
            /*
            可以註釋掉上述代碼的原因，是因為在mysql的Driver類中聲明有：
            static {
                try {
                    DriverManager.registerDriver(new Driver());
                } catch (SQLException var1) {
                    throw new RuntimeException("Can't register driver!");
                }
            }
​
             */
​
​
            //3.獲取連接
            Connection conn = DriverManager.getConnection(url, user, password);
            System.out.println(conn);
        } catch (Exception e) {
            e.printStackTrace();
        }
​
    }

說明：不必顯式的註冊驅動了。因為在DriverManager的源碼中已經存在靜態代碼塊，實現了驅動的註冊。

2.4.5 連接方式五(最終版)

    @Test
    public  void testConnection5() throws Exception {
        //1.載入配置文件
        InputStream is = ConnectionTest.class.getClassLoader().getResourceAsStream("jdbc.properties");
        Properties pros = new Properties();
        pros.load(is);
        
        //2.讀取配置信息
        String user = pros.getProperty("user");
        String password = pros.getProperty("password");
        String url = pros.getProperty("url");
        String driverClass = pros.getProperty("driverClass");
​
        //3.載入驅動
        Class.forName(driverClass);
​
        //4.獲取連接
        Connection conn = DriverManager.getConnection(url,user,password);
        System.out.println(conn);
​
    }

其中，配置文件聲明在工程的src目錄下：【jdbc.properties】

user=root
password=abc123
url=jdbc:mysql://localhost:3306/test
driverClass=com.mysql.jdbc.Driver

說明：使用配置文件的方式保存配置信息，在代碼中載入配置文件

使用配置文件的好處：

①實現了代碼和數據的分離，如果需要修改配置信息，直接在配置文件中修改，不需要深入代碼 ②如果修改了配置信息，省去重新編譯的過程。

第3章：使用PreparedStatement實現CRUD操作

3.1 操作和訪問資料庫

• 資料庫連接被用於向資料庫伺服器發送命令和 SQL 語句，並接受資料庫伺服器返回的結果。其實一個資料庫連接就是一個Socket連接。

• 在 java.sql 包中有 3 個介面分別定義了對資料庫的調用的不同方式：

  • Statement：用於執行靜態 SQL 語句並返回它所生成結果的對象。

  • PrepatedStatement：SQL 語句被預編譯並存儲在此對象中，可以使用此對象多次高效地執行該語句。

  • CallableStatement：用於執行 SQL 存儲過程

  註意：方法是getPrepareStatement（），介面是PreparedStatement。比方法多了一個d

  statement：語句

   

3.2 使用Statement操作數據表的弊端

• 通過調用 Connection 對象的 createStatement() 方法創建該對象。該對象用於執行靜態的 SQL 語句，並且返回執行結果。

• Statement 介面中定義了下列方法用於執行 SQL 語句：

  int excuteUpdate(String sql)：執行更新操作INSERT、UPDATE、DELETE
  ResultSet executeQuery(String sql)：執行查詢操作SELECT

• 但是使用Statement操作數據表存在弊端：

  • 問題一：存在拼串操作，繁瑣

  • 問題二：存在SQL註入問題

• SQL 註入是利用某些系統沒有對用戶輸入的數據進行充分的檢查，而在用戶輸入數據中註入非法的 SQL 語句段或命令(如：SELECT user, password FROM user_table WHERE user='a' OR 1 = ' AND password = ' OR '1' = '1') ，從而利用系統的 SQL 引擎完成惡意行為的做法。

• 對於 Java 而言，要防範 SQL 註入，只要用 PreparedStatement(從Statement擴展而來) 取代 Statement 就可以了。

• 代碼演示：

public class StatementTest {
​
    // 使用Statement的弊端：需要拼寫sql語句，並且存在SQL註入的問題
    @Test
    public void testLogin() {
        Scanner scan = new Scanner(System.in);
​
        System.out.print("用戶名：");
        String userName = scan.nextLine();
        System.out.print("密   碼：");
        String password = scan.nextLine();
​
        // SELECT user,password FROM user_table WHERE USER = '1' or ' AND PASSWORD = '='1' or '1' = '1';
        String sql = "SELECT user,password FROM user_table WHERE USER = '" + userName + "' AND PASSWORD = '" + password
                + "'";
        User user = get(sql, User.class);
        if (user != null) {
            System.out.println("登陸成功!");
        } else {
            System.out.println("用戶名或密碼錯誤！");
        }
    }
​
    // 使用Statement實現對數據表的查詢操作
    public <T> T get(String sql, Class<T> clazz) {
        T t = null;
​
        Connection conn = null;
        Statement st = null;
        ResultSet rs = null;
        try {
            // 1.載入配置文件
            InputStream is = StatementTest.class.getClassLoader().getResourceAsStream("jdbc.properties");
            Properties pros = new Properties();
            pros.load(is);
​
            // 2.讀取配置信息
            String user = pros.getProperty("user");
            String password = pros.getProperty("password");
            String url = pros.getProperty("url");
            String driverClass = pros.getProperty("driverClass");
​
            // 3.載入驅動
            Class.forName(driverClass);
​
            // 4.獲取連接
            conn = DriverManager.getConnection(url, user, password);
​
            st = conn.createStatement();
​
            rs = st.executeQuery(sql);
​
            // 獲取結果集的元數據
            ResultSetMetaData rsmd = rs.getMetaData();
​
            // 獲取結果集的列數
            int columnCount = rsmd.getColumnCount();
​
            if (rs.next()) {
​
                t = clazz.newInstance();
​
                for (int i = 0; i < columnCount; i++) {
                    // //1. 獲取列的名稱
                    // String columnName = rsmd.getColumnName(i+1);
​
                    // 1. 獲取列的別名
                    String columnName = rsmd.getColumnLabel(i + 1);
​
                    // 2. 根據列名獲取對應數據表中的數據
                    Object columnVal = rs.getObject(columnName);
​
                    // 3. 將數據表中得到的數據，封裝進對象
                    Field field = clazz.getDeclaredField(columnName);
                    field.setAccessible(true);
                    field.set(t, columnVal);
                }
                return t;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 關閉資源
            if (rs != null) {
                try {
                    rs.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (st != null) {
                try {
                    st.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
​
            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
​
        return null;
    }
}

綜上：

connection連接需要四個基本信息：url，user，password，driver

3.3 PreparedStatement的使用

3.3.1 PreparedStatement介紹

• 可以通過調用 Connection 對象的 preparedStatement(String sql) 方法獲取 PreparedStatement 對象

• PreparedStatement 介面是 Statement 的子介面，它表示一條預編譯過的 SQL 語句

• PreparedStatement 對象所代表的 SQL 語句中的參數用問號(?)來表示，調用 PreparedStatement 對象的 setXxx() 方法來設置這些參數. setXxx() 方法有兩個參數，第一個參數是要設置的 SQL 語句中的參數的索引(從 1 開始)，第二個是設置的 SQL 語句中的參數的值

3.3.2 面試題：PreparedStatement 和 Statement的異同

• PreparedStatement 和Statement 是sun公司JDBC介面下定義的一組規範，介面，不是第三方提供的。

• PreparedStatement 是Statement 的子介面。

• Statement 是傳輸sql語句到資料庫執行的，一般不建議使用Statement ，而是用PreparedStatement 替換Statement 。

• 因為使用Statement操作數據表存在弊端：

  • 問題一：存在拼串操作，繁瑣

  • 問題二：存在SQL註入問題

• PreparedStatement 可以防止 SQL 註入 ，PreparedStatement 可以實現Blob數據操作，和批量操作

• 代碼的可讀性和可維護性。

• PreparedStatement 更高效：

  • PreparedStatement 有預編譯

  • DBServer會對預編譯語句提供性能優化。因為預編譯語句有可能被重覆調用，所以語句在被DBServer的編譯器編譯後的執行代碼被緩存下來，那麼下次調用時只要是相同的預編譯語句就不需要編譯，只要將參數直接傳入編譯過的語句執行代碼中就會得到執行。

• 在statement語句中,即使是相同操作但因為數據內容不一樣,所以整個語句本身不能匹配,沒有緩存語句的意義.事實是沒有資料庫會對普通語句編譯後的執行代碼緩存。這樣每執行一次都要對傳入的語句編譯一次。

  • (語法檢查，語義檢查，翻譯成二進位命令，緩存)

   

3.3.3 Java與SQL對應數據類型轉換表

3.3.4 使用PreparedStatement實現增、刪、改操作

    //通用的增、刪、改操作（體現一：增、刪、改 ； 體現二：針對於不同的表）
    public void update(String sql,Object ... args){
        Connection conn = null;
        PreparedStatement ps = null;
        try {
            //1.獲取資料庫的連接
            conn = JDBCUtils.getConnection();
            
            //2.獲取PreparedStatement的實例 (或：預編譯sql語句)
            ps = conn.prepareStatement(sql);
            //3.填充占位符
            for(int i = 0;i < args.length;i++){
                ps.setObject(i + 1, args[i]);
            }
            
            //4.執行sql語句
            ps.execute();
        } catch (Exception e) {
            
            e.printStackTrace();
        }finally{
            //5.關閉資源
            JDBCUtils.closeResource(conn, ps);
            
        }
    }

註意：

方法加註解@Test將不能被調用，否則報錯

Connection conn = DriverManager.getConnection(url,user,password);//參數順序不要混淆
prep.setDate(3, new Date(date.getTime()));//Date類型為sql包下的
​

Statement是把整個的sql語句解析，sql註入可以在where處把本來and關係變為or關係。

而PreparedStatement預編譯後，要填的只有占位符的位置，不會混淆

除瞭解決Statement的拼串、sql問題之外，PreparedStatement還有哪些好處呢？

1.PreparedStatement操作Blob的數據，而Statement做不到。

2.PreparedStatement可以實現更高效的批量操作。

3.3.5 使用PreparedStatement實現查詢操作

query：查詢

    // 通用的針對於不同表的查詢:返回一個對象 (version 1.0)
    public <T> T getInstance(Class<T> clazz, String sql, Object... args) {
​
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            // 1.獲取資料庫連接
            conn = JDBCUtils.getConnection();
​
            // 2.預編譯sql語句，得到PreparedStatement對象
            ps = conn.prepareStatement(sql);
​
            // 3.填充占位符
            for (int i = 0; i < args.length; i++) {
                ps.setObject(i + 1, args[i]);
            }
​
            // 4.執行executeQuery(),得到結果集：ResultSet
            rs = ps.executeQuery();
​
            // 5.得到結果集的元數據：ResultSetMetaData
            ResultSetMetaData rsmd = rs.getMetaData();
​
            // 6.1通過ResultSetMetaData得到columnCount,columnLabel；通過ResultSet得到列值
            int columnCount = rsmd.getColumnCount();
            if (rs.next()) {
                T t = clazz.newInstance();
                for (int i = 0; i < columnCount; i++) {// 遍歷每一個列
​
                    // 獲取列值
                    Object columnVal = rs.getObject(i + 1);
                    // 獲取列的別名:列的別名，使用類的屬性名充當
                    String columnLabel = rsmd.getColumnLabel(i + 1);
                    // 6.2使用反射，給對象的相應屬性賦值
                    Field field = clazz.getDeclaredField(columnLabel);
                    field.setAccessible(true);
                    field.set(t, columnVal);
​
                }
​
                return t;
​
            }
        } catch (Exception e) {
​
            e.printStackTrace();
        } finally {
            // 7.關閉資源
            JDBCUtils.closeResource(conn, ps, rs);
        }
​
        return null;
​
    }

說明：使用PreparedStatement實現的查詢操作可以替換Statement實現的查詢操作，解決Statement拼串和SQL註入問題。

3.4 ResultSet與ResultSetMetaData

3.4.1 ResultSet

• 查詢需要調用PreparedStatement 的 executeQuery() 方法，查詢結果是一個ResultSet 對象

• ResultSet 對象以邏輯表格的形式封裝了執行資料庫操作的結果集，ResultSet 介面由資料庫廠商提供實現

• ResultSet 返回的實際上就是一張數據表。有一個指針指向數據表的第一條記錄的前面。

• ResultSet 對象維護了一個指向當前數據行的游標，初始的時候，游標在第一行之前，可以通過 ResultSet 對象的 next() 方法移動到下一行。調用 next()方法檢測下一行是否有效。若有效，該方法返回 true，且指針下移。相當於Iterator對象的 hasNext() 和 next() 方法的結合體。

• 當指針指向一行時, 可以通過調用 getXxx(int index) 或 getXxx(int columnName) 獲取每一列的值。

  • 例如: getInt(1), getString("name")

  • 註意：Java與資料庫交互涉及到的相關Java API中的索引都從1開始。

• ResultSet 介面的常用方法：

  • boolean next()

  • getString()

  • …

  

3.4.2 ResultSetMetaData

元數據是指對值修飾的屬性

• 可用於獲取關於 ResultSet 對象中列的類型和屬性信息的對象

• ResultSetMetaData meta = rs.getMetaData();

  • getColumnName(int column)：獲取指定列的名稱（不推薦使用）

  • getColumnLabel(int column)：獲取指定列的別名

   

  針對於表的欄位名與類的屬性名不相同的情況：

  1.必須表名sql時，使用類的屬性名來命名欄位的別名

  2.使用ResultSetMetaData時，需要使用getColumnLabel（）來替換getColumnName（），獲取列的別名。

  說明：如果sql中沒有給欄位起別名，getColumnLabel（）獲取的就是列名

   

  • getColumnCount()：返回當前 ResultSet 對象中的列數。

  • getColumnTypeName(int column)：檢索指定列的資料庫特定的類型名稱。

  • getColumnDisplaySize(int column)：指示指定列的最大標準寬度，以字元為單位。

  • isNullable(int column)：指示指定列中的值是否可以為 null。

  • isAutoIncrement(int column)：指示是否自動為指定列進行編號，這樣這些列仍然是只讀的。

問題1：得到結果集後, 如何知道該結果集中有哪些列 ？ 列名是什麼？

需要使用一個描述 ResultSet 的對象， 即 ResultSetMetaData

問題2：關於ResultSetMetaData

1. 如何獲取 ResultSetMetaData： 調用 ResultSet 的 getMetaData() 方法即可

2. 獲取 ResultSet 中有多少列：調用 ResultSetMetaData 的 getColumnCount() 方法

3. 獲取 ResultSet 每一列的列的別名是什麼：調用 ResultSetMetaData 的getColumnLabel() 方法

查詢圖解：

return ps.execute()：

如果執行的是查詢操作，有返回結果，則方法返回true；

如果執行的是增，刪，改操作，沒有返回結果，則方法返回false；

return ps.executeUpdate();

如果返回int型的row數，則增/刪/改了row條；大於0則成功，否則失敗

如果返回0，則沒有執行成功，或沒進入操作；

3.5 資源的釋放

• 釋放ResultSet, Statement,Connection。

• 資料庫連接（Connection）是非常稀有的資源，用完後必須馬上釋放，如果Connection不能及時正確的關閉將導致系統宕機。Connection的使用原則是儘量晚創建，儘量早的釋放。

• 可以在finally中關閉，保證及時其他代碼出現異常，資源也一定能被關閉。

3.6 JDBC API小結

• 兩種思想

  • 面向介面編程的思想（不會有第三方出現）

  • ORM思想(object relational mapping)

    • 一個數據表對應一個java類

    • 表中的一條記錄對應java類的一個對象

    • 表中的一個欄位對應java類的一個屬性

  sql是需要結合列名和表的屬性名來寫。註意起別名。

• 兩種技術

  • JDBC結果集的元數據：ResultSetMetaData

    • 獲取列數：getColumnCount()

    • 獲取列的別名：getColumnLabel()

  • 通過反射，創建指定類的對象，獲取指定的屬性並賦值

   

第4章 操作BLOB類型欄位

4.1 MySQL BLOB類型

• MySQL中，BLOB是一個二進位大型對象，是一個可以存儲大量數據的容器，它能容納不同大小的數據。

• 插入BLOB類型的數據必須使用PreparedStatement，因為BLOB類型的數據無法使用字元串拼接寫的。

• MySQL的四種BLOB類型(除了在存儲的最大信息量上不同外，他們是等同的)

• 實際使用中根據需要存入的數據大小定義不同的BLOB類型。

• 需要註意的是：如果存儲的文件過大，資料庫的性能會下降。

• 如果在指定了相關的Blob類型以後，還報錯：xxx too large，那麼在mysql的安裝目錄下，找my.ini文件加上如下的配置參數： max_allowed_packet=16M。同時註意：修改了my.ini文件之後，需要重新啟動mysql服務。

if("a".equalsIgnoreCase(selection)); //"a"放前面避免空指針異常，最多返回false。

4.2 向數據表中插入大數據類型

//獲取連接
Connection conn = JDBCUtils.getConnection();
        
String sql = "insert into customers(name,email,birth,photo)values(?,?,?,?)";
PreparedStatement ps = conn.prepareStatement(sql);
​
// 填充占位符
ps.setString(1, "徐海強");
ps.setString(2, "[email protected]");
ps.setDate(3, new Date(new java.util.Date().getTime()));
// 操作Blob類型的變數
FileInputStream fis = new FileInputStream("xhq.png");
ps.setBlob(4, fis);
//執行
ps.execute();
        
fis.close();
JDBCUtils.closeResource(conn, ps);
​

4.3 修改數據表中的Blob類型欄位

Connection conn = JDBCUtils.getConnection();
String sql = "update customers set photo = ? where id = ?";
PreparedStatement ps = conn.prepareStatement(sql);
​
// 填充占位符
// 操作Blob類型的變數
FileInputStream fis = new FileInputStream("coffee.png");
ps.setBlob(1, fis);
ps.setInt(2, 25);
​
ps.execute();
​
fis.close();
JDBCUtils.closeResource(conn, ps);

4.4 從數據表中讀取大數據類型

String sql = "SELECT id, name, email, birth, photo FROM customer WHERE id = ?";
conn = getConnection();
ps = conn.prepareStatement(sql);
ps.setInt(1, 8);
rs = ps.executeQuery();
if(rs.next()){
    Integer id = rs.getInt(1);
    String name = rs.getString(2);
    String email = rs.getString(3);
    Date birth = rs.getDate(4);
    Customer cust = new Customer(id, name, email, birth);
    System.out.println(cust); 
    //讀取Blob類型的欄位
    Blob photo = rs.getBlob(5);
    InputStream is = photo.getBinaryStream();
    OutputStream os = new FileOutputStream("c.jpg");
    byte [] buffer = new byte[1024];
    int len = 0;
    while((len = is.read(buffer)) != -1){
        os.write(buffer, 0, len);
    }
    JDBCUtils.closeResource(conn, ps, rs);
        
    if(is != null){
        is.close();
    }
        
    if(os !=  null){
        os.close();
    }
    
}
​

第5章 批量插入

5.1 批量執行SQL語句

當需要成批插入或者更新記錄時，可以採用Java的批量更新機制，這一機制允許多條語句一次性提交給資料庫批量處理。通常情況下比單獨提交處理更有效率

JDBC的批量處理語句包括下麵三個方法：

• addBatch(String)：添加需要批量處理的SQL語句或是參數；

• executeBatch()：執行批量處理語句；

• clearBatch():清空緩存的數據

通常我們會遇到兩種批量執行SQL語句的情況：

• 多條SQL語句的批量處理；

• 一個SQL語句的批量傳參；

5.2 高效的批量插入

Batch：一批

舉例：向數據表中插入20000條數據

• 資料庫中提供一個goods表。創建如下：

CREATE TABLE goods(
id INT PRIMARY KEY AUTO_INCREMENT,
NAME VARCHAR(20)
);

5.2.1 實現層次一：使用Statement

Connection conn = JDBCUtils.getConnection();
Statement st = conn.createStatement();
for(int i = 1;i <= 20000;i++){
    String sql = "insert into goods(name) values('name_' + "+ i +")";
    st.executeUpdate(sql);
}

5.2.2 實現層次二：使用PreparedStatement

long start = System.currentTimeMillis();
        
Connection conn = JDBCUtils.getConnection();
        
String sql = "insert into goods(name)values(?)";
PreparedStatement ps = conn.prepareStatement(sql);
for(int i = 1;i <= 20000;i++){
    ps.setString(1, "name_" + i);
    ps.executeUpdate();
}
        
long end = System.currentTimeMillis();
System.out.println("花費的時間為：" + (end - start));//82340
        
        
JDBCUtils.closeResource(conn, ps);

5.2.3 實現層次三

/*
 * 修改1： 使用 addBatch() / executeBatch() / clearBatch()
 * 修改2：mysql伺服器預設是關閉批處理的，我們需要通過一個參數，讓mysql開啟批處理的支持。
 *       ?rewriteBatchedStatements=true 寫在配置文件的url後面
 * 修改3：使用更新的mysql 驅動：mysql-connector-java-5.1.37-bin.jar
 * 
 */
@Test
public void testInsert1() throws Exception{
    long start = System.currentTimeMillis();
        
    Connection conn = JDBCUtils.getConnection();