第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, "[email protected]");
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, "何成飛", "[email protected]", "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","[email protected]",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類提供了關閉的相關操作 }
}
// 獲取每個列的列名