【原创】Spring连接、事务代码分析
1.JdbcTemplate
ConnectionHolder conHolder = (ConnectionHolder) TransactionSynchronizationManager.getResource(dataSource);
if (conHolder != null && (conHolder.hasConnection() || conHolder.isSynchronizedWithTransaction())) {
conHolder.requested();
if (!conHolder.hasConnection()) {
logger.debug("Fetching resumed JDBC Connection from DataSource");
conHolder.setConnection(dataSource.getConnection());
}
return conHolder.getConnection();//首先从当前的线程上下文中获取
}
// Else we either got no holder or an empty thread-bound holder here. logger.debug("Fetching JDBC Connection from DataSource");
public Object execute(StatementCallback action) throws DataAccessException {
Assert.notNull(action, "Callback object must not be null"); Connection con = DataSourceUtils.getConnection(getDataSource());
Statement stmt = null;
try {
Connection conToUse = con;
if (this.nativeJdbcExtractor != null &&
this.nativeJdbcExtractor.isNativeConnectionNecessaryForNativeStatements()) {
conToUse = this.nativeJdbcExtractor.getNativeConnection(con);
}
stmt = conToUse.createStatement();
applyStatementSettings(stmt);
Statement stmtToUse = stmt;
if (this.nativeJdbcExtractor != null) {
stmtToUse = this.nativeJdbcExtractor.getNativeStatement(stmt);
}
Object result = action.doInStatement(stmtToUse);
SQLWarning warning = stmt.getWarnings();
throwExceptionOnWarningIfNotIgnoringWarnings(warning);
return result;//返回语句执行的结果
}
catch (SQLException ex) {
// Release Connection early, to avoid potential connection pool deadlock
// in the case when the exception translator hasn't been initialized yet.
JdbcUtils.closeStatement(stmt);
stmt = null;
DataSourceUtils.releaseConnection(con, getDataSource());
con = null;
throw getExceptionTranslator().translate("StatementCallback", getSql(action), ex);
}
finally {
JdbcUtils.closeStatement(stmt);//最后释放资源关闭连接
DataSourceUtils.releaseConnection(con, getDataSource());
}
}
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="datasource"/>
然后定义一个:DefaultTransactionDefinition
DefaultTransactionDefinition def = new DefaultTransactionDefinition(); def.setIsolationLevel(TransactionDefinition.ISOLATION_READ_COMMITTED); def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
由此创建一个TransactionStatus:
private TransactionStatus beginTransaction(){
DefaultTransactionDefinition def = new DefaultTransactionDefinition();
def.setIsolationLevel(TransactionDefinition.ISOLATION_READ_COMMITTED);
def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
return getMager().getTransaction(def);
}
private DataSourceTransactionManager getMager(){
DataSourceTransactionManager man= (DataSourceTransactionManager) con.getBean("transactionManager");
return man;
}
下面看创建status时做了什么?
connectionholder字面意思为连接持有者,即为每个线程保存绑定连接的对象,每个线程绑定的连接保存在该对象中,然后保存在一个map里面,key为当前的DataSource,该DataSource为应用程序级的,可以是一个tns连接描述,也可以是一个jndi也可以是一个连接池对象,总之所有线程共享,通过该key值找到线程自己通过该DateSource创建的连接,该Map保存到线程自己的本地变量中,以便下次获取,下次线程获取连接时,首先去自己的本地变量中寻找map,看map释放为空,如果为空,说明没有绑定的连接,直接创建,若有,则通过jdbcTemplate中的DataSource对象作为key去map中拿出绑定的连接使用。
protected void doBegin(Object transaction, TransactionDefinition definition) {
DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction; Connection con = null; try {
if (txObject.getConnectionHolder() == null) {//如果当前的connectionholder不存在
Connection newCon = this.dataSource.getConnection();//则创建一个新连接
if (logger.isDebugEnabled()) {
logger.debug("Acquired Connection [" + newCon + "] for JDBC transaction");
}
txObject.setConnectionHolder(new ConnectionHolder(newCon), true);//并将该连接进行持有
} txObject.getConnectionHolder().setSynchronizedWithTransaction(true);
con = txObject.getConnectionHolder().getConnection(); Integer previousIsolationLevel = DataSourceUtils.prepareConnectionForTransaction(con, definition);
txObject.setPreviousIsolationLevel(previousIsolationLevel); // Switch to manual commit if necessary. This is very expensive in some JDBC drivers,
// so we don't want to do it unnecessarily (for example if we've explicitly
// configured the connection pool to set it already).
if (con.getAutoCommit()) {
txObject.setMustRestoreAutoCommit(true);
if (logger.isDebugEnabled()) {
logger.debug("Switching JDBC Connection [" + con + "] to manual commit");
}
con.setAutoCommit(false);//为事务做准备
}
txObject.getConnectionHolder().setTransactionActive(true); if (definition.getTimeout() != TransactionDefinition.TIMEOUT_DEFAULT) {
txObject.getConnectionHolder().setTimeoutInSeconds(definition.getTimeout());
} // Bind the session holder to the thread.
if (txObject.isNewConnectionHolder()) {
TransactionSynchronizationManager.bindResource(getDataSource(), txObject.getConnectionHolder());
}//重要的一步,将该连接和当前的线程进行绑定,并将该连接的自动提交设为false,为事务使用做准备
} catch (SQLException ex) {//出现异常则关闭任何打开的连接,物理释放
DataSourceUtils.releaseConnection(con, this.dataSource);
throw new CannotCreateTransactionException("Could not open JDBC Connection for transaction", ex);
}
}
这时,status其实就是将连接和当前线程绑定,然后做一些必要的准备工作,如事务传播级别等等的设置:
public static void bindResource(Object key, Object value) throws IllegalStateException {
Assert.notNull(key, "Key must not be null");
Assert.notNull(value, "Value must not be null");
Map map = (Map) resources.get();//从ThreadLocal中获取当前连接信息的Map结构
// set ThreadLocal Map if none found
if (map == null) {
map = new HashMap();
resources.set(map);//如果未找到,则将其设置进去
}
if (map.containsKey(key)) {
throw new IllegalStateException("Already value [" + map.get(key) + "] for key [" + key +
"] bound to thread [" + Thread.currentThread().getName() + "]");
}
map.put(key, value);
if (logger.isDebugEnabled()) {
logger.debug("Bound value [" + value + "] for key [" + key + "] to thread [" +
Thread.currentThread().getName() + "]");
}
}
如果想获得当前会话中执行的数据库连接,则使用以下方法:
Connection conn = DataSourceUtils.getConnection(dataSource);
这个获得和当前事务绑定的连接,否则使用getDataSource().getConnection()会创建一个全新的连接,这样会造成出现事务从而被隔离了。
当执行了getTransaction方法并返回一个TransactionStatus之后,表示事务已经开启了,后续所有的执行语句的操作都会使用一个数据库连接,而该连接在步骤1中会自动从当前线程的上下文中获取:
public static Object getResource(Object key) {
Assert.notNull(key, "Key must not be null");
Map map = (Map) resources.get();//从当前线程的上下文中拿到线程保持的map,为什么不直接将连接保持到resources中,而是放入一个map再放入resource中呢?原因是,类TransactionSynchronizationManager为一个事务同步的管理器,不光是为了持有连接,还有其他资源,所以,将线程自身其他的一些资源放入map,可以保寸多种对象不至于和其他线程产生冲突
if (map == null) {
return null;
}
Object value = map.get(key);//如果是想拿到连接,此时的key是一个DataSource对象,说明是想从线程的变量集合中拿到本线程绑定的数据库连接
if (value != null && logger.isDebugEnabled()) {
logger.debug("Retrieved value [" + value + "] for key [" + key + "] bound to thread [" +
Thread.currentThread().getName() + "]");
}
return value;
}
未来后续的所有的操作使用的连接都将是该连接,而不是建立新的连接,这和不使用事务时有根本的区别。而事务开始之后,每个语句执行完毕之后,finally语句都会关闭连接释放资源,那么此时将会如何执行呢?
public static void doReleaseConnection(Connection con, DataSource dataSource) throws SQLException {
if (con == null) {
return;
} if (dataSource != null) {
ConnectionHolder conHolder = (ConnectionHolder) TransactionSynchronizationManager.getResource(dataSource);
if (conHolder != null && conHolder.hasConnection() && connectionEquals(conHolder.getConnection(), con)) {//在status创建时初始化的holder对象在这个地方区分出到底是事务连接还是普通的非事务连接,如果是事务连接,那么执行Holder自己的释放方法
// It's the transactional Connection: Don't close it.
conHolder.released();
return;
}
} // Leave the Connection open only if the DataSource is our
// special data source, and it wants the Connection left open.
if (!(dataSource instanceof SmartDataSource) || ((SmartDataSource) dataSource).shouldClose(con)) {
logger.debug("Returning JDBC Connection to DataSource");
con.close();//这是不使用事务时使用的释放方法,即为物理关闭连接,执行完后,该连接即实实在在的关闭
}
}
那么conHolder.released();如何执行呢?
public void released() {
this.referenceCount--;
if (this.currentConnection != null) {
this.connectionHandle.releaseConnection(this.currentConnection);//这是一个空方法
this.currentConnection = null;//释放引用
}
}
protected void doCleanupAfterCompletion(Object transaction) {
DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction; // Remove the connection holder from the thread, if exposed.
if (txObject.isNewConnectionHolder()) {
TransactionSynchronizationManager.unbindResource(this.dataSource);//解除连接绑定
} // Reset connection.
Connection con = txObject.getConnectionHolder().getConnection();
try {
if (txObject.isMustRestoreAutoCommit()) {
con.setAutoCommit(true);//虽然将要关闭连接,但是仍然将该连接的自动提交恢复,为什么呢?原因就是,该连接可能是从连接池中拿到的,从连接池中拿到的连接并不会真正关闭,而是返回连接池,因此需要将该连接重置初始化,否则该连接被其他线程拿到时会影响执行结果,如无法自动提交,丢失事务等。可见spring想的非常周到。而且后续会将该连接一系列的属性重置,如事务的隔离级别、只读事务等等
}
DataSourceUtils.resetConnectionAfterTransaction(con, txObject.getPreviousIsolationLevel());
//重置连接的一些属性,以为了连接重用
}
catch (Throwable ex) {
logger.debug("Could not reset JDBC Connection after transaction", ex);
} if (txObject.isNewConnectionHolder()) {
if (logger.isDebugEnabled()) {
logger.debug("Releasing JDBC Connection [" + con + "] after transaction");
}
DataSourceUtils.releaseConnection(con, this.dataSource);//最后会释放连接,由于连接已经和当前线程解除绑定,因此关闭连接是物理关闭(此处关闭的方法由数据库的驱动程序决定,驱动程序关闭时会判断是普通连接还是连接池连接,对应用程序是透明的)
} txObject.getConnectionHolder().clear();//清除Holder信息,将当前为事务做的准备工作和信息全部清除归位
}
【原创】Spring连接、事务代码分析的更多相关文章
- 老生常谈系列之Aop--Aop的经典应用之Spring的事务实现分析(三)
老生常谈系列之Aop--Aop的经典应用之Spring的事务实现分析(三) 前言 上一篇文章老生常谈系列之Aop--Aop的经典应用之Spring的事务实现分析(二)从三个问题导入,分析了Spring ...
- Spring AOP实现声明式事务代码分析
众所周知,Spring的声明式事务是利用AOP手段实现的,所谓"深入一点,你会更快乐",本文试图给出相关代码分析. AOP联盟为增强定义了org.aopalliance.aop.A ...
- 备忘:spring jdbc事务代码 mybatis, nhibernate
http://files.cnblogs.com/files/mikelij/mymavenMar1.rar
- spring transaction源码分析--事务架构
1. 引言 事务特性 事务是并发控制的单元,是用户定义的一个操作序列.这些操作要么都做,要么都不做,是一个不可分割的工作单位.通过事务将逻辑相关的一组操作绑定在一起,以便服务器 保持数据的完整性.事 ...
- Spring事务原理分析-部分二
Spring事务原理分析-部分二 说明:这是我在蚂蚁课堂学习了余老师Spring手写框架的课程的一些笔记,部分代码代码会用到余老师的课件代码.这不是广告,是我听了之后觉得很好. 课堂链接:Spring ...
- Spring事务原理分析--手写Spring事务
一.基本概念和原理 1.Spring事务 基于AOP环绕通知和异常通知的 2.Spring事务分为编程式事务.声明事务.编程事务包括注解方式和扫包方式(xml) Spring事务底层使用编程事务(自己 ...
- Spring事务原理分析-部分一
Spring事务原理分析-部分一 什么事务 事务:逻辑上的一组操作,组成这组操作的各个单元,要么全都成功,要么全都失败. 事务基本特性 ⑴ 原子性(Atomicity) 原子性是指事务包含的所有操作要 ...
- Mybatis整合Spring实现事务管理的源码分析
一:前言 没有完整看完,但是看到了一些关键的地方,这里做个记录,过程会有点乱,以后逐渐补充最终归档为完整流程:相信看过框架源码的都知道过程中无法完全确定是怎样的流程,毕竟不可能全部都去测试一遍 ,但是 ...
- Spring Cloud 请求重试机制核心代码分析
场景 发布微服务的操作一般都是打完新代码的包,kill掉在跑的应用,替换新的包,启动. spring cloud 中使用eureka为注册中心,它是允许服务列表数据的延迟性的,就是说即使应用已经不在服 ...
随机推荐
- Android系统自适应屏幕大小
1.屏幕相关概念1.1分辨率是指屏幕上有横竖各有多少个像素1.2屏幕尺寸指的是手机实际的物理尺寸,比如常用的2.8英寸,3.2英寸,3.5英寸,3.7英寸android将屏幕大小分为四个级别(smal ...
- DataTables入门
转载 https://blog.csdn.net/gfd54gd5f46/article/details/65938189
- swift使用查阅资料备份3
自主学习之RxSwift(二) -----flatMap https://blog.csdn.net/chelongfei/article/details/50995603 RxSwift 系列(九) ...
- 2015 Objective-C 新特性
Overview 自 WWDC 2015 推出和开源 Swift 2.0 后,大家对 Swift 的热情又一次高涨起来,在羡慕创业公司的朋友们大谈 Swift 新特性的同时,也有很多像我一样工作上依然 ...
- Unity坐标系 左手坐标系 图
x轴:从左指向右 y轴:从下指向上 z轴:指向屏幕里的是左手坐标系,指向屏幕外的是右手坐标系 记忆小技巧:都是X轴朝右,Y轴向上,跟平时画坐标一模一样,区别只是Z的朝向.你用手试一下就知道了,当大拇指 ...
- CDR中怎么绘制一个漂亮的球衣?
cdr中怎么绘制一个漂亮的球衣?想要绘制一个漂亮的球衣,该怎么绘制呢?下面我们就来看看cdr绘制漂亮的球衣的教程,需要的朋友可以参考下: 1.画一个长方形,增加节点,移动节点,变形成如图 2.直线变曲 ...
- Hihocoder1061-Beautiful String
时间限制:10000ms单点时限:1000ms内存限制:256MB 描述 We say a string is beautiful if it has the equal amount of 3 or ...
- day06-2 基本运算符(解压缩)
目录 运算符 算数运算符 比较运算符 赋值运算符 逻辑运算符 运算规则 成员运算符 身份运算符 Python运算符优先级 链式赋值(必考) 交叉赋值(必考) 解压缩(必考) 运算符 算数运算符 进行算 ...
- 【转】Retina 屏幕下,网页图片的显示兼容
感谢 Apple,带来了 Retina 屏幕的革命,让我们可以在电子显示屏上享受到印刷级的分辨率.由于分辨率的提升,网页中的文字.Flash 和 SVG 内容显示得比原来更加精细,但网页中的图片却变得 ...
- B-Tree概念
记录下学习B-Tree: concept:(m-阶) 1. 根节点 孩子数 ( 2 <= N <= m) 根节点key数([m/2] - 1 <= n <= m -1) 2 ...