第一部分:事务

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(User.class),loginName);

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(User.class),loginName,loginPwd);

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.class), loginName);

//查到返回: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(UserModel.class), user.getLoginName(),user.getLoginPwd());

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(AccountBean.class),userName);

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 local = new 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(AccountBean.class),userName);

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的方式控制事务