Spring分布式事务实现
Spring分布式事务实现
分布式事务是指操作多个数据库之间的事务,spring的org.springframework.transaction.jta.JtaTransactionManager,提供了分布式事务支持。如果使用WAS的JTA支持,把它的属性改为WebSphere对应的TransactionManager。
在tomcat下,是没有分布式事务的,不过可以借助于第三方软件jotm(Java Open Transaction Manager )和AtomikosTransactionsEssentials实现,在spring中分布式事务是通过jta(jotm,atomikos)来进行实现。
1、https://www.360docs.net/doc/1116058075.html,/
2、https://www.360docs.net/doc/1116058075.html,/Main/TransactionsEssentials
一、使用JOTM例子
(1) Dao及实现
GenericDao接口:
?
1 2 3 4 public interface GenericDao {
public int save(String ds, String sql, Object[] obj) throws Exception; public intfindRowCount(String ds, String sql);
}
GenericDaoImpl实现:?
1 2 3 4 5 6 7 8 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28 public class GenericDaoImpl implements GenericDao{
private JdbcTemplatejdbcTemplateA;
private JdbcTemplatejdbcTemplateB;
public void setJdbcTemplateA(JdbcTemplatejdbcTemplate) {
this.jdbcTemplateA = jdbcTemplate;
}
public void setJdbcTemplateB(JdbcTemplatejdbcTemplate) {
this.jdbcTemplateB = jdbcTemplate;
}
public int save(String ds, String sql, Object[] obj) throws Exception{ if(null == ds || "".equals(ds)) return -1;
try{
if(ds.equals("A")){
return this.jdbcTemplateA.update(sql, obj);
}else{
return this.jdbcTemplateB.update(sql, obj);
}
}catch(Exception e){
e.printStackTrace();
throw new Exception("执行" + ds + "数据库时失败!");
}
}
public intfindRowCount(String ds, String sql) {
29
30
31
32
33
34
35
36
37 if(null == ds || "".equals(ds)) return -1;
if(ds.equals("A")){
return this.jdbcTemplateA.queryForInt(sql); }else{
return this.jdbcTemplateB.queryForInt(sql); }
}
}
(2) Service及实现UserService接口:?
1 2 3 public interface UserService {
public void saveUser() throws Exception; }
UserServiceImpl实现:?
1 2 3 4 5 6 7 8 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24 public class UserServiceImpl implements UserService{
private GenericDaogenericDao;
public void setGenericDao(GenericDaogenericDao) {
this.genericDao = genericDao;
}
public void saveUser() throws Exception {
String userName = "user_" + Math.round(Math.random()*10000); System.out.println(userName);
StringBuildersql = new StringBuilder();
sql.append(" insert into t_user(username, gender) values(?,?); "); Object[] objs = new Object[]{userName,"1"};
genericDao.save("A", sql.toString(), objs);
sql.delete(0, sql.length());
sql.append(" insert into t_user(name, sex) values(?,?); ");
objs = new Object[]{userName,"男的"};//值超出范围
genericDao.save("B", sql.toString(), objs);
}
}
(3) applicationContext-jotm.xml ?
1 2 3
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 xmlns:context="https://www.360docs.net/doc/1116058075.html,/schema/context" xmlns:aop="https://www.360docs.net/doc/1116058075.html,/schema/aop" xmlns:tx="https://www.360docs.net/doc/1116058075.html,/schema/tx" xsi:schemaLocation="https://www.360docs.net/doc/1116058075.html,/schema/beans https://www.360docs.net/doc/1116058075.html,/schema/beans/s https://www.360docs.net/doc/1116058075.html,/schema/context https://www.360docs.net/doc/1116058075.html,/schema/context/spring-context-2.5.x https://www.360docs.net/doc/1116058075.html,/schema/tx https://www.360docs.net/doc/1116058075.html,/schema/tx/spring-tx-2.5.xsd https://www.360docs.net/doc/1116058075.html,/schema/aop https://www.360docs.net/doc/1116058075.html,/schema/aop/spring-aop-2.5.xsd"> class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"> 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 class = "org.springframework.jdbc.core.JdbcTemplate"> class = "org.springframework.jdbc.core.JdbcTemplate"> expression="execution(* com.logcd.service..*.*(..))"/>
(4) 测试?
1 2 3 4 5 6 7 public class TestUserService{
private static UserServiceuserService;
@BeforeClass
public static void init(){
ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext-jotm.xml");
8 9
10
11
12
13
14
15
16
17
18
19
20
21 userService = (UserService)app.getBean("userService"); }
@Test
public void save(){
System.out.println("begin...");
try{
userService.saveUser();
}catch(Exception e){
System.out.println(e.getMessage());
}
System.out.println("finish...");
}
}
二、关于使用atomikos实现
(1) 数据源配置
?
1 2 3 4 5 6 7 8 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
(2)、事务配置?
1 2
3 4 5 6 7 8 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
有关JTA
JTA全称为Java Transaction API,顾名思义JTA定义了一组统一的事务编程的接口,这些接口如下:
XAResource
XAResource接口是对实现了X/Open CAE规范的资源管理器(Resource Manager,数据库就是典型的资源管理器) 的抽象,它由资源适配器(Resource Apdater) 提供实现。XAResource是支持事务控制的核心。
Transaction
Transaction接口是一个事务实例的抽象,通过它可以控制事务内多个资源的提交或者回滚。二阶段提交过程也是由Transaction接口的实现者来完成的。
TransactionManager
托管模式(managed mode) 下,TransactionManager接口是被应用服务器调用,以控制事务的边界的。
UserTransaction
非托管模式(non-managed mode) 下,应用程序可以通过UserTransaction接口控制事务的边界
托管模式下的事务提交场景
注意:在上图中3和5的步骤之间省略了应用程序对资源的操作(如CRUD)。另外,应用服务器什么时机enlistResource,又是什么时候delistResource呢?这在后文中会解释。
有关JCA
下图为JCA的架构图
中间涉及元素说明如下:
1)Enterprise Information System
简称EIS,在JTA中它又被称为资源管理器。典型的EIS有数据库,事务处理系统(Transaction Processing System),ERP 系统。
2)Resource Adapter
资源适配器(Resource Adaper)是JCA的关键。要想把不同的EIS整合(或者连接)到J2EE运行环境中,就必须为每个EIS 提供资源适配器,它会将将EIS适配为一个具备统一编程接口的资源(Resource) 。这个统一编程接口就是上图中的System Contracts和Client API。下面的UML类图将完美诠释资源适配器。
3)Application Server
应用服务器(Application Server) 通过System Contracts来管理对EIS的安全、事务、连接等。典型的应用服务器有JBoss、JOnAS、Geronimo、GlassFish等。
4)Application Component
应用组件(Application Component) ,它封装了应用业务逻辑,像对资源的访问和修改。典型的应用组件就是EJB。
更多细节请参见:
Sun Microsystems Inc.J2EE Connector Architecture 1.5
来自:https://www.360docs.net/doc/1116058075.html,/ithomer/article/details/10859235
spring配置文件各个属性详解
spring配置文件各个属性详解 分类:spring 2012-08-09 11:25 9316人阅读评论(2) 收藏举报springaophibernateattributesxhtmlwebsphere 目录(?)[+]一、引用外部属性文件
spring使用基于注解的AOP事务管理
spring使用基于注解的AOP事务管理 16.6 AOP事务管理 AOP事务管理利用了Spring AOP的基础设施,在大多数情况下,Spring AOP会创建一个JDK代理以拦截方法调用。你可以使用装载时编织以在装载期编织切面,这样就不需要代理了(如果你记不清什么是装载时编织,请参看第6章)。你有两种方式来配置Spring AOP 事务管理,基于注解的配置以及XML配置。 16.6.1 使用基于注解的AOP事务管理 你可以借助于AOP的自动代理,通过注解将事务性行为引入到现有的bean中。让我们以代码清单16-21开始吧,它展示了类DeclarativeTxBankService。 代码清单16-21 DeclarativeTxBankService实现 请注意@Transactional属性,为了让Spring的事务管理基础设施可以利用该属性创建恰当的切入点和通知,我们需要使用AOP的自动代理和注解驱动的事务支持。代码清单16-22展示了与该注解相对应的XML配置。 代码清单16-22 基于注解的事务管理的配置文件
该XML配置文件展示了标准的bankService bean声明,紧跟其后的是
S详细讲解SH中Spring事务流程
给你详细讲一下SSH框架的事物管理,希望对你有帮助。 Struts+hibernate+spring整合开发web应用是相当流行的,只需要简单的配置就能轻松的对数据库进行crud操作,下面就hibernate+spring 的配置做一下剖析,一边与大家一起分享经验: 1、准备工作: 可以利用hibernate tools生成相关映射文件已经po对象、dao对象,dao 也可以自己手动编写,无非就是实现crud,如果通过继承hibernate提供的HibernateDaoSupport,则可以更轻松的实现 关键就在于配置文件,下面看一个样例:
Spring分布式事务实现
Spring分布式事务实现 分布式事务是指操作多个数据库之间的事务,spring的org.springframework.transaction.jta.JtaTransactionManager,提供了分布式事务支持。如果使用WAS的JTA支持,把它的属性改为WebSphere对应的TransactionManager。 在tomcat下,是没有分布式事务的,不过可以借助于第三方软件jotm(Java Open Transaction Manager )和AtomikosTransactionsEssentials实现,在spring中分布式事务是通过jta(jotm,atomikos)来进行实现。 1、https://www.360docs.net/doc/1116058075.html,/ 2、https://www.360docs.net/doc/1116058075.html,/Main/TransactionsEssentials 一、使用JOTM例子 (1) Dao及实现 GenericDao接口: ? 1 2 3 4 public interface GenericDao { public int save(String ds, String sql, Object[] obj) throws Exception; public intfindRowCount(String ds, String sql); } GenericDaoImpl实现:? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 public class GenericDaoImpl implements GenericDao{ private JdbcTemplatejdbcTemplateA; private JdbcTemplatejdbcTemplateB; public void setJdbcTemplateA(JdbcTemplatejdbcTemplate) { this.jdbcTemplateA = jdbcTemplate; } public void setJdbcTemplateB(JdbcTemplatejdbcTemplate) { this.jdbcTemplateB = jdbcTemplate; } public int save(String ds, String sql, Object[] obj) throws Exception{ if(null == ds || "".equals(ds)) return -1; try{ if(ds.equals("A")){ return this.jdbcTemplateA.update(sql, obj); }else{ return this.jdbcTemplateB.update(sql, obj); } }catch(Exception e){ e.printStackTrace(); throw new Exception("执行" + ds + "数据库时失败!"); } } public intfindRowCount(String ds, String sql) {
全面分析 Spring 的编程式事务管理及声明式事务管理
开始之前 关于本教程 本教程将深入讲解Spring 简单而强大的事务管理功能,包括编程式事务和声明式事务。通过对本教程的学习,您将能够理解Spring 事务管理的本质,并灵活运用之。 先决条件 本教程假定您已经掌握了Java 基础知识,并对Spring 有一定了解。您还需要具备基本的事务管理的知识,比如:事务的定义,隔离级别的概念,等等。 本文将直接使用这些概念而不做详细解释。另外,您最好掌握数据库的基础知识,虽然这不是必须。 系统需求 要试验这份教程中的工具和示例,硬件配置需求为:至少带有512MB 内存(推荐1GB)的系统。需要安装以下软件: ?Sun JDK 或更新版本或IBM Developer Kit for the Java 5 platform 版本。?Spring framework 。本教程附带的示例代码已经在Spring 上测试过。?MySQL 或更新版本。 ? Spring 事务属性分析 事务管理对于企业应用而言至关重要。它保证了用户的每一次操作都是可靠的,即便出现了异常的访问情况,也不至于破坏后台数据的完整性。就像银行的自助取款机,通常都能正常为客户服务,但是也难免遇到操作过程中机器突然出故障的情况,此时,事务就必须确保出故障前对账户的操作不生效,就像用户刚才完全没有使用过取款机一样,以保证用户和银行的利益都不受损失。 在Spring 中,事务是通过TransactionDefinition 接口来定义的。该接口包含与事务属性有关的方法。具体如清单1所示: 清单1. TransactionDefinition 接口中定义的主要方法 public interface TransactionDefinition{ int getIsolationLevel(); int getPropagationBehavior(); int getTimeout(); boolean isReadOnly();
spring的@Transactional注解详细用法
spring的@Transactional注解详细用法 各位读友大家好!你有你的木棉,我有我的文章,为了你的木棉,应读我的文章!若为比翼双飞鸟,定是人间有情人!若读此篇优秀文,必成天上比翼鸟! spring的@Transactional注解详细用法Spring Framework对事务管理提供了一致的抽象,其特点如下:为不同的事务API 提供一致的编程模型,比如JTA(Java Transaction API), JDBC, Hibernate, JPA(Java Persistence API和JDO(Java Data Objects)支持声明式事务管理,特别是基于注解的声明式事务管理,简单易用提供比其他事务API如JTA更简单的编程式事务管理API与spring数据访问抽象的完美集成事务管理方式spring支持编程式事务管理和声明式事务管理两种方式。编程式事务管理使用TransactionTemplate或者直接使用底层的PlatformTransactionManager。对于编程式事务管理,spring推荐使用TransactionTemplate。声明式事务管理建立在AOP之上的。其本质是对方法前后进行拦截,然后在目标方法开始之前创建或者加入一个事务,在执行完目标方法之后根据执行情况提交或者回滚事务。声明式事务最大的优点就是不需要通过编程的方式管理事务,这样就不需要在业务逻辑代码中掺杂事务管理的代码,只需在配置文件中做相关的事务规则声明(或通过基于@Transactional注解的方式),便可以将事务规则应用到业务逻辑中。显然声明式事务管理要优于编程式事务管理,这正是spring
Spring事务配置的五种方式
Spring事务原理 统观spring事务,围绕着两个核心PlatformTransactionManager和TransactionStatus spring提供了几个关于事务处理的类: TransactionDefinition //事务属性定义 TranscationStatus //代表了当前的事务,可以提交,回滚。 PlatformTransactionManager这个是spring提供的用于管理事务的基础接口,其下有一个实现的抽象类AbstractPlatformTransactionManager,我们使用的事务管理类例如DataSourceTransactionManager等都是这个类的子类。 一般事务定义步骤: TransactionDefinition td = new TransactionDefinition(); TransactionStatus ts = transactionManager.getTransaction(td); try { //do sth https://www.360docs.net/doc/1116058075.html,mit(ts); } catch(Exception e){transactionManager.rollback(ts);} spring提供的事务管理可以分为两类:编程式的和声明式的。编程式的,比较灵活,但是代码量大,存在重复的代码比较多;声明式的比编程式的更灵活。 编程式主要使用transactionTemplate。省略了部分的提交,回滚,一系列的事务对象定义,需注入事务管理对象. void add() { transactionTemplate.execute( new TransactionCallback(){ pulic Object doInTransaction(TransactionStatus ts) { //do sth} } } 声明式: 使用TransactionProxyFactoryBean:
计算机软件,spring中事务管理器的配置
浅析Spring提供的事务管理方法
浅析Spring提供的事务管理方法 Spring提供的事务管理可以分为两类:编程式的和声明式的。编程式的,比较灵活,但是代码量大,存在重复的代码比较多;而声明式的比编程式的更灵活方便。本文将讨论这两种事务管理的区别。 传统的JDBC事务管理 以往使用JDBC进行数据操作时,一般采用DataSource,从数据源中得到Connection,我们知道数据源是线程安全的,而连接不是线程安全的,所以对每个请求都是从数据源中重新取出一个连接。一般的数据源由容器进行管理,包括连接池。例如TOMCAT,WEBSPHERE,WEBLOGIC等这些J2EE商业容器都提供了这个功能。 以往的我们使用JDBC在写代码时,事务管理可能会是这样: Connection conn = null; try { conn = DBConnectionFactory.getConnection; conn.setAutoCommit(false); //do something https://www.360docs.net/doc/1116058075.html,mit(); //commit transcation } catch(Exception e) { conn.rollback(); //do sth } finally { try { conn.close();
catch(SQLException se){ //do sth.} //close ResultSet,PreparedStatement,Connection //notice:Maybe ocurr Exception when u close rs,pstmt,conn } 按照以往的思路来写代码,代码量比较长,而且容易疏忽,忘掉一些try/catch,引发一些异常无法catch,虽然有时候我们会写DBTool类,来关闭这些资源,并且保证在关闭这些资源时,不向外抛异常。 Spring提供的编程式的事务处理 Spring提供了几个关于事务处理的类: ?TransactionDefinition //事务属性定义 ?TranscationStatus //代表了当前的事务,可以提交,回滚。 ?PlatformTransactionManager这个是spring提供的用于管理事务的基础接口,其下有一个实现的抽象类AbstractPlatformTransactionManager,我们使用的事务管理类例如DataSourceTransactionManager等都是这个类的子类。 我们使用编程式的事务管理流程可能如下: 1 声明数据源 2 声明一个事务管理类,例如DataSourceTransactionManager,HibernateTransactionManger,JTATransactionManager等 3 在我们的代码中加入事务处理代码: TransactionDefinition td = new TransactionDefinition(); TransactionStatus ts = transactionManager.getTransaction(td); try { //do sth https://www.360docs.net/doc/1116058075.html,mit(ts); } catch(Exception e){transactionManager.rollback(ts);} 使用spring提供的事务模板TransactionTemplate void add()
在spring中如何配代码的事务管理
在spring中如何配代码的事务管理 在J2EE的web应用里面配置spring非常简单,最简单的只需要把spring得ContextLoaderListener添加到你的web.xml文件里面就可以了,示例如下:org.springframework.web.context.ContextLoaderListener ContextLoaderListener是一个ServletContextListener, 它在你的web应用启动的时候初始化。缺省情况下,它会在WEB-INF/applicationContext.xml文件找Spring的配置。你可以通过定义一个元素名字为”contextConfigLocation”来改变Spring 配置文件的位置。示例 使用”org.springframework.jdbc.datasource.DriverManagerDataSou rce”数据源来配置数据库驱动。示例如下:org.hsqldb.jdbcDriver jdbc:hsqldb:db/appfuse sa spring提供了几个关于事务处理的类:TransactionDefinition //事务属性定义TranscationStatus //代表了当前的事务,可以提交,回滚。PlatformTransactionManager这个是spring提供的用于管理事务的基础接口,其下有一个实现的抽象类AbstractPlatformTransac 在context中定义DataSource,创建SessionFactoy,设置参
数;DAO类继承HibernateDaoSupport,实现具体接口,从中获得HibernateTemplate进行具体操作。在使用中如果遇到OpenSessionInView的问题,可以添加OpenSessionInViewFilter 或OpenSessionInViewIntercepto 一个类需要用到某个接口的方法,我们需要将类A和接口B的实现关联起来,最简单的方法是类A中创建一个对于接口B的实现C 的实例,但这种方法显然两者的依赖(Dependency)太大了。而IoC 的方法是只在类A中定义好用于关联接口B的实现的方法,将类A,接口B和接口B的
spring,mybatis事务管理配置与@Transactional注解使用[转]
spring,mybatis事务管理配置与@Transactional注解使用 [转] spring,mybatis事务管理配置与@Transactional注解使用 概述 事务管理对于企业应用来说是至关重要的,即使出现异常情况,它也可以保证数据的一致性。 Spring Framework对事务管理提供了一致的抽象,其特点如下: 为不同的事务API提供一致的编程模型,比如JTA(Java Transaction API), JDBC, Hibernate, JPA(Java Persistence API和JDO(Java Data Objects)支持声明式事务管理,特别是基于注解的声明式事务管理,简单易用提供比其他事务API如JTA更简单的编程式事务管理API与spring数据访问抽象的完美集成 事务管理方式 spring支持编程式事务管理和声明式事务管理两种方式。 编程式事务管理使用TransactionTemplate或者直接使用底层的PlatformTransactionManager。对于编程式事务管理,spring推荐使用TransactionTemplate。 声明式事务管理建立在AOP之上的。其本质是对方法前后
进行拦截,然后在目标方法开始之前创建或者加入一个事务,在执行完目标方法之后根据执行情况提交或者回滚事务。声明式事务最大的优点就是不需要通过编程的方式管理事务,这样就不需要在业务逻辑代码中掺杂事务管理的代码,只需在配置文件中做相关的事务规则声明(或通过基于 @Transactional注解的方式),便可以将事务规则应用到业 务逻辑中。 显然声明式事务管理要优于编程式事务管理,这正是spring 倡导的非侵入式的开发方式。声明式事务管理使业务代码不受污染,一个普通的POJO对象,只要加上注解就可以获得完全的事务支持。和编程式事务相比,声明式事务唯一不足地方是,后者的最细粒度只能作用到方法级别,无法做到像编程式事务那样可以作用到代码块级别。但是即便有这样的需求,也存在很多变通的方法,比如,可以将需要进行事务管理的代码块独立为方法等等。 声明式事务管理也有两种常用的方式,一种是基于tx和aop 名字空间的xml配置文件,另一种就是基于@Transactional 注解。显然基于注解的方式更简单易用,更清爽。 自动提交(AutoCommit)与连接关闭时的是否自动提交 自动提交 默认情况下,数据库处于自动提交模式。每一条语句处于一个单独的事务中,在这条语句执行完毕时,如果执行成功则
Spring 自动事务代理
spring 同时支持编程事务策略和声明式事务策略,大部分时候,都推荐使用声明式事务策略,使用声明式事务策略的优势十分明显。 对于使用声明式事务策略,可以使用TransactionProxyFactoryBean来配置事务代理Bean。正如它的类名所暗示的,它是一个工厂Bean,工厂Bean用于生成一系列的Bean实例,这一系列的Bean实例都是Proxy.这种事务代理正是基于Spring AOP组件。配置TransactionProxyFactoryBean时,一样需要指定目标Bean. 每个TransactionProxyFactoryBean为一个目标Bean生成事务代理,事务代理的方法改写了目标Bean的方法,就是在目标Bean的方法执行之前加入了事务,在目标Bean的方法正常结束之前提交事务,如查遇到了异常则回滚事务。 TransactionProxyFactoryBean创建事务代理时,需要了解当前事务所处的环境,该环境属性通过PlatformTransactionManager实例传入,而相关事务传入规则在TransactionProxyFactoryBean的定义中给出.
事务管理的五种方法
前段时间对Spring的事务配置做了比较深入的研究,在此之间对Spring的事务配置虽说也配置过,但是一直没有一个清楚的认识。通过这次的学习发觉Spring的事务配置只要把思路理清,还是比较好掌握的。 总结如下: Spring配置文件中关于事务配置总是由三个组成部分,分别是DataSource、TransactionManager和代理机制这三部分,无论哪种配置方式,一般变化的只是代理机制这部分。 DataSource、TransactionManager这两部分只是会根据数据访问方式有所变化,比如使用Hibernate进行数据访问时,DataSource实际为SessionFactory,TransactionManager的实现为HibernateTransactionManager。 具体如下图: 根据代理机制的不同,总结了五种Spring事务的配置方式,配置文件如下:
第一种方式:每个Bean都有一个代理
spring事务
1.6 Spring事务: 1. 编程式事务管理——编程式的事务管理可以清楚滴控制事务的边界,也就是让您自行实现事务开始时间、撤消操作的时机、结束时间等,可以实现细粒度的事务控制。 2. 声明式事务管理——然而多数的情况下,事务并不需要细粒度的控制,而是采用声明式的事务管理,好处是Spring事务管理的相关API可以不用介入程序之中,从对象的角度来看,它并不知道自己正被纳入事务管理之中,在不需要事务管理的时候,只要在设置文件上修改一下设置,即可移去事务管理服务。 Spring声明式的事务管理依赖它的AOP框架来完成。使用声明式事务管理的好处是,事务管理不能侵入您所开发的组件,具体来说,DAO对象不会意识到正在事务管理之中,事实上也应该如此,因为事务管理是属于系统层面的服务,而不是业务逻辑的一部分,如果想要改变事务管理策略的话,也只需要在定义文件中重新配置。 事务的属性介绍: Spring使用AOP来完成声明式的事务管理,因而声明式事务是以方法为边界的,Spring的事务属性自然就在于描述事务应用至方法上的策略,在Spring 中事务属性分作以下的几个参数:传播行为(Propagation behavior)、隔离层级(Isolation Level)、只读提示(Read-only hints)、事务超时期间(The transaction timeout period) 传播行为(Propagation behavior):传播行为定义了事务应用于方法的边界(Boundaries),它告知何时该开始一个新的事务,或何时事务被暂停,或方法是否要在事务中进行。如,若传播行为设置为PROPAGATION_REQUIRED,则事务的边界在开始第一个事务的方法呼叫及结束时,如果先前没有事务被开始,则事务边界即为目前方法的执行前后。又如果传播行为被声明为PROPAGATION_REQUIRES_NEW,则事务的边界即为该方法执行的前后。 隔离层级(Isolation Level):在一个应用程序中,可能有多个事务同时在进行,这些事务应当彼此之间另一个事务的存在,好比现在整个应用程序就只有一个事务存在,由于事务彼此之间独立,若读取的是同一个数据的话,就容易发生问题。如: 脏读:(Dirty Read)脏读就是指当一个事务正在访问数据,并且对数据进行了修改,而这种修改还没有提交到数据库中,这时,另一个事务也访问了这个数据,然后使用了这个数据,由于这个数据是还没有提交的数据,(有可能回滚)那么另外这个事务读到的数据就是脏数据,依据脏数据所做的操作可能是不正确的。 不可重复读:(Non-repeatable read)指在一个事物中,多次读取同一个数据。当这个事务还没结束时,另外一个事务也访问该同一数据。那么,在第一个事务中
spring事务配置详解
Spring事务配置的五种方法 2009-04-24 10:20 总结如下: Spring配置文件中关于事务配置总是由三个组成部分,分别是DataSource、TransactionManager和代理机制这三部分,无论哪种配置方式,一般变化的只是代理机制这部分。 DataSource、TransactionManager这两部分只是会根据数据访问方式有所变化,比如使用Hibernate进行数据访问时,DataSource实际为SessionFactory,TransactionManager的实现为HibernateTransactionManager。 具体如下图: 根据代理机制的不同,总结了五种Spring事务的配置方式,配置文件如下: 第一种方式:每个Bean都有一个代理
Spring事务管理注解开发
Spring事务管理注解开发1.在Spring的配置文件中配置事务管理器 2.在Spring的配置文件中开启注解事务 3.在对应业务层添加@Transactional注解 4.在某些方法上加上事务 5.事物传播行为介绍 6.事务隔离级别
7.@Transactional注解中常用参数说明 参数名称功能描述readOnly该属性用于设置当前事务是否为只读事务,设置为true表示只读,false则表示可读写,默认值为false。例如:@Transactional(readOnly=true) rollbackFor 该属性用于设置需要进行回滚的异常类数组,当方法中抛出指定异常数组中的异常时,则进行事务回滚。例如:指定单一异常类:@Transactional(rollbackFor=RuntimeException.class) 指定多个异常类:@Transactional(rollbackFor={RuntimeException.class, Exception.class}) rollbackForClassName 该属性用于设置需要进行回滚的异常类名称数组,当方法中抛出指定异常名称数组中的异常时,则进行事务回滚。例如:指定单一异常类名称:@Transactional(rollbackForClassName="RuntimeException") 指定多个异常类名称:@Transactional(rollbackForClassName={"RuntimeException","Exception"}) noRollbackFor 该属性用于设置不需要进行回滚的异常类数组,当方法中抛出指定异常数组中的异常时,不进行事务回滚。例如:指定单一异常类:@Transactional(noRollbackFor=RuntimeException.class) 指定多个异常类:@Transactional(noRollbackFor={RuntimeException.class, Exception.class}) noRollbackForClassName 该属性用于设置不需要进行回滚的异常类名称数组,当方法中抛出指定异常名称数组中的异常时,不进行事务回滚。例如:指定单一异常类名称:@Transactional(noRollbackForClassName="RuntimeException") 指定多个异常类名称: @Transactional(noRollbackForClassName={"RuntimeException","Exception"}) propagation 该属性用于设置事务的传播行为,具体取值可参考表6-7。 例如:@Transactional(propagation=Propagation.NOT_SUPPORTED,readOnly=true) isolation该属性用于设置底层数据库的事务隔离级别,事务隔离级别用于处理多事务并发的情况,通常使用数据库的默认隔离级别即可,基本不需要进行设置timeout该属性用于设置事务的超时秒数,默认值为-1表示永不超时 注意:1、@Transactional 只能被应用到public方法上, 对于其它非public的方法,如果标记了@Transactional也不会报错,但方法没有事务功能.
Spring中的事务管理实例详解
Spring中的事务管理实例详解 本文实例讲述了Spring中的事务管理。分享给大家供大家参考。具体分析如下:事务简介:事务管理是企业级应用程序开发中必不可少的技术,用来确保数据的完整性和一致性事务就是一系列的动作,它们被当作一个单独的工作单元。这些动作要么全部完成,要么全部不起作用事务的四个关键属性(ACID)①原子性(atomicity):事务室一个原子操作,有一系列动作组成。事务的原子性确保动作要么全部完成,要么完全不起作用 ②一致性(consistency):一旦所有事务动作完成,事务就被提交。数据和资源就处于一种满足业务规则的一致性状态中 ③隔离性(isolation):可能有许多事务会同时处理相同的数据,因此每个事物都应该与其他事务隔离开来,防止数据损坏 ④持久性(durability):一旦事务完成,无论发生什么系统错误,它的结果都不应该受到影响。通常情况下,事务的结果被写到持久化存储器中Spring中的事务管理作为企业级应用程序框架,Spring在不同的事务管理API之上定义了一个抽象层。而应用程序开发人员不必了解底层的事务管理API,就可以使用Spring的事务管理机制。Spring既支持编程式事务管理,也支持声明式的事务管理编程式事务管理:将事务
管理代码嵌入到业务方法中来控制事务的提交和回滚,在编程式事务中,必须在每个业务操作中包含额外的事务管理代码声明式事务管理:大多数情况下比编程式事务管理更好用。它将事务管理代码从业务方法中分离出来,以声明的方式来实现事务管理。事务管理作为一种横切关注点,可以通过AOP方法模块化。Spring通过Spring AOP框架支持声明式事务管理。Spring事务的传播属性:当事务方法被另一个事务方法调用时,必须指定事务应该如何传播。例如:方法可能继续在现有事务中运行,也可能开启一个新事务,并在自己的事务中运行。事务的传播行为可以由传播属性指定。Spring定义了7种传播行为:Spring支持的事务传播行为传播行为含义PROPAGATION_MANDATORY 表示该 方法必须在事务中运行,如果当前事务不存在,则会抛出一个异常PROPAGATION_NESTED 表示如果当前已经存 在一个事务,那么该方法将会在嵌套事务中运行。嵌套的事务可以独立于当前事务进行单独地提交或回滚。如果当前事务不存在,那么其行为与PROPAGATION_REQUIRED一样。注意各厂商对这种传播行为的支持是有所差异的。可以参考资源管理器的文档来确认它们是否支持嵌套事务PROPAGATION_NEVER表示当前方法不应该运行在 事务上下文中。如果当前正有一个事务在运行,则会抛出异常PROPAGATION_NOT_SUPPORTED 表示该方法不应