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

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

扫码关注云+社区

领取腾讯云代金券