java核心技术第五篇之事务和MVC模式

第一部分:事务

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

你可能感兴趣的:(java核心技术第五篇之事务和MVC模式)