JDBC連線mysql
JDBC
JDBC基礎
概念
1. 概念：Java DataBase Connectivity Java 資料庫連線， Java語言運算元據庫
* JDBC本質：其實是官方（sun公司）定義的一套操作所有關係型資料庫的規則，即介面。各個資料庫廠商去實現這套介面，提供資料庫驅動jar包。我們可以使用這套介面（JDBC）程式設計，真正執行的程式碼是驅動jar包中的實現類。
快速入門
2. 快速入門：
* 步驟：
1. 匯入驅動jar包 mysql-connector-java-5.1.37-bin.jar
1.複製mysql-connector-java-5.1.37-bin.jar到專案的libs目錄下
--自己建立libs資料夾，管理
2.右鍵-->Add As Library
2. 註冊驅動
3. 獲取資料庫連線物件 Connection
4. 定義sql
5. 獲取執行sql語句的物件 Statement
6. 執行sql，接受返回結果
7. 處理結果
8. 釋放資源
程式碼實現
package itcase.jdbc;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
public class JdbcDemo1 {
public static void main(String[] args) throws Exception {
//1.匯入啟動jir包
//2.匯入註冊驅動 - 注意：mysql5之後的驅動jar包可以省略註冊驅動的步驟，但還是建議寫上。
Class.forName("com.mysql.jdbc.Driver");
//3.獲取資料庫連線物件
Connection coon = DriverManager.getConnection("jdbc:mysql://localhost:3306/db3", "root", "root");
// 本機可簡寫為
//Connection coon = DriverManager.getConnection("jdbc:mysql:///db3", "root", "root");
//4.定義sql語句
String sql = "update account set balance = 500 where id = 1";
//5.獲取執行sql的物件 Statement
Statement stmt = coon.createStatement();
//6.執行sql
int count = stmt.executeUpdate(sql);
//7.處理結果
System.out.println(count);
//8.釋放資源
stmt.close();
coon.close();
}
}
詳解各個物件
DriverManager：驅動管理物件
1. DriverManager：驅動管理物件
* 功能：
1. 註冊驅動：告訴程式該使用哪一個資料庫驅動jar
static void registerDriver(Driver driver) :註冊與給定的驅動程式 DriverManager 。
寫程式碼使用： Class.forName("com.mysql.jdbc.Driver");
通過檢視原始碼發現：在com.mysql.jdbc.Driver類中存在靜態程式碼塊
static {
try {
java.sql.DriverManager.registerDriver(new Driver()); //真正執行註冊驅動
} catch (SQLException E) {
throw new RuntimeException("Can't register driver!");
}
}
注意：mysql5之後的驅動jar包可以省略註冊驅動的步驟。
2. 獲取資料庫連線：
* 方法：static Connection getConnection(String url, String user, String password)
* 引數：
* url：指定連線的路徑
* 語法：jdbc:mysql://ip地址(域名):埠號/資料庫名稱
* 例子：jdbc:mysql://localhost:3306/db3
* 細節：如果連線的是本機mysql伺服器，並且mysql服務預設埠是3306，則url可以簡寫為：jdbc:mysql:///資料庫名稱
* user：使用者名稱
* password：密碼
Connection：資料庫連線物件
2. Connection：資料庫連線物件
1. 功能：
1. 獲取執行sql 的物件
* Statement createStatement()
* PreparedStatement prepareStatement(String sql)
2. 管理事務：
* 開啟事務：setAutoCommit(boolean autoCommit) ：呼叫該方法設定引數為false，即開啟事務
* 提交事務：commit()
* 回滾事務：rollback()
Statement：執行sql的物件 （靜態sql）
3. Statement：執行sql的物件
1. 執行sql
1. boolean execute(String sql) ：可以執行任意的sql 瞭解
2. int executeUpdate(String sql) ：執行DML（insert、update、delete）語句、DDL(create，alter、drop)語句
* 返回值：影響的行數，可以通過這個影響的行數判斷DML語句是否執行成功 返回值>0的則執行成功，反之，則失敗。
3. ResultSet executeQuery(String sql) ：執行DQL（select)語句
練習
2. 練習：
1. account表 新增一條記錄
2. account表 修改記錄
3. account表 刪除一條記錄
程式碼：
package itcase.jdbc;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
/**
* account表 增刪該語句
*/
public class JdbcDemo2 {
public static void main(String[] args) {
Connection coon = null;
Statement stmt = null;
try {
//1 註冊驅動
Class.forName("com.mysql.jdbc.Driver");
//2.定義mysql
String sql = "insert into account values(null,'王五',3000)"; //插入資料
// String sql = "update account set balance = 1500 where id = 3"; //修改資料
// String sql = "delete from account where id = 3"; //刪除資料
// String sql = "create table student(in int,name varchar(20))"; //建立表
//3.獲取Connection物件
coon = DriverManager.getConnection("jdbc:mysql:///db3", "root", "root");
//4.獲取執行sql的物件 Statement
stmt = coon.createStatement();
//5.執行sql
int count = stmt.executeUpdate(sql); //影響行數
// 6.處理結果
System.out.println(count);
if(count>0){
System.out.println("新增成功");
}else {
System.out.println("新增失敗");
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
// 7.釋放資源
// 避免空指標，判斷stmt是否為空
if(stmt != null){
try {
stmt.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
if(coon!=null){
try {
coon.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
}
}
}
ResultSet：結果集物件,封裝查詢結果
4. ResultSet：結果集物件,封裝查詢結果
* boolean next(): 遊標向下移動一行，判斷當前行是否是最後一行末尾(是否有資料)，如果是，則返回false，如果不是則返回true
* getXxx(引數):獲取資料
* Xxx：代表資料型別 如： int getInt() , String getString()
* 引數：
1. int：代表列的編號,從1開始 如： getString(1)
2. String：代表列名稱。 如： getDouble("balance")
* 注意：
* 使用步驟：
1. 遊標向下移動一行
2. 判斷是否有資料
3. 獲取資料
//迴圈判斷遊標是否是最後一行末尾。
while(rs.next()){
//獲取資料
//6.2 獲取資料
int id = rs.getInt(1);
String name = rs.getString("name");
double balance = rs.getDouble(3);
System.out.println(id + "---" + name + "---" + balance);
}
//程式碼
package itcase.jdbc;
import java.sql.*;
public class JdbcDemo3 {
public static void main(String[] args) {
Connection coon = null;
Statement stmt = null;
ResultSet rs = null;
try {
//1 註冊驅動
Class.forName("com.mysql.jdbc.Driver");
//2.定義mysql
String sql = "select * from account"; //
//3.獲取Connection物件
coon = DriverManager.getConnection("jdbc:mysql:///db3", "root", "root");
//4.獲取執行sql的物件 Statement
stmt = coon.createStatement();
//5.執行sql
rs = stmt.executeQuery(sql);
// 6.處理結果
// 6.1 讓遊標向下移動一行 rs.next();
while (rs.next()) { //迴圈判斷結果集是否有下一行；即遊標是否是最後一行末尾
// 6.2 獲取資料
int id = rs.getInt(1);
String name = rs.getString("name");
double balance = rs.getDouble(3);
System.out.println(id + "-------" + name + "-------" + balance);
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
// 7.釋放資源
// 避免空指標，判斷stmt是否為空
if (rs != null) {
try {
stmt.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
if (stmt != null) {
try {
coon.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
}
}
}
- 練習
- emp表
* 練習：
* 定義一個方法，查詢emp表的資料將其封裝為物件，然後裝載集合，返回。
1. 定義Emp類
2. 定義方法 public List<Emp> findAll(){}
3. 實現方法 select * from emp;
package itcase.jdbc.domain;
import java.util.Date;
/**
* 封裝資料庫Emp表資料的JavaBean
* 欄位名稱可不與資料庫欄位一致；但是資料型別要一致
*/
public class Emp {
private int id;
private String ename;
private int job_id;
private int mgr;
private Date joindate;
private double salary;
private double bonus;
private int dept_id;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getEname() {
return ename;
}
public void setEname(String ename) {
this.ename = ename;
}
public int getJob_id() {
return job_id;
}
public void setJob_id(int job_id) {
this.job_id = job_id;
}
public int getMgr() {
return mgr;
}
public void setMgr(int mgr) {
this.mgr = mgr;
}
public Date getJoindate() {
return joindate;
}
public void setJoindate(Date joindate) {
this.joindate = joindate;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
public double getBonus() {
return bonus;
}
public void setBonus(double bonus) {
this.bonus = bonus;
}
public int getDept_id() {
return dept_id;
}
public void setDept_id(int dept_id) {
this.dept_id = dept_id;
}
@Override
public String toString() {
return "Emp{" +
"id=" + id +
", ename='" + ename + '\'' +
", job_id=" + job_id +
", mgr=" + mgr +
", joindate=" + joindate +
", salary=" + salary +
", bonus=" + bonus +
", dept_id=" + dept_id +
'}';
}
}
package itcase.jdbc.domain;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
/**
* * 定義一個方法，查詢emp表的資料將其封裝為物件，然後裝載集合，返回。
* 1. 定義Emp類
* 2. 定義方法 public List<Emp> findAll(){}
* 3. 實現方法 select * from emp;
*/
public class JDBCDemo {
public static void main(String[] args) {
List<Emp> list = new JDBCDemo().findAll();
for (Emp emp : list) {
System.out.println(emp);
}
// System.out.println(list);
System.out.println(list.size());
}
// 查詢所有emp物件
public List<Emp> findAll(){
ResultSet rs = null;
Statement stmt = null;
Connection coon = null;
List<Emp> list = null;
try {
// 1.註冊驅動 ;加了，可以向下相容
Class.forName("com.mysql.jdbc.Driver");
// 2 獲取資料庫連線物件
coon = DriverManager.getConnection("jdbc:mysql:///db3", "root", "root");
// 3 定義sql
String sql = "select * from emp";
// 4 獲取執行sql語句的物件
stmt = coon.createStatement();
// 5 執行sql
rs = stmt.executeQuery(sql);
Emp emp = null;
list = new ArrayList<Emp>();
while(rs.next()){
//獲取資料 注意：名稱是與資料庫名稱一致
int id = rs.getInt("id");
String ename = rs.getString("ename");
int job_id = rs.getInt("job_id");
int mgr = rs.getInt("mgr");
Date joindate = rs.getDate("joindate");
double salary = rs.getDouble("salary");
double bonus = rs.getDouble("bonus");
int dept_id = rs.getInt("dept_id");
//建立emp物件,並賦值
emp = new Emp();
emp.setId(id);
emp.setEname(ename);
emp.setJob_id(job_id);
emp.setMgr(mgr);
emp.setJoindate(joindate);
emp.setSalary(salary);
emp.setBonus(bonus);
emp.setDept_id(dept_id);
//裝載集合
list.add(emp);
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException throwables) {
throwables.printStackTrace();
}finally {
if(rs !=null){
try {
rs.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
if(stmt !=null){
try {
stmt.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
if(coon !=null){
try {
coon.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
}
return list;
}
}
//執行結果---------------
Emp{id=1001, ename='孫悟空', job_id=4, mgr=1004, joindate=2000-12-17, salary=8000.0, bonus=0.0, dept_id=20}
Emp{id=1002, ename='盧俊義', job_id=3, mgr=1006, joindate=2001-02-20, salary=16000.0, bonus=3000.0, dept_id=30}
Emp{id=1003, ename='林沖', job_id=3, mgr=1006, joindate=2001-02-22, salary=12500.0, bonus=5000.0, dept_id=30}
Emp{id=1004, ename='唐僧', job_id=2, mgr=1009, joindate=2001-04-02, salary=29750.0, bonus=0.0, dept_id=20}
Emp{id=1005, ename='李逵', job_id=4, mgr=1006, joindate=2001-09-28, salary=12500.0, bonus=14000.0, dept_id=30}
Emp{id=1006, ename='宋江', job_id=2, mgr=1009, joindate=2001-05-01, salary=28500.0, bonus=0.0, dept_id=30}
Emp{id=1007, ename='劉備', job_id=2, mgr=1009, joindate=2001-09-01, salary=24500.0, bonus=0.0, dept_id=10}
Emp{id=1008, ename='豬八戒', job_id=4, mgr=1004, joindate=2007-04-19, salary=30000.0, bonus=0.0, dept_id=20}
Emp{id=1009, ename='羅貫中', job_id=1, mgr=0, joindate=2001-11-17, salary=50000.0, bonus=0.0, dept_id=10}
Emp{id=1010, ename='吳用', job_id=3, mgr=1006, joindate=2001-09-08, salary=15000.0, bonus=0.0, dept_id=30}
Emp{id=1011, ename='沙僧', job_id=4, mgr=1004, joindate=2007-05-23, salary=11000.0, bonus=0.0, dept_id=20}
Emp{id=1012, ename='李逵', job_id=4, mgr=1006, joindate=2001-12-03, salary=9500.0, bonus=0.0, dept_id=30}
Emp{id=1013, ename='小白龍', job_id=4, mgr=1004, joindate=2001-12-03, salary=30000.0, bonus=0.0, dept_id=20}
Emp{id=1014, ename='關羽', job_id=4, mgr=1007, joindate=2002-01-23, salary=13000.0, bonus=0.0, dept_id=10}
14
PreparedStatement：執行sql的物件
5. PreparedStatement：執行sql的物件
1. SQL隱碼攻擊問題：在拼接sql時，有一些sql的特殊關鍵字參與字串的拼接。會造成安全性問題
1. 輸入使用者隨便，輸入密碼：a' or 'a' = 'a
2. sql：select * from user where username = 'fhdsjkf' and password = 'a' or 'a' = 'a'
2. 解決sql注入問題：使用PreparedStatement物件來解決
3. 預編譯的SQL：引數使用?作為佔位符
4. 步驟：
1. 匯入驅動jar包 mysql-connector-java-5.1.37-bin.jar
2. 註冊驅動
3. 獲取資料庫連線物件 Connection
4. 定義sql
* 注意：sql的引數使用？作為佔位符。 如：select * from user where username = ? and password = ?;
5. 獲取執行sql語句的物件 PreparedStatement Connection.prepareStatement(String sql)
6. 給？賦值：
* 方法： setXxx(引數1,引數2)
* 引數1：？的位置編號 從1 開始
* 引數2：？的值
7. 執行sql，接受返回結果，不需要傳遞sql語句
8. 處理結果
9. 釋放資源
5. 注意：後期都會使用PreparedStatement來完成增刪改查的所有操作
1. 可以防止SQL隱碼攻擊
2. 效率更高
抽取JDBC工具類
JDBCUtils
* 目的：簡化書寫
* 分析：
1. 註冊驅動也抽取
2. 抽取一個方法獲取連線物件
* 需求：不想傳遞引數（麻煩），還得保證工具類的通用性。
* 解決：配置檔案
jdbc.properties
url=
user=
password=
3. 抽取一個方法釋放資源
程式碼實現
jdbc.properties --src下配置檔案
JDBCUtils — 封裝的JDBC工具類
JDBCDemoUtils – JDBC測試類，註釋的程式碼即使用JDBC工具類替換的程式碼
jdbc.properties
url=jdbc:mysql:///db3
user=root
password=root
driver=com.mysql.jdbc.Driver
JDBCUtils
package itcase.jdbc.util;
import java.io.FileReader;
import java.io.IOException;
import java.net.URL;
import java.sql.*;
import java.util.Properties;
/**
* JDBC工具類
*/
public class JDBCUtils {
private static String url;
private static String user;
private static String password;
private static String driver;
/**
* 檔案的讀取,只需要讀取一次即可拿到這些值。使用靜態程式碼塊
* jdbc.properties
*/
static {
//讀取資原始檔，獲取值
try {
//1.建立Properties集合類
Properties pro = new Properties();
// 獲取src路徑下檔案的方式 --》ClassLoader類
ClassLoader classLoader = JDBCUtils.class.getClassLoader();
URL res = classLoader.getResource("jdbc.properties");
String path = res.getPath();
// System.out.println(path);
//2.載入檔案 jdbc.properties
pro.load(new FileReader(path));
//3 獲取資料，賦值
url =pro.getProperty("url");
user =pro.getProperty("user");
password =pro.getProperty("password");
driver =pro.getProperty("driver");
//4 註冊驅動
Class.forName(driver);
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
/**
* 獲取連線
* @return 連線物件
*/
public static Connection getConnection() throws SQLException {
return DriverManager.getConnection(url,user,password);
}
/**
* 釋放資源
* @param rs
* @param stmt
* @param coon
*/
public static void close(ResultSet rs,Statement stmt, Connection coon){
if(rs != null){
try {
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(stmt != null){
try {
stmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(coon != null){
try {
coon.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
JDBCDemoUtils
package itcase.jdbc.domain;
import itcase.jdbc.util.JDBCUtils;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
/**
* * 定義一個方法，查詢emp表的資料將其封裝為物件，然後裝載集合，返回。
* 1. 定義Emp類
* 2. 定義方法 public List<Emp> findAll(){}
* 3. 實現方法 select * from emp;
*/
public class JDBCDemoUtils {
public static void main(String[] args) {
List<Emp> list = new JDBCDemoUtils().findAll2();
for (Emp emp : list) {
System.out.println(emp);
}
// System.out.println(list);
System.out.println(list.size());
}
// 查詢所有emp物件
public List<Emp> findAll2(){
ResultSet rs = null;
Statement stmt = null;
Connection coon = null;
List<Emp> list = null;
try {
// // 1.註冊驅動 ;加了，可以向下相容
// Class.forName("com.mysql.jdbc.Driver");
//
// // 2 獲取資料庫連線物件
// coon = DriverManager.getConnection("jdbc:mysql:///db3", "root", "root");
coon = JDBCUtils.getConnection();
// 3 定義sql
String sql = "select * from emp";
// 4 獲取執行sql語句的物件
stmt = coon.createStatement();
// 5 執行sql
rs = stmt.executeQuery(sql);
Emp emp = null;
list = new ArrayList<Emp>();
while(rs.next()){
//獲取資料 注意：名稱是與資料庫名稱一致
int id = rs.getInt("id");
String ename = rs.getString("ename");
int job_id = rs.getInt("job_id");
int mgr = rs.getInt("mgr");
Date joindate = rs.getDate("joindate");
double salary = rs.getDouble("salary");
double bonus = rs.getDouble("bonus");
int dept_id = rs.getInt("dept_id");
//建立emp物件,並賦值
emp = new Emp();
emp.setId(id);
emp.setEname(ename);
emp.setJob_id(job_id);
emp.setMgr(mgr);
emp.setJoindate(joindate);
emp.setSalary(salary);
emp.setBonus(bonus);
emp.setDept_id(dept_id);
//裝載集合
list.add(emp);
}
} catch (SQLException throwables) {
throwables.printStackTrace();
}finally {
/*
if(rs !=null){
try {
rs.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
if(stmt !=null){
try {
stmt.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
if(coon !=null){
try {
coon.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
*/
JDBCUtils.close(rs,stmt,coon);
}
return list;
}
}
練習
* 練習：
* 需求：
1. 通過鍵盤錄入使用者名稱和密碼
2. 判斷使用者是否登入成功
* select * from user where username = "" and password = "";
* 如果這個sql有查詢結果，則成功，反之，則失敗
資料庫建立表及資料 – 資料庫為db4
CREATE TABLE USER(
id INT PRIMARY KEY auto_increment,
username VARCHAR(32),
password VARCHAR(32)
);
INSERT INTO USER VALUES(NULL,'zhangsan','123')
INSERT INTO USER VALUES(NULL,'lisi','456')
SELECT * FROM USER
程式碼 – login2為最終改進的程式碼
package itcase.jdbc;
import itcase.jdbc.util.JDBCUtils;
import java.sql.*;
import java.util.Scanner;
/**
* * 需求：
* 1. 通過鍵盤錄入使用者名稱和密碼
* 2. 判斷使用者是否登入成功
* * select * from user where username = "" and password = "";
* * 如果這個sql有查詢結果，則成功，反之，則失敗
*/
public class JdbcDemo4 {
public static void main(String[] args) {
// 1 鍵盤錄入使用者名稱和密碼
Scanner sc = new Scanner(System.in);
System.out.println("請輸入使用者名稱：");
String username = sc.nextLine();
System.out.println("請輸入密碼：");
String password = sc.nextLine();
// 2 呼叫方法
boolean flag = new JdbcDemo4().login(username, password);
// 3.判斷結果，輸出不同語句
if (flag) {
System.out.println("登陸成功！");
} else {
System.out.println("使用者名稱或密碼錯誤！");
}
}
/**
* 登入方法 -- or "1=1" 最終為true sql注入
* @param username
* @param password
* @return
*/
public boolean login(String username, String password) {
if (username == null || password == null) {
return false;
}
//連線資料庫，判斷是否成功
Connection coon = null;
Statement stmt = null;
ResultSet rs = null;
try {
// 1 獲取連線
coon = JDBCUtils.getConnection();
// 2 定義sql
String sql = "select * from user where username = '" + username + "' and password = '" + password + "' ";
// 3 獲取sql執行物件
stmt = coon.createStatement();
// 4 執行sql
rs = stmt.executeQuery(sql);
// 5 判斷
/*
if(rs.next()){ //如果有下一行，則返回true
return true;
}else {
return false;
}
*/
return rs.next();
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
JDBCUtils.close(rs, stmt, coon);
}
return false;
}
/**
* 登入方法，使用PreparedStatement方法
* @param username
* @param password
* @return
*/
public boolean login2(String username, String password) {
if (username == null || password == null) {
return false;
}
//連線資料庫，判斷是否成功
Connection coon = null;
// Statement stmt = null;
PreparedStatement pstmt = null;
ResultSet rs = null;
try {
// 1 獲取連線
coon = JDBCUtils.getConnection();
// 2 定義sql
// String sql = "select * from user where username = '" + username + "' and password = '" + password + "' ";
String sql = "select * from user where username = ? and password = ? ";
// 3 獲取sql執行物件
// stmt = coon.createStatement();
pstmt = coon.prepareStatement(sql);
//給?號賦值
pstmt.setString(1,username);
pstmt.setString(2,password);
// 4 執行sql
rs = pstmt.executeQuery(); //不用傳參
// rs = stmt.executeQuery(sql);
// 5 判斷
return rs.next();
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
JDBCUtils.close(rs, pstmt, coon);
}
return false;
}
}
JDBC控制事務
1. 事務：一個包含多個步驟的業務操作。如果這個業務操作被事務管理，則這多個步驟要麼同時成功，要麼同時失敗。
2. 操作：
1. 開啟事務
2. 提交事務
3. 回滾事務
3. 使用Connection物件來管理事務
* 開啟事務：setAutoCommit(boolean autoCommit) ：呼叫該方法設定引數為false，即開啟事務
* 在執行sql之前開啟事務
* 提交事務：commit()
* 當所有sql都執行完提交事務
* 回滾事務：rollback()
* 在catch中回滾事務
package itcase;
import itcase.jdbc.util.JDBCUtils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
/**
* 事務操作
* --資料庫為 db3
*/
public class JdbcDemo5 {
public static void main(String[] args) {
Connection conn = null;
PreparedStatement pstmt1 = null;
PreparedStatement pstmt2 = null;
try {
// 1 獲取連線
conn = JDBCUtils.getConnection();
//開啟事務 *
conn.setAutoCommit(false);
// 2 定義sql
// 2.1 張三 -500
String sql1 = "update account set balance = balance - ? where id = ?";
// 2.2 李四 +500
String sql2 = "update account set balance = balance + ? where id = ?";
// 3.獲取執行sql物件
pstmt1 = conn.prepareStatement(sql1);
pstmt2 = conn.prepareStatement(sql2);
// 4.設定引數
pstmt1.setDouble(1, 500);
pstmt1.setDouble(2, 1);
pstmt2.setDouble(1, 500);
pstmt2.setDouble(2, 2);
// 5 執行sql
pstmt1.executeUpdate();
pstmt2.executeUpdate();
// 手動製造異常 !!
int i = 3/0;
// 提交事務 *
conn.commit();
} catch (Exception e) {
//事務回滾 *
try {
if (conn != null) {
conn.rollback();
}
} catch (SQLException e1) {
e1.printStackTrace();
}
e.printStackTrace();
} finally {
JDBCUtils.close(null, pstmt1, conn);
JDBCUtils.close(null, pstmt1, conn);
}
}
}
資料庫連線池
1. 概念：其實就是一個容器(集合)，存放資料庫連線的容器。
當系統初始化好後，容器被建立，容器中會申請一些連線物件，當使用者來訪問資料庫時，從容器中獲取連線物件，使用者訪問完之後，會將連線物件歸還給容器。
2. 好處：
1. 節約資源
2. 使用者訪問高效
3. 實現：
1. 標準介面：DataSource javax.sql包下的
1. 方法：
* 獲取連線：getConnection()
* 歸還連線：Connection.close()。如果連線物件Connection是從連線池中獲取的，那麼呼叫Connection.close()方法，則不會再關閉連線了。而是歸還連線
2. 一般我們不去實現它，有資料庫廠商來實現
1. C3P0：資料庫連線池技術
2. Druid：資料庫連線池實現技術，由阿里巴巴提供的
C3P0
4. C3P0：資料庫連線池技術
* 步驟：
1. 匯入jar包 (兩個) c3p0-0.9.5.2.jar mchange-commons-java-0.2.12.jar ，
* 不要忘記匯入資料庫驅動jar包
2. 定義配置檔案：
* 名稱： c3p0.properties 或者 c3p0-config.xml
* 路徑：直接將檔案放在src目錄下即可。
3. 建立核心物件 資料庫連線池物件 ComboPooledDataSource
4. 獲取連線： getConnection
* 程式碼：
//1.建立資料庫連線池物件
DataSource ds = new ComboPooledDataSource();
//2. 獲取連線物件
Connection conn = ds.getConnection();
- 程式碼實現
package itcase.datasource.c3p0;
import com.mchange.v2.c3p0.ComboPooledDataSource;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;
/**
* c3p0基礎使用
*/
public class C3P0Demo1 {
public static void main(String[] args) throws SQLException {
//1 建立資料庫連線池物件
DataSource ds = new ComboPooledDataSource();
//2 獲取連線物件
Connection coon = ds.getConnection();
//3 列印
System.out.println(coon);
}
}
//-----------------------
12月 20, 2020 9:14:31 下午 com.mchange.v2.log.MLog
資訊: MLog clients using java 1.4+ standard logging.
12月 20, 2020 9:14:32 下午 com.mchange.v2.c3p0.C3P0Registry
資訊: Initializing c3p0-0.9.5.2 [built 08-December-2015 22:06:04 -0800; debug? true; trace: 10]
12月 20, 2020 9:14:32 下午 com.mchange.v2.c3p0.impl.AbstractPoolBackedDataSource
資訊: Initializing c3p0 pool... com.mchange.v2.c3p0.ComboPooledDataSource [ acquireIncrement -> 3, acquireRetryAttempts -> 30, acquireRetryDelay -> 1000, autoCommitOnClose -> false, automaticTestTable -> null, breakAfterAcquireFailure -> false, checkoutTimeout -> 3000, connectionCustomizerClassName -> null, connectionTesterClassName -> com.mchange.v2.c3p0.impl.DefaultConnectionTester, contextClassLoaderSource -> caller, dataSourceName -> 1hge0ytaezlfbtj1r8egmx|2357d90a, debugUnreturnedConnectionStackTraces -> false, description -> null, driverClass -> com.mysql.jdbc.Driver, extensions -> {}, factoryClassLocation -> null, forceIgnoreUnresolvedTransactions -> false, forceSynchronousCheckins -> false, forceUseNamedDriverClass -> false, identityToken -> 1hge0ytaezlfbtj1r8egmx|2357d90a, idleConnectionTestPeriod -> 0, initialPoolSize -> 5, jdbcUrl -> jdbc:mysql://localhost:3306/db3, maxAdministrativeTaskTime -> 0, maxConnectionAge -> 0, maxIdleTime -> 0, maxIdleTimeExcessConnections -> 0, maxPoolSize -> 10, maxStatements -> 0, maxStatementsPerConnection -> 0, minPoolSize -> 3, numHelperThreads -> 3, preferredTestQuery -> null, privilegeSpawnedThreads -> false, properties -> {password=******, user=******}, propertyCycle -> 0, statementCacheNumDeferredCloseThreads -> 0, testConnectionOnCheckin -> false, testConnectionOnCheckout -> false, unreturnedConnectionTimeout -> 0, userOverrides -> {}, usesTraditionalReflectiveProxies -> false ]
com.mchange.v2.c3p0.impl.NewProxyConnection@6a84a97d [wrapping: com.mysql.jdbc.JDBC4Connection@6c130c45]
- 配置檔案的最大連線數
package itcase.datasource.c3p0;
import com.mchange.v2.c3p0.ComboPooledDataSource;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;
public class C3P0Demo2 {
public static void main(String[] args) throws SQLException {
// //1 建立資料庫連線池物件；DataSource ，使用預設配置
// DataSource ds = new ComboPooledDataSource();
//
// // 2 獲取連線物件 (超過10個會報錯，但可設定歸還，在範圍內就不會報錯)
// for (int i = 1; i <= 11; i++) { // 02 最大11連線，超過；但將第5個使用後進行歸還；沒有超過，不會報錯
// Connection coon = ds.getConnection();
// System.out.println(i + ":" + coon);
//
// if(i==5){
// coon.close(); // 01 歸還連線到連線池中
// }
// }
testNameConfig();
}
/**
*使用指定名稱配置 otherc3p0
* 最大8連線數，超過會報錯
* @throws SQLException
*/
public static void testNameConfig() throws SQLException {
//1 建立資料庫連線池物件；DataSource ，使用指定名稱配置
DataSource ds = new ComboPooledDataSource("otherc3p0");
// 2 獲取連線物件 (超過10個會報錯)
for (int i = 1; i <= 11; i++) {
Connection coon = ds.getConnection();
System.out.println(i + ":" + coon);
}
}
}
Druid
5. Druid：資料庫連線池實現技術，由阿里巴巴提供的
1. 步驟：
1. 匯入jar包 druid-1.0.9.jar
2. 定義配置檔案：
* 是properties形式的
* 可以叫任意名稱，可以放在任意目錄下
3. 載入配置檔案。Properties
4. 獲取資料庫連線池物件：通過工廠來來獲取 DruidDataSourceFactory
5. 獲取連線：getConnection
* 程式碼：
//3.載入配置檔案
Properties pro = new Properties();
InputStream is = DruidDemo.class.getClassLoader().getResourceAsStream("druid.properties");
pro.load(is);
//4.獲取連線池物件
DataSource ds = DruidDataSourceFactory.createDataSource(pro);
//5.獲取連線
Connection conn = ds.getConnection();
2. 定義工具類
1. 定義一個類 JDBCUtils
2. 提供靜態程式碼塊載入配置檔案，初始化連線池物件
3. 提供方法
1. 獲取連線方法：通過資料庫連線池獲取連線
2. 釋放資源
3. 獲取連線池的方法
- 演示程式碼
package itcase.datasource.druid;
import com.alibaba.druid.pool.DruidDataSourceFactory;
import javax.sql.DataSource;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.util.Properties;
/**
* Druid演示
*/
public class DruidDemo {
public static void main(String[] args) throws Exception {
//載入配置檔案
Properties pro = new Properties();
InputStream is = DruidDemo.class.getClassLoader().getResourceAsStream("druid.properties");
pro.load(is);
// 獲取連線池物件
DataSource ds = DruidDataSourceFactory.createDataSource(pro);
// 5 獲取連線
Connection coon = ds.getConnection();
System.out.println(coon);
}
}
//-----------------------
12月 20, 2020 10:12:59 下午 com.alibaba.druid.pool.DruidDataSource info
資訊: {dataSource-1} inited
com.mysql.jdbc.JDBC4Connection@752325ad
- Druid連線池的工具類
package itcase.datasource.utils;
import com.alibaba.druid.pool.DruidDataSourceFactory;
import javax.sql.DataSource;
import java.io.IOException;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;
/**
* Druid連線池的工具類
*/
public class JDBCUtils {
//定義成員變數
private static DataSource ds;
static {
try {
// 1 載入配置檔案
Properties pro = new Properties();
pro.load(JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties"));
// 2 獲取DataSource
ds = DruidDataSourceFactory.createDataSource(pro);
} catch (IOException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 獲取資源
* @return
* @throws SQLException
*/
public static Connection getConnection() throws SQLException {
return ds.getConnection();
}
/**
* 釋放資源
* @param stmt
* @param coon
*/
public static void close(Statement stmt,Connection coon){
/*
if(stmt != null){
try {
stmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(coon != null){
try {
stmt.close(); //歸還連線
} catch (SQLException e) {
e.printStackTrace();
}
}
*/
close(null,stmt,coon); //直接呼叫下面的方法
}
/**
* 釋放資源
* @param stmt
* @param coon
*/
public static void close(ResultSet rs , Statement stmt, Connection coon){
if(rs != null){
try {
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(stmt != null){
try {
stmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(coon != null){
try {
stmt.close(); //歸還連線
} catch (SQLException e) {
e.printStackTrace();
}
}
}
/**
* 獲取連線池方法
* @return
*/
public static DataSource getDataSource(){
return ds;
}
}
- Druid連線池的測試類
package itcase.datasource.druid;
import itcase.datasource.utils.JDBCUtils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
/**
* 使用 Druid連線池的工具類
*/
public class DruidDemo2 {
public static void main(String[] args) {
//
Connection coon = null;
PreparedStatement pstmt = null;
try {
//1 獲取連線
coon = JDBCUtils.getConnection();
// 2 定義sql
String sql = "insert into account values(null,?,?)";
// 3 獲取pstmt物件
pstmt = coon.prepareStatement(sql);
// 4 給？賦值
pstmt.setString(1,"趙六");
pstmt.setDouble(2,300);
// 5 執行sql
int count = pstmt.executeUpdate();
System.out.println(count);
} catch (SQLException throwables) {
throwables.printStackTrace();
}finally {
// 6 釋放資源
JDBCUtils.close(pstmt,coon);
}
}
}
//----------------------------
12月 20, 2020 10:58:58 下午 com.alibaba.druid.pool.DruidDataSource info
資訊: {dataSource-1} inited
1
Spring JDBC–JDBCTemplate
* Spring框架對JDBC的簡單封裝。提供了一個JDBCTemplate物件簡化JDBC的開發
* 步驟：
1. 匯入jar包
2. 建立JdbcTemplate物件。依賴於資料來源DataSource
* JdbcTemplate template = new JdbcTemplate(ds);
3. 呼叫JdbcTemplate的方法來完成CRUD的操作
* update():執行DML語句。增、刪、改語句
* queryForMap():查詢結果將結果集封裝為map集合，將列名作為key，將值作為value 將這條記錄封裝為一個map集合
* 注意：這個方法查詢的結果集長度只能是1
* queryForList():查詢結果將結果集封裝為list集合
* 注意：將每一條記錄封裝為一個Map集合，再將Map集合裝載到List集合中
* query():查詢結果，將結果封裝為JavaBean物件
* query的引數：RowMapper
* 一般我們使用BeanPropertyRowMapper實現類。可以完成資料到JavaBean的自動封裝
* new BeanPropertyRowMapper<型別>(型別.class)
* queryForObject：查詢結果，將結果封裝為物件
* 一般用於聚合函式的查詢
- 基礎使用
package itcase.jdbctemplate;
import itcase.datasource.utils.JDBCUtils;
import org.springframework.jdbc.core.JdbcTemplate;
public class JdbcTemplateDemo1 {
public static void main(String[] args) {
// 建立 JdbcTemplate 物件 JDBCUtils ———》Druid連線池的工具類
JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
//3 呼叫方法 -- 獲取物件，釋放資源等操作 JdbcTemplate已完成
String sql = "update account set balance = 5000 where id = ?";
int count = template.update(sql, 3);
System.out.println(count);
}
}
- 詳細使用
package itcase.jdbctemplate.domian;
import itcase.datasource.utils.JDBCUtils;
import org.junit.Test;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import java.sql.Date;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;
/**
* * 需求：
* 1. 修改1號資料的 salary 為 10000
* 2. 新增一條記錄
* 3. 刪除剛才新增的記錄
* 4. 查詢id為1的記錄，將其封裝為Map集合
* 5. 查詢所有記錄，將其封裝為List
* 6. 查詢所有記錄，將其封裝為Emp物件的List集合
* 7. 查詢總記錄數
*/
public class JdbcTemplateDemo {
//Junit單元測試,可以讓方法獨立執行
// 1 .獲取JDBCT JDBCUtils --> Druid連線池的工具類
private JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
/**
* 1. 修改1號資料的 salary 為 10000
*/
@Test
public void test1() {
// 2 定義sql
String sql = "update emp set salary = 10000 where id = 10001";
// 3執行sql
int count = template.update(sql);
}
/**
* 新增一條記錄
*/
@Test
public void test2() {
// 2 定義sql
String sql = "insert into emp(id,ename,dept_id) value(?,?,?)";
// 3執行sql
int count = template.update(sql, 1015, "郭靖", 10);
}
/**
* 刪除一條記錄
*/
@Test
public void test3() {
// 2 定義sql
String sql = "delect from emp where id = ?";
// 3執行sql
int count = template.update(sql, 1015);
}
/**
* 查詢id為1的記錄，將其封裝為Map集合
* 注意：這個方法查詢的結果集長度只能是1 （列名為key，值為value）
*/
@Test
public void test4() {
// 2 定義sql
String sql = "select * from emp where id =?";
// 3執行sql
Map<String, Object> map = template.queryForMap(sql, 1001);
System.out.println(map);
//{id=1005, ename=李逵, job_id=4, mgr=1006, joindate=2001-09-28, salary=12500.00, bonus=14000.00, dept_id=30}
}
/**
* 查詢所有記錄，將其封裝為List
* 注意：將每一條記錄封裝為一個Map集合，再將Map集合裝載到List集合中
*/
@Test
public void test5() {
// 2 定義sql
String sql = "select * from emp";
// 3執行sql
List<Map<String, Object>> list = template.queryForList(sql);
System.out.println(list);
}
/**
* 查詢所有記錄，將其封裝為Emp物件的List集合
* 注意：將每一條記錄封裝為一個Map集合，再將Map集合裝載到List集合中
*/
@Test
public void test6() {
// 2 定義sql
String sql = "select * from emp";
// 3執行sql
List<Emp> list = template.query(sql, new RowMapper<Emp>() {
@Override
public Emp mapRow(ResultSet rs, int i) throws SQLException {
Emp emp = new Emp();
int id = rs.getInt("id");
String ename = rs.getString("ename");
int job_id = rs.getInt("job_id");
int mgr = rs.getInt("mgr");
Date joindate = rs.getDate("joindate");
double salary = rs.getDouble("salary");
double bonus = rs.getDouble("bonus");
int dept_id = rs.getInt("dept_id");
emp.setId(id);
emp.setEname(ename);
emp.setJob_id(job_id);
emp.setMgr(mgr);
emp.setJoindate(joindate);
emp.setSalary(salary);
emp.setBonus(bonus);
emp.setDept_id(dept_id);
return emp;
}
});
for (Emp emp : list) {
System.out.println(emp);
}
}
/**
* 查詢所有記錄，將其封裝為Emp物件的List集合
* 注意：將每一條記錄封裝為一個Map集合，再將Map集合裝載到List集合中
*/
@Test
public void test66() {
// 2 定義sql
String sql = "select * from emp";
// 3執行sql
List<Emp> list = template.query(sql, new BeanPropertyRowMapper<Emp>(Emp.class));
for (Emp emp : list) {
System.out.println(emp);
}
/*
報錯：注意Emp中的資料型別改成基本封裝資料型別
org.springframework.beans.TypeMismatchException: Failed to convert property value of type 'null' to required type 'double' for property 'bonus'; nested exception is org.springframework.core.convert.ConversionFailedException: Failed to convert from type [null] to type [double] for value 'null'; nested exception is java.lang.IllegalArgumentException: A null value cannot be assigned to a primitive type
*/
}
/**
* 查詢總記錄數
*/
@Test
public void test7() {
// 2 定義sql
String sql = "select count(id) from emp";
// 3執行sql
Long total = template.queryForObject(sql, Long.class);
System.out.println(total);
}
}
package itcase.jdbctemplate.domian;
import java.util.Date;
/**
* 封裝資料庫Emp表資料的JavaBean
* 欄位名稱可不與資料庫欄位一致；但是資料型別要一致
*/
public class Emp {
private Integer id;
private String ename;
private Integer job_id;
private Integer mgr;
private Date joindate;
private Double salary;
private Double bonus;
private Integer dept_id;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getEname() {
return ename;
}
public void setEname(String ename) {
this.ename = ename;
}
public Integer getJob_id() {
return job_id;
}
public void setJob_id(Integer job_id) {
this.job_id = job_id;
}
public Integer getMgr() {
return mgr;
}
public void setMgr(Integer mgr) {
this.mgr = mgr;
}
public Date getJoindate() {
return joindate;
}
public void setJoindate(Date joindate) {
this.joindate = joindate;
}
public Double getSalary() {
return salary;
}
public void setSalary(Double salary) {
this.salary = salary;
}
public Double getBonus() {
return bonus;
}
public void setBonus(Double bonus) {
this.bonus = bonus;
}
public Integer getDept_id() {
return dept_id;
}
public void setDept_id(Integer dept_id) {
this.dept_id = dept_id;
}
@Override
public String toString() {
return "Emp{" +
"id=" + id +
", ename='" + ename + '\'' +
", job_id=" + job_id +
", mgr=" + mgr +
", joindate=" + joindate +
", salary=" + salary +
", bonus=" + bonus +
", dept_id=" + dept_id +
'}';
}
}
相關文章
- Java JDBC連線MYsqlJavaJDBCMySql
- mysql的jdbc連線java實現MySqlJDBCJava
- JDBC連線MySQL8.0.13的記錄JDBCMySql
- 關於Spring的JDBC連線mysql（與傳統jdbc比較）SpringJDBCMySql
- MySQL 8.x 新版本JDBC連線方式MySqlJDBC
- JDBC 連線詳解JDBC
- JDBC連線mysql-8.0實現增刪改查JDBCMySql
- JDBC連線MySQL資料庫的方法和例項JDBCMySql資料庫
- 什麼是 MySQL JDBC 連線池中最高效的連線檢測語句？MySqlJDBC
- Tomcat 的 JDBC 連線池TomcatJDBC
- JDBC連線資料庫JDBC資料庫
- MySQL下載安裝配置及JDBC連線資料庫MySqlJDBC資料庫
- mysql的JDBC架包下載及簡單測試連線MySqlJDBC
- Java的JDBC通過SSH Tunnel連線MySQL資料庫JavaJDBCMySql資料庫
- 連線zk 報錯連線不上hbase jdbcJDBC
- spring 簡單的使用 Hikari連線池 和 jdbc連線mysql 的一個簡單例子SpringJDBCMySql單例
- 【JDBC】java連線池模擬測試 連線oracleJDBCJavaOracle
- 【JDBC】使用OracleDataSource建立連線池用於連線OracleJDBCOracle
- [轉載] 1.1Java使用JDBC原生方式連線MySql資料庫JavaJDBCMySql資料庫
- jdbc連線elasticsearch6.3.0demo展示JDBCElasticsearch
- JDBC之連線sqlserver資料庫JDBCSQLServer資料庫
- 解決Mybatis連線Sql server 出現 Cannot load JDBC driver class 'com.mysql.jdbc.Driver '的問題MyBatisServerJDBCMySql
- Jdbc 封裝, 利用反射, 加入連線池JDBC封裝反射
- 被纏上了，小王問我怎麼在 Spring Boot 中使用 JDBC 連線 MySQLSpring BootJDBCMySql
- 轉:ORACLE的JDBC連線方式:OCI和THINOracleJDBC
- JDBC連線批量處理資料入庫JDBC
- 淺談JDBC和資料庫連線池JDBC資料庫
- Python 連線 MySQLPythonMySql
- python連線MySQLPythonMySql
- IDEA連線MySQLIdeaMySql
- GO 連線 MySQLGoMySql
- C連線MySQLMySql
- MYSQL語法：左連線、右連線、內連線、全外連線MySql
- MySQL筆記3——內連線/外連線、多表連線MySql筆記
- JDBC第一篇【介紹JDBC、使用JDBC連線資料庫、簡單的工具類】JDBC資料庫
- JDBC中連線資料庫的常用jar包JDBC資料庫JAR
- jdbc連線oracle rac資料庫的寫法JDBCOracle資料庫
- 資料庫連線分析(1)-從JDBC到MyBatis資料庫JDBCMyBatis