事务
事务：
事务的概念-----事务指逻辑上的一组操作，组成这组操作的各个单元，要不全部成功，要不全部不成功。
数据库开启事务命令:cmd
start transaction 开启事务
Rollback 回滚事务
Commit 提交事务
JDBC控制事务语句
Connection.setAutoCommit(false); start transaction
Connection.rollback(); rollback
Connection.commit(); commit
设置事务回滚点
Savepoint sp = conn.setSavepoint();
Conn.rollback(sp);
Conn.commit(); //回滚后必须要提交
模拟转账：
db.properties
driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/day16
username=root
password=lcp8090
cn.lcp.utils--JdbcUtils.java
package cn.lcp.utils;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;
public class JdbcUtils {
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");
Properties prop = new Properties();
prop.load(in);
String driver = prop.getProperty("driver");
url = prop.getProperty("url");
username = prop.getProperty("username");
password = prop.getProperty("password");
Class.forName(driver);
}catch (Exception e) {
throw new ExceptionInInitializerError(e);
}
}
public static Connection getConnection() throws SQLException{
return DriverManager.getConnection(url, username, password);
}
public static void release(Connection conn,Statement st,ResultSet rs){
if(rs!=null){
try{
rs.close();
}catch (Exception e) {
e.printStackTrace();
}
rs = null;
}
if(st!=null){
try{
st.close();
}catch (Exception e) {
e.printStackTrace();
}
}
if(conn!=null){
try{
conn.close();
}catch (Exception e) {
e.printStackTrace();
}
}
}
}
模拟转账demo.java
package cn.lcp.demo;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import cn.lcp.utils.JdbcUtils;
//模拟转账
public class demo {
public static void main(String[] args) {
Connection conn = null;
PreparedStatement st = null;
ResultSet rs = null;
try {
conn = JdbcUtils.getConnection();
// 执行多条sql语句，开启事务
conn.setAutoCommit(false); // start transaction
String sql1 = "update account set money=money-100 where name='aaa'";
// 预编译sql语句
st = conn.prepareStatement(sql1);
st.executeUpdate();
String sql2 = "update account set money=money+100 where name='bbb'";
st = conn.prepareStatement(sql2);
st.executeUpdate();
//
conn.commit();
System.out.println("成功！！！"); // log4j
} catch (Exception e) {
// 出现异常自动回滚
try {
conn.rollback();
} catch (SQLException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
e.printStackTrace();
} finally {
JdbcUtils.release(conn, st, rs);
}
}
}
demo2:设置事务回滚点：
package cn.lcp.demo;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Savepoint;
import cn.lcp.utils.JdbcUtils;
//模拟转账
public class demo {
public static void main(String[] args) {
Connection conn = null;
PreparedStatement st = null;
ResultSet rs = null;
Savepoint sp = null;
try {
conn = JdbcUtils.getConnection();
// 执行多条sql语句，开启事务
conn.setAutoCommit(false); // start transaction
String sql1 = "update account set money=money-100 where name='aaa'";
// 预编译sql语句
st = conn.prepareStatement(sql1);
st.executeUpdate();
//设置事务回滚点
sp = conn.setSavepoint();
String sql2 = "update account set money=money+100 where name='bbb'";
st = conn.prepareStatement(sql2);
st.executeUpdate();
int i = 10 / 0; //这里出现异常，到catch里面执行回滚
String sql3 = "update account set money=money+100 where name='ccc'";
st = conn.prepareStatement(sql3);
st.executeUpdate();
//提交事务
conn.commit();
System.out.println("成功！！！"); // log4j
} catch (Exception e) {
try {
conn.rollback(); // 出现异常自动回滚到事务回滚点
conn.commit(); //提交事务---
} catch (SQLException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
e.printStackTrace();
} finally {
JdbcUtils.release(conn, st, rs);
}
}
}
事务的特性(ACID)：
原子性（Atomicity）--原子性是指事务是一个不可分割的工作单位，事务中的操作要么都发生，要么都不发生。
一致性（Consistency）--事务必须使数据库从一个一致性状态变换到另外一个一致性状态。
隔离性（Isolation）--事务的隔离性是多个用户并发访问数据库时，数据库为每一个用户开启的事务，不能被其他事务的操作数据所干扰，多个并发事务之间要相互隔离。
持久性（Durability）--持久性是指一个事务一旦被提交，它对数据库中数据的改变就是永久性的，接下来即使数据库发生故障也不应该对其有任何影响。
事务的隔离级别：多个线程开启各自事务操作数据库中数据时，数据库系统要负责隔离操作，以保证各个线程在获取数据时的准确性.
如果不考虑隔离性，可能会引发如下问题：
脏读：指一个事务读取了另外一个事务未提交的数据。
不可重复读：在一个事务内读取表中的某一行数据，多次读取结果不同。脏读的区别是，脏读是读取前一事务未提交的脏数据，不可重复读是重新读取了前一事务已提交的数据。
虚读(幻读):是指在一个事务内读取到了别的事务插入的数据，导致前后读取不一致。
数据库共定义了四种隔离级别：
Serializable：可避免脏读、不可重复读、虚读情况的发生。（串行化） 统计可以使用此隔离级别
Repeatable read：可避免脏读、不可重复读情况的发生。（可重复读）
Read committed：可避免脏读情况发生（读已提交）。 查询
Read uncommitted：最低级别，以上情况均无法保证。(读未提交)
set transaction isolation level 设置事务隔离级别
select @@tx_isolation 查询当前事务隔离级别
设置事务隔离级别
package cn.lcp.demo;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import cn.lcp.utils.JdbcUtils;
public class Demo3 {
/**
* 设置事务隔离级别 写一个查询程序。设置隔离级别为：Connection.TRANSACTION_READ_COMMITTED
* 统计程序的隔离级别为：Connection.TRANSACTION_SERIALIZABLE
*/
public static void main(String[] args) {
Connection conn = null;
PreparedStatement st = null;
ResultSet rs = null;
try {
conn = JdbcUtils.getConnection();
conn.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);
conn.setAutoCommit(false);
String sql = "select * from account where name='aaa'";
st = conn.prepareStatement(sql);
rs = st.executeQuery();
rs.next();
System.out.println(rs.getFloat("money"));
Thread.sleep(1000 * 10);
rs = st.executeQuery();
rs.next();
System.out.println(rs.getFloat("money"));
Thread.sleep(1000 * 10);
rs = st.executeQuery();
rs.next();
System.out.println(rs.getFloat("money"));
} catch (Exception e) {
e.printStackTrace();
} finally {
JdbcUtils.release(conn, st, rs);
}
}
}
