JDBC是指資料庫連接技術,用於java連接mySQL等資料庫。本文詳細介紹了尚矽谷課程中JDBC的學習內容和補充知識。 概述 java語言只提供規範介面,存在於java.sql.javax.sql包下,然後資料庫軟體根據java提供的規範實現具體的驅動代碼(jar) jar包是java程式打成的一 ...
JDBC是指資料庫連接技術,用於java連接mySQL等資料庫。本文詳細介紹了尚矽谷課程中JDBC的學習內容和補充知識。
概述
- java語言只提供規範介面,存在於java.sql.javax.sql包下,然後資料庫軟體根據java提供的規範實現具體的驅動代碼(jar)
- jar包是java程式打成的一種壓縮包格式,只要導入就可以使用對應方法
學習思路:(可以學完再看)
-
六大基本步驟獲取連接,包括直接輸入字元串的Statement和改進版的PreparedStatement(通過占位符解決了容易SQL攻擊的問題)
-
JDBC的增刪改查,其中插入數據需要考慮主鍵自增長、批量插入效率低的問題
-
建立資料庫事務(基本特征是關閉了自動提交,要同時完成多個操作後再一起提交,如轉賬過程先增加A賬戶的錢,再扣除B賬戶的錢,一定要一起提交,防止出現只成功一件事)
-
連接池,優化建立連接的過程(每件事都去連接很繁瑣,浪費資源,Druid連接池)
- 硬編碼:通過設置參數的方式
- 軟編碼:通過讀取外部配置文件的方式(讀取方法使用了類載入器,補充說明在末尾)
-
封裝連接工具類(通過靜態代碼塊的方式保證連接池只被創建一次,而不是每次調用方法都創建一個新的連接池對象。)
- V1.0:不同方法調用拿到的是不同連接對象
- V2.0:利用線程本地量的方法,保證同一個線程不同方法拿到的是同一個連接
-
完整工具類封裝(連接池優化了建立連接,那麼把增刪改查操作也封裝一下吧)
- executeUpdate(實現數據的更新操作,包括增,刪,改)
- executeQuery(實現數據的查詢操作,通過反射機制,輸入模板對象,返回查詢出的對象列表)
基本步驟
- 註冊驅動,將依賴的jar包進行安裝
- 建立連接 connection
- 創建發送SQL語句的對象statement
- statement對象去發送SQL數據到資料庫獲取返回結果
- 解析結果集
- 銷毀資源
mySQL端 創建t_user表
create database atguigu;
use atguigu;
create table t_user(
id int primary key auto_increment comment '用戶主鍵',
account varchar(20) not null unique comment '賬號',
password varchar(64) not null comment '密碼',
nickname varchar(20) not null comment '昵稱');
insert into t_user(account,password,nickname) values('root','123456','經理'),('admin','666666','管理員');
java端獲取數據
public class StatementQuery {
public static void main(String[] args) throws SQLException {
//1.註冊驅動
DriverManager.registerDriver(new Driver());//8+驅動要選擇帶cj的
//2. 獲取連接,需要資料庫ip地址(127.0.0.1),資料庫埠號(3306),賬號(root),密碼,連接資料庫的名稱(atguigu)
//jdbc:資料庫廠商名//ip:埠號/資料庫名
Connection connection=DriverManager.
getConnection("jdbc:mysql://127.0.0.1:3306/atguigu","root","mypassword");
//3. 創建statement
Statement statement = connection.createStatement();
//4. 發送SQL語句
String sql="select * from t_user";
ResultSet resultSet = statement.executeQuery(sql);
//5. 進行結果集更新
while(resultSet.next()){
int id = resultSet.getInt("id");
String account = resultSet.getString("account");
String password = resultSet.getString("password");
String nickname = resultSet.getString("nickname");
System.out.println(id+"--"+account+"--"+password+"--"+nickname);
}
//6. 關閉資源
resultSet.close();
statement.close();
connection.close();
}
}
模擬用戶登錄
- 模擬用戶登錄
- 鍵盤輸入事件收集賬號密碼信息
- 輸入賬號密碼進行查詢驗證是否登錄成功
public class SatetementUserLoginPart {
public static void main(String[] args) throws SQLException, ClassNotFoundException {
//0. 獲取用戶輸入信息
Scanner scanner = new Scanner(System.in);
System.out.println("請輸入賬號");
String account = scanner.nextLine();
System.out.println("請輸入密碼");
String password = scanner.nextLine();
//1.註冊驅動,有兩種方案
/*方案一--------------
//DriverManager.registerDriver(new Driver());//會註冊兩次驅動,可以考慮僅觸發靜態代碼塊
//類載入機制:類記載時刻會觸發靜態代碼塊,可以通過new,靜態方法,靜態屬性等觸發
*/
//方案二-------------
Class.forName("com.mysql.cj.jdbc.Driver");//觸發類載入,觸發靜態代碼塊的調用
//優點是字元串可以提取到外部的配置文件,便於更換數據驅動,會更加靈活
//2. 獲取資料庫連接,共有三種方法
//該方法是一個重載方法,允許開發者用不同的形式傳入資料庫連接的核心參數
//三個參數-------------
Connection connection=DriverManager.
getConnection("jdbc:mysql://127.0.0.1:3306/atguigu","root","mypassword");
//jdbc:mysql:///atguigu 如果本機和3306可以省略為///
//兩個參數--------------
/*
Properties info=new Properties();
info.put("user","root");
info.put("password","root");
DriverManager.getConnection("jdbc:mysql:///atguigu",info);
//一個參數--------------
//jdbc:資料庫廠商名//ip:埠號/資料庫名?user=root&password=root
DriverManager.getConnection("jdbc:mysql:///atguigu?user=root&password=root");
//其他可選信息,如果是sql8.0以後的版本可以省略serverTimezone=Asia/Shanghai&UseUnicode=true&characterEncoding=utf8&useSSL=true
*/
//3. 創建發送SQL語句的Statetment對象
Statement statement = connection.createStatement();
//4. 發送SQL語句
String sql="SELECT * FROM t_user WHERE account='"+account+"'AND PASSWORD='"+password+"';";
//executeUpdate用於更新數據,返回影響的函數,executeQuery負責返回查詢結果,返回結果封裝對象
ResultSet resultSet = statement.executeQuery(sql);
//5.查詢結果集解析,resultSet給出的是逐行的對象,使用next可以逐行提取下一個,遍歷完畢時返回false
/*僅查詢的方案
while(resultSet.next()){
//游標已經移動,此時利用getInt\getString讀取該行的數據
//getString輸入可以是index(列的下角標,從左向右從1開始),可以是列名(有別名寫別名)
int id = resultSet.getInt("id");
String account1 = resultSet.getString("account");
String password1 = resultSet.getString("password");
String nickname = resultSet.getString("nickname");
System.out.println(id+"--"+account+"--"+password+"--"+nickname);
}
*/
//考慮實際需求,只需要有一行數據證明就可以登錄成功
if(resultSet.next()){
System.out.println("登錄成功");
}else {
System.out.println("登錄失敗,用戶名或密碼錯誤");
}
//6. 關閉資源
resultSet.close();
statement.close();
connection.close();
}
}
存在幾個問題
-
SQL語句需要字元串拼接比較麻煩
-
只能拼接字元串類型,其他的資料庫類型無法處理
-
可能發生註入攻擊(動態值充當了SQL語句結構)
模擬用戶登錄(prepare改進)
public class SPUserLoginPart {
public static void main(String[] args) throws ClassNotFoundException, SQLException {
//0. 獲取用戶輸入信息
Scanner scanner = new Scanner(System.in);
System.out.println("請輸入賬號");
String account = scanner.nextLine();
System.out.println("請輸入密碼");
String password = scanner.nextLine();
//1.註冊驅動,有兩種方案
Class.forName("com.mysql.cj.jdbc.Driver");//觸發類載入,觸發靜態代碼塊的調用
//2. 獲取資料庫連接
Connection connection= DriverManager.
getConnection("jdbc:mysql://127.0.0.1:3306/atguigu","root","mypassword");
//3. 創建發送SQL語句的preparedstatetment對象
//(1). 編寫SQL語句結構,動態值部分使用占位符?替代(2).創建preparedstatetment,傳入動態值
//(3). 動態值 占位符 賦值? 單獨賦值即可 (4). 發送
String sql="SELECT * FROM t_user where account=? and password=?;";
PreparedStatement preparedStatement = connection.prepareStatement(sql);
/*
參數一:index占位符的位置,從1開始
參數二:Object占位符的值,可以是任何類型
*/
preparedStatement.setObject(1,account);
preparedStatement.setObject(2,password);
ResultSet resultSet = preparedStatement.executeQuery();
//5. 結果集解析
if(resultSet.next()){
System.out.println("登錄成功");
}else {
System.out.println("登錄失敗,用戶名或密碼錯誤");
}
//6. 關閉資源
resultSet.close();
preparedStatement.close();
connection.close();
}
}
JDBC實現增刪改查
public class PSCURDPart {
@Test
public void testInsert() throws ClassNotFoundException, SQLException {
//1.註冊驅動,有兩種方案
Class.forName("com.mysql.cj.jdbc.Driver");//觸發類載入,觸發靜態代碼塊的調用
//2. 獲取資料庫連接
Connection connection= DriverManager.
getConnection("jdbc:mysql://127.0.0.1:3306/atguigu","root","mypassword");
//3. 創建發送SQL語句的preparedstatetment對象
String sql="insert into t_user(account,password,nickname) values(?,?,?)";
PreparedStatement preparedStatement = connection.prepareStatement(sql);
preparedStatement.setObject(1,"test");
preparedStatement.setObject(2,"test");
preparedStatement.setObject(3,"二狗");
int rows = preparedStatement.executeUpdate();
//5. 結果集解析
if(rows>0){
System.out.println("插入成功");
}else {
System.out.println("插入失敗");
}
//6. 關閉資源
preparedStatement.close();
connection.close();
}
@Test
public void testUpdate() throws ClassNotFoundException, SQLException {
//1.註冊驅動,有兩種方案
Class.forName("com.mysql.cj.jdbc.Driver");//觸發類載入,觸發靜態代碼塊的調用
//2. 獲取資料庫連接
Connection connection= DriverManager.
getConnection("jdbc:mysql://127.0.0.1:3306/atguigu","root","mypassword");
//3. 創建發送SQL語句的preparedstatetment對象
String sql="update t_user set nickname=? where id=?";
PreparedStatement preparedStatement = connection.prepareStatement(sql);
preparedStatement.setObject(1,"張三");
preparedStatement.setObject(2,3);
int rows = preparedStatement.executeUpdate();
//5. 結果集解析
if(rows>0){
System.out.println("修改成功");
}else {
System.out.println("修改失敗");
}
//6. 關閉資源
preparedStatement.close();
connection.close();
}
@Test
public void testDelete() throws ClassNotFoundException, SQLException {
//1.註冊驅動,有兩種方案
Class.forName("com.mysql.cj.jdbc.Driver");//觸發類載入,觸發靜態代碼塊的調用
//2. 獲取資料庫連接
Connection connection= DriverManager.
getConnection("jdbc:mysql://127.0.0.1:3306/atguigu","root","mypassword");
//3. 創建發送SQL語句的preparedstatetment對象
String sql="delete from t_user where id=?";
PreparedStatement preparedStatement = connection.prepareStatement(sql);
preparedStatement.setObject(1,3);
int rows = preparedStatement.executeUpdate();
//5. 結果集解析
if(rows>0){
System.out.println("刪除成功");
}else {
System.out.println("刪除失敗");
}
//6. 關閉資源
preparedStatement.close();
connection.close();
}
//查詢所有用戶數據,並封裝到一個List<Map> 集合中,key=列名,value=列的內容
@Test
public void testSelect() throws ClassNotFoundException, SQLException {
//1.註冊驅動,有兩種方案
Class.forName("com.mysql.cj.jdbc.Driver");//觸發類載入,觸發靜態代碼塊的調用
//2. 獲取資料庫連接
Connection connection= DriverManager.
getConnection("jdbc:mysql://127.0.0.1:3306/atguigu","root","mypassword");
//3. 創建發送SQL語句的preparedstatetment對象
String sql="SELECT id,account,password,nickname FROM t_user;";
PreparedStatement preparedStatement = connection.prepareStatement(sql);
ResultSet resultSet = preparedStatement.executeQuery();
//5. 結果集解析
List<Map> list=new ArrayList<>();
ResultSetMetaData metaData = resultSet.getMetaData();//獲取當前結果集列的信息對象
int columnCount = metaData.getColumnCount();//為了水平遍歷
while(resultSet.next()){
Map map=new HashMap();
for (int i = 1; i <columnCount ; i++) {
Object value = resultSet.getObject(i);
String columnLabel = metaData.getColumnLabel(i);//getlabel可以得到別名,name只能別名
map.put(columnLabel,value);
}
list.add(map);
}
System.out.println(list);
//6. 關閉資源
preparedStatement.close();
connection.close();
}
}
靈活插入
主鍵回顯
在多表關聯插入數據時,一般主表的主鍵是自動生成的,所以插入數據前無法獲取主鍵,但是從表需要再插入數據之前就綁定主表的主鍵,這時可以使用主鍵回顯技術
public class PSOthePart {
//t_user 插入一條數據,並獲取資料庫自增長的主鍵
@Test
public void returnPrimaryKey() throws ClassNotFoundException, SQLException {
Class.forName("com.mysql.cj.jdbc.Driver");
Connection connection= DriverManager.
getConnection("jdbc:mysql://127.0.0.1:3306/atguigu","root","mypassword");
String sql="Insert into t_user(account,password,nickname) values(?,?,?);";
//插入數據同時獲取返回主鍵
PreparedStatement preparedStatement = connection.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
preparedStatement.setObject(1,"test1");
preparedStatement.setObject(2,"123456");
preparedStatement.setObject(3,"蛋");
int i=preparedStatement.executeUpdate();
if(i>0){
System.out.println("插入成功");
//獲取主鍵的結果集對象,一行一列,id=值
ResultSet resultSet = preparedStatement.getGeneratedKeys();
resultSet.next();
int id=resultSet.getInt(1);
System.out.println("id="+id);
}else{
System.out.println("插入失敗");
}
preparedStatement.close();
connection.close();
}
}
批量插入
public void returnPrimaryKey2() throws ClassNotFoundException, SQLException {
Class.forName("com.mysql.cj.jdbc.Driver");
// 1.路徑後面添加允許批量操作
Connection connection= DriverManager.
getConnection("jdbc:mysql:///atguigu?rewriteBatchedStatements=true","root","mypassword");
String sql="Insert into t_user(account,password,nickname) values(?,?,?);";
PreparedStatement preparedStatement = connection.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
long start=System.currentTimeMillis();
for (int i = 1; i < 10000; i++) {
preparedStatement.setObject(1,"dd"+i);
preparedStatement.setObject(2,"dd"+i);
preparedStatement.setObject(3,"蛋"+i);
preparedStatement.addBatch();//2. 不執行,追加到values後面,批量添加addBatch
}
preparedStatement.executeBatch();//3. 執行批量操作
long end = System.currentTimeMillis();
preparedStatement.close();
connection.close();
}
資料庫事務
-
允許在失敗情況下,數據回歸到業務之前的狀態!
-
具有原子性(不可切分)、一致性(狀態不變)、隔離性(互不幹擾)、持久性(永久性改變)
-
手動提交
實現目標:實現兩個賬戶之間的安全轉賬,如果一方餘額不足不會出現轉賬錯誤(即一方賬戶增加了另一方沒有減少)
業務表的創建
CREATE TABLE t_bank(
id INT PRIMARY KEY AUTO_INCREMENT,
account VARCHAR(20) NOT NULL UNIQUE COMMENT '賬戶',
money INT UNSIGNED COMMENT '金額,不能為負值'
);
INSERT INTO t_bank(account,money) VALUES
('ergouz1',1000),('lvdandan',1000);
BankService.java(實現業務操作,即轉賬)
public class BankService {
@Test
public void start() throws SQLException, ClassNotFoundException {
transfer("lvdandan","ergouz1",500);
}
public void transfer(String addAccount,String subAccount,int money) throws SQLException, ClassNotFoundException {
Class.forName("com.mysql.cj.jdbc.Driver");
// 1.路徑後面添加允許批量操作
Connection connection= DriverManager.
getConnection("jdbc:mysql:///atguigu","root","mypassword");
BankDao bankDao=new BankDao();
try{
connection.setAutoCommit(false);//關閉自動提交,開啟手動提交
bankDao.add(addAccount,money,connection);
System.out.println("----");
bankDao.sub(subAccount,money,connection);
connection.commit();//事務提交
}catch (Exception e){
connection.rollback();
throw e;
}finally {
connection.close();
}
}
}
BankDao.java(業務實現細節,即賬戶錢增加和減少)
public class BankDao {
public void add(String account,int money,Connection connection) throws ClassNotFoundException, SQLException {
String sql="Update t_bank set money=money+? where account=?;";
PreparedStatement statement = connection.prepareStatement(sql);
statement.setObject(1,money);
statement.setObject(2,account);
statement.executeUpdate();
statement.close();
}
public void sub(String account,int money,Connection connection) throws ClassNotFoundException, SQLException {
String sql="Update t_bank set money=money-? where account=?;";
PreparedStatement statement = connection.prepareStatement(sql);
statement.setObject(1,money);
statement.setObject(2,account);
statement.executeUpdate();
statement.close();
}
}
連接池
- 每次獲取新的連接消耗很大,為了節約創建和銷毀連接的性能消耗
- javax.sql.DataSource介面,規範了連接池獲取連接的方法,規範了連接池回收連接的方法,連接池有多種,但都實現了該介面
- 硬編碼:通過設置參數的方式
- 軟編碼:通過讀取外部配置文件的方式(讀取方法使用了類載入器,補充說明在末尾)
public class DruidUsePart {
//直接使用代碼設置連接池連接參數等方式
@Test
public void testHard() throws SQLException {
DruidDataSource dataSource=new DruidDataSource();
//連接資料庫驅動類的全限定符 註冊驅動
dataSource.setUrl("jdbc:mysql:///atguigu");
dataSource.setUsername("root");
dataSource.setPassword("mypassword");
dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
dataSource.setInitialSize(5);//初始化連接數量
dataSource.setMaxActive(10);//最大的數量
DruidPooledConnection connection = dataSource.getConnection();//獲取連接
//資料庫操作
//
connection.close();
}
//讀取外部配置文件的方法實例化連接對象
public void testSoft() throws Exception {
Properties properties = new Properties();
InputStream ips = DruidUsePart.class.getClassLoader().getResourceAsStream("druid.properties");
properties.load(ips);
DataSource dataSource = DruidDataSourceFactory.createDataSource(properties);
Connection connection = dataSource.getConnection();
//資料庫操作
//
connection.close();
}
}
druid.properties
#key = value => java properties讀取
#druid的key必須固定命名
driverClassName=com.mysql.cj.jdbc.Driver
username=root
password=123456
url=jdbc:mysql://127.0.0.1:3306/atguigu
連接工具類封裝
通過靜態代碼塊的方式保證連接池只被創建一次,而不是每次調用方法都創建一個新的連接池對象
V1.0
public class JdbcUtils {
private static DataSource dataSource = null;//連接池對象
static{
//初始化連接池對象
Properties properties = new Properties();
InputStream is = JdbcUtils.class.getClassLoader().getResourceAsStream("druid.properties");
try {
properties.load(is);
} catch (IOException e) {
throw new RuntimeException(e);
}
try {
dataSource = DruidDataSourceFactory.createDataSource(properties);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public static Connection getConnection() throws SQLException {
return dataSource.getConnection();
}
public static void freeConnection(Connection connection) throws SQLException {
connection.close();//連接池的連接執行回收
}
}
問題:不同方法調用拿到的是不同對象,考慮如何同一個線程不同方法拿到的是同一個連接
V2.0(線程本地量)
利用線程本地變數,存儲連接信息 確保一個線程的多個方法可以獲取同一個connection
-
優勢:事務操作的時候server 和 dao 屬於同一個線程,不用再傳遞參數
-
大家都可以調用getConnection自動獲取的是相同的連接池
private static ThreadLocal<Connection> threadLocal = new ThreadLocal<Connection>();
V2版本代碼
import com.alibaba.druid.pool.DruidDataSourceFactory;
import javax.sql.DataSource;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;
public class JdbcUtilsV2 {
private static DataSource dataSource = null;//連接池對象
private static ThreadLocal<Connection> threadLocal = new ThreadLocal<Connection>();
static{
//初始化連接池對象
Properties properties = new Properties();
InputStream is = JdbcUtilsV2.class.getClassLoader().getResourceAsStream("druid.properties");
try {
properties.load(is);
} catch (IOException e) {
throw new RuntimeException(e);
}
try {
dataSource = DruidDataSourceFactory.createDataSource(properties);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public static Connection getConnection() throws SQLException {
//先查看線程本地變數中是否存在
Connection connection = threadLocal.get();
if(connection == null){
//線程本地變數沒有,連接池獲取
connection = dataSource.getConnection();
threadLocal.set(connection);
}
return dataSource.getConnection();
}
public static void freeConnection() throws SQLException {
Connection connection = threadLocal.get();
if(connection != null){
threadLocal.remove();//清空本地變數數據
connection.setAutoCommit(true);
connection.close();//連接池的連接執行回收
}
}
}
此時的封裝只針對了獲取連接部分,還不夠完善,可以創建一個更加完善的工具類,包括資料庫的增刪改查
完整工具類(修改和查詢)
類代碼
package utils;
import java.lang.reflect.Field;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
/**
* Description:封裝dao層資料庫重覆代碼
* TODO:封裝兩個方法
* 一個簡化非DQL
* 一個簡化DQL(查詢語句)
*/
public class BaseDao {
/**
* 封裝簡化非DQL語句
* @param sql 帶占位符的SQL語句
* @param params 占位符的值 註意:傳入的占位符的值,必須等於SQL語句?位置的值
* @return 執行影響的行數
*/
public int executeUpdate(String sql, Object... params) throws SQLException {//Object...可變參數傳參數形式,在代碼中可以作為數組使用
//獲取連接
Connection connection = JdbcUtilsV2.getConnection();
PreparedStatement preparedStatement = connection.prepareStatement(sql);
//可變參數可當作數組使用
for (int i = 1; i <= params.length; i++) {
preparedStatement.setObject(i+1, params[i-1]);
}
int rows = preparedStatement.executeUpdate();
preparedStatement.close();
//是否回收連接,需要考慮是不是事務,如果不是事務,則直接回收連接
if (connection.getAutoCommit()) {
//true -> 沒有開啟事物,正常回收連接
JdbcUtilsV2.freeConnection();
}
return rows;
}
/**
* 將查結果封裝到一個實體類集合
* @param clazz 要接值的實體類集合的模板對象
* @param sql 查詢語句,要求類名或者別名等於實體類的屬性名 u_id as uId => uId
* @param params 占位符的值 要和 ? 位置對象對應
* @return 查詢的實體類集合
* @param <T> 聲明的結果的泛型
* @throws SQLException
* @throws InstantiationException
* @throws IllegalAccessException
* @throws NoSuchFieldException
*/
//第一個<T>是方法泛型,需要調用時確定
// 第三個T是指使用反射技術賦值
public <T> List<T> executeQuery(Class<T> clazz,String sql,Object... params) throws SQLException, InstantiationException, IllegalAccessException, NoSuchFieldException {
Connection connection = JdbcUtilsV2.getConnection();
PreparedStatement preparedStatement = connection.prepareStatement(sql);
if(params != null && params.length != 0) {
for (int i = 1; i <= params.length; i++) {
preparedStatement.setObject(i,params[i-1]);
}
}
ResultSet resultSet = preparedStatement.executeQuery();
List<T> list = new ArrayList<>();
//獲取列的信息
//TODO:metadata裝的是列的信息(可以獲取列的名稱根據下角標,可以獲取列的數量)
ResultSetMetaData metaData = resultSet.getMetaData();
int columnCount = metaData.getColumnCount();
while (resultSet.next()) {
T t = clazz.newInstance();//調用類的無參構造函數實例化對象
//自動遍歷列 註意:要從1開始,等於總列數
for (int i = 1; i <= columnCount; i++) {
//獲取指定列下角標的值
Object value = resultSet.getObject(i);
//獲取指定列下角標列的名稱
//getColumnLabel: 會獲取別名,如果沒有定義別名,獲取列名 不要使用getColumnName:只會獲取列名
String key = metaData.getColumnLabel(i);
//反射,給對象的屬性值賦值
Field field = clazz.getDeclaredField(key);//獲取屬性key
field.setAccessible(true);//屬性可以設置,打破private限制
field.set(t,value);//給對象賦值(賦值對象,屬性值),如果是靜態屬性,第一個參數可以為null
}
list.add(t);
}
resultSet.close();
preparedStatement.close();
if(connection.getAutoCommit()){
JdbcUtilsV2.freeConnection();
}
return list;
}
}
測試代碼
package utils;
import org.junit.Test;
import java.util.List;
/**
* @create 2024-03-{DAY}-{TIME}
*/
public class JdbcCurdPart extends BaseDao {
@Test
public void testInsert() throws Exception {
/**
* t_user表插入一條數據
* account test
* password test
* nickname 二狗子
*/
String sql = "insert into t_user(account,password,nickname) values(?,?,?)";
int i = executeUpdate(sql, "測試333", "333", "ergouzi");
if (i > 0) {
System.out.println("插入成功");
} else {
System.out.println("插入失敗");
}
}
@Test
public void testUpdate() throws Exception {
String sql = "update t_user set nickname = ? where id = ?;";
executeUpdate(sql, "新的nickname", "4");
}
@Test
public void testDelete() throws Exception {
String sql = "delete from t_user where id = ?;";
executeUpdate(sql, 4);
}
@Test
public void testSelect() throws Exception {
String sql = "select id,account,money from t_bank;";
List<Bank> banks = executeQuery(Bank.class, sql);
for (Bank bank : banks) {
System.out.println(bank);
}
}
@Test
public void testSelect1() throws Exception {
String sql = "select * from t_bank;";
executeQuery(Bank.class,sql);
}
}
class Bank{
int id;
String account;
int money;
}
附加知識
這部分內容用於反射、泛型不熟練的進一步理解代碼
獲取類class對象
目的是執行類的靜態代碼塊
- Class.forName(類名可以不固定)
使用 Class.forName("com.mysql.cj.jdbc.Driver")
語句是為了載入MySQL JDBC驅動程式。在Java中,類的載入是通過類載入器(ClassLoader)來完成的,Class.forName
方法是一種觸發類載入的方式。這種載入方式主要用於載入類的靜態代碼塊。
- 動態載入驅動程式: 使用
Class.forName
允許在運行時根據需要載入特定的驅動程式類。這使得你可以在不修改代碼的情況下,通過配置文件或其他方式動態更改要使用的資料庫驅動。 - 提高靈活性: 通過將驅動程式類名硬編碼在代碼中,你的代碼將直接依賴於特定的資料庫驅動。使用反射可以將驅動程式類的選擇推遲到運行時,使得代碼更加靈活,更容易適應變化。
總之,Class.forName("com.mysql.cj.jdbc.Driver")
的目的是為了載入並註冊MySQL資料庫驅動程式,使用反射的方式允許在運行時動態選擇和載入驅動程式,提高了代碼的靈活性和可配置性。
- 固定類名
類字面常量是在Java中引入的一種語法,用於獲取類的Class
對象。它是在編譯時就被解析的,因此具有更好的類型安全性。類字面常量的語法形式為在類名後面添加.class
。
以下是類字面常量的示例:
javaClass<MyClass> myClass = MyClass.class;
這裡,MyClass.class
表示 MyClass
類的 Class
對象。與使用 Class.forName()
方法不同,類字面常量在編譯時就會受到檢查,如果類名不存在或有語法錯誤,編譯器將會報錯。
這種方式的優點包括:
- 類型安全: 編譯器會在編譯時檢查類名的正確性,避免了在運行時可能出現的 ClassNotFoundException。
- 更簡潔: 語法更加簡潔清晰,不需要字元串形式的類名。
- 更高效: 類字面常量的方式更高效,因為它是在編譯時就進行解析的,不需要在運行時動態載入類。
總體而言,如果在編譯時就知道要載入的類,而且希望代碼更加類型安全,類字面常量是一個更好的選擇。如果類名是在運行時動態確定的,那麼可以考慮使用 Class.forName()
方法。
讀取配置文件
InputStream ips = DruidUsePart.class.getClassLoader().getResourceAsStream("druid.properties");
這行代碼是通過類載入器(ClassLoader)獲取資源文件的輸入流。這種方式通常用於從類路徑中載入配置文件。讓我解釋一下為什麼這樣獲取配置文件是常見的做法:
- 相對路徑的問題: 使用類載入器可以避免相對路徑的問題。當你使用相對路徑載入文件時,具體的相對位置可能會受到調用代碼的影響,可能導致找不到文件。而使用類載入器可以相對於類路徑來查找資源,這樣不受調用位置的具體影響。
- 支持打包為JAR文件: 如果你的應用被打包為JAR文件,直接使用相對路徑可能會導致找不到文件。類載入器能夠在JAR文件中查找資源,並將其作為輸入流返回。
- 類載入器的一致性: 類載入器提供了一種一致的方式來載入資源,無論是從文件系統、網路還是JAR文件中。這樣的一致性可以簡化代碼,並使其在不同環境中都能夠正常工作。
- getResourceAsStream方法:
getResourceAsStream
方法是ClassLoader
類的一個方法,它返回指定資源的輸入流。這使得你可以直接使用輸入流來讀取資源,而不需要關心其具體的物理路徑。
在你的例子中,通過 DruidUsePart.class.getClassLoader().getResourceAsStream("druid.properties")
獲取了名為 "druid.properties" 的配置文件的輸入流。
泛型方法
public <T> List<T> executeQuery(Class<T> clazz, String sql, Object... params)
- 這是一個泛型方法的定義,
<T>
表示該方法是泛型的,返回類型為List<T>
,其中T
是在調用時確定的類型參數。這意味著,調用該方法時,需要提供一個具體的類型,例如Bank.class
,以告訴方法返回什麼類型的對象列表。 Class<T> clazz
:這個參數表示需要執行查詢的對象類型。通過傳入clazz
參數,方法可以瞭解需要構建的對象類型,並使用反射機制來創建對象或者設置對象的屬性。Object... params
:這個參數是可變參數,用於傳遞查詢中需要的參數。
如何通過反射獲取模板類的屬性呢?
Field field = clazz.getDeclaredField(key);//獲取屬性key
field.setAccessible(true);//屬性可以設置,打破private限制
field.set(t,value);//給對象賦值(賦值對象,屬性值),如果是靜態屬性,第一個參數可以為null
Field field = clazz.getDeclaredField(key)
:這行代碼使用了反射技術。clazz.getDeclaredField(key)
用於獲取指定名稱的欄位。在這裡,key
應該是你查詢中的一個列名或者屬性名。field.setAccessible(true)
:這行代碼打破了欄位的封裝性,使得即使欄位是私有的,也可以通過反射來訪問或者修改它的值。field.set(t, value)
:這行代碼將指定對象t
的屬性field
的值設置為value
。這裡的t
是一個對象實例,value
是要設置的值。