關于jdbc的全部jar包
鏈接：https://pan.baidu.com/s/1peofgu89SpepTTYuZuphNw
提取碼：vd5v
一、獲取資料庫連接
1. Driver介面介紹
- java.sql.Driver 介面是所有 JDBC 驅動程式需要實作的介面，這個介面是提供給資料庫廠商使用的，不同資料庫廠商提供不同的實作
- 在程式中不需要直接去訪問實作了 Driver 介面的類，而是由驅動程式管理器類(java.sql.DriverManager)去呼叫這些Driver實作
- mySql的驅動： com.mysql.jdbc.Driver
- 將上述jar包拷貝到Java工程的一個目錄中，并且在新建一個lib檔案夾
- 然后在jar包上右鍵，如下圖操作
注意：如果是Dynamic Web Project（動態的web專案）話，則是把驅動jar放到WebContent（有的開發工具叫WebRoot）目錄中的WEB-INF目錄中的lib目錄下即可
2. 加載與注冊JDBC驅動
- 加載驅動：加載 JDBC 驅動需呼叫 Class 類的靜態方法 forName()，向其傳遞要加載的 JDBC 驅動的類名
- Class.forName(“com.mysql.jdbc.Driver”);
- 注冊驅動：DriverManager 類是驅動程式管理器類，負責管理驅動程式
- 使用DriverManager.registerDriver(com.mysql.jdbc.Driver)來注冊驅動
- 通常不用顯式呼叫 DriverManager 類的 registerDriver() 方法來注冊驅動程式類的實體，因為 Driver 介面的驅動程式類都包含了靜態代碼塊，在這個靜態代碼塊中，會呼叫 DriverManager.registerDriver() 方法來注冊自身的一個實體
3. URL
- JDBC URL 用于標識一個被注冊的驅動程式，驅動程式管理器通過這個 URL 選擇正確的驅動程式，從而建立到資料庫的連接，
- JDBC URL的標準由三部分組成，各部分間用冒號分隔，
- jdbc:子協議:子名稱
- 協議：JDBC URL中的協議總是jdbc
- 子協議：子協議用于標識一個資料庫驅動程式
- 子名稱：一種標識資料庫的方法，子名稱可以依不同的子協議而變化，用子名稱的目的是為了定位資料庫提供足夠的資訊，包含主機名(對應服務端的ip地址)，埠號，資料庫名
MySQL的連接URL撰寫方式：
- jdbc:mysql://主機名稱:mysql服務埠號/資料庫名稱?引數=值&引數=值
- jdbc:mysql://localhost:3306/資料庫名
- jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8（如果JDBC程式與服務器端的字符集不一致，會導致亂碼，那么可以通過引數指定服務器端的字符集）
- jdbc:mysql://localhost:3306/test?user=root&password=123456
二、資料庫連接方式
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. 連接方式二
@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", "123456");
//4.呼叫driver的connect()，獲取連接
Connection conn = driver.connect(url, info);
System.out.println(conn);
} catch (Exception e) {
e.printStackTrace();
}
}
說明：相較于方式一，這里使用反射實體化Driver，不在代碼中體現第三方資料庫的API，體現了面向介面編程思想，
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個基本要素，
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的原始碼中已經存在靜態代碼塊，實作了驅動的注冊，
5. 連接方式五
@Test
public void testConnection5() throws Exception {
//1.加載組態檔
InputStream is = testConnection5.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=123456
url=jdbc:mysql://localhost:3306/test
driverClass=com.mysql.jdbc.Driver
說明：使用組態檔的方式保存配置資訊，在代碼中加載組態檔
使用組態檔的好處：
①實作了代碼和資料的分離，如果需要修改配置資訊，直接在組態檔中修改，不需要深入代碼
②如果修改了配置資訊，省去重新編譯的程序，
6. 封裝版JDBCUtils
方便后面使用，組態檔還是上面的
package com.md.util;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Properties;
public class JDBCUtils {
/**
* 獲取資料庫的連接
* @return
* @throws Exception
*/
public static Connection getConnection() throws Exception {
//1.加載組態檔
InputStream is = ClassLoader.getSystemClassLoader().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);
return conn;
}
/**
* 關閉資源
* @param conn
* @param ps
* @return
*/
public static void closeResource(Connection conn , PreparedStatement ps) {
try {
if(ps != null)
ps.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
if(conn != null)
conn.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
* 關閉資源 ， 有結果集呼叫這個
* @param conn
* @param ps
* @param rs
*/
public static void closeResource(Connection conn , PreparedStatement ps , ResultSet rs) {
try {
if(ps != null)
ps.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
if(conn != null)
conn.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
if(rs != null)
rs.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
三、使用PreparedStatement實作CRUD操作
1. 操作和訪問資料庫
- 資料庫連接被用于向資料庫服務器發送命令和 SQL 陳述句，并接受資料庫服務器回傳的結果，其實一個資料庫連接就是一個Socket連接，
- 在 java.sql 包中有 3 個介面分別定義了對資料庫的呼叫的不同方式：
- Statement：用于執行靜態 SQL 陳述句并回傳它所生成結果的物件，
- PrepatedStatement：SQL 陳述句被預編譯并存盤在此物件中，可以使用此物件多次高效地執行該陳述句，
- CallableStatement：用于執行 SQL 存盤程序
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. PreparedStatement介紹
- 可以通過呼叫 Connection 物件的 preparedStatement(String sql) 方法獲取 PreparedStatement 物件
- PreparedStatement 介面是 Statement 的子介面，它表示一條預編譯過的 SQL 陳述句
- PreparedStatement 物件所代表的 SQL 陳述句中的引數用問號(?)來表示，呼叫 PreparedStatement 物件的 setXxx() 方法來設定這些引數. setXxx() 方法有兩個引數，第一個引數是要設定的 SQL 陳述句中的引數的索引(從 1 開始)，第二個是設定的 SQL 陳述句中的引數的值
4. PreparedStatement vs Statement
- 代碼的可讀性和可維護性，
- PreparedStatement 能最大可能提高性能：
- DBServer會對預編譯陳述句提供性能優化，因為預編譯陳述句有可能被重復呼叫，所以陳述句在被DBServer的編譯器編譯后的執行代碼被快取下來，那么下次呼叫時只要是相同的預編譯陳述句就不需要編譯，只要將引數直接傳入編譯過的陳述句執行代碼中就會得到執行，
- 在statement陳述句中,即使是相同操作但因為資料內容不一樣,所以整個陳述句本身不能匹配,沒有快取陳述句的意義.事實是沒有資料庫會對普通陳述句編譯后的執行代碼快取，這樣每執行一次都要對傳入的陳述句編譯一次，
- (語法檢查，語意檢查，翻譯成二進制命令，快取)
- PreparedStatement 可以防止 SQL 注
5. 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 |
6. 使用PreparedStatement實作增、刪、改操作(重點 )
ps.execute(); 執行sql陳述句
或者是ps.executeUpdate();，回傳影響的行數int型
public void testUpdate() {
Connection conn = null;
PreparedStatement ps = null;
try {
// 1. 建立連接
conn = JDBCUtils.getConnection();
// 2. 預編譯sql陳述句，回傳prepareStatement實體
String sql = "update customers set name = ? where id = ?";
ps = conn.prepareStatement(sql);
// 3. 填充占位符，sql下標是從1開始的
ps.setObject(1, "唐三");
ps.setObject(2, 2);
// 4. 執行
ps.execute();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally {
// 5. 資源關閉
JDBCUtils.closeResource(conn, ps);
}
}
可以看到，現在只是適合于簡單的sql陳述句，接下來改成通用版本的
//通用的增、刪、改操作（體現一：增、刪、改 ； 體現二：針對于不同的表）
public void update(String sql,Object ... args){
Connection conn = null;
PreparedStatement ps = null;
try {
//1.獲取資料庫的連接
conn = JDBCUtils.getConnection();
//2.獲取PreparedStatement的實體 (或：預編譯sql陳述句)
ps = conn.prepareStatement(sql);
//3.填充占位符，sql的下標從1開始，而陣列下標從0開始
for(int i = 0;i < args.length;i++){
ps.setObject(i + 1, args[i]);
}
//4.執行sql陳述句
ps.execute();
} catch (Exception e) {
e.printStackTrace();
}finally{
//5.關閉資源
JDBCUtils.closeResource(conn, ps);
}
}
7. 使用PreparedStatement實作查詢操作(重點 )
查詢使用這個：ps.executeQuery(); 執行sql陳述句，有結果集，注意和上面的不同
首先還是一個簡單版本的
@Test
public void testQuery() {
Connection conn = null;
PreparedStatement ps = null;
ResultSet rs = null;
try {
// 1. 建立連接
conn = JDBCUtils.getConnection();
// 2. 預編譯sql陳述句，回傳prepareStatement實體
String sql = "select id,name,email,birth from customers where id = ?";
ps = conn.prepareStatement(sql);
// 3. 填充占位符
ps.setObject(1, 2);
// 4. 執行,并回傳結果集
rs= ps.executeQuery();
// 處理結果集 ，現在只能執行一條資料
// 判斷結果集下一條是否有資料，如果有資料回傳true，并且指標下移，如果沒有資料回傳false
if(rs.next()) {
// 獲取當前這條資料的各個欄位的值
int id = rs.getInt(1);
String name = rs.getString(2);
String email = rs.getString(3);
Date birth = rs.getDate(4);
// 方式一：直接顯示
// 方式二：推薦直接封裝成類的物件
Customer customer = new Customer(id,name,email,birth);
System.out.println(customer);
}
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally {
// 5. 資源關閉
JDBCUtils.closeResource(conn, ps , rs);
}
}
然后進行改進，利用反射和泛型，但是還是有弊端，只能回傳一個物件
// 通用的針對于不同表的查詢:回傳一個物件 (version 1.0)
public <T> T getInstance(Class<T> clazz, String sql, Object... args) {
Connection conn = null;
PreparedStatement ps = null;
ResultSet rs = null;
try {
// 1.獲取資料庫連接
conn = JDBCUtils.getConnection();
// 2.預編譯sql陳述句，得到PreparedStatement物件
ps = conn.prepareStatement(sql);
// 3.填充占位符
for (int i = 0; i < args.length; i++) {
ps.setObject(i + 1, args[i]);
}
// 4.執行executeQuery(),得到結果集：ResultSet 注意：增刪改用的execute()方法
rs = ps.executeQuery();
// 5.得到結果集的元資料：ResultSetMetaData ， 具體看下面介紹
ResultSetMetaData rsmd = rs.getMetaData();
// 6.1通過ResultSetMetaData得到columnCount,columnLabel；通過ResultSet得到列值
int columnCount = rsmd.getColumnCount(); // 得到列數
if (rs.next()) {
T t = clazz.newInstance();
for (int i = 0; i < columnCount; i++) {// 遍歷每一個列
// 獲取列值，相當于值
Object columnVal = rs.getObject(i + 1);
// 獲取列的別名:列的別名，使用類的屬性名充當，相當于屬性
String columnLabel = rsmd.getColumnLabel(i + 1);
// 6.2使用反射，給物件的相應屬性賦值
Field field = clazz.getDeclaredField(columnLabel);
field.setAccessible(true);
field.set(t, columnVal);
}
return t;
}
} catch (Exception e) {
e.printStackTrace();
} finally {
// 7.關閉資源
JDBCUtils.closeResource(conn, ps, rs);
}
return null;
}
最終版本，使用集合來接收物件
/**
* 查詢多條資料
* @param clazz
* @param sql
* @param args
* @return
*/
public <T> List<T> getInstance(Class<T> clazz, String sql, Object... args) {
Connection conn = null;
PreparedStatement ps = null;
ResultSet rs = null;
try {
// 1.獲取資料庫連接
conn = JDBCUtils.getConnection();
// 2.預編譯sql陳述句，得到PreparedStatement物件
ps = conn.prepareStatement(sql);
// 3.填充占位符
for (int i = 0; i < args.length; i++) {
ps.setObject(i + 1, args[i]);
}
// 4.執行executeQuery(),得到結果集：ResultSet
rs = ps.executeQuery();
// 5.得到結果集的元資料：ResultSetMetaData，具體看下面介紹
ResultSetMetaData rsmd = rs.getMetaData();
// 6.1通過ResultSetMetaData得到columnCount,columnLabel；通過ResultSet得到列值
int columnCount = rsmd.getColumnCount(); // 得到列數
// 創建集合物件
ArrayList<T> list = new ArrayList<T>();
while (rs.next()) {
T t = clazz.newInstance();
// 遍歷每一個列,給每一個t物件指定的屬性賦值
for (int i = 0; i < columnCount; i++) {
// 獲取列值，相當于值
Object columnVal = rs.getObject(i + 1);
// 獲取列的別名:列的別名，使用類的屬性名充當，相當于屬性
String columnLabel = rsmd.getColumnLabel(i + 1);
// 6.2使用反射，給物件的相應屬性賦值
Field field = clazz.getDeclaredField(columnLabel);
field.setAccessible(true);
field.set(t, columnVal);
}
// 往集合中添加物件
list.add(t);
}
// 最后回傳集合
return list;
} catch (Exception e) {
e.printStackTrace();
} finally {
// 7.關閉資源
JDBCUtils.closeResource(conn, ps, rs);
}
return null;
}
測驗：
@Test
public void test() {
String sql = "select id,name,email,birth from customers where id < ?";
List<Customer> list = getInstance(Customer.class , sql , 9);
for (Customer customer : list) {
System.out.println(customer);
}
//
// 或者這樣寫，不用寫for了
String sql1 = "select id,name,email,birth from customers";
List<Customer> list1 = getInstance(Customer.class , sql1);
list1.forEach(System.out::println);
}
四、ResultSet與ResultSetMetaData(重點)
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()
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() 方法
注意：當java類的屬性名和資料庫中的列名不一致的時候時候，宣告sql查詢時使用類的屬性名來命名欄位的別名，所以推薦使用getColumnLabel()，一致時，即使沒有寫別名，默認的也是獲取的列名
通過ResultSet可以獲得到列值，
通過ResultSetMetaData可以獲得到列數以及列名
通過反射創建指定的類物件，然后指定列名(屬性)賦值
五、JDBC小結
-
兩種思想
- 面向介面編程的思想
- ORM思想(object relational mapping)
- 一個資料表對應一個java類
- 表中的一條記錄對應java類的一個物件
- 表中的一個欄位對應java類的一個屬性
sql是需要結合列名和表的屬性名來寫，注意起別名，
-
兩種技術
- JDBC結果集的元資料：ResultSetMetaData
- 獲取列數：getColumnCount()
- 獲取列的別名：getColumnLabel()
- 通過反射，創建指定類的物件，獲取指定的屬性并賦值
- JDBC結果集的元資料：ResultSetMetaData
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/119098.html
標籤：Java
下一篇：JAVA_NIO通信理論基礎