事务
Transaction 其实指的一组操作，里面包含许多个单一的逻辑。只要有一个逻辑没有执行成功，那么都算失败。 所有的数据都回归到最初的状态(回滚)
事务的作用：
为了确保逻辑的成功。 例子： 银行的转账。
命令行方式：
开启事务
start transaction;
提交或者回滚事务
commit; 提交事务， 数据将会写到磁盘上的数据库
rollback ; 数据回滚，回到最初的状态。
关闭自动提交功能
show variable like '%commit%';
查看autocommit默认是on
set autocommit = off；
代码方式：
代码里面的事务，主要是针对连接来的。
1. 通过conn.setAutoCommit（false ）来关闭自动提交的设置。
2. 提交事务 conn.commit();
3. 回滚事务 conn.rollback();
@Test
public void testTransaction(){ Connection conn = null;
PreparedStatement ps = null;
ResultSet rs = null;
try {
conn = JDBCUtil.getConn(); //连接，事务默认就是自动提交的。 关闭自动提交。
conn.setAutoCommit(false); String sql = "update account set money = money - ? where id = ?";
ps = conn.prepareStatement(sql); //扣钱， 扣ID为1 的100块钱
ps.setInt(1, 100);
ps.setInt(2, 1);
ps.executeUpdate(); int a = 10 /0 ; //加钱， 给ID为2 加100块钱
ps.setInt(1, -100);
ps.setInt(2, 2);
ps.executeUpdate(); //成功： 提交事务。
conn.commit(); } catch (SQLException e) {
try {
//事变： 回滚事务
conn.rollback();
} catch (SQLException e1) {
e1.printStackTrace();
}
e.printStackTrace(); }finally {
JDBCUtil.release(conn, ps, rs);
}
}
事务的特性，acid
* 原子性（Atomicity）
指的是 事务中包含的逻辑，不可分割。
* 一致性（Consistency）
指的是 事务执行前后。数据完整性
* 隔离性（Isolation）
指的是 事务在执行期间不应该受到其他事务的影响
* 持久性（Durability）
指的是 事务执行成功，那么数据应该持久保存到磁盘上。
事务的安全隐患
不考虑隔离级别设置，那么会出现以下问题。
* 读
脏读 不可重读读 幻读.
* 脏读，一个事务读到另外一个事务还未提交的数据
* 不可重复读 ，一个事务读到了另外一个事务提交的数据 ，造成了前后两次查询结果不一致。
* 写
* 丢失更新
Read Uncommited【读未提交】
指的是 ： 一个事务可以读取到另一个事务还未提交的数据。 这就会引发 “脏读” 读取到的是数据库
内存中的数据，而并非真正磁盘上的数据。
例子：
1. 开启一个命令行窗口A， 开始事务，然后查询表中记录。 设置当前窗口的事务隔离级别为
读未提交 命令如下：
set session transaction isolation level read uncommitted;
2. 另外在打开一个窗口B， 也开启事务， 然后执行 sql 语句， 但是不提交
3. 在A窗口重新执行查询， 会看到B窗口没有提交的数据。
查看隔离级别：select @@tx_isolation;
1. 设置A窗口的隔离级别为 读未提交
Read Commited 【读已提交】
这个隔离级别能够屏蔽 脏读的现象， 但是引发了另一个问题 ，不可重复读。
只能读取到其他事务已经提交的数据，那些没有提交的数据是读不出来的。但是这会造成一个问题是： 前后读取到的结果不一样。 发生了不可重复!!!, 所谓的不可重复读，就是不能执行多次读取，否则出 现结果不一 。 例子如下： 1. 开启一个命令行窗口A， 开始事务，然后查询表中记录。 设置当前窗口的事务隔离级别为 读未提交 命令如下：
set session transaction isolation level read committed; 2. 另外在打开一个窗口B， 也开启事务， 然后执行 sql 语句， 但是不提交
3. 在A窗口重新执行查询， 是不会看到B窗口刚才执行sql 语句的结果，因为它还没有提交。
4. 在B窗口执行提交。
5. 在A窗口中执行查看， 这时候才会看到B窗口已经修改的结果。
6. 但是这会造成一个问题是： 在A窗口中， 第一次查看数据和第二次查看数据，结果不一样 。
Repeatable Read 【重复读】 - MySql 默认的隔离级别就是这个。
该隔离级别， 可以让事务在自己的会话中重复读取数据，并且不会出现结果不一样的状况，即使其他事
务已经提交了，也依然还是显示以前的数据。
1. 开启一个命令行窗口A， 开始事务，然后查询表中记录。 设置当前窗口的事务隔离级别为
重复读 命令如下：
set session transaction isolation level repeatable read;
2. 另外在打开一个窗口B， 也开启事务， 然后执行 sql 语句， 但是不提交
3. 在A窗口重新执行查询， 是不会看到B窗口刚才执行sql 语句的结果，因为它还没有提交。
4. 在B窗口执行提交。
5. 在A窗口中执行查看， 这时候查询结果，和以前的查询结果一致。不会发生改变。
Serializable 【可串行化】
该事务级别是*的事务级别了。
1. 开启一个命令行窗口A， 开始事务，然后查询表中记录。 设置当前窗口的事务隔离级别为
读未提交 命令如下：
set session transaction isolation level read serializable;
2. 另外在打开一个窗口B， 也开启事务， 然后执行 sql 语句， 但是不提交
3. 在A窗口重新执行查询， 会卡主，没有任何信息显示。
4. 在B窗口执行提交。
5. 在A窗口中执行查看， 这时候才会显示结果。
Serializable 可以防止上面的所有问题，但是都使用该隔离级别也会有些问题。 比如造成并发的性能问题。 其他的事务必须得等当前正在操作表的事务先提交，才能接着往下，否则只能一直在等着。
如果有一个连接的隔离级别设置为了串行化 ，那么谁先打开了事务， 谁就有了先执行的权利， 谁后打开事务，谁就只能得着，等前面的那个事务，提交或者回滚后，才能执行。 但是这种隔离级别一般比
较少用。 容易造成性能上的问题。 效率比较低。
按效率划分，从高到低
> 读未提交 > 读已提交 > 可重复读 > 可串行化
按拦截程度 ，从高到底
> 可串行化 > 可重复读 > 读已提交 > 读未提交
丢失更新：
指一个事务去修改数据库， 另一个事务也修改数据库，最后的那个事务，不管是提交还是回滚都会造成前面一个事务的数据更新丢失
解决丢失更新，通常有两种方法: 悲观锁 和 乐观锁
悲观锁
可以在查询的时候，加入 for update
乐观锁
要求程序员自己控制。
通过比对版本或者比对字段的方式来实现的， 这与使用到的版本控制软件【SVN , GIT】机制是一样的。
事务总结
需要掌握的
1. 在代码里面使用事务
conn.setAutoCommit(false);
conn.commit();
conn.rollback();
2. 事务只是针对连接连接对象，如果再开一个连接对象，那么那是默认的提交。
3. 事务是会自动提交的。
需要了解的
1.安全隐患：
读
脏读
一个事务读到了另一个事务未提交的数据
不可重复读
一个事务读到了另一个事务已提交的数据，造成前后两次查询结果不一致
幻读
一个事务读到了另一个事务insert的数据 ，造成前后查询结果不一致 。
写
丢失更新。
2.隔离级别
读未提交
> 引发问题： 脏读
读已提交
> 解决： 脏读 ， 引发： 不可重复读
可重复读
> 解决： 脏读 、 不可重复读 ， 未解决： 幻读
可串行化
> 解决： 脏读、 不可重复读 、 幻读。
mySql 默认的隔离级别是 可重复读
Oracle 默认的隔离级别是 读已提交
如何扩展某一个方法?
原有的方法逻辑，不是我们想要的。 想修改自己的逻辑
1. 直接改源码 无法实现。
2. 继承， 必须得知道这个接口的具体实现是谁。
3. 使用装饰者模式。
开源连接池：
DBCP
1. 导入jar文件
commons-dbcp-1.4.jar
commons-pool-1.5.6.jar
2. 不使用配置文件：
public void testDBCP01(){
Connection conn = null;
PreparedStatement ps = null;
try {
//1. 构建数据源对象
BasicDataSource dataSource = new BasicDataSource();
//连的是什么类型的数据库， 访问的是哪个数据库 ， 用户名，
密码。。
//jdbc:mysql://localhost/bank 主协议：子协议 ://本地/数据库
dataSource.setDriverClassName("com.mysql.jdbc.Driver");
dataSource.setUrl("jdbc:mysql://localhost/bank");
dataSource.setUsername("root");
dataSource.setPassword("root");
//2. 得到连接对象
conn = dataSource.getConnection();
String sql = "insert into account values(null , ? , ?)";
ps = conn.prepareStatement(sql);
ps.setString(1, "admin");
ps.setInt(2, 1000);
ps.executeUpdate();
} catch (SQLException e) {
e.printStackTrace();
}finally {
JDBCUtil.release(conn, ps);
}
}
2. 使用配置文件方式：
Connection conn = null;
PreparedStatement ps = null;
try {
BasicDataSourceFactory factory = new BasicDataSourceFactory();
Properties properties = new Properties();
InputStream is = new FileInputStream("src//dbcpconfig.properties");
properties.load(is);
DataSource dataSource = factory.createDataSource(properties); //2. 得到连接对象
conn = dataSource.getConnection();
String sql = "insert into account values(null , ? , ?)";
ps = conn.prepareStatement(sql);
ps.setString(1, "liangchaowei");
ps.setInt(2, 100); ps.executeUpdate(); } catch (Exception e) {
e.printStackTrace();
}finally {
JDBCUtil.release(conn, ps);
}
C3P0
拷贝jar文件 到 lib目录
c3p0-0.9.1.2.jar
不使用配置文件方式
Connection conn = null;
PreparedStatement ps = null;
try {
//1. 创建datasource
ComboPooledDataSource dataSource = new ComboPooledDataSource();
//2. 设置连接数据的信息
dataSource.setDriverClass("com.mysql.jdbc.Driver"); dataSource.setJdbcUrl("jdbc:mysql://localhost/bank");
dataSource.setUser("root");
dataSource.setPassword("root"); //2. 得到连接对象
conn = dataSource.getConnection();
String sql = "insert into account values(null , ? , ?)";
ps = conn.prepareStatement(sql);
ps.setString(1, "admi234n");
ps.setInt(2, 103200); ps.executeUpdate(); } catch (Exception e) {
e.printStackTrace();
}finally {
JDBCUtil.release(conn, ps);
}
使用配置文件方式
//默认会找 xml 中的 default-config 分支。
ComboPooledDataSource dataSource = new ComboPooledDataSource(); //2. 得到连接对象
conn = dataSource.getConnection();
String sql = "insert into account values(null , ? , ?)";
ps = conn.prepareStatement(sql);
ps.setString(1, "admi234n");
ps.setInt(2, 103200);
c3p0-config.xml
<?xml version="1.0" encoding="UTF-8"?>
<c3p0-config> <!-- default-config 默认的配置， -->
<default-config>
<property name="driverClass">com.mysql.jdbc.Driver</property>
<property name="jdbcUrl">jdbc:mysql://localhost/xx</property>
<property name="user">root</property>
<property name="password">xx</property> <property name="initialPoolSize">10</property>
<property name="maxIdleTime">30</property>
<property name="maxPoolSize">100</property>
<property name="minPoolSize">10</property>
<property name="maxStatements">200</property>
</default-config> <!-- This app is massive! -->
<named-config name="oracle">
<property name="acquireIncrement">50</property>
<property name="initialPoolSize">100</property>
<property name="minPoolSize">50</property>
<property name="maxPoolSize">1000</property> <!-- intergalactoApp adopts a different approach to configuring statement caching -->
<property name="maxStatements">0</property>
<property name="maxStatementsPerConnection">5</property> <!-- he's important, but there's only one of him -->
<user-overrides user="master-of-the-universe">
<property name="acquireIncrement">1</property>
<property name="initialPoolSize">1</property>
<property name="minPoolSize">1</property>
<property name="maxPoolSize">5</property>
<property name="maxStatementsPerConnection">50</property>
</user-overrides>
</named-config> </c3p0-config>
DBUtils：
commons-dbutils-1.4.jar
增删改
//dbutils 只是帮我们简化了CRUD 的代码， 但是连接的创建以及 获取工作。 不在他的考虑范围
QueryRunner queryRunner = new QueryRunner(new ComboPooledDataSource()); //增加
//queryRunner.update("insert into account values (null , ? , ? )", "aa" ,1000); //删除
//queryRunner.update("delete from account where id = ?", 5); //更新
//queryRunner.update("update account set money = ? where id = ?", 10000000 , 6);
查询
1. 直接new接口的匿名实现类
QueryRunner queryRunner = new QueryRunner(new ComboPooledDataSource());
Account account = queryRunner.query("select * from account where id = ?",
new ResultSetHandler<Account>(){
@Override
public Account handle(ResultSet rs) throws SQLException {
Account account = new Account();
while(rs.next()){
String name = rs.getString("name");
int money = rs.getInt("money");
account.setName(name);
account.setMoney(money);
}
return account;
}
}, 6);
System.out.println(account.toString());
2. 直接使用框架已经写好的实现类
* 查询单个对象
QueryRunner queryRunner = new QueryRunner(new ComboPooledDataSource());
//查询单个对象
Account account = queryRunner.query("select * from account where id = ?",
new BeanHandler<Account>(Account.class), 8);
//Account.class内部通过反射获取类的实例
//Account.class.newInstance()
* 查询多个对象
QueryRunner queryRunner = new QueryRunner(new ComboPooledDataSource());
List<Account> list = queryRunner.query("select * from account ",
new BeanListHandler<Account>(Account.class));
ResultSetHandler 常用的实现类
以下两个是使用频率最高的
BeanHandler, 查询到的单个数据封装成一个对象
BeanListHandler, 查询到的多个数据封装 成一个List<对象>
其他
ArrayHandler, 查询到的单个数据封装成一个数组
ArrayListHandler, 查询到的多个数据封装成一个集合 ，集合里面的元素是数组。
MapHandler, 查询到的单个数据封装成一个map
MapListHandler,查询到的多个数据封装成一个集合 ，集合里面的元素是map。
ColumnListHandler
KeyedHandler
ScalarHandler 用于处理平均值，总的个数
元数据
Meata data
描述数据的数据 String sql , 描述这份sql字符串的数据叫做元数据
数据库元数据 DatabaseMetaData
参数元数据 ParameterMetaData
结果集元数据 ResultSetMetaData
dbutils自定义：
import java.sql.ResultSet;
/**
* 查询返回结果接口
* @author fly
*
* @param <T>
*/
public interface ResultSetHandler<T> {
public T handle(ResultSet rs);
}
import java.sql.Connection;
import java.sql.ParameterMetaData;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException; import com.fly.util.JDBCUtil2; public class MyQueryRunner {
/**
* 通用查询功能
* @param sql 需要操作的sql语句
* @param rsh 定义查询返回的类型
* @param args sql语句的参数
* @return 查询的结果
*/
public<T> T query(String sql,ResultSetHandler<T> rsh,Object...args) {
Connection conn = null;
PreparedStatement ps = null;
ResultSet rs=null;
try {
conn = JDBCUtil2.getConn();
ps = conn.prepareStatement(sql);
// 参数元数据
ParameterMetaData metaData = ps.getParameterMetaData();
int count = metaData.getParameterCount();
for (int i = 0; i < count; i++) {
ps.setObject(i+1,args[i]);
}
rs = ps.executeQuery();
T t = rsh.handle(rs);
return t; } catch (SQLException e) {
e.printStackTrace();
}finally {
JDBCUtil2.closeAll(conn, ps, rs);
}
return null;
}
/**
* 通用的增删改功能
* @param sql 需要操作的sql语句
* @param args sql语句的参数
* @return 受影响的行数
*/
public int update(String sql,Object...args) {
Connection conn = null;
PreparedStatement ps = null;
try {
conn = JDBCUtil2.getConn();
ps = conn.prepareStatement(sql);
ParameterMetaData metaData = ps.getParameterMetaData();
int count = metaData.getParameterCount();
for (int i = 0; i < count; i++) {
ps.setObject(i+1,args[i]);
}
int update = ps.executeUpdate();
return update;
} catch (SQLException e) {
e.printStackTrace();
}finally {
JDBCUtil2.closeAll(conn, ps);
}
return (Integer) null;
}
}
测试：
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List; import org.junit.Test; public class TestCRUD {
@Test
public void queryDemo() {
MyQueryRunner queryRunner = new MyQueryRunner();
String sql = "select * from account where id=?";
Account account = queryRunner.query(sql, new ResultSetHandler<Account>() { @Override
public Account handle(ResultSet rs) {
try {
Account account = new Account();
if (rs.next()) {
account.setName(rs.getString("name"));
account.setMoney(rs.getInt("money"));
}
return account;
} catch (SQLException e) {
e.printStackTrace();
}
return null;
}
}, 1);
System.out.println(account.toString());
}
@Test
public void queryDemo2() {
MyQueryRunner queryRunner = new MyQueryRunner();
String sql = "select * from account where id>?";
List<Account> accounts = queryRunner.query(sql, new ResultSetHandler<List<Account>>() { @Override
public List<Account> handle(ResultSet rs) {
try {
List<Account> list = new ArrayList<>();
while (rs.next()) {
Account account = new Account();
account.setName(rs.getString("name"));
account.setMoney(rs.getInt("money"));
list.add(account);
}
return list;
} catch (SQLException e) {
e.printStackTrace();
}
return null;
} }, 1);
for (Account account : accounts) {
System.out.println(account.toString());
}
}
@Test
public void updateDamo() {
MyQueryRunner queryRunner = new MyQueryRunner();
// String sql = "insert into account values(null,?,?)";
// String sql = "update account set money=? where name=?";
String sql = "delete from account where name=?";
// int update = queryRunner.update(sql,1000,"lisi");
int update = queryRunner.update(sql,"lisi");
System.out.println(update);
}
}
JDBCUti：
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement; import com.mchange.v2.c3p0.ComboPooledDataSource; public class JDBCUtil2 { static ComboPooledDataSource dataSource = null;
static {
dataSource = new ComboPooledDataSource();
}
/**
* 返回DataSource
* @return
*/
public static DataSource getDataSouse() {
return dataSource;
}
/**
* 返回连接对象
* @return
*/
public static Connection getConn() {
Connection conn = null;
try {
conn = dataSource.getConnection();
} catch (Exception e) {
e.printStackTrace();
}
return conn;
} /**
* 释放资源
* @param conn
* @param st
* @param rs
*/
public static void closeAll(Connection conn,Statement st,ResultSet rs) {
closeRs(rs);
closeSt(st);
closeConn(conn);
}
public static void closeAll(Connection conn,Statement st) {
closeSt(st);
closeConn(conn);
} private static void closeRs(ResultSet rs) {
try {
if (rs!=null) {
rs.close();
}
} catch (SQLException e) {
e.printStackTrace();
}finally {
rs = null;
}
}
private static void closeSt(Statement st) {
try {
if (st!=null) {
st.close();
}
} catch (SQLException e) {
e.printStackTrace();
}finally {
st = null;
}
}
private static void closeConn(Connection conn) {
try {
if (conn!=null) {
conn.close();
}
} catch (SQLException e) {
e.printStackTrace();
}finally {
conn = null;
}
}
}