第一部分:事务
1.事务的简介:
1.1 在一组操作中(比如增加操作,修改操作),只有增加和修改操作都成功之后,这两个操作才能真正的成功.
,如果这两个操作中,有一个失败了,这两个操作都失败了.
1.2 应用的场景:转账的例子.
(1) 有两个人:小奥和小温
(2) 小温转账5000给小奥
(3) 小温少5000,小奥多5000
(4) 产生问题:小温给小奥转账5000,小温少5000,发生异常错误,小奥没有得到钱
(5) 使用事务解决问题
2.mysql中操作事务:
2.0 两个概念
(1) 提交事务:让表中数据真正生效
(2) 回滚事务:回到操作之前的状态
2.1 在mysql中事务默认是自动提交的
2.2 设置mysql的事务提交方式不是自动提交,需要手动提交事务.
(1)查询当前mysql的事务提交方式:show variables like '%commit%';
(2)查询提交方式:set autocommit = off/0; 0---OFF 1---ON
(3)mysql数据库操作事务语句
= 打开事务:start transaction;
= 提交事务:commit;
= 回滚事务:rollback;
3.jdbc操作事务:
3.1 在jdbc操作中,事务也是自动提交的
3.2 设置事务不是自动提交
(1) 在Connection里面setAutoCommit(boolean autocommit),设置是否自动提交
=参数值,默认是true,设置不自动提交设置值false;
(2) 在connection里面commit(),提交事务
(3) 在Connection里面rollback(),回滚事务
3.3 演示转账的例子()
4.事务的特性:
4.1有四个特性
(1)原子性 : 在一组操作中,要么都成功,有一个失败所有的都失败.
(2)一致性 : 在操作之前和之后数据一致的
(3)隔离性 : 多个事务之间的操作不会互相影响的
= 开启第一个事务一
= 开启第二个事务二
== 如果在事务一,添加数据,不提交事务
== 在事务二厘米,查询不到添加的数据的
(4)持久性 : 提交事务之后,数据真正生效
5.如果不考虑事务的隔离性,产生问题(三个读的问题)
5.1脏读
(1)有两个事务,其中一个事务读到另一个事务没有提交的数据
insert into account values('小胖',30000);
insert into account values('小苍',30000);
(2)演示操作步骤:
第一步:打开两个cmd窗口,分别连接数据库,切换到day14;
第二步:在左边的窗口中设置事务的隔离级别 read uncommitted
set session transaction isolation level read uncommitter;
第三步:在两个窗口中分别开启事务
第四步:在右边窗口,小胖给小苍转账10000;
update account sel sal = sal -10000 where username = "小胖";
update account sal sal = sal + 10000 where username = "小苍";
(3)产生的问题: 如果小胖把事务回滚了,小苍查询不到数据,称为脏读.
(4)解决脏读的方法: 设置事务额隔离级别
(5)脏读是一个问题,不允许发生的
5.2不可重复读
(1)有两个事务,其中一个没有提交的事务读到另一事务提交的update的操作
(2) 操作步骤:
第一步:打开两个cmd窗口,分别连接数据库,切换到day14;
第二步:在左边的窗口设置隔离级别 read committed
set session set sal = sal-10000 where username = '小胖';
第三步:在两个窗口中分别开启事务
第四步:在右边窗口,小胖给小苍转账10000;
update account set sal = sal -10000 where username = '小胖';
update account set sal = sal + 10000 where username = '小苍';
第五步: 在左边查询结果,发现数据变化,左边是在一个事务中,没有提交的事务,却读到另一事务中提交的数据.
称为不可重复读
(3)是一种现象,在一些情况下允许发生的
(4)解决脏读的方法:设置事务的隔离级别解决
(5)演示步骤:
第一步:打开两个cmd窗口,分别连接数据库,切换到day14;
第二步:在左边的窗口中设置事务的隔离级别 repeatable read
set session transaction isolation level repeatable read;
第三步:在两个cmd窗口中分别开启事务
第四步:在右边窗口,小胖给小苍转账10000;
update account set sal = sal-10000 where username = '小胖';
update account set sal = sal + 10000 where username = "小苍";
(3)产生问题:如果小胖把事务回滚了,小苍查询不到数据,称为脏读
5.3虚读(幻读)
(1)有两个事务,其中一个没有提交的事务读到另一事务提交的insert的操作
5.4解决读的问题: 设置事务的隔离级别解决
数据库提供四个隔离级别,防止三类读问题:
serializable : 串行的.避免脏读,不可重复读和虚读发生
repeatable read : 重复读.避免脏读,但是不可重复读和虚读有可能发生
read committed : 已提交读.避免脏读,但是不可重复读和虚读有可能发生
read uncommitted : 未提交读.脏读,不可重复读,虚读
隔离级别优先级:read uncommitted << read commited << repeatble read << serializable
(2)mysql数据库默认隔离级别: repeatble read
(3)操作语句
select @@tx isolation; 查询当前事务隔离级别
set session transaction isolation level 设置事务隔离级别
6.JDBC中设置事务的隔离级别
6.1 Connection里面setTransactionIsolation(int lexel)方法设置
= 方法的参数:使用Connection里面常量表示不同的隔离级别
关于事务中掌握内容:
1.mysql里面操作事务语句:
(1) 开启事务:start transaction
(2) 提交事务:commit
(3) 回滚事务:rollback
(4) 在mysql里面默认自动提交
2.jdbc操作事务的三个方法
3.事务的四个特性
4.如果不考虑隔离性,产生三个读的问题
(1)设置事务的隔离级别解决
(2)mysql默认的隔离级别,repeatable read
*/
/*
01.事务_概述
1)."事务"是"数据库"中的概念，它是指针对一个业务，在数据库中要执行多个操作。
例如：银行转账
张三给李四转账1000元；
在数据库中至少要做两个操作：
1).将张三的账户减少1000元；
2).将李四的账户增加1000元；
对于数据库软件，要有能力将多个SQL语句作为一个"整体"，要么全部成功，要么全部失败。
这个整体被执行的业务就叫：事务。
2).我们今天讲到的事务处理的方式：
1).在MySQL中怎样直接操作事务；
2).通过JDBC怎样操作数据库中的事务；
3).通过DBUtils怎样操作数据库中的事务；
02.事务_MySQL中的事务处理
1).自动事务：MySQL的默认事务处理方式
将每条SQL作为一个独立的事务的进行处理，会被立即修改到数据库中。
2).手动事务：
1).关闭自动事务[不常用]：
A).查看当前的事务处理方式：show variables like 'autocommit';
结果：autocommit ON (自动提交--打开)
B).关闭自动提交：
set autocommit = off;
C).发送SQL语句
update users set ....
....
update users set ....
D).提交：
commit;//将把之前发送的所有SQL语句全部更新
或者
回滚：
rollback;//将把之前所有的SQL语句全部取消
注意：此设置只对当前的连接用户有效
2).在"自动事务"的情况下，临时开启一个事务【常用】：
A).临时开启一个事务：
start transaction;
B).发送SQL语句
update users set ....
....
update users set ....
C).提交：
commit;
或者
回滚：
rollback;
注意：不论提交或者回滚，当前的事务立即结束。而且立即恢复到之前的提交模式。
如果不提交或者回滚，就断开连接，后期数据库会将此次事务的所有操作全部回滚。
03.事务_JDBC中的事务处理
......
conn.setAutoCommit(false);//开启事务--设置Connection对象的"自动提交-false"
try{
int row1 = stmt.executeUpdate("update users set loginName = 'aa33' where uid = 1");
int row2 = stmt.executeUpdate("update users set loginName = 'bb33' where uid = 2");
conn.commit();//5.提交
}catch(Exception e){
conn.rollback();//6.回滚事务
}finally{
conn.setAutoCommit(true);//开启自动提交
conn.close();//关闭连接
}
System.out.println("完毕！");
源码:
package cn.baidu.demo01_JDBC中的事务处理;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
public class Demo {
public static void main(String[] args) throws Exception {
//1.注册驱动
Class.forName("com.mysql.jdbc.Driver");
//2.获取连接对象
Connection conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/hei66_day21","root","123");
//3.开启事务--设置Connection对象的"自动提交-false"
conn.setAutoCommit(false);
//4.发送SQL语句
Statement stmt = conn.createStatement();
try{
int row1 = stmt.executeUpdate("update users set loginName = 'aa33' where uid = 1");
int row2 = stmt.executeUpdate("update users set loginName = 'bb33' where uid = 2");
//5.提交
conn.commit();
System.out.println("提交事务......");
}catch(Exception e){
//6.回滚事务
conn.rollback();
System.out.println("回滚事务......");
}finally{
//开启自动提交
conn.setAutoCommit(true);
//关闭连接
conn.close();
}
System.out.println("完毕！");
}
}
04.事务_DBUtils中的事务处理
QueryRunner qr = new QueryRunner();//1.创建一个QueryRunner对象
//2.获取一个Connection对象
ComboPooledDataSource ds = new ComboPooledDataSource();
Connection conn = ds.getConnection();
//设置为手动提交
conn.setAutoCommit(false);
//3.发送SQL语句
String sql1 = "update users set loginName = 'aa55' where uid = 1";
String sql2 = "update users2 set loginName = 'bb55' where uid = 2";
try{
int row1 = qr.update(conn, sql1);//【注意--调用的update方法要接收一个Connection对象】
int row2 = qr.update(conn, sql2);//【注意--调用的update方法要接收一个Connection对象】
//提交
conn.commit();
System.out.println("提交事务......");
}catch(Exception e){
//回滚
conn.rollback();
System.out.println("回滚事务......");
}finally{
//设置为自动提交
conn.setAutoCommit(true);
//回收连接
conn.close();
}
源码:
package cn.baidu.demo02_DBUtils中的事务处理;
import java.sql.Connection;
import java.sql.Statement;
import org.apache.commons.dbutils.QueryRunner;
import com.mchange.v2.c3p0.ComboPooledDataSource;
public class Demo {
public static void main(String[] args) throws Exception {
//1.创建一个QueryRunner对象
QueryRunner qr = new QueryRunner();
//2.获取一个Connection对象
ComboPooledDataSource ds = new ComboPooledDataSource();
Connection conn = ds.getConnection();
//设置为手动提交
conn.setAutoCommit(false);
//3.发送SQL语句
String sql1 = "update users set loginName = 'aa55' where uid = 1";
String sql2 = "update users2 set loginName = 'bb55' where uid = 2";
try{
int row1 = qr.update(conn, sql1);
int row2 = qr.update(conn, sql2);
//提交
conn.commit();
System.out.println("提交事务......");
}catch(Exception e){
//回滚
conn.rollback();
System.out.println("回滚事务......");
}finally{
//设置为自动提交
conn.setAutoCommit(true);
//回收连接
conn.close();
}
}
}
-----------------------------------------------------------------------------------
05.MVC模式_不使用MVC模式实现登录注册案例
package cn.baidu.demo03_不使用MVC模式实现登录注册案例;
import java.sql.SQLException;
import java.util.Scanner;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
public class Demo {
public static void main(String[] args) throws SQLException {
Scanner sc = new Scanner(System.in);
while(true){
System.out.println("1.登录 2.注册 3.退出:");
int op = sc.nextInt();
switch(op){
case 1://登录
toLogin();
break;
case 2://注册
toRegist();
break;
case 3://退出
System.out.println("谢谢使用！！");
System.exit(0);
default:
System.out.println("错误的输入！");
break;
}
}
}
//注册
private static void toRegist() throws SQLException {
Scanner sc = new Scanner(System.in);
System.out.println("请输入用户名：");
String loginName = sc.next();
System.out.println("请输入密码：");
String loginPwd = sc.next();
//1.验证用户名和密码的字符
//略
//2.数据库验证--用户名不能重复
QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
String sql = "select * from users where loginName = ?";
User userBean = qr.query(sql, new BeanHandler
if(userBean != null){
System.out.println("用户名：" + loginName + " 已存在！");
return;
}
//3.将这条信息写入到数据库
sql = "insert into users values(null,?,?)";
int row = qr.update(sql,loginName,loginPwd);
if(row > 0){
System.out.println("注册成功！");
}else{
System.out.println("注册失败！");
}
}
//登录
private static void toLogin() throws SQLException {
Scanner sc = new Scanner(System.in);
System.out.println("请输入登录名：");
String loginName = sc.next();
System.out.println("请输入密码：");
String loginPwd = sc.next();
//查询数据
QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
String sql = "select * from users where loginName = ? and loginPwd = ?";
User user = qr.query(sql, new BeanHandler
if(user != null){
System.out.println("欢迎：" + loginName + " 登录系统！！");
}else{
System.out.println("用户名或密码错误！！");
}
}
}
package cn.baidu.demo03_不使用MVC模式实现登录注册案例;
import javax.sql.DataSource;
import com.mchange.v2.c3p0.ComboPooledDataSource;
public class JDBCUtils {
private static ComboPooledDataSource dataSource = new ComboPooledDataSource();
public static DataSource getDataSource(){
return dataSource;
}
}
06.MVC模式_使用MVC模式实现登录
MVC模式:(MVC模式产生的原因)如果将程序的所有代码写在一个类中,这样代码量太大,会对后期程序维护造成困难.
什么是MVC模式呢?
A:任何的程序都可以分为两部分代码:
1.用于接收用户数据,为用户显示数据的代码:视图层 例如:键盘录入和输出语句
2.用于业务逻辑处理的代码 :控制层 例如:数据逻辑处理和执行SQL语句等
3.作为逻辑模型 :模型层 例如:JavaBean
B:作为企业级开发,要分五层:
1.视图层(View)(1.接收数据;2.显示数据)
2.控制层(Controller)(1.业务分发:查找相应的业务层)
3.业务层(Service)(1.负责处理具体的业务逻辑)
4.持久层(DAO)(1.所有访问数据库的代码)
5.数据类型(类:Model)
(从1-5,进过数据库再返回去5-1)
好处:1.将不同功能的代码分到不同的类中,使一个类中都具有相同功能的代码(高内聚)
2.从视图层-->控制层-->业务层-->持久层 有一个"顺序的依赖关系",反向,则没有这种依赖关系,相互独立.(低耦合)
注意:1.从视图层到持久层,之间是顺序的依赖关系,不能跳级.
2.返现不存在依赖关系,不能在底层主动调用上一层的类中的方法.
/*
package cn.baidu.demo04_MVC实现登录注册;
public class UserModel {
private Integer uid;
private String loginName;
private String loginPwd;
public UserModel(Integer uid, String loginName, String loginPwd) {
super();
this.uid = uid;
this.loginName = loginName;
this.loginPwd = loginPwd;
}
public UserModel() {
super();
// TODO Auto-generated constructor stub
}
public Integer getUid() {
return uid;
}
public void setUid(Integer uid) {
this.uid = uid;
}
public String getLoginName() {
return loginName;
}
public void setLoginName(String loginName) {
this.loginName = loginName;
}
public String getLoginPwd() {
return loginPwd;
}
public void setLoginPwd(String loginPwd) {
this.loginPwd = loginPwd;
}
@Override
public String toString() {
return "User [uid=" + uid + ", loginName=" + loginName + ", loginPwd=" + loginPwd + "]";
}
}
package cn.baidu.demo04_MVC实现登录注册;
import javax.sql.DataSource;
import com.mchange.v2.c3p0.ComboPooledDataSource;
public class JDBCUtils {
private static ComboPooledDataSource dataSource = new ComboPooledDataSource();
public static DataSource getDataSource(){
return dataSource;
}
}
/*
* 视图层:只接受和输出语句,显示
*
*/
public class View {
private Controller control = new Controller();
public void start() {
Scanner sc = new Scanner(System.in);
while(true) {
System.out.println("1.登录 2.注册 3.退出");
int op = sc.nextInt();
switch(op) {
case 1://登录
toLogin();
break;
case 2://注册
toRegist();
break;
case 3://退出
System.out.println("谢谢使用!!");
System.exit(0);
default :
System.out.println("错误的输入!");
break;
}
}
}
//注册
private void toRegist() {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);
System.out.println("请输入用户名:");
String loginName = sc.nextLine();
System.out.println("请输入密码:");
String loginPwd = sc.nextLine();
//把接收的数据封装到一个User对象
UserModel user = new UserModel();
user.setLoginName(loginName);
user.setLoginPwd(loginPwd);
//调用控制层
try{
if(control.toRegist(user)) {
System.out.println("注册成功!");
}else {
System.out.println("注册失败!");
}
} catch (Exception e) {
e.printStackTrace();
}
}
//登录
private void toLogin() {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);
System.out.println("请输入登录名:");
String loginName = sc.nextLine();
System.out.println("请输入密码:");
String loginPwd = sc.nextLine();
//封装JavaBean
UserModel user = new UserModel();
user.setLoginName(loginName);
user.setLoginPwd(loginPwd);
//调用控制层
try {
if(this.control.toLogin(user)) {
System.out.println("欢迎:" + loginName + "登录系统!");
//启动学员信息管理的视图层代码
}else {
System.out.println("登录失败!可能的原因:用户名和密码错误!");
}
}catch (Exception e) {
e.printStackTrace();
}
}
}
package com.baidu_02;
/*
* 控制层:进行业务分发,发给业务层
*
*/
public class Controller {
private Service service = new Service();
//1.注册
public boolean toRegist(UserModel user) throws Exception {
//1.调用Service
return service.toRegist(user);
}
//2.登录
public boolean toLogin(UserModel user) throws Exception {
//调用Service
return service.toLogin(user);
}
}
//业务层:主要进行逻辑处理
public class Service {
private DAO dao = new DAO();
//1.注册:
public boolean toRegist(UserModel user) throws Exception {
/*
* 1.验证用户名和密码的字符
* 用户名6-12个字符,由数字,大小字母,小写字母组成
* 密码:必须是6位数字
*
*/
String regex = "[0-9,A-Z,a-z]{6,12}";
if(!user.getLoginName().matches(regex)) {
return false;
}
// \\d 表示数字
regex = "\\d{6}";
if(!user.getLoginPwd().matches(regex)) {
return false;
}
//2.数据库验证--用户名不能重复--调用DAO
UserModel resultUser = dao.findByLoginName(user.getLoginName());
//此用户名已经被使用
if(resultUser != null) {
return false;
}
//3.将这条信息写入到数据库
return dao.save(user);
}
//2.登录
public boolean toLogin(UserModel user) throws Exception {
//1.做一些用户名和密码的字符验证
//...
//2.查询此用户
UserModel resultBean = dao.findByLoginAndPassword(user);
return resultBean != null;
}
}
//持久层:主要对数据库进行操作
public class DAO {
private QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
//1.使用用户名查询一条记录
public UserModel findByLoginName(String loginName) throws Exception {
String sql = "select * from user where loginName = ?";
UserModel user = qr.query(sql, new BeanHandler
//查到返回:UserModel对象:否则:返回NULL
return user;
}
//2.写入一条记录
public boolean save(UserModel user) throws Exception {
String sql = "insert into user values(null,?,?)";
int row = qr.update(sql, user.getLoginName(),user.getLoginPwd());
//如果不影响1行: 返回true;如果影响0行:返回false
return row > 0;
}
//3.用户名和密码查询一个用户
public UserModel findByLoginAndPassword(UserModel user) throws Exception {
String sql = "select * from user where loginName = ? and loginPwd = ?";
//这里的BeanHandler是因为查询满足条件的数据的第一条记录
UserModel query = qr.query(sql, new BeanHandler
return query;
}
}
/*
07.转账案例_MVC模式部署分析
08.转账案例_MVC模式事务处理实现
10.线程间共享对象实现_ThreadLocal
11.转账案例_使用ThreadLocal实现在service层和DAO层实现共享Connection对象
其实从程序角度看，tlt变量的确是一个，毫无疑问的。但是为什么打印出来的数字就互不影响呢？
是因为使用了Integer吗？-----不是。
原因是：protected T initialValue()和get()，因为每个线程在调用get()时候，发现Map中不存在就创建。调用它的时候，就创建了一个新变量
，类型为T。每次都新建，当然各用个的互不影响了。
意义:
1.提供了保存对象的方法：每个线程中都有一个自己的ThreadLocalMap类对象，可以将线程自己的对象保持到其中，各管各的，线程可以正确的访问到自己的对象。
2.避免参数传递的方便的对象访问方式：将一个共用的ThreadLocal静态实例作为key，将不同对象的引用保存到不同线程的ThreadLocalMap中，然后在线程执行的各处通过这个静态ThreadLocal实例的get()
方法取得自己线程保存的那个对象，避免了将这个对象作为参数传递的麻烦。
理解ThreadLocal中提到的变量副本
“当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本” —— 并不是通过ThreadLocal.set( )实现的，而是每个线程使用“new对象”（或拷贝） 的操作来创建对象副本, 通过ThreadLocal.set()将这个新创建的对象的引用保存到各线程的自己的一个map中，每个线程都有这样一个map，执行ThreadLocal.get()时，各线程从自己的map中取出放进去的对象，因此取出来的是各自自己线程中的对象（ThreadLocal实例是作为map的key来使用的）。
如果ThreadLocal.set( )进去的对象是多线程共享的同一个对象，那么ThreadLocal.get( )取得的还是这个共享对象本身 —— 那么ThreadLocal还是有并发访问问题的！
解决线程安全问题，本质上就是解决资源共享问题，一般有以下手段：
1）可重入（不依赖环境）；2）互斥（同一时间段只允许一个线程使用）；3）原子操作；4）Thread-Local
为了保证函数是可重入的，需要做到一下几点：
1，不在函数内部使用静态或者全局数据
2，不返回静态或者全局数据，所有的数据都由函数调用者提供
3，使用本地数据，或者通过制作全局数据的本地拷贝来保护全局数据
4， 如果必须访问全局数据，使用互斥锁来保护
5，不调用不可重入函数
可重入函数：可重入函数是线程安全函数的一种，其特点在于它们被多个线程调用时，不会引用任何共享数据。
可重入函数通常要比不可重入的线程安全函数效率高一些，因为它们不需要同步操作。更进一步说，将第2类线程不安全函数转化为线程安全函数的唯一方法就是重写它，使之可重入。
显式可重入函数：如果所有函数的参数都是传值传递的（没有指针），并且所有的数据引用都是本地的自动栈变量（也就是说没有引用静态或全局变量），那么函数就是显示可重入的，也就是说不管如何调用，我们都可断言它是可重入的。
隐式可重入函数：可重入函数中的一些参数是引用传递（使用了指针），也就是说，在调用线程小心地传递指向非共享数据的指针时，它才是可重入的。例如rand_r就是隐式可重入的。
我们使用可重入（reentrant）来包括显式可重入函数和隐式可重入函数。然而，可重入性有时是调用者和被调用者共有的属性，并不只是被调用者单独的属性。
原子操作是指不会被线程调度机制打断的操作；这种操作一旦开始，就一直运行到结束，中间不会有任何 context switch （切[1] 换到另一个线程）.
public class View {
public void start(){
Scanner sc = new Scanner(System.in);
System.out.println("转出方：");
String outUserName = sc.next();
System.out.println("转入方：");
String inUserName = sc.next();
System.out.println("转账金额：");
int money = sc.nextInt();
//封装JavaBean
TransBean t = new TransBean();
t.setOutUserName(outUserName);
t.setInUserName(inUserName);
t.setMoney(money);
Thread tt;
//调用控制层
Controller contrl = new Controller();
try {
if(contrl.toTrans(t)){
System.out.println("转账成功！");
}else{
System.out.println("转账失败，所有操作被取消！");
}
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
public class Controller {
public boolean toTrans(TransBean t) throws SQLException{
//调用服务层
Service service = new Service();
return service.toTrans(t);
}
}
public class Service {
private DAO dao = new DAO();
public boolean toTrans(TransBean t) throws SQLException{
//1.验证账户是否存在；
AccountBean acc = dao.findByUserName(t.getOutUserName());
if(acc == null){
return false;
}
acc = dao.findByUserName(t.getInUserName());
if(acc == null){
return false;
}
//2.验证转出方的余额是否支持转账；
Integer outBalance = dao.findBalanceByUserName(t.getOutUserName());
if(t.getMoney() > outBalance){
return false;
}
//3.事务处理实施转账业务；
//1.获取一个连接对象
Connection conn = JDBCUtils.getDataSource().getConnection();
//2.关闭自动提交
conn.setAutoCommit(false);
//将conn通过ThreadLocal存储到当前线程的map中
Const.local.set(conn);
//3.调用dao，执行转账
try{
boolean b1 = dao.updateBalanceByUserName(t.getOutUserName(), -t.getMoney());
int i = 10 / 0;
boolean b2 = dao.updateBalanceByUserName(t.getInUserName(), t.getMoney());
if(b1 && b2){
//4.提交
conn.commit();
return true;
}else{
//5.回滚
conn.rollback();
return false;
}
}catch(Exception e){
//5.回滚
conn.rollback();
return false;
}finally{
conn.setAutoCommit(true);//还原为自动事务
conn.close();//归还到连接池中
}
}
}
public class DAO {
private QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
//1.使用用户名查找一个用户
public AccountBean findByUserName(String userName) throws SQLException{
String sql = "select * from account where username = ?";
AccountBean acc = qr.query(sql, new BeanHandler
return acc;
}
//2.获取某个用户的余额
public Integer findBalanceByUserName(String userName) throws SQLException{
String sql = "select balance from account where username = ?";
Object result = qr.query(sql, new ScalarHandler(),userName);
if(result != null){
return Integer.valueOf(result.toString());
}
return null;
}
//3.修改某个账户的余额
public boolean updateBalanceByUserName(String userName,Integer money) throws SQLException{
String sql = "update account set balance = balance + ? where username = ?";
//通过ThreadLocal从当前线程对象的Map中获取conn
int row = qr.update(Const.local.get(), sql, money,userName);
return row > 0;
}
}
public class Const {
public static ThreadLocal
}
07.转账案例_MVC模式部署分析
/*
* 前端的JavaBean，跟前端表单对应
*/
public class TransBean {
private String outUserName;
private String inUserName;
private Integer money;
public TransBean(String outUserName, String inUserName, Integer money) {
super();
this.outUserName = outUserName;
this.inUserName = inUserName;
this.money = money;
}
public TransBean() {
super();
// TODO Auto-generated constructor stub
}
public String getOutUserName() {
return outUserName;
}
public void setOutUserName(String outUserName) {
this.outUserName = outUserName;
}
public String getInUserName() {
return inUserName;
}
public void setInUserName(String inUserName) {
this.inUserName = inUserName;
}
public Integer getMoney() {
return money;
}
public void setMoney(Integer money) {
this.money = money;
}
@Override
public String toString() {
return "TransBean [outUserName=" + outUserName + ", inUserName=" + inUserName + ", money=" + money + "]";
}
}
/*
* 后端的JavaBean，跟表结构相同
*/
public class AccountBean {
private Integer id;
private String username;
private Integer money;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public Integer getMoney() {
return money;
}
public void setMoney(Integer money) {
this.money = money;
}
public AccountBean() {
super();
// TODO Auto-generated constructor stub
}
public AccountBean(Integer id, String username, Integer money) {
super();
this.id = id;
this.username = username;
this.money = money;
}
@Override
public String toString() {
return "Account [id=" + id + ", username=" + username + ", money=" + money + "]";
}
}
package cn.baidu.demo05_MVC_结合事务处理实现转账案例;
import javax.sql.DataSource;
import com.mchange.v2.c3p0.ComboPooledDataSource;
public class JDBCUtils {
private static ComboPooledDataSource dataSource = new ComboPooledDataSource();
public static DataSource getDataSource(){
return dataSource;
}
}
import java.util.Scanner;
//视图层
public class View {
public void start(){
Scanner sc = new Scanner(System.in);
System.out.println("转出方：");
String outUserName = sc.next();
System.out.println("转入方：");
String inUserName = sc.next();
System.out.println("转账金额：");
int money = sc.nextInt();
//封装JavaBean
TransBean t = new TransBean();
t.setOutUserName(outUserName);
t.setInUserName(inUserName);
t.setMoney(money);
Thread tt;
//调用控制层
Controller contrl = new Controller();
try {
if(contrl.toTrans(t)){
System.out.println("转账成功！");
}else{
System.out.println("转账失败，所有操作被取消！");
}
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
//控制层
public class Controller {
public boolean toTrans(TransBean t) throws SQLException{
//调用服务层
Service service = new Service();
return service.toTrans(t);
}
}
//业务层或者服务层
public class Service {
private DAO dao = new DAO();
public boolean toTrans(TransBean t) throws SQLException{
//1.验证账户是否存在；
AccountBean acc = dao.findByUserName(t.getOutUserName());
if(acc == null){
return false;
}
acc = dao.findByUserName(t.getInUserName());
if(acc == null){
return false;
}
//2.验证转出方的余额是否支持转账；
Integer outBalance = dao.findBalanceByUserName(t.getOutUserName());
if(t.getMoney() > outBalance){
return false;
}
//3.事务处理实施转账业务；
//1.获取一个连接对象
Connection conn = JDBCUtils.getDataSource().getConnection();
//2.关闭自动提交
conn.setAutoCommit(false);
//3.调用dao，执行转账
try{
boolean b1 = dao.updateBalanceByUserName(conn,t.getOutUserName(), -t.getMoney());
// int i = 10 / 0;
boolean b2 = dao.updateBalanceByUserName(conn,t.getInUserName(), t.getMoney());
if(b1 && b2){
//4.提交
conn.commit();
return true;
}else{
//5.回滚
conn.rollback();
return false;
}
}catch(Exception e){
//5.回滚
conn.rollback();
return false;
}finally{
conn.setAutoCommit(true);//还原为自动事务
conn.close();//归还到连接池中
}
}
}
public class DAO {
private QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
//1.使用用户名查找一个用户
public AccountBean findByUserName(String userName) throws SQLException{
String sql = "select * from account where username = ?";
AccountBean acc = qr.query(sql, new BeanHandler
return acc;
}
//2.获取某个用户的余额
public Integer findBalanceByUserName(String userName) throws SQLException{
String sql = "select balance from account where username = ?";
Object result = qr.query(sql, new ScalarHandler(),userName);
if(result != null){
return Integer.valueOf(result.toString());
}
return null;
}
//3.修改某个账户的余额
public boolean updateBalanceByUserName(Connection conn,String userName,Integer money) throws SQLException{
String sql = "update account set balance = balance + ? where username = ?";
int row = qr.update(conn, sql, money,userName);
return row > 0;
}
}
08.转账案例_MVC模式事务处理实现
10.线程间共享对象实现_ThreadLocal
11.转账案例_使用ThreadLocal实现在service层和DAO层实现共享Connection对象
------------------------以下内容【了解】-------------------------------------------
12.事务的特性_ACID
原子性：强调事务的不可分割.多条语句要么都成功，要么都失败。
一致性：强调的是事务的执行的前后，数据要保持一致.
隔离性：一个事务的执行不应该受到其他事务的干扰.
持久性：事务一旦结束(提交/回滚)数据就持久保持到了数据库.
13.事务的特性_不考虑事务的隔离性可能引发的问题
* 脏读 :一个事务读到另一个事务还没有提交的数据.
* 不可重复读 :一个事务读到了另一个事务已经提交的update的数据,导致在当前的事务中多次查询结果不一致.
* 虚读/幻读 :一个事务读到另一个事务已经提交的insert的数据,导致在当前的事务中多次的查询结果不一致.
14.事务的特性_解决引发的读问题
设置事务的隔离级别:
1 read uncommitted :未提交读.脏读，不可重复读，虚读都可能发生.
2 read committed :已提交读.避免脏读.但是不可重复读和虚读有可能发生.（Oracle默认）
4 repeatable read :可重复读.避免脏读,不可重复读.但是虚读有可能发生.（MySql默认）
8 serializable :串行化的.避免脏读，不可重复读，虚读的发生.
1).查看当前事务的隔离级别：
select @@tx_isolation;
2).设置当前事务的隔离级别：
set session transaction isolation level 上面1，2,4,8四个隔离级别名称之一;
3).级别超高，越安全，效率越低。
==========================================================================================================================
学习目标总结：
1、理解事务的概念
a. 能够说出事务的概念
事务指的是逻辑上的一组操作(多条sql语句),组成这组操作的各个单元要么全都成功,要么全都失败。
b. 能够说出事务的特性
原子性：强调事务的不可分割.多条语句要么都成功，要么都失败。
一致性：强调的是事务的执行的前后，数据要保持一致.
隔离性：一个事务的执行不应该受到其他事务的干扰.
持久性：事务一旦结束(提交/回滚)数据就持久保持到了数据库.
2、理解脏读,不可重复读,幻读的概念及解决办法
a. 能够说出不考虑事务的隔离性会出现的问题
1.脏读:一个事务读到另一个事务还没有提交的数据.
2.不可重复读:一个事务读到了另一个事务已经提交的update的数据,导致在当前的事务中多次查询结果不一致.
3.虚读/幻读:一个事务读到另一个事务已经提交的insert的数据,导致在当前的事务中多次的查询结果不一致.
b. 能够说出如何使用事务的隔离级别分别可以解决哪些问题
1 read uncommitted:什么都没解决。
2 read committed:只解决脏读。（Oracle默认）
4 repeatable read:解决了脏读、不可重复读、(MYSQL中也解决了虚读)（MySql默认）
8 serializable:将两个事务完全隔离，一个事务没有执行完毕，另一个事务只能等待；
3、能够在MySQL中使用事务
a. 说出mysql中对事务支持的特点
1.自动事务：MySQL默认
2.手动事务：
b. 使用命令行手动开启事务
start transaction;
c. 使用命令行手动提交事务
commit;
d. 使用命令行手动回滚事务
rollback;
e. 说出MySQL数据库的默认隔离级别
repeatable read
4、能够在转账功能中使用DBUtils开发包完成事务控制
a. 能够编写一个转账的程序功能
b. 能够在程序中添加事务保证转账程序的数据正确
5、能够使用DBUtils并通过ThreadLocal绑定Connection的方式控制事务
a. 独立编写操作数据库的JDBC程序
b. 能够在程序中使用ThreadLocal绑定Connection的方式控制事务