数据库事务
数据库事务介绍
事务:一组逻辑操作单元,使数据从一种状态变换到另一种状态。
事务处理(事务操作):保证所有事务都作为一个工作单元来执行,即使出现了故障,都不能改变这种执行方
式。当在一个事务中执行多个操作时,要么所有的事务都被提交(commit),那么这些修改就永久地保存下来;
要么数据库管理系统将放弃所作的所有修改,整个事务回滚(rollback)到最初状态。
为确保数据库中数据的一致性,数据的操纵应当是离散的成组的逻辑单元:当它全部完成时,数据的一致性可
以保持,而当这个单元中的一部分操作失败,整个事务应全部视为错误,所有从起始点以后的操作应全部回退
到开始状态。
JDBC事务处理
数据一旦提交,就不可回滚。
数据什么时候意味着提交?
当一个连接对象被创建时,默认情况下是自动提交事务:每次执行一个 SQL 语句时,如果执行成功,就会向数据库自动提交,而不能回滚。
**关闭数据库连接,数据就会自动的提交。**如果多个操作,每个操作使用的是自己单独的连接,则无法保证事务。即同一个事务的多个操作必须在同一个连接下。
JDBC程序中为了让多个 SQL 语句作为一个事务执行:
调用 Connection 对象的 setAutoCommit(false); 以取消自动提交事务
在所有的 SQL 语句都成功执行后,调用 commit(); 方法提交事务
在出现异常时,调用 rollback(); 方法回滚事务
若此时 Connection 没有被关闭,还可能被重复使用,则需要恢复其自动提交状态
setAutoCommit(true)。尤其是在使用数据库连接池技术时,执行close()方法前,建议恢复自动提交状态
【案例:用户AA向用户BB转账100】
public class TransactionTest {
public static void main(String[] args) throws SQLException, IOException, ClassNotFoundException {
String sql1 = "update user_table set balance=balance+100 where user=?";
String sql2 = "update user_table set balance=balance-100 where user=?";
testUpdate2(sql1, sql2);
}
//1.什么叫数据库事务?
// 事务:—组逻辑操作单元,使数据从一种状态变换到另—种状态。
// >—组逻辑操作单元:一个或多个DML操作。
// 2.事务处理的原则,保证所有事务都作为一个工作单元来执行,即使出现了故障,都不能改变这种执行方式。
// 当在一个事务中执行多个操作时,要么所有的事务都被提交(commit),那么这些修改就永久地保存
// 下来;要么数据库管理系统将放弃所作的所有修改,整个事务回滚(rollback)到最初状态。
// 3.数据一旦提交,就不可回滚
//4.哪些操作会导致数据的自动提交?
// I
//>DDL操作一旦执行,都会自动提交。
// >set autocommit = false 对DDL操作失效
//>默认情况下,—旦执行,就会自动提交。
// >我们可以通过set autocommit = false的方式取消DML操作的自动提交.
//>关闭数据库连接,数据就会自动的提交
//示例:AA用户给BB用户转账100(未考虑事务)
public static void testUpdate(String sql1, String sql2) throws SQLException, IOException, ClassNotFoundException {
change(sql2, "AA");
//模拟异常
System.out.println(10 / 0);
change(sql1, "BB");
System.out.println("转账成功!");
}
//示例:AA用户给BB用户转账100(考虑事务)
public static void testUpdate2(String sql1, String sql2) {
Connection connection = null;
try {
connection = JDBCUtils.getConnection();
//取消数据的自动提交(DML操作)
connection.setAutoCommit(false);
change2(connection, sql2, "AA");
//模拟异常
//System.out.println(10 / 0);
change2(connection, sql1, "BB");
System.out.println("转账成功!");
} catch (Exception e) {
e.printStackTrace();
//回滚数据
try {
connection.rollback();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
} finally {
//修改其为自动提交
//主要针对数据库连接池的使用
try {
connection.setAutoCommit(true);
} catch (SQLException throwables) {
throwables.printStackTrace();
}
try {
JDBCUtils.closeResource(connection, null);
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
}
public static void change(String sql, Object... args) throws SQLException, IOException, ClassNotFoundException {
//1.获取数据库连接
Connection connection = JDBCUtils.getConnection();
//2.预编译Sql语句,返回PreparedStatement实例
PreparedStatement preparedStatement = connection.prepareStatement(sql);
//3.填充占位符
for (int i = 0; i < args.length; i++) {
preparedStatement.setObject(i + 1, args[i]);
}
//4.执行操作
preparedStatement.execute();
//5.关闭资源
JDBCUtils.closeResource(connection, preparedStatement);
}
//通用的增删改操作---version 1.0(考虑事务)
public static void change2(Connection connection, String sql, Object... args) throws SQLException, IOException, ClassNotFoundException {
// 预编译Sql语句,返回PreparedStatement实例
PreparedStatement preparedStatement = connection.prepareStatement(sql);
// 填充占位符
for (int i = 0; i < args.length; i++) {
preparedStatement.setObject(i + 1, args[i]);
}
// 执行操作
preparedStatement.execute();
// 关闭资源
JDBCUtils.closeResource(null, preparedStatement);
}
}
事务的ACID属性
- 原子性(Atomicity) 原子性是指事务是一个不可分割的工作单位,事务中的操作要么都发生,要么都不发生。
- 一致性(Consistency) 事务必须使数据库从一个一致性状态变换到另外一个一致性状态。
- 隔离性(Isolation) 事务的隔离性是指一个事务的执行不能被其他事务干扰,即一个事务内部的操作及使用的数据对并发的其他事务是隔离的,并发执行的各个事务之间不能互相干扰。
- 持久性(Durability) 持久性是指一个事务一旦被提交,它对数据库中数据的改变就是永久性的,接下来的其他操作和数据库故障不应该对其有任何影响。
数据库的并发问题
对于同时运行的多个事务, 当这些事务访问数据库中相同的数据时, 如果没有采取必要的隔离机制, 就会导致各种
并发问题:
脏读: 对于两个事务 T1, T2, T1 读取了已经被 T2 更新但还没有被提交的字段。之后, 若 T2 回滚, T1读取的
内容就是临时且无效的。
不可重复读: 对于两个事务T1, T2, T1 读取了一个字段, 然后 T2 更新了该字段。之后, T1再次读取同一个字段, 值就不同了。
幻读: 对于两个事务T1, T2, T1 从一个表中读取了一个字段, 然后 T2 在该表中插入了一些新的行。之后, 如果 T1 再次读取同一个表, 就会多出几行。
快速理解脏读、不可重复读、幻读 .
数据库事务的隔离性: 数据库系统必须具有隔离并发运行各个事务的能力, 使它们不会相互影响, 避免各种并发问题。
一个事务与其他事务隔离的程度称为隔离级别。数据库规定了多种事务隔离级别, 不同隔离级别对应不同的干扰程度, 隔离级别越高, 数据一致性就越好, 但并发性越弱。
四种隔离级别
数据库提供的4种事务隔离级别:
隔离级别 | 描述 | 脏读 | 不可重复读 | 幻读 |
---|---|---|---|---|
READ UNCOMMITTED(读未提交数据) | 允许事务读取未被其他事物提交的变更.脏读,不可重复读和幻读的问题都会出现 | ×(未解决) | × | × |
READ COMIMITED(读已提交数据) | 只允许事务读取已经被其它事务提交的变更.可以避免脏读,但不可重复读和幻读问 | ✔(已解决) | × | × |
REPEATABLE READ(可重复读) | 确保事务可以多次从一个字段中读取相同的值.在这个事务持续期间,禁止其他事物 | ✔ | ✔ | × |
SERIALIZABLE(串行化) | 执行插入,更新和删除操作.所有并发问题都可以避免.但性能十分低下. | ✔ | ✔ | ✔ |
int TRANSACTION_READ_UNCOMMITTED = 1;
int TRANSACTION_READ_COMMITTED = 2;
int TRANSACTION_REPEATABLE_READ = 4;
int TRANSACTION_SERIALIZABLE = 8;
public class transactionIsolationLevel {
@Test
public void testTransactionSelect() throws Exception {
Connection connection = JDBCUtils.getConnection();
//获取当前连接的隔离级别
System.out.println(connection.getTransactionIsolation());
//取消自动提交数据
connection.setAutoCommit(false);
//设置数据库的隔离级别
connection.setTransactionIsolation(Connection.TRANSACTION_REPEATABLE_READ);
String sql = "select user,password,balance from user_table where user=?";
User user = getInstance(connection, User.class, sql, "CC");
System.out.println(user);
}
@Test
public void testTransactionUpdate() throws Exception {
Connection connection = JDBCUtils.getConnection();
//取消自动提交数据
connection.setAutoCommit(false);
String sql = "update user_table set balance=? where user=?";
change2(connection, sql, "5000", "CC");
Thread.sleep(5000);
System.out.println("修改结束!");
}
//通用的增删改操作---version 2.0(考虑事务)
public void change2(Connection connection, String sql, Object... args) throws SQLException, IOException, ClassNotFoundException {
// 预编译Sql语句,返回PreparedStatement实例
PreparedStatement preparedStatement = connection.prepareStatement(sql);
// 填充占位符
for (int i = 0; i < args.length; i++) {
preparedStatement.setObject(i + 1, args[i]);
}
// 执行操作
preparedStatement.execute();
// 关闭资源
JDBCUtils.closeResource(null, preparedStatement);
}
// 通用的针对于不同表的查询(查询一条记录)version2.0---考虑事务
public <T> T getInstance(Connection connection, Class<T> clazz, String sql, Object... args) {
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
try {
preparedStatement = connection.prepareStatement(sql);
for (int i = 0; i < args.length; i++) {
preparedStatement.setObject(i + 1, args[i]);
}
resultSet = preparedStatement.executeQuery();
//获取结果集的元数据:ResultSetMethod
ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
//通过ResultSetMetaData和获取结果集中的列数
int columnCount = resultSetMetaData.getColumnCount();
if (resultSet.next()) {
T t = clazz.newInstance();
for (int i = 0; i < columnCount; i++) {
Object columnValue = resultSet.getObject(i + 1);
//获取每个列的列名:getColumnName()
//获取列的别名:getColumnLabel()
// String columnName = resultSetMetaData.getColumnName(i + 1);
String columnLabel = resultSetMetaData.getColumnLabel(i + 1);
//给Customer对象columnName属性,赋值位columnValue,通过反射
Field field = clazz.getDeclaredField(columnLabel);
field.setAccessible(true);
field.set(t, columnValue);
}
return t;
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
JDBCUtils.closeResource2(null, preparedStatement, resultSet);
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
return null;
}
DAO及相关实现类
DAO:Data Access Object访问数据信息的类和接口,包括了对数据的CRUD(Create、Retrival、Update、Delete),而不包含任何业务相关的信息。有时也称作:BaseDAO
作用:为了实现功能的模块化,更有利于代码的维护和升级。
下面是尚硅谷JavaWeb阶段书城项目中DAO使用的体现:
下面是对customers表的操作作为示例
BaseDao
package dao;
import util.JDBCUtils;
import java.io.IOException;
import java.lang.reflect.Field;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
/*
* 封装了针对数据表的通用的操作
*
*
* */
public abstract class BaseDao {
//通用的增删改操作---version 2.0(考虑事务)
public static void update(Connection connection, String sql, Object... args) {
PreparedStatement preparedStatement=null;
try {
// 预编译Sql语句,返回PreparedStatement实例
preparedStatement= connection.prepareStatement(sql);
// 填充占位符
for (int i = 0; i < args.length; i++) {
preparedStatement.setObject(i + 1, args[i]);
}
// 执行操作
preparedStatement.execute();
} catch (SQLException e) {
e.printStackTrace();
}finally {
// 关闭资源
JDBCUtils.closeResource(null, preparedStatement);
}
}
// 通用的针对于不同表的查询(查询一条记录)version2.0---考虑事务
public <T> T getInstance(Connection connection, Class<T> clazz, String sql, Object... args) {
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
try {
preparedStatement = connection.prepareStatement(sql);
for (int i = 0; i < args.length; i++) {
preparedStatement.setObject(i + 1, args[i]);
}
resultSet = preparedStatement.executeQuery();
//获取结果集的元数据:ResultSetMethod
ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
//通过ResultSetMetaData和获取结果集中的列数
int columnCount = resultSetMetaData.getColumnCount();
if (resultSet.next()) {
T t = clazz.newInstance();
for (int i = 0; i < columnCount; i++) {
Object columnValue = resultSet.getObject(i + 1);
//获取每个列的列名:getColumnName()
//获取列的别名:getColumnLabel()
// String columnName = resultSetMetaData.getColumnName(i + 1);
String columnLabel = resultSetMetaData.getColumnLabel(i + 1);
//给Customer对象columnName属性,赋值位columnValue,通过反射
Field field = clazz.getDeclaredField(columnLabel);
field.setAccessible(true);
field.set(t, columnValue);
}
return t;
}
} catch (Exception e) {
e.printStackTrace();
} finally {
JDBCUtils.closeResource2(null, preparedStatement, resultSet);
}
return null;
}
//通用的查询操作,用于返回数据表中的多条记录构成的集合version2.0(考虑事务)
public static <T> List<T> getForList(Connection connection, Class<T> clazz, String sql, Object... args) {
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
try {
preparedStatement = connection.prepareStatement(sql);
for (int i = 0; i < args.length; i++) {
preparedStatement.setObject(i + 1, args[i]);
}
resultSet = preparedStatement.executeQuery();
//获取结果集的元数据:ResultSetMethod
ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
//通过ResultSetMetaData和获取结果集中的列数
int columnCount = resultSetMetaData.getColumnCount();
List<T> list = new ArrayList<>();
while (resultSet.next()) {
T t = clazz.newInstance();
for (int i = 0; i < columnCount; i++) {
Object columnValue = resultSet.getObject(i + 1);
//获取每个列的列名:getColumnName()
//获取列的别名:getColumnLabel()
// String columnName = resultSetMetaData.getColumnName(i + 1);
String columnLabel = resultSetMetaData.getColumnLabel(i + 1);
//给Customer对象columnName属性,赋值位columnValue,通过反射
Field field = clazz.getDeclaredField(columnLabel);
field.setAccessible(true);
field.set(t, columnValue);
}
list.add(t);
}
return list;
} catch (Exception e) {
e.printStackTrace();
} finally {
JDBCUtils.closeResource2(null, preparedStatement, resultSet);
}
return null;
}
//查询一些特殊值的方法
public <E> E getValue(Connection connection, String sql, Object... args) {
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
try {
preparedStatement = connection.prepareStatement(sql);
for (int i = 0; i < args.length; i++) {
preparedStatement.setObject(i + 1, args[i]);
}
resultSet = preparedStatement.executeQuery();
if (resultSet.next()) {
return (E) resultSet.getObject(1);
}
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
JDBCUtils.closeResource2(null, preparedStatement, resultSet);
}
return null;
}
}
CustomersDao (interface)
package dao;
import bean.Customer;
import java.sql.Connection;
import java.util.Date;
import java.util.List;
/*
* 此接口用于规范针对于customers表的常用操作
*
* */
public interface CustomersDao {
/* 将customer对象添加到数据库中*/
void insert(Connection connection, Customer customer);
/* 根据指定的id,删除表中的一条记录*/
void deletedById(Connection connection, int id);
/* 根据内存的customer对象,去修改数据表中的指定的记录*/
void testUpdate(Connection connection, Customer customer);
/* 根据指定的id查询得到对应的Customer对象*/
Customer getCustomerById(Connection connection, int id);
/* 查询表中的所有记录构成的集合*/
List<Customer> getAll(Connection connection);
/* 返回数据表中数据的条目数*/
Long getCount(Connection connection);
/* 返回数据表中最大的生日(出生日 2010>2004)*/
Date getMaxBirth(Connection connection);
}
CustomerDaoImpl
package dao;
import bean.Customer;
import util.JDBCUtils;
import java.io.IOException;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Date;
import java.util.List;
public class CustomerDaoImpl extends BaseDao implements CustomersDao {
/* 将customer对象添加到数据库中*/
@Override
public void insert(Connection connection, Customer customer) {
String sql = "insert into customers(name,email,birth)values(?,?,?)";
update(connection, sql, customer.getName(), customer.getEmail(), customer.getBirth());
}
/* 根据指定的id,删除表中的一条记录*/
@Override
public void deletedById(Connection connection, int id) {
String sql = "delete from customers where id=?";
update(connection, sql, id);
}
/* 根据内存的customer对象,去修改数据表中的指定的记录*/
@Override
public void testUpdate(Connection connection, Customer customer) {
String sql = "update customers set name=?,email=?,birth=? where id=?";
update(connection, sql, customer.getName(), customer.getEmail(), customer.getBirth(), customer.getId());
}
/* 根据指定的id查询得到对应的Customer对象*/
@Override
public Customer getCustomerById(Connection connection, int id) {
String sql = "select id,name,email,birth from customers where id=?";
Customer customer = getInstance(connection, Customer.class, sql, id);
return customer;
}
/* 查询表中的所有记录构成的集合*/
@Override
public List<Customer> getAll(Connection connection) {
String sql = "select id,name,email,birth from customers";
List<Customer> list = getForList(connection, Customer.class, sql);
return list;
}
/* 返回数据表中数据的条目数*/
@Override
public Long getCount(Connection connection) {
String sql = "select count(*) from customers";
Long value = (Long) getValue(connection, sql);
return value;
}
/* 返回数据表中最大的生日(出生日 2010>2004)*/
@Override
public Date getMaxBirth(Connection connection) {
String sql = "select max(birth) from customers";
return getValue(connection, sql);
}
}