JDBC使用詳解

本文轉載自查看原文 2021-06-01 00:16 117 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驅動程序的數據庫系統，這樣就使得程序員無需對特定的數據庫系統的特點有過多的了解，從而大大簡化和加快了開發過程。
如果沒有JDBC，那么Java程序訪問數據庫時是這樣的：

有了JDBC，Java程序訪問數據庫時是這樣的：

總結如下：

1.4 JDBC體系結構

JDBC接口（API）包括兩個層次：
- 面向應用的API：Java API，抽象接口，供應用程序開發人員使用（連接數據庫，執行SQL語句，獲得結果）。
- 面向數據庫的API：Java Driver API，供開發商開發數據庫驅動程序用。

JDBC是sun公司提供一套用於數據庫操作的接口，java程序員只需要面向這套接口編程即可。

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

1.5 JDBC程序編寫步驟

補充：ODBC(Open Database Connectivity，開放式數據庫連接)，是微軟在Windows平台下推出的。使用者在程序中只需要調用ODBC API，由 ODBC 驅動程序將調用轉換成為對特定的數據庫的調用請求。

第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

將上述jar包拷貝到Java工程的一個目錄中，習慣上新建一個lib文件夾。

在驅動jar上右鍵-->Build Path-->Add to Build Path

注意：如果是Dynamic Web Project（動態的web項目）話，則是把驅動jar放到WebContent（有的開發工具叫WebRoot）目錄中的WEB-INF目錄中的lib目錄下即可

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地址)，端口號，數據庫名
舉例：
幾種常用數據庫的 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 存儲過程

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;
 }
}

綜上：

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 vs Statement

代碼的可讀性和可維護性。
PreparedStatement 能最大可能提高性能：
- DBServer會對預編譯語句提供性能優化。因為預編譯語句有可能被重復調用，所以語句在被DBServer的編譯器編譯后的執行代碼被緩存下來，那么下次調用時只要是相同的預編譯語句就不需要編譯，只要將參數直接傳入編譯過的語句執行代碼中就會得到執行。
- 在statement語句中,即使是相同操作但因為數據內容不一樣,所以整個語句本身不能匹配,沒有緩存語句的意義.事實是沒有數據庫會對普通語句編譯后的執行代碼緩存。這樣每執行一次都要對傳入的語句編譯一次。
- (語法檢查，語義檢查，翻譯成二進制命令，緩存)
PreparedStatement 可以防止 SQL 注入

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

Java類型	SQL類型
boolean	BIT
byte	TINYINT
short	SMALLINT
int	INTEGER
long	BIGINT
String	CHAR,VARCHAR,LONGVARCHAR
byte array	BINARY , VAR BINARY
java.sql.Date	DATE
java.sql.Time	TIME
java.sql.Timestamp	TIMESTAMP

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

package com.atguigu3.preparedstatement.crud;

import java.io.InputStream;
import java.sql.Connection;
import java.sql.Date;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.text.SimpleDateFormat;
import java.util.Properties;
import org.junit.Test;
import com.atguigu3.util.JDBCUtils;

/*
 * 使用PreparedStatement來替換Statement,實現對數據表的增刪改操作
 * 
 * 增刪改；查
 * 
 * 
 */
public class PreparedStatementUpdateTest {
    
    @Test
    public void testCommonUpdate(){
        String sql = "update `order` set order_name = ? where order_id = ?";
        update(sql,"DD","2");
        
    }
    
    //通用的增刪改操作
    public void update(String sql,Object ...args){//sql中占位符的個數與可變形參的長度相同！
        Connection conn = null;
        PreparedStatement ps = null;
        try {
            // 1.讀取配置文件中的4個基本信息
            InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("jdbc.properties");

            Properties pros = new Properties();
            pros.load(is);

            String user = pros.getProperty("user");
            String password = pros.getProperty("password");
            String url = pros.getProperty("url");
            String driverClass = pros.getProperty("driverClass");

            // 2.加載驅動
            Class.forName(driverClass);

            // 3.獲取連接
            conn = DriverManager.getConnection(url, user, password);
            
            //2.預編譯sql語句，返回PreparedStatement的實例
            ps = conn.prepareStatement(sql);
            //3.填充占位符
            for(int i = 0;i < args.length;i++){
                ps.setObject(i + 1, args[i]);//小心參數聲明錯誤！！
            }
            //4.執行
            ps.execute();
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            //7.資源的關閉
            try {
                if(ps != null)
                    ps.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            try {
                if(conn != null)
                    conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            
        }
    }
}

3.3.5 使用PreparedStatement實現查詢操作

package com.atguigu3.preparedstatement.crud;

import java.lang.reflect.Field;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.util.ArrayList;
import java.util.List;
import org.junit.Test;
import com.atguigu3.bean.Customer;
import com.atguigu3.bean.Order;
import com.atguigu3.util.JDBCUtils;

/**
 * 
 * @Description 使用PreparedStatement實現針對於不同表的通用的查詢操作
 * @author wwy
 * @version
 * @date 上午11:32:55
 *
 */
public class PreparedStatementQueryTest {
    
    @Test
    public void testGetForList(){
        
        String sql = "select id,name,email from customers where id < ?";
        List<Customer> list = getForList(Customer.class,sql,12);
        list.forEach(System.out::println);
        
        String sql1 = "select order_id orderId,order_name orderName from `order`";
        List<Order> orderList = getForList(Order.class, sql1);
        orderList.forEach(System.out::println);
    }
    
    public <T> List<T> getForList(Class<T> clazz,String sql, Object... args){
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            conn = JDBCUtils.getConnection();

            ps = conn.prepareStatement(sql);
            for (int i = 0; i < args.length; i++) {
                ps.setObject(i + 1, args[i]);
            }

            rs = ps.executeQuery();
            // 獲取結果集的元數據 :ResultSetMetaData
            ResultSetMetaData rsmd = rs.getMetaData();
            // 通過ResultSetMetaData獲取結果集中的列數
            int columnCount = rsmd.getColumnCount();
            //創建集合對象
            ArrayList<T> list = new ArrayList<T>();
            while (rs.next()) {
                T t = clazz.newInstance();
                // 處理結果集一行數據中的每一個列:給t對象指定的屬性賦值
                for (int i = 0; i < columnCount; i++) {
                    // 獲取列值
                    Object columValue = rs.getObject(i + 1);

                    // 獲取每個列的列名
                    // String columnName = rsmd.getColumnName(i + 1);
                    String columnLabel = rsmd.getColumnLabel(i + 1);

                    // 給t對象指定的columnName屬性，賦值為columValue：通過反射
                    Field field = clazz.getDeclaredField(columnLabel);
                    field.setAccessible(true);
                    field.set(t, columValue);
                }
                list.add(t);
            }
            
            return list;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(conn, ps, rs);

        }

        return null;
    }
    
    @Test
    public void testGetInstance(){
        String sql = "select id,name,email from customers where id = ?";
        Customer customer = getInstance(Customer.class,sql,12);
        System.out.println(customer);
        
        String sql1 = "select order_id orderId,order_name orderName from `order` where order_id = ?";
        Order order = getInstance(Order.class, sql1, 1);
        System.out.println(order);
    }
    
    /**
     * 查詢單條記錄
     * @param clazz
     * @param sql
     * @param args
     * @return
     */
    public <T> T getInstance(Class<T> clazz,String sql, Object... args) {
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            conn = JDBCUtils.getConnection();

            ps = conn.prepareStatement(sql);
            for (int i = 0; i < args.length; i++) {
                ps.setObject(i + 1, args[i]);
            }

            rs = ps.executeQuery();
            // 獲取結果集的元數據 :ResultSetMetaData
            ResultSetMetaData rsmd = rs.getMetaData();
            // 通過ResultSetMetaData獲取結果集中的列數
            int columnCount = rsmd.getColumnCount();

            if (rs.next()) {
                T t = clazz.newInstance();
                // 處理結果集一行數據中的每一個列
                for (int i = 0; i < columnCount; i++) {
                    // 獲取列值
                    Object columValue = rs.getObject(i + 1);

                    // 獲取每個列的列名
                    // String columnName = rsmd.getColumnName(i + 1);
　　　　　　　　　　　　

                    String columnLabel = rsmd.getColumnLabel(i + 1);

                    // 給t對象指定的columnName屬性，賦值為columValue：通過反射
                    Field field = clazz.getDeclaredField(columnLabel);
                    field.setAccessible(true);
                    field.set(t, columValue);
                }
                return t;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            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)：獲取指定列的別名
- getColumnCount()：返回當前 ResultSet 對象中的列數。
- getColumnTypeName(int column)：檢索指定列的數據庫特定的類型名稱。
- getColumnDisplaySize(int column)：指示指定列的最大標准寬度，以字符為單位。
- isNullable(int column)：指示指定列中的值是否可以為 null。
- isAutoIncrement(int column)：指示是否自動為指定列進行編號，這樣這些列仍然是只讀的。

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

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

問題2：關於ResultSetMetaData

如何獲取 ResultSetMetaData：調用 ResultSet 的 getMetaData() 方法即可
獲取 ResultSet 中有多少列：調用 ResultSetMetaData 的 getColumnCount() 方法
獲取 ResultSet 每一列的列的別名是什么：調用 ResultSetMetaData 的getColumnLabel() 方法

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服務。

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

@Test
    public void testInsert() throws Exception{
        Connection conn = JDBCUtils.getConnection();
        String sql = "insert into customers(name,email,birth,photo)values(?,?,?,?)";
        
        PreparedStatement ps = conn.prepareStatement(sql);
        
        ps.setObject(1,"袁浩");
        ps.setObject(2, "yuan@qq.com");
        ps.setObject(3,"1992-09-08");
        FileInputStream is = new FileInputStream(new File("girl.jpg"));
        ps.setBlob(4, is);
        
        ps.execute();
        
        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 高效的批量插入

舉例：向數據表中插入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

@Test
    public void testInsert1() {
        Connection conn = null;
        PreparedStatement ps = null;
        try {
            
            long start = System.currentTimeMillis();
            
            conn = JDBCUtils.getConnection();
            String sql = "insert into goods(name)values(?)";
            ps = conn.prepareStatement(sql);
            for(int i = 1;i <= 20000;i++){
                ps.setObject(1, "name_" + i);
                
                ps.execute();
            }
            
            long end = System.currentTimeMillis();
            
            System.out.println("花費的時間為：" + (end - start));//20000:83065
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            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 testInsert2() {
        Connection conn = null;
        PreparedStatement ps = null;
        try {
            
            long start = System.currentTimeMillis();
            
            conn = JDBCUtils.getConnection();
            String sql = "insert into goods(name)values(?)";
            ps = conn.prepareStatement(sql);
            for(int i = 1;i <= 1000000;i++){
                ps.setObject(1, "name_" + i);
                
                //1."攢"sql
                ps.addBatch();
                
                if(i % 500 == 0){
                    //2.執行batch
                    ps.executeBatch();
                    
                    //3.清空batch
                    ps.clearBatch();
                }
                
            }
            
            long end = System.currentTimeMillis();
            
            System.out.println("花費的時間為：" + (end - start));//20000:83065 -- 565
        } catch (Exception e) {                                //1000000:16086
            e.printStackTrace();
        }finally{
            JDBCUtils.closeResource(conn, ps);
            
        }
        
    }

5.2.4 實現層次四

//批量插入的方式四：設置連接不允許自動提交數據
    @Test
    public void testInsert3() {
        Connection conn = null;
        PreparedStatement ps = null;
        try {
            
            long start = System.currentTimeMillis();
            
            conn = JDBCUtils.getConnection();
            
            //設置不允許自動提交數據
            conn.setAutoCommit(false);
            
            String sql = "insert into goods(name)values(?)";
            ps = conn.prepareStatement(sql);
            for(int i = 1;i <= 1000000;i++){
                ps.setObject(1, "name_" + i);
                
                //1."攢"sql
                ps.addBatch();
                
                if(i % 500 == 0){
                    //2.執行batch
                    ps.executeBatch();
                    
                    //3.清空batch
                    ps.clearBatch();
                }
                
            }
            
            //提交數據
            conn.commit();
            
            long end = System.currentTimeMillis();
            
            System.out.println("花費的時間為：" + (end - start));//20000:83065 -- 565
        } catch (Exception e) {                                //1000000:16086 -- 5114
            e.printStackTrace();
        }finally{
            JDBCUtils.closeResource(conn, ps);
            
        }
        
    }

第6章：數據庫事務

6.1 數據庫事務介紹

事務：一組邏輯操作單元,使數據從一種狀態變換到另一種狀態。
事務處理（事務操作）：保證所有事務都作為一個工作單元來執行，即使出現了故障，都不能改變這種執行方式。當在一個事務中執行多個操作時，要么所有的事務都被提交(commit)，那么這些修改就永久地保存下來；要么數據庫管理系統將放棄所作的所有修改，整個事務回滾(rollback)到最初狀態。
為確保數據庫中數據的一致性，數據的操縱應當是離散的成組的邏輯單元：當它全部完成時，數據的一致性可以保持，而當這個單元中的一部分操作失敗，整個事務應全部視為錯誤，所有從起始點以后的操作應全部回退到開始狀態。

6.2 JDBC事務處理

數據一旦提交，就不可回滾。
數據什么時候意味着提交？
- 當一個連接對象被創建時，默認情況下是自動提交事務：每次執行一個 SQL 語句時，如果執行成功，就會向數據庫自動提交，而不能回滾。
- 關閉數據庫連接，數據就會自動的提交。如果多個操作，每個操作使用的是自己單獨的連接，則無法保證事務。即同一個事務的多個操作必須在同一個連接下。
JDBC程序中為了讓多個 SQL 語句作為一個事務執行：
- 調用 Connection 對象的 setAutoCommit(false); 以取消自動提交事務
- 在所有的 SQL 語句都成功執行后，調用 commit(); 方法提交事務
- 在出現異常時，調用 rollback(); 方法回滾事務
若此時 Connection 沒有被關閉，還可能被重復使用，則需要恢復其自動提交狀態 setAutoCommit(true)。尤其是在使用數據庫連接池技術時，執行close()方法前，建議恢復自動提交狀態。

【案例：用戶AA向用戶BB轉賬100】

@Test
    public void testUpdateWithTx() {
        Connection conn = null;
        try {
            conn = JDBCUtils.getConnection();
            System.out.println(conn.getAutoCommit());//true
            //1.取消數據的自動提交
            conn.setAutoCommit(false);
            
            String sql1 = "update user_table set balance = balance - 100 where user = ?";
            update(conn,sql1, "AA");
            
            //模擬網絡異常
            System.out.println(10 / 0);
            
            String sql2 = "update user_table set balance = balance + 100 where user = ?";
            update(conn,sql2, "BB");
            
            System.out.println("轉賬成功");
            
            //2.提交數據
            conn.commit();
            
        } catch (Exception e) {
            e.printStackTrace();
            //3.回滾數據
            try {
                conn.rollback();
            } catch (SQLException e1) {
                e1.printStackTrace();
            }
        }finally{
            
            JDBCUtils.closeResource(conn, null);
        }
        
    }

其中，對數據庫操作的方法為：

// 通用的增刪改操作---version 2.0 （考慮上事務）
    public int update(Connection conn,String sql, Object... args) {// sql中占位符的個數與可變形參的長度相同！
        PreparedStatement ps = null;
        try {
            // 1.預編譯sql語句，返回PreparedStatement的實例
            ps = conn.prepareStatement(sql);
            // 2.填充占位符
            for (int i = 0; i < args.length; i++) {
                ps.setObject(i + 1, args[i]);// 小心參數聲明錯誤！！
            }
            // 3.執行
            return ps.executeUpdate();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 4.資源的關閉
            JDBCUtils.closeResource(null, ps);

        }
        return 0;

    }

6.3 事務的ACID屬性

原子性（Atomicity） 原子性是指事務是一個不可分割的工作單位，事務中的操作要么都發生，要么都不發生。
一致性（Consistency） 事務必須使數據庫從一個一致性狀態變換到另外一個一致性狀態。
隔離性（Isolation） 事務的隔離性是指一個事務的執行不能被其他事務干擾，即一個事務內部的操作及使用的數據對並發的其他事務是隔離的，並發執行的各個事務之間不能互相干擾。
持久性（Durability） 持久性是指一個事務一旦被提交，它對數據庫中數據的改變就是永久性的，接下來的其他操作和數據庫故障不應該對其有任何影響。

6.3.1 數據庫的並發問題

對於同時運行的多個事務, 當這些事務訪問數據庫中相同的數據時, 如果沒有采取必要的隔離機制, 就會導致各種並發問題:
- 臟讀: 對於兩個事務 T1, T2, T1 讀取了已經被 T2 更新但還沒有被提交的字段。之后, 若 T2 回滾, T1讀取的內容就是臨時且無效的。
- 不可重復讀: 對於兩個事務T1, T2, T1 讀取了一個字段, 然后 T2 更新了該字段。之后, T1再次讀取同一個字段, 值就不同了。
- 幻讀: 對於兩個事務T1, T2, T1 從一個表中讀取了一個字段, 然后 T2 在該表中插入了一些新的行。之后, 如果 T1 再次讀取同一個表, 就會多出幾行。
數據庫事務的隔離性: 數據庫系統必須具有隔離並發運行各個事務的能力, 使它們不會相互影響, 避免各種並發問題。
一個事務與其他事務隔離的程度稱為隔離級別。數據庫規定了多種事務隔離級別, 不同隔離級別對應不同的干擾程度, 隔離級別越高, 數據一致性就越好, 但並發性越弱。

6.3.2 四種隔離級別

數據庫提供的4種事務隔離級別：
Oracle 支持的 2 種事務隔離級別：READ COMMITED, SERIALIZABLE。 Oracle 默認的事務隔離級別為: READ COMMITED 。

Mysql 支持 4 種事務隔離級別。Mysql 默認的事務隔離級別為: REPEATABLE READ。

6.3.3 在MySql中設置隔離級別

每啟動一個 mysql 程序, 就會獲得一個單獨的數據庫連接. 每個數據庫連接都有一個全局變量 @@tx_isolation, 表示當前的事務隔離級別。
查看當前的隔離級別:
```
SELECT @@tx_isolation;
```

設置當前 mySQL 連接的隔離級別:

set  transaction isolation level read committed;

設置數據庫系統的全局的隔離級別:

set global transaction isolation level read committed;

補充操作：

創建mysql數據庫用戶：
```
create user tom identified by 'abc123';
```

授予權限

#授予通過網絡方式登錄的tom用戶，對所有庫所有表的全部權限，密碼設為abc123.
grant all privileges on *.* to tom@'%' identified by 'abc123'; 

 #給tom用戶使用本地命令行方式，授予atguigudb這個庫下的所有表的插刪改查的權限。
grant select,insert,delete,update on atguigudb.* to tom@localhost identified by 'abc123';

第7章：DAO及相關實現類

DAO：Data Access Object訪問數據信息的類和接口，包括了對數據的CRUD（Create、Retrival、Update、Delete），而不包含任何業務相關的信息。有時也稱作：BaseDAO
作用：為了實現功能的模塊化，更有利於代碼的維護和升級。

層次結構：

【BaseDAO.java】

package com.atguigu2.dao;

import java.lang.reflect.Field;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import com.atguigu1.util.JDBCUtils;

/*
 * DAO: data(base) access object
 * 封裝了針對於數據表的通用的操作
 */
public abstract class BaseDAO {
    // 通用的增刪改操作---version 2.0 （考慮上事務）
    public int update(Connection conn, String sql, Object... args) {// sql中占位符的個數與可變形參的長度相同！
        PreparedStatement ps = null;
        try {
            // 1.預編譯sql語句，返回PreparedStatement的實例
            ps = conn.prepareStatement(sql);
            // 2.填充占位符
            for (int i = 0; i < args.length; i++) {
                ps.setObject(i + 1, args[i]);// 小心參數聲明錯誤！！
            }
            // 3.執行
            return ps.executeUpdate();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 4.資源的關閉
            JDBCUtils.closeResource(null, ps);

        }
        return 0;

    }

    // 通用的查詢操作，用於返回數據表中的一條記錄（version 2.0：考慮上事務）
    public <T> T getInstance(Connection conn, Class<T> clazz, String sql, Object... args) {
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {

            ps = conn.prepareStatement(sql);
            for (int i = 0; i < args.length; i++) {
                ps.setObject(i + 1, args[i]);
            }

            rs = ps.executeQuery();
            // 獲取結果集的元數據 :ResultSetMetaData
            ResultSetMetaData rsmd = rs.getMetaData();
            // 通過ResultSetMetaData獲取結果集中的列數
            int columnCount = rsmd.getColumnCount();

            if (rs.next()) {
                T t = clazz.newInstance();
                // 處理結果集一行數據中的每一個列
                for (int i = 0; i < columnCount; i++) {
                    // 獲取列值
                    Object columValue = rs.getObject(i + 1);

                    // 獲取每個列的列名
                    // String columnName = rsmd.getColumnName(i + 1);
                    String columnLabel = rsmd.getColumnLabel(i + 1);

                    // 給t對象指定的columnName屬性，賦值為columValue：通過反射
                    Field field = clazz.getDeclaredField(columnLabel);
                    field.setAccessible(true);
                    field.set(t, columValue);
                }
                return t;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(null, ps, rs);

        }

        return null;
    }
    // 通用的查詢操作，用於返回數據表中的多條記錄構成的集合（version 2.0：考慮上事務）
    public <T> List<T> getForList(Connection conn, Class<T> clazz, String sql, Object... args) {
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {

            ps = conn.prepareStatement(sql);
            for (int i = 0; i < args.length; i++) {
                ps.setObject(i + 1, args[i]);
            }

            rs = ps.executeQuery();
            // 獲取結果集的元數據 :ResultSetMetaData
            ResultSetMetaData rsmd = rs.getMetaData();
            // 通過ResultSetMetaData獲取結果集中的列數
            int columnCount = rsmd.getColumnCount();
            // 創建集合對象
            ArrayList<T> list = new ArrayList<T>();
            while (rs.next()) {
                T t = clazz.newInstance();
                // 處理結果集一行數據中的每一個列:給t對象指定的屬性賦值
                for (int i = 0; i < columnCount; i++) {
                    // 獲取列值
                    Object columValue = rs.getObject(i + 1);

                    // 獲取每個列的列名
                    // String columnName = rsmd.getColumnName(i + 1);
                    String columnLabel = rsmd.getColumnLabel(i + 1);

                    // 給t對象指定的columnName屬性，賦值為columValue：通過反射
                    Field field = clazz.getDeclaredField(columnLabel);
                    field.setAccessible(true);
                    field.set(t, columValue);
                }
                list.add(t);
            }

            return list;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(null, ps, rs);

        }

        return null;
    }
    //用於查詢特殊值的通用的方法
    public <E> E getValue(Connection conn,String sql,Object...args){
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            ps = conn.prepareStatement(sql);
            for(int i = 0;i < args.length;i++){
                ps.setObject(i + 1, args[i]);
                
            }
            
            rs = ps.executeQuery();
            if(rs.next()){
                return (E) rs.getObject(1);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally{
            JDBCUtils.closeResource(null, ps, rs);
            
        }
        return null;
        
    }    
}

【CustomerDAO.java】

package com.atguigu2.dao;

import java.sql.Connection;
import java.sql.Date;
import java.util.List;

import com.atguigu2.bean.Customer;

/*
 * 此接口用於規范針對於customers表的常用操作
 */
public interface CustomerDAO {
    /**
     * 
     * @Description 將cust對象添加到數據庫中
     * @author wwy
     * @date 上午11:00:27
     * @param conn
     * @param cust
     */
    void insert(Connection conn,Customer cust);
    /**
     * 
     * @Description 針對指定的id，刪除表中的一條記錄
     * @author shkstart
     * @date 上午11:01:07
     * @param conn
     * @param id
     */
    void deleteById(Connection conn,int id);
    /**
     * 
     * @Description 針對內存中的cust對象，去修改數據表中指定的記錄
     * @author shkstart
     * @date 上午11:02:14
     * @param conn
     * @param cust
     */
    void update(Connection conn,Customer cust);
    /**
     * 
     * @Description 針對指定的id查詢得到對應的Customer對象
     * @author shkstart
     * @date 上午11:02:59
     * @param conn
     * @param id
     */
    Customer getCustomerById(Connection conn,int id);
    /**
     * 
     * @Description 查詢表中的所有記錄構成的集合
     * @author shkstart
     * @date 上午11:03:50
     * @param conn
     * @return
     */
    List<Customer> getAll(Connection conn);
    /**
     * 
     * @Description 返回數據表中的數據的條目數
     * @author shkstart
     * @date 上午11:04:44
     * @param conn
     * @return
     */
    Long getCount(Connection conn);
    
    /**
     * 
     * @Description 返回數據表中最大的生日
     * @author shkstart
     * @date 上午11:05:33
     * @param conn
     * @return
     */
    Date getMaxBirth(Connection conn);
    
}

【CustomerDAOImpl.java】

package com.atguigu2.dao;

import java.sql.Connection;
import java.sql.Date;
import java.util.List;

import com.atguigu2.bean.Customer;

public class CustomerDAOImpl extends BaseDAO implements CustomerDAO{

    @Override
    public void insert(Connection conn, Customer cust) {
        String sql = "insert into customers(name,email,birth)values(?,?,?)";
        update(conn, sql,cust.getName(),cust.getEmail(),cust.getBirth());
    }

    @Override
    public void deleteById(Connection conn, int id) {
        String sql = "delete from customers where id = ?";
        update(conn, sql, id);
    }

    @Override
    public void update(Connection conn, Customer cust) {
        String sql = "update customers set name = ?,email = ?,birth = ? where id = ?";
        update(conn, sql,cust.getName(),cust.getEmail(),cust.getBirth(),cust.getId());
    }

    @Override
    public Customer getCustomerById(Connection conn, int id) {
        String sql = "select id,name,email,birth from customers where id = ?";
        Customer customer = getInstance(conn,Customer.class, sql,id);
        return customer;
    }

    @Override
    public List<Customer> getAll(Connection conn) {
        String sql = "select id,name,email,birth from customers";
        List<Customer> list = getForList(conn, Customer.class, sql);
        return list;
    }

    @Override
    public Long getCount(Connection conn) {
        String sql = "select count(*) from customers";
        return getValue(conn, sql);
    }

    @Override
    public Date getMaxBirth(Connection conn) {
        String sql = "select max(birth) from customers";
        return getValue(conn, sql);
    }

}

【Customer.java】

package com.atguigu2.bean;

import java.sql.Date;

/*
 * ORM編程思想  （object relational mapping）
 * 一個數據表對應一個java類
 * 表中的一條記錄對應java類的一個對象
 * 表中的一個字段對應java類的一個屬性
 * 
 */
public class Customer {
    
    private int id;
    private String name;
    private String email;
    private Date birth;
}

第8章：數據庫連接池

8.1 JDBC數據庫連接池的必要性

在使用開發基於數據庫的web程序時，傳統的模式基本是按以下步驟：　　
- 在主程序（如servlet、beans）中建立數據庫連接
- 進行sql操作
- 斷開數據庫連接
這種模式開發，存在的問題:
- 普通的JDBC數據庫連接使用 DriverManager 來獲取，每次向數據庫建立連接的時候都要將 Connection 加載到內存中，再驗證用戶名和密碼(得花費0.05s～1s的時間)。需要數據庫連接的時候，就向數據庫要求一個，執行完成后再斷開連接。這樣的方式將會消耗大量的資源和時間。數據庫的連接資源並沒有得到很好的重復利用。若同時有幾百人甚至幾千人在線，頻繁的進行數據庫連接操作將占用很多的系統資源，嚴重的甚至會造成服務器的崩潰。
- 對於每一次數據庫連接，使用完后都得斷開。否則，如果程序出現異常而未能關閉，將會導致數據庫系統中的內存泄漏，最終將導致重啟數據庫。（回憶：何為Java的內存泄漏？）
- 這種開發不能控制被創建的連接對象數，系統資源會被毫無顧及的分配出去，如連接過多，也可能導致內存泄漏，服務器崩潰。

8.2 數據庫連接池技術

為解決傳統開發中的數據庫連接問題，可以采用數據庫連接池技術。
數據庫連接池的基本思想：就是為數據庫連接建立一個“緩沖池”。預先在緩沖池中放入一定數量的連接，當需要建立數據庫連接時，只需從“緩沖池”中取出一個，使用完畢之后再放回去。
數據庫連接池負責分配、管理和釋放數據庫連接，它允許應用程序重復使用一個現有的數據庫連接，而不是重新建立一個。
數據庫連接池在初始化時將創建一定數量的數據庫連接放到連接池中，這些數據庫連接的數量是由最小數據庫連接數來設定的。無論這些數據庫連接是否被使用，連接池都將一直保證至少擁有這么多的連接數量。連接池的最大數據庫連接數量限定了這個連接池能占有的最大連接數，當應用程序向連接池請求的連接數超過最大連接數量時，這些請求將被加入到等待隊列中。

工作原理：

數據庫連接池技術的優點

1. 資源重用

由於數據庫連接得以重用，避免了頻繁創建，釋放連接引起的大量性能開銷。在減少系統消耗的基礎上，另一方面也增加了系統運行環境的平穩性。

2. 更快的系統反應速度

數據庫連接池在初始化過程中，往往已經創建了若干數據庫連接置於連接池中備用。此時連接的初始化工作均已完成。對於業務請求處理而言，直接利用現有可用連接，避免了數據庫連接初始化和釋放過程的時間開銷，從而減少了系統的響應時間

3. 新的資源分配手段

對於多應用共享同一數據庫的系統而言，可在應用層通過數據庫連接池的配置，實現某一應用最大可用數據庫連接數的限制，避免某一應用獨占所有的數據庫資源

4. 統一的連接管理，避免數據庫連接泄漏

在較為完善的數據庫連接池實現中，可根據預先的占用超時設定，強制回收被占用連接，從而避免了常規數據庫連接操作中可能出現的資源泄露

8.3 多種開源的數據庫連接池

JDBC 的數據庫連接池使用 javax.sql.DataSource 來表示，DataSource 只是一個接口，該接口通常由服務器(Weblogic, WebSphere, Tomcat)提供實現，也有一些開源組織提供實現：
- DBCP 是Apache提供的數據庫連接池。tomcat 服務器自帶dbcp數據庫連接池。速度相對c3p0較快，但因自身存在BUG，Hibernate3已不再提供支持。
- C3P0 是一個開源組織提供的一個數據庫連接池，速度相對較慢，穩定性還可以。hibernate官方推薦使用
- Proxool 是sourceforge下的一個開源項目數據庫連接池，有監控連接池狀態的功能，穩定性較c3p0差一點
- BoneCP 是一個開源組織提供的數據庫連接池，速度快
- Druid 是阿里提供的數據庫連接池，據說是集DBCP 、C3P0 、Proxool 優點於一身的數據庫連接池，但是速度不確定是否有BoneCP快
DataSource 通常被稱為數據源，它包含連接池和連接池管理兩個部分，習慣上也經常把 DataSource 稱為連接池
DataSource用來取代DriverManager來獲取Connection，獲取速度快，同時可以大幅度提高數據庫訪問速度。
特別注意：
- 數據源和數據庫連接不同，數據源無需創建多個，它是產生數據庫連接的工廠，因此整個應用只需要一個數據源即可。
- 當數據庫訪問結束后，程序還是像以前一樣關閉數據庫連接：conn.close(); 但conn.close()並沒有關閉數據庫的物理連接，它僅僅把數據庫連接釋放，歸還給了數據庫連接池。

8.3.1 C3P0數據庫連接池

package com.atguigu4.connection;

import java.sql.Connection;
import java.sql.SQLException;

import org.junit.Test;

import com.mchange.v2.c3p0.ComboPooledDataSource;

public class C3P0Test {
    //方式一：
    @Test
    public void testGetConnection() throws Exception{
        //獲取c3p0數據庫連接池
        ComboPooledDataSource cpds = new ComboPooledDataSource();
        cpds.setDriverClass( "com.mysql.jdbc.Driver" ); 
        cpds.setJdbcUrl( "jdbc:mysql://localhost:3306/test" );
        cpds.setUser("root");                                  
        cpds.setPassword("111"); 
        //通過設置相關的參數，對數據庫連接池進行管理：
        //設置初始時數據庫連接池中的連接數
        cpds.setInitialPoolSize(10);
        
        Connection conn = cpds.getConnection();
        System.out.println(conn);
        
        //銷毀c3p0數據庫連接池
//        DataSources.destroy( cpds );
    }
    //方式二：使用配置文件
    @Test
    public void testGetConnection1() throws SQLException{
        ComboPooledDataSource cpds = new ComboPooledDataSource("hellc3p0");
        Connection conn = cpds.getConnection();
        System.out.println(conn);
    }
}

其中，src下的配置文件為：【c3p0-config.xml】

<?xml version="1.0" encoding="UTF-8"?>
<c3p0-config>

    <named-config name="hellc3p0">
        <!-- 提供獲取連接的4個基本信息 -->
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql:///test</property>
        <property name="user">root</property>
        <property name="password">111</property>
        
        <!-- 進行數據庫連接池管理的基本信息 -->
        <!-- 當數據庫連接池中的連接數不夠時，c3p0一次性向數據庫服務器申請的連接數 -->
        <property name="acquireIncrement">5</property>
        <!-- c3p0數據庫連接池中初始化時的連接數 -->
        <property name="initialPoolSize">10</property>
        <!-- c3p0數據庫連接池維護的最少連接數 -->
        <property name="minPoolSize">10</property>
        <!-- c3p0數據庫連接池維護的最多的連接數 -->
        <property name="maxPoolSize">100</property>
        <!-- c3p0數據庫連接池最多維護的Statement的個數 -->
        <property name="maxStatements">50</property>
        <!-- 每個連接中可以最多使用的Statement的個數 -->
        <property name="maxStatementsPerConnection">2</property>

    </named-config>
</c3p0-config>

8.3.2 DBCP數據庫連接池

DBCP 是 Apache 軟件基金組織下的開源連接池實現，該連接池依賴該組織下的另一個開源系統：Common-pool。如需使用該連接池實現，應在系統中增加如下兩個 jar 文件：
- Commons-dbcp.jar：連接池的實現
- Commons-pool.jar：連接池實現的依賴庫
Tomcat 的連接池正是采用該連接池來實現的。該數據庫連接池既可以與應用服務器整合使用，也可由應用程序獨立使用。
數據源和數據庫連接不同，數據源無需創建多個，它是產生數據庫連接的工廠，因此整個應用只需要一個數據源即可。
當數據庫訪問結束后，程序還是像以前一樣關閉數據庫連接：conn.close(); 但上面的代碼並沒有關閉數據庫的物理連接，它僅僅把數據庫連接釋放，歸還給了數據庫連接池。
配置屬性說明

屬性	默認值	說明
initialSize	0	連接池啟動時創建的初始化連接數量
maxActive	8	連接池中可同時連接的最大的連接數
maxIdle	8	連接池中最大的空閑的連接數，超過的空閑連接將被釋放，如果設置為負數表示不限制
minIdle	0	連接池中最小的空閑的連接數，低於這個數量會被創建新的連接。該參數越接近maxIdle，性能越好，因為連接的創建和銷毀，都是需要消耗資源的；但是不能太大。
maxWait	無限制	最大等待時間，當沒有可用連接時，連接池等待連接釋放的最大時間，超過該時間限制會拋出異常，如果設置-1表示無限等待
poolPreparedStatements	false	開啟池的Statement是否prepared
maxOpenPreparedStatements	無限制	開啟池的prepared 后的同時最大連接數
minEvictableIdleTimeMillis		連接池中連接，在時間段內一直空閑，被逐出連接池的時間
removeAbandonedTimeout	300	超過時間限制，回收沒有用(廢棄)的連接
removeAbandoned	false	超過removeAbandonedTimeout時間后，是否進行沒用連接（廢棄）的回收

package com.atguigu4.connection;

import java.io.File;
import java.io.FileInputStream;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;

import javax.sql.DataSource;

import org.apache.commons.dbcp.BasicDataSource;
import org.apache.commons.dbcp.BasicDataSourceFactory;
import org.junit.Test;

public class DBCPTest {
    /**
     * 
     * @Description 測試DBCP的數據庫連接池技術
     * @author shkstart
     * @throws SQLException 
     * @date 下午3:20:50
     */
    //方式一：不推薦
    @Test
    public void testGetConnection() throws SQLException{
        //創建了DBCP的數據庫連接池
        BasicDataSource source = new BasicDataSource();
        
        //設置基本信息
        source.setDriverClassName("com.mysql.jdbc.Driver");
        source.setUrl("jdbc:mysql:///test");
        source.setUsername("root");
        source.setPassword("abc123");
        
        //還可以設置其他涉及數據庫連接池管理的相關屬性：
        source.setInitialSize(10);
        source.setMaxActive(10);
        //。。。
        
        Connection conn = source.getConnection();
        System.out.println(conn);
    }
    
    //方式二：推薦：使用配置文件
    @Test
    public void testGetConnection1() throws Exception{
        Properties pros = new Properties();
        
        //方式1：
//        InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("dbcp.properties");
        //方式2：
        FileInputStream is = new FileInputStream(new File("src/dbcp.properties"));
        
        
        pros.load(is);
        DataSource source = BasicDataSourceFactory.createDataSource(pros);
        
        Connection conn = source.getConnection();
        System.out.println(conn);
    }
    
    
}

其中，src下的配置文件為：【dbcp.properties】

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql:///test
username=root
password=abc123

initialSize=10

8.3.3 Druid（德魯伊）數據庫連接池

Druid是阿里巴巴開源平台上一個數據庫連接池實現，它結合了C3P0、DBCP、Proxool等DB池的優點，同時加入了日志監控，可以很好的監控DB池連接和SQL的執行情況，可以說是針對監控而生的DB連接池，可以說是目前最好的連接池之一。

package com.atguigu4.connection;

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

import javax.sql.DataSource;

import org.junit.Test;

import com.alibaba.druid.pool.DruidDataSourceFactory;

public class DruidTest {
    
    @Test
    public void getConnection() throws Exception{
        Properties pros = new Properties();
        
        InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("druid.properties");
        
        pros.load(is);
        
        DataSource source = DruidDataSourceFactory.createDataSource(pros);
        Connection conn = source.getConnection();
        System.out.println(conn);
        
    }
}

其中，src下的配置文件為：【druid.properties】

url=jdbc:mysql:///test
username=root
password=abc123456
driverClassName=com.mysql.jdbc.Driver

initialSize=10
maxActive=10

詳細配置參數：

配置	缺省	說明
name		配置這個屬性的意義在於，如果存在多個數據源，監控的時候可以通過名字來區分開來。如果沒有配置，將會生成一個名字，格式是：”DataSource-” + System.identityHashCode(this)
url		連接數據庫的url，不同數據庫不一樣。例如：mysql : jdbc:mysql://10.20.153.104:3306/druid2 oracle : jdbc:oracle:thin:@10.20.149.85:1521:ocnauto
username		連接數據庫的用戶名
password		連接數據庫的密碼。如果你不希望密碼直接寫在配置文件中，可以使用ConfigFilter。詳細看這里：https://github.com/alibaba/druid/wiki/%E4%BD%BF%E7%94%A8ConfigFilter
driverClassName		根據url自動識別這一項可配可不配，如果不配置druid會根據url自動識別dbType，然后選擇相應的driverClassName(建議配置下)
initialSize	0	初始化時建立物理連接的個數。初始化發生在顯示調用init方法，或者第一次getConnection時
maxActive	8	最大連接池數量
maxIdle	8	已經不再使用，配置了也沒效果
minIdle		最小連接池數量
maxWait		獲取連接時最大等待時間，單位毫秒。配置了maxWait之后，缺省啟用公平鎖，並發效率會有所下降，如果需要可以通過配置useUnfairLock屬性為true使用非公平鎖。
poolPreparedStatements	false	是否緩存preparedStatement，也就是PSCache。PSCache對支持游標的數據庫性能提升巨大，比如說oracle。在mysql下建議關閉。
maxOpenPreparedStatements	-1	要啟用PSCache，必須配置大於0，當大於0時，poolPreparedStatements自動觸發修改為true。在Druid中，不會存在Oracle下PSCache占用內存過多的問題，可以把這個數值配置大一些，比如說100
validationQuery		用來檢測連接是否有效的sql，要求是一個查詢語句。如果validationQuery為null，testOnBorrow、testOnReturn、testWhileIdle都不會其作用。
testOnBorrow	true	申請連接時執行validationQuery檢測連接是否有效，做了這個配置會降低性能。
testOnReturn	false	歸還連接時執行validationQuery檢測連接是否有效，做了這個配置會降低性能
testWhileIdle	false	建議配置為true，不影響性能，並且保證安全性。申請連接的時候檢測，如果空閑時間大於timeBetweenEvictionRunsMillis，執行validationQuery檢測連接是否有效。
timeBetweenEvictionRunsMillis		有兩個含義： 1)Destroy線程會檢測連接的間隔時間2)testWhileIdle的判斷依據，詳細看testWhileIdle屬性的說明
numTestsPerEvictionRun		不再使用，一個DruidDataSource只支持一個EvictionRun
minEvictableIdleTimeMillis
connectionInitSqls		物理連接初始化的時候執行的sql
exceptionSorter		根據dbType自動識別當數據庫拋出一些不可恢復的異常時，拋棄連接
filters		屬性類型是字符串，通過別名的方式配置擴展插件，常用的插件有：監控統計用的filter:stat日志用的filter:log4j防御sql注入的filter:wall
proxyFilters		類型是List，如果同時配置了filters和proxyFilters，是組合關系，並非替換關系

第9章：Apache-DBUtils實現CRUD操作

9.1 Apache-DBUtils簡介

commons-dbutils 是 Apache 組織提供的一個開源 JDBC工具類庫，它是對JDBC的簡單封裝，學習成本極低，並且使用dbutils能極大簡化jdbc編碼的工作量，同時也不會影響程序的性能。
API介紹：
- org.apache.commons.dbutils.QueryRunner
- org.apache.commons.dbutils.ResultSetHandler
- 工具類：org.apache.commons.dbutils.DbUtils
API包說明：

9.2 主要API的使用

9.2.1 DbUtils

DbUtils ：提供如關閉連接、裝載JDBC驅動程序等常規工作的工具類，里面的所有方法都是靜態的。主要方法如下：
- public static void close(…) throws java.sql.SQLException：　DbUtils類提供了三個重載的關閉方法。這些方法檢查所提供的參數是不是NULL，如果不是的話，它們就關閉Connection、Statement和ResultSet。
- public static void closeQuietly(…): 這一類方法不僅能在Connection、Statement和ResultSet為NULL情況下避免關閉，還能隱藏一些在程序中拋出的SQLEeception。
- public static void commitAndClose(Connection conn)throws SQLException：用來提交連接的事務，然后關閉連接
- public static void commitAndCloseQuietly(Connection conn)：用來提交連接，然后關閉連接，並且在關閉連接時不拋出SQL異常。
- public static void rollback(Connection conn)throws SQLException：允許conn為null，因為方法內部做了判斷
- public static void rollbackAndClose(Connection conn)throws SQLException
- rollbackAndCloseQuietly(Connection)
- public static boolean loadDriver(java.lang.String driverClassName)：這一方裝載並注冊JDBC驅動程序，如果成功就返回true。使用該方法，你不需要捕捉這個異常ClassNotFoundException。

9.2.2 QueryRunner類

該類簡單化了SQL查詢，它與ResultSetHandler組合在一起使用可以完成大部分的數據庫操作，能夠大大減少編碼量。
QueryRunner類提供了兩個構造器：
- 默認的構造器
- 需要一個 javax.sql.DataSource 來作參數的構造器
QueryRunner類的主要方法：
- 更新
  - public int update(Connection conn, String sql, Object... params) throws SQLException:用來執行一個更新（插入、更新或刪除）操作。
  - ......
- 插入
  - public <T> T insert(Connection conn,String sql,ResultSetHandler<T> rsh, Object... params) throws SQLException：只支持INSERT語句，其中 rsh - The handler used to create the result object from the ResultSet of auto-generated keys. 返回值: An object generated by the handler.即自動生成的鍵值
  - ....
- 批處理
  - public int[] batch(Connection conn,String sql,Object params)throws SQLException： INSERT, UPDATE, or DELETE語句
  - public <T> T insertBatch(Connection conn,String sql,ResultSetHandler<T> rsh,Object params)throws SQLException：只支持INSERT語句
  - .....
- 查詢
  - public Object query(Connection conn, String sql, ResultSetHandler rsh,Object... params) throws SQLException：執行一個查詢操作，在這個查詢中，對象數組中的每個元素值被用來作為查詢語句的置換參數。該方法會自行處理 PreparedStatement 和 ResultSet 的創建和關閉。
  - ......
測試

// 測試添加
@Test
public void testInsert() throws Exception {
 QueryRunner runner = new QueryRunner();
 Connection conn = JDBCUtils.getConnection3();
 String sql = "insert into customers(name,email,birth)values(?,?,?)";
 int count = runner.update(conn, sql, "何成飛", "he@qq.com", "1992-09-08");

 System.out.println("添加了" + count + "條記錄");
  
 JDBCUtils.closeResource(conn, null);

}

// 測試刪除
@Test
public void testDelete() throws Exception {
 QueryRunner runner = new QueryRunner();
 Connection conn = JDBCUtils.getConnection3();
 String sql = "delete from customers where id < ?";
 int count = runner.update(conn, sql,3);

 System.out.println("刪除了" + count + "條記錄");
  
 JDBCUtils.closeResource(conn, null);

}

9.2.3 ResultSetHandler接口及實現類

該接口用於處理 java.sql.ResultSet，將數據按要求轉換為另一種形式。
ResultSetHandler 接口提供了一個單獨的方法：Object handle (java.sql.ResultSet .rs)。
接口的主要實現類：
- ArrayHandler：把結果集中的第一行數據轉成對象數組。
- ArrayListHandler：把結果集中的每一行數據都轉成一個數組，再存放到List中。
- BeanHandler：將結果集中的第一行數據封裝到一個對應的JavaBean實例中。
- BeanListHandler：將結果集中的每一行數據都封裝到一個對應的JavaBean實例中，存放到List里。
- ColumnListHandler：將結果集中某一列的數據存放到List中。
- KeyedHandler(name)：將結果集中的每一行數據都封裝到一個Map里，再把這些map再存到一個map里，其key為指定的key。
- MapHandler：將結果集中的第一行數據封裝到一個Map里，key是列名，value就是對應的值。
- MapListHandler：將結果集中的每一行數據都封裝到一個Map里，然后再存放到List
- ScalarHandler：查詢單個值對象
測試

/*
 * 測試查詢:查詢一條記錄
 * 
 * 使用ResultSetHandler的實現類：BeanHandler
 */
@Test
public void testQueryInstance() throws Exception{
 QueryRunner runner = new QueryRunner();

 Connection conn = JDBCUtils.getConnection3();
  
 String sql = "select id,name,email,birth from customers where id = ?";
  
 //
 BeanHandler<Customer> handler = new BeanHandler<>(Customer.class);
 Customer customer = runner.query(conn, sql, handler, 23);
 System.out.println(customer); 
 JDBCUtils.closeResource(conn, null);
}

/*
 * 測試查詢:查詢多條記錄構成的集合
 * 
 * 使用ResultSetHandler的實現類：BeanListHandler
 */
@Test
public void testQueryList() throws Exception{
 QueryRunner runner = new QueryRunner();

 Connection conn = JDBCUtils.getConnection3();
  
 String sql = "select id,name,email,birth from customers where id < ?";
  
 //
 BeanListHandler<Customer> handler = new BeanListHandler<>(Customer.class);
 List<Customer> list = runner.query(conn, sql, handler, 23);
 list.forEach(System.out::println);
  
 JDBCUtils.closeResource(conn, null);
}

/*
 * 自定義ResultSetHandler的實現類
 */
@Test
public void testQueryInstance1() throws Exception{
 QueryRunner runner = new QueryRunner();

 Connection conn = JDBCUtils.getConnection3();
  
 String sql = "select id,name,email,birth from customers where id = ?";
  
 ResultSetHandler<Customer> handler = new ResultSetHandler<Customer>() {

  @Override
  public Customer handle(ResultSet rs) throws SQLException {
   System.out.println("handle");
//   return new Customer(1,"Tom","tom@126.com",new Date(123323432L));
    
   if(rs.next()){
    int id = rs.getInt("id");
    String name = rs.getString("name");
    String email = rs.getString("email");
    Date birth = rs.getDate("birth");
     
    return new Customer(id, name, email, birth);
   }
   return null;
    
  }
 };
  
 Customer customer = runner.query(conn, sql, handler, 23);
  
 System.out.println(customer);
  
 JDBCUtils.closeResource(conn, null);
}

/*
 * 如何查詢類似於最大的，最小的，平均的，總和，個數相關的數據，
 * 使用ScalarHandler
 * 
 */
@Test
public void testQueryValue() throws Exception{
 QueryRunner runner = new QueryRunner();

 Connection conn = JDBCUtils.getConnection3();
  
 //測試一：
// String sql = "select count(*) from customers where id < ?";
// ScalarHandler handler = new ScalarHandler();
// long count = (long) runner.query(conn, sql, handler, 20);
// System.out.println(count);
  
 //測試二：
 String sql = "select max(birth) from customers";
 ScalarHandler handler = new ScalarHandler();
 Date birth = (Date) runner.query(conn, sql, handler);
 System.out.println(birth);
  
 JDBCUtils.closeResource(conn, null);
}

JDBC總結

總結
@Test
public void testUpdateWithTx() {
		
	Connection conn = null;
	try {
		//1.獲取連接的操作（
		//① 手寫的連接：JDBCUtils.getConnection();
		//② 使用數據庫連接池：C3P0;DBCP;Druid
		//2.對數據表進行一系列CRUD操作
		//① 使用PreparedStatement實現通用的增刪改、查詢操作（version 1.0 \ version 2.0)
//version2.0的增刪改public void update(Connection conn,String sql,Object ... args){}
//version2.0的查詢 public <T> T getInstance(Connection conn,Class<T> clazz,String sql,Object ... args){}
		//② 使用dbutils提供的jar包中提供的QueryRunner類
			
		//提交數據
		conn.commit();
			
	
	} catch (Exception e) {
		e.printStackTrace();
			
			
		try {
			//回滾數據
			conn.rollback();
		} catch (SQLException e1) {
			e1.printStackTrace();
		}
			
	}finally{
		//3.關閉連接等操作
		//① JDBCUtils.closeResource();
		//② 使用dbutils提供的jar包中提供的DbUtils類提供了關閉的相關操作
			
	}
}

// 獲取每個列的列名

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 JDBC學習1：詳解JDBC使用 Jmeter JDBC Request 使用詳解 JDBC詳解一 jdbc是什么 JDBC詳解 JDBC詳解 JDBC詳解 JDBC基本詳解 Dremio的部署搭建和JDBC-Client實戰使用詳解 jdbc 使用in Mybatis和JDBC的區別詳解