事务
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; } } }