Spring声明式事务原理分析

引言

要想对某个技术学习的比较好，就需要我们对其原理和源码有一定的了解，如果只停留在会用的层面是很难理解到这门技术的精髓所在的。最近小编对spring的声明式事务学习了一下，下面就总结一下。

声明式事务处理概念理解

声明式：程序员告诉spring容器生么样的目标方法采用什么样的事务策略

事务处理：spring容器所做的事情

在这种框架下，程序员只需要做好CRUD操作即可

原理图

从上面来看我们只需要在配置文件中配置和事务相关的策略，其余的事情都交给spring容器来完成，程序员不在关心和事务有关的东西，将精力都放在CURD操作的业务代码上。

下面看一下配置文件中的配置：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	   xmlns:aop="http://www.springframework.org/schema/aop"
	   xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/aop 
           http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
           http://www.springframework.org/schema/tx 
           http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
  	<!-- 
  		引入prperties配置文件
  	 -->
  	<bean
		class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
		<property name="locations">
			<value>classpath:jdbc.properties</value>
		</property>
	</bean>
    
  	<bean id="dataSource" destroy-method="close"
		class="org.apache.commons.dbcp.BasicDataSource">
		<property name="driverClassName" value="${jdbc.driverClassName}" />
		<property name="url" value="${jdbc.url}" />
		<property name="username" value="${jdbc.username}" />
		<property name="password" value="${jdbc.password}" />
	</bean>
	
	<bean id="classesDao" class="com.itheima11.spring.jdbc.transaction.dao.impl.ClassesDaoImpl">
		<property name="dataSource">
			<ref bean="dataSource"/>
		</property>
	</bean>
	<bean id="classesService" class="com.itheima11.spring.jdbc.transaction.service.impl.ClassesServiceImpl">
		<property name="classesDao">
			<ref bean="classesDao"/>
		</property>
	</bean>
	
	<!-- 
		事务管理器 的作用就是告诉spring容器利用jdbc的技术进行处理，如果是采用的hibernate则需要配置HibernateTransactionManager来实现
	 -->
	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource">
			<ref bean="dataSource"/>
		</property>
	</bean>
	
	<!-- 
		声明事务策略
		  id是标示符
		  transaction-manager 事务管理器
	 -->
	<tx:advice id="tx" transaction-manager="transactionManager">
		<tx:attributes>
			<!-- 
				告诉spring容器什么样的目标方法采用什么样的事务策略
				 name 用来说明目标方法
				   save*  以save开头的目标方法
				   isolation 隔离属性
				   propagation 传播属性
				      	是解决事务嵌套问题的
				   read-only
				      	为true:只读事务  只能读
				      	为false:读写事务
			 -->
			<tx:method name="save*"
				isolation="DEFAULT"
				propagation="REQUIRED"
				read-only="false"/>
		</tx:attributes>
	</tx:advice>
	
	<aop:config>
		<aop:pointcut 
			expression="execution(* com.itheima11.spring.jdbc.transaction.service.impl.*.*(..))" 
			id="perform"/>
		<aop:advisor advice-ref="tx" pointcut-ref="perform"/>
	</aop:config>
</beans>
  我们需要引入 xmlns:tx="http://w

我们需要引入 xmlns:tx="http://www.springframework.org/schema/tx"命名空间，从而可以在配置文件中进行事务的配置。关于事务的配置上面的代码中都有注释，在这里小编不在多说。下面小编来分析一下源代码。

下面来看一下声明式事务的简单的架构图

在上面的图中我们看出，首先spring容器对外提供了了一个总的接口PlatformTransaction，其中声明了事务操作有关的几个方法，然后又定义了一个抽象类，这个抽象类是实现了上面的接口，从而实现接口中的方法，然后就是具体的有关的事务操作了，不同的技术对应不同的实现，jdbc技术则对应一个DataSourceTransactionManager、Hibernater技术对应HibernateTransactionManager等等。

思考一、为什么会出现一个接口呢？

在这个架构的最上端为什么会设计了一个接口？spring技术这么做的好处是什么呢？其实这么做正好体现了spring技术的强大之处，在这设计一个接口就可以让我们在客户端编程的时候不用关系采用的是什么技术，例如上图中右边那样来写代码，用接口来定义一个参数，来控制事务，避免采和具体的技术相关，看到这也许会有疑问。我们不关心具体的技术，那么spring容器到底采用哪种事务处理技术呢？jdbc的还是hibernate的？这其实需要我们在配置文件中引入即可，看下面一句代码

在这个例子中采用的是JDBC技术所以引入事务管理器的时候就采用了DataSourceTransactionManager，如果我们dao层采用的是hibernate则在配置文件中需要还不HibernateTransactionManager。这样就真正做到了面向接口编程

思考二、为什么设计一个抽象类？

有了一个接口了为什么还需要一个抽象类呢？当我们跟踪源码的时候发现，在不同的技术实现中其实他们的commit操作和rollbac操作是一样的，开启事务是不一样的。不同的技术有了相同的行为，我们就需要考虑抽象类的作用了，其实在java面向对象的实现中抽象类的出现就是解决相同行为的问题，因为在抽象类中我们可以实现相同的行为，然后不同的行为继承这个抽象类然后重写不同的行为，这就是这个架构的精髓所在。这我们既做到了面向接口编程，有抽象出了共同的行为。

这个架构处处体现这模板设计模式，spring已经将模板的骨架设计好了，我们只需要按照这个框架套进去需要的代码即可，当然在事务管理器的引入哪儿也存在很多的技术，spring的强大之处就是把非常复杂的事情封装的非常简单，我们只需要简单的配置一下就可以实现。

在这也在此深刻的理解类、抽象类、接口的具体使用场景，为什么这样使用这几个就可以设计出非常灵活的框架，这几个概念其实在java基础中是比较难理解的几个概念，这就需要我们不断的度优秀开源框架的源代码，体会优秀架构是怎样的设计思想，这些思想是最伟大的，其实spring的技术并不是非常强大，但是这种思想是非常了不起的，现在我们这些程序员都不得不佩服这些有思想的人啊。

附几个核心类代码：

Dao层的实现类，接口代码略


package com.itheima11.spring.jdbc.transaction.dao.impl;
 
import org.springframework.jdbc.core.support.JdbcDaoSupport;
 
import com.itheima11.spring.jdbc.transaction.dao.ClassesDao;
 
public class ClassesDaoImpl extends JdbcDaoSupport implements ClassesDao {
 
	public void saveClasses(String sql) {
		this.getJdbcTemplate().execute(sql);
	}
}

service层实现类的代码，接口代码略

ackage com.itheima11.spring.jdbc.transaction.service.impl;
 
import com.itheima11.spring.jdbc.transaction.dao.ClassesDao;
import com.itheima11.spring.jdbc.transaction.service.ClassesService;
 
public class ClassesServiceImpl implements ClassesService{
	private ClassesDao classesDao;
 
	public void setClassesDao(ClassesDao classesDao) {
		this.classesDao = classesDao;
	}
 
	public void saveClasses(String sql) {
		this.classesDao.saveClasses(sql);
		int a = 1/0;
		this.classesDao.saveClasses(sql);
	}
}

客户端代码

package com.itheima11.spring.jdbc.transaction.test;
 
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
import com.itheima11.spring.jdbc.transaction.service.ClassesService;
 
public class ClassesTest {
	@Test
	public void testSaveClasses(){
		ApplicationContext context = 
				new ClassPathXmlApplicationContext("applicationContext.xml");
		ClassesService classesService = (ClassesService)context.getBean("classesService");
		classesService.saveClasses("insert into classes(name,description) values('11','aaa')");
	}

小结

上面就是小编在学习spring容器的时候的一些总结，感觉声明式事务大大简化了代码的编写，当然了上面这些代码都是架构级别的，也就是我们在接手一个项目的时候，如果不搭建框架的话这些代码是不需要我们编写的，但是我们也需要理解，方便我们以后排错，就分析到这，希望对读者有所帮助。当然也希望拍砖。

转载于：https://blog.csdn.net/hao134838/article/details/54292025

Spring声明式事务原理分析

猜你喜欢