本文介绍了MySQL数据库的事务概念，包括ACID特性，并详细讲解了JDBC在处理事务、数据库连接、Statement与PreparedStatement对象等方面的应用，同时提到了数据库连接池如DBCP的重要性和使用。
前面的见博客：https://blog.csdn.net/weixin_45483328/article/details/113759286
6、事务
6.1、什么是事务
要么都成功，要么都失败
参考博客：https://blog.csdn.net/dengjili/article/details/82468576
ACID
原子性（Atomicity）：要么都成功，要么都失败
一致性（Consistency）：事务前后数据完整性要保证一致
隔离性（Isolation）：
隔离性是多个用户并发访问数据库时，数据库为每个用户开启的事务，不能被其他事务的操作数据所干扰，事务之间要相互隔离
持久性（Durability） – 事务提交
- 事务没有提交，恢复原状
- 事务提交，持久化到数据库
隔离所导致的一些问题
脏读：
指一个事务读取了另外一个事务未提交的数据。
不可重复读：
在一个事务内读取表中的某一行数据，多次读取结果不同。（这个不一定是错误，只是某些场合不对）
虚读(幻读)
是指在一个事务内读取到了别的事务插入的数据，导致前后读取不一致。
（一般是行影响，多了一行）
执行事务
-- mysql是默认开始事务自动提交的
SET autocommit = 0 -- 关闭
-- 手动处理事务
SET autocommit = 0 -- 关闭自动提交
-- 事务开启
START TRANSACTION -- 标记一个事务的开始，从这个之后的sql都在同一个事务内
-- 提交：持久化（成功）
COMMIT
-- 回滚：回到原来的样子（失败）
ROLLBACK
-- 事务结束
SET autocommit = 1 -- 开启自动提交
SAVEPOINT 保存点名 -- 设置一个事务的保存点
ROLLBACK TO SAVEPOINT 保存点名 -- 回滚到保存点
RELEASE SAVEPOINT 保存点 -- 撤销保存点
模拟场景
/*
课堂测试题目
A在线买一款价格为500元商品,网上银行转账.
A的银行卡余额为2000,然后给商家B支付500.
商家B一开始的银行卡余额为10000
创建数据库shop和创建表account并插入2条数据
*/
CREATE DATABASE `shop`CHARACTER SET utf8 COLLATE utf8_general_ci;
USE `shop`;
CREATE TABLE `account` (
`id` INT(11) NOT NULL AUTO_INCREMENT,
`name` VARCHAR(32) NOT NULL,
`cash` DECIMAL(9,2) NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8
INSERT INTO account (`name`,`cash`)
VALUES('A',2000.00),('B',10000.00)
-- 转账实现
SET autocommit = 0; -- 关闭自动提交
START TRANSACTION; -- 开始一个事务,标记事务的起始点
UPDATE account SET cash=cash-500 WHERE `name`='A';
UPDATE account SET cash=cash+500 WHERE `name`='B';
COMMIT; -- 提交事务
rollback; -- 回滚
SET autocommit = 1; -- 恢复自动提交
在Java中如何实现
7、索引
参考博客：http://blog.codinglabs.org/articles/theory-of-mysql-index.html
这篇博客讲到了索引底层，讲的很好，老师力推的。
MySQL官方对索引的定义为：索引（Index）是帮助MySQL高效获取数据的数据结构。提取句子主干，就可以得到索引的本质：索引是数据结构。
- 主键索引（PRIMARY KEY）
- 唯一索引 （UNIQUE KEY）
- 常规索引（KEY / INDEX)
- 全文索引 （FullText)
（这里漏掉一点，需要补）
10、JDBC（重点）
10.1、数据库驱动
驱动：类似于声卡、显卡，数据库也需要驱动
我们的程序会通过数据库驱动，和数据库打交道！
10.2、JDBC
SUN公司为了简化开发人员的（对数据库的统一）操作，提供了一个（Java操作数据库的）规范，俗称JDBC。
这些规范的实现有具体的厂商去做。
对于开发人员，我们只需要掌握JDBC接口的操作即可！
java.sql javax.sql（这两个是Java默认就有的）
还需要导入一个数据库驱动包mysql-connector-java-版本号jar（这里用的5.1.47版本）
10.3、第一个JDBC程序
创建测试数据库
CREATE DATABASE jdbcStudy CHARACTER SET utf8 COLLATE utf8_general_ci;
USE jdbcStudy;
CREATE TABLE `users`(
id INT PRIMARY KEY,
NAME VARCHAR(40),
PASSWORD VARCHAR(40),
email VARCHAR(60),
birthday DATE
);
INSERT INTO `users`(id,NAME,PASSWORD,email,birthday)
VALUES(1,'zhansan','123456','zs@sina.com','1980-12-04'),
(2,'lisi','123456','lisi@sina.com','1981-12-04'),
(3,'wangwu','123456','wangwu@sina.com','1979-12-04')
1、创建一个普通项目
2、导入数据库驱动
3、编写测试代码
package com.kuang.lesson01;
import java.sql.*;
/**
* 我的第一个JDBC程序
*
* @author shkstart
* @create 2021-04-21 15:15
*/
public class JdbcFirstDemo {
public static void main(String[] args) throws ClassNotFoundException, SQLException {
//1.加载驱动
Class.forName("com.mysql.jdbc.Driver"); //固定写法，加载驱动
//2.用户信息和url
String url = "jdbc:mysql://localhost:3306/jdbcStudy?useUnicode=true&characterEncoding=utf8&useSSL=false";
//老师写的是useSSL=true，我跑不通，改成false就可以了
String username = "root";
String password = "123456";
//3.连接成功，数据库对象 Connection 代表数据库
Connection connection = DriverManager.getConnection(url, username, password);
//4.执行SQL的对象 Statement 执行sql的对象
Statement statement = connection.createStatement();
//5.执行sql的对象 去执行sql，可能存在结果，查看返回结果
String sql = "SELECT * FROM users";
ResultSet resultSet = statement.executeQuery(sql);//返回的结果集，结果集中封装了我们全部的查询出来的结果
while(resultSet.next()) {
System.out.println("id = " + resultSet.getObject("id"));
System.out.println("name = " + resultSet.getObject("NAME"));
System.out.println("password = " + resultSet.getObject("PASSWORD"));
System.out.println("email = " + resultSet.getObject("email"));
System.out.println("birthday = " + resultSet.getObject("birthday"));
System.out.println("=======================================================");
}
//6.释放连接
resultSet.close();
statement.close();
connection.close();//尤其是connection连接非常占内存
}
}
步骤总结：
1.加载驱动
2.连接数据库 DriverManager
3.获得执行SQL的对象 Statement
4.获得返回的结果集 ()
5.释放连接
DriverManager
//DriverManager.registerDriver(new com.mysql.jdbc.Driver());
Class.forName("com.mysql.jdbc.Driver");//固定写法，加载驱动（推荐使用这种写法）
Connection connection= DriverManager.getConnection(url,name,password);
//connection代表数据库
//数据库设置自动提交
//事务提交
//事务回滚
connection.rollback();
connection.commit();
connection.setAutoCommit();
URL
String url ="jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&&useSSL=false";
//mysql 默认端口为：3306
//jdbc:mysql://主机地址:端口号/数据库名？参数1&参数2&参数3
//协议://主机地址:端口号/数据库名？参数1&参数2&参数3
//Oracle 1521
//jdbc:oralce:thin:@localhost:1521:sid
Statement 执行SQL的对象 PrepareStatement 执行SQL的对象
String sql="SELECT * FROM users";//编写Sql
statement.executeQuery();//查询操作返回ResultSet
statement.execute();//执行任何sql
statement.executeUpdate();//更新，插入，删除。都是用这个，返回一个受影响的行数
123456
ResultSet 查询的结果集，封装了所有的查询结果
获得指定的数据类型
ResultSet resultSet = statement.executeQuery(sql);//返回的结果集,结果集中封装了我们全部查询的结果
resultSet.getObject();//在不知道列类型的情况下使用
//如果知道列的类型就使用指定的类型
resultSet.getString();
resultSet.getInt();
resultSet.getFloat();
resultSet.getDate();
...
遍历，指针
resultSet.next(); //移动到下一个数据
resultSet.afterLast();//移动到最后面
resultSet.beforeFirst();//移动到最前面
resultSet.previous();//移动到前一行
resultSet.absolute(row);//移动到指定行
释放资源
resultSet.close();
statement.close();
connection.close();//尤其是connection连接非常占内存
10.4、statement对象
Jdbc中的statement对象用于向数据库发送SQL语句，想完成对数据库的增删改查，只需要通过这个对象向数据库发送增删改查语句即可。
Statement对象的executeUpdate方法，用于向数据库发送增、删、改的sq|语句，executeUpdate执行完后， 将会返回一个整数(即增删改语句导致了数据库几行数据发生了变化)。
Statement.executeQuery方法用于向数据库发生查询语句，executeQuery方法返回代表查询结果的ResultSet对象。
CRUD操作-create
使用executeUpdate(String sql)方法完成数据添加操作，示例操作：
Statement statement = connection.createStatement();
String sql = "insert into user(...) values(...)";
int num = statement.executeUpdate(sql);
if(num>0){
System.out.println("插入成功！！！");
}
CRUD操作-delete
使用executeUpdate(String sql)方法完成数据删除操作，示例操作：
Statement statement = connection.createStatement();
String sql = "delete from user where id =1";
int num = statement.executeUpdate(sql);
if(num>0){
System.out.println("删除成功！！！");
}
CRUD操作-delete
使用executeUpdate(String sql)方法完成数据修改操作，示例操作：
Statement statement = connection.createStatement();
String sql = "update user set name ='' where name = ''";
int num = statement.executeUpdate(sql);
if(num>0){
System.out.println("修改成功！！！");
}
1234567
CRUD操作-read
使用executeUpdate(String sql)方法完成数据查询操作，示例操作：
Statement statement = connection.createStatement();
String sql = "select * from user where id =1";
ResultSet rs= statement.executeQuery(sql);
while(rs.next()){
//根据获取列的数据类型，分别调用rs的相应方法映射到java对象中
}
代码实现
1、提取工具类
package com.kuang.lesson02.utils;
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;
/**
* @author shkstart
* @create 2021-04-21 16:45
*/
public class JdbcUtils {
private static String driver = null;
private static String url = null;
private static String username = null;
private static String password = null;
static {
try{
InputStream in = JdbcUtils.class.getClassLoader().getResourceAsStream("db.properties");//db.properties文件放在src下面，这里就不用写文件路径了
Properties properties = new Properties();
properties.load(in);
driver = properties.getProperty("driver");
url = properties.getProperty("url");
username = properties.getProperty("username");
password = properties.getProperty("password");
//1.驱动只用加载一次
Class.forName(driver);
} catch (Exception e) {
e.printStackTrace();
}
}
//获取连接
public static Connection getConnection() throws SQLException {
return DriverManager.getConnection(url, username, password);
}
//释放连接资源
public static void release(Connection connection, Statement statement, ResultSet resultSet){
if (resultSet != null) {
try {
resultSet.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
if (statement != null) {
try {
statement.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
if (connection != null) {
try {
connection.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
}
}
2、编写增删改的方法，executeUpdate
package com.kuang.lesson02.utils;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
/**
* 增
* 增、删、改都是用 executeUpdate()
*
* @author shkstart
* @create 2021-04-21 18:37
*/
public class TestInsert {
public static void main(String[] args) {
Connection conn = null;
Statement st = null;
ResultSet rs = null;
try {
conn = JdbcUtils.getConnection(); //获取数据库连接
st = conn.createStatement(); //获取SQL的执行对象
String sql = "INSERT INTO users(id,`NAME`,`PASSWORD`,`email`,`birthday`)" +
"VALUES(4,'sanjin','123456','233223@qq.com','2020-01-01')";
int i = st.executeUpdate(sql);
if (i > 0) {
System.out.println("插入成功！");
}
} catch (SQLException throwables) {
throwables.printStackTrace();
}finally {
JdbcUtils.release(conn,st,rs);
}
}
}
package com.kuang.lesson02.utils;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
/**
* 删
*
* @author shkstart
* @create 2021-04-21 18:45
*/
public class TestDelete {
public static void main(String[] args) {
Connection conn = null;
Statement st = null;
ResultSet rs = null;
try {
conn = JdbcUtils.getConnection(); //获取数据库连接
st = conn.createStatement(); //获取SQL的执行对象
String sql = "DELETE FROM users WHERE id = 4";
int i = st.executeUpdate(sql);
if (i > 0) {
System.out.println("删除成功！");
}
} catch (SQLException throwables) {
throwables.printStackTrace();
}finally {
JdbcUtils.release(conn,st,rs);
}
}
}
package com.kuang.lesson02.utils;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
/**
* 改
*
* @author shkstart
* @create 2021-04-21 18:59
*/
public class TestUpdate {
public static void main(String[] args) {
Connection conn = null;
Statement st = null;
ResultSet rs = null;
try {
conn = JdbcUtils.getConnection(); //获取数据库连接
st = conn.createStatement(); //获取SQL的执行对象
String sql = "UPDATE users SET `NAME`='kuangshen',`email`='24631565@qq.com' WHERE id=1";
int i = st.executeUpdate(sql);
if (i > 0) {
System.out.println("更新成功！");
}
} catch (SQLException throwables) {
throwables.printStackTrace();
}finally {
JdbcUtils.release(conn,st,rs);
}
}
}
3、查询， executeQuery
package com.kuang.lesson02.utils;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
/**
* @author shkstart
* @create 2021-04-21 19:14
*/
public class TestSelect {
public static void main(String[] args) {
Connection conn = null;
Statement st = null;
ResultSet rs = null;
try {
conn = JdbcUtils.getConnection();
st = conn.createStatement();
//SQL
String sql = "select * from users where id=1";
rs = st.executeQuery(sql); //查询完毕会返回一个结果集
while (rs.next()){
System.out.println(rs.getString("NAME"));
}
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
JdbcUtils.release(conn,st,rs);
}
}
}
SQL注入问题
sql存在漏洞，会被攻击导致数据泄露 SQL会被拼接 or
package com.kuang.lesson02.utils;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
/**
* @author shkstart
* @create 2021-04-21 20:23
*/
public class SQL注入 {
public static void main(String[] args) {
//SQL注入
login("' or '1=1","123456");
}
public static void login(String name,String password){
Connection conn =null;
Statement st = null;
ResultSet rs =null;
try {
conn = JdbcUtils.getConnection();//获取连接
st = conn.createStatement();//获取SQL执行对象
String sql = "select * from users where `NAME`='"+ name +"' AND `PASSWORD`='"+ password +"'" ;
rs=st.executeQuery(sql);//查询完毕返回结果集
while (rs.next()){
System.out.println(rs.getString("NAME"));
}
JdbcUtils.release(conn,st,rs);
} catch (Exception e) {
e.printStackTrace();
}finally {
JdbcUtils.release(conn,st,rs);
}
}
}
10.5、PreparedStatement对象
PreparedStatement 可以防止SQL注入 ，效率更高。
- 新增
- 删除
- 更新
- 查询
- 防止SQL注入
代码演示如下：
- 新增
package com.kuang.lesson03;
import com.kuang.lesson02.utils.JdbcUtils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.Date;
/**
* @author shkstart
* @create 2021-04-21 20:28
*/
public class TestInsert {
public static void main(String[] args) {
Connection connection= null;
PreparedStatement pstm=null;
try {
connection = JdbcUtils.getConnection();
//区别
//使用 ? 占位符代替参数
String sql = "insert into users(id,`NAME`,`PASSWORD`,`email`,`birthday`) values(?,?,?,?,?)";//编写SQL
pstm = connection.prepareStatement(sql);//预编译sql，先写sql，然后不执行
//手动给参数赋值
pstm.setInt(1,4);//id
pstm.setString(2,"SANJIN");
pstm.setString(3,"123456");
pstm.setString(4,"123456@qq.com");
//注意点：sql.Date 数据库 java.sql.Date()
// util.Date Java new Date().getTime() 这是获得时间戳
pstm.setDate(5,new java.sql.Date(new Date().getTime()));
//执行
int i = pstm.executeUpdate();
if (i>0){
System.out.println("插入成功");
}
} catch (Exception e) {
e.printStackTrace();
}finally {
JdbcUtils.release(connection,pstm,null);
}
}
}
- 删除
package com.kuang.lesson03;
import com.kuang.lesson02.utils.JdbcUtils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.util.Date;
/**
* @author shkstart
* @create 2021-04-21 21:07
*/
public class TestDelete {
public static void main(String[] args) {
Connection connection= null;
PreparedStatement pstm=null;
try {
connection = JdbcUtils.getConnection();
//区别
//使用 ? 占位符代替参数
String sql = "delete from users where id=?";//编写SQL
pstm = connection.prepareStatement(sql);//预编译sql，先写sql，然后不执行
//手动给参数赋值
pstm.setInt(1,4);
//执行
int i = pstm.executeUpdate();
if (i>0){
System.out.println("删除成功");
}
} catch (Exception e) {
e.printStackTrace();
}finally {
JdbcUtils.release(connection,pstm,null);
}
}
}
- 更新
package com.kuang.lesson03;
import com.kuang.lesson02.utils.JdbcUtils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.util.Date;
/**
* @author shkstart
* @create 2021-04-21 21:08
*/
public class TestUpdate {
public static void main(String[] args) {
Connection connection= null;
PreparedStatement pstm=null;
try {
connection = JdbcUtils.getConnection();
//区别
//使用 ? 占位符代替参数
String sql = "update users set `NAME`=? where id=?";//编写SQL
pstm = connection.prepareStatement(sql);//预编译sql，先写sql，然后不执行
//手动给参数赋值
pstm.setString(1,"狂神");
pstm.setInt(2,1);
//执行
int i = pstm.executeUpdate();
if (i>0){
System.out.println("更新成功");
}
} catch (Exception e) {
e.printStackTrace();
}finally {
JdbcUtils.release(connection,pstm,null);
}
}
}
- 查询
package com.kuang.lesson03;
import com.kuang.lesson02.utils.JdbcUtils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
/**
* @author shkstart
* @create 2021-04-21 21:16
*/
public class TestSelect {
public static void main(String[] args) {
Connection connection = null;
PreparedStatement pstm = null;
ResultSet rs = null;
try {
connection = JdbcUtils.getConnection();
String sql = "select * from users where id = ?";//编写SQL
pstm = connection.prepareStatement(sql);//预编译
pstm.setInt(1,1);//传递参数
rs = pstm.executeQuery();//执行
if (rs.next()) {
System.out.println(rs.getString("NAME"));
}
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
JdbcUtils.release(connection,pstm,rs);
}
}
}
- 防止SQL注入
package com.kuang.lesson03;
import com.kuang.lesson02.utils.JdbcUtils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.Statement;
/**
* @author shkstart
* @create 2021-04-21 20:23
*/
public class SQL注入 {
public static void main(String[] args) {
//SQL注入
// login("'' or 1=1","123456");
login("lisi","123456");
}
//登录业务
public static void login(String name,String password){
Connection conn =null;
PreparedStatement st = null;
ResultSet rs =null;
try {
conn = JdbcUtils.getConnection();//获取连接
//PreparedStatement防止SQL注入的本质，把传递进来的参数当做字符
//假设其中存在转义字符，比如说 '' 会被直接转义 （引号）
String sql = "select * from users where `NAME`=? AND `PASSWORD`=?" ; //Mybatis
st = conn.prepareStatement(sql);//获取SQL执行对象
st.setString(1,name);
st.setString(2,password);
rs=st.executeQuery();//查询完毕返回结果集
while (rs.next()){
System.out.println(rs.getString("NAME"));
System.out.println(rs.getString("password"));
}
JdbcUtils.release(conn,st,rs);
} catch (Exception e) {
e.printStackTrace();
}finally {
JdbcUtils.release(conn,st,rs);
}
}
}
10.6、使用IDEA连接数据库
连接成功后，可以选择数据库
双击数据库
更新数据要点这个绿色箭头
编写sql代码的地方
10.7、JDBC事务
要么都成功，要么都失败
ACID原则
原子性：要么全部完成，要么都不完成
一致性：结果总数不变
隔离性：多个进程互不干扰
持久性：一旦提交则不可逆，持久化到数据库了
隔离性的问题：
脏读： 一个事务读取了另一个没有提交的事务
不可重复读：在同一个事务内，重复读取表中的数据，表数据发生了改变
虚读（幻读）：在一个事务内，读取到了别人插入的数据，导致前后读出来的结果不一致
代码实现
-
开启事务
connection.setAutoCommit(false); -
一组业务执行完毕，提交事务
-
可以在catch语句中显示的定义回滚语句，但是默认失败会回滚
package com.kuang.lesson04;
import com.kuang.lesson02.utils.JdbcUtils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
/**
* @author shkstart
* @create 2021-04-21 22:48
*/
public class TestTransaction1 {
public static void main(String[] args) {
Connection connection = null;
PreparedStatement pstm = null;
ResultSet rs = null;
try {
connection = JdbcUtils.getConnection();
//关闭数据库的自动提交，此时会自动开启事务，不需要想SQLyog中那样手动开启
connection.setAutoCommit(false);
String sql = "update account set money = money-500 where id = 1";
pstm =connection.prepareStatement(sql);
pstm.executeUpdate();
String sql2 = "update account set money = money-500 where id = 2";
pstm=connection.prepareStatement(sql2);
pstm.executeUpdate();
//业务完毕，提交事务
connection.commit();
System.out.println("操作成功");
} catch (SQLException throwables) {
try {
//如果失败，则默认回滚
connection.rollback();//如果失败，回滚
} catch (SQLException throwables1) {
throwables1.printStackTrace();
}
throwables.printStackTrace();
} finally {
JdbcUtils.release(connection,pstm,rs);
}
}
}
10.9、数据库连接池
数据库连接 — 执行完毕 — 释放
连接 — 释放：这个过程是十分浪费系统资源的
池化技术：准备一些预先的资源，过来就连接预先准备好的
常用连接数：10
最少连接数：10 （最少连接数和常用连接数保持差不多一致）
最大连接数 ： 100 是业务最高承载上限，超过最大连接数要排队等待
等待超时：100ms
编写连接池，实现一个接口 DateSource
开源数据源实现(拿来即用)
DBCP
C3P0
Druid: 阿里巴巴
使用了这些数据库连接池之后，我们在项目开发中就不需要编写连接数据库的代码了!
DBCP
需要用到的 jar 包
commons-dbcp-1.4 、commons-pool-1.6
C3P0
需要用到的 jar 包
c3p0-0.9.5.5 、mchange-commons-java-0.2.19
结论
无论使用什么数据源，本质是不变的，DateSource接口不会变，方法就不会变！
扫一扫
6713
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
