目录
事务的传播机制有7种，如下图所示：
为了更好的理解，下面我们形象的说明一下几种传播机制是什么意思：
比如你下班回家，有以下几种场景
0.REQUIRED ------ 就是如果老婆做饭了，你就吃老婆做的饭；如果老婆没有做饭，你就自己做饭吃，反正你就是要吃饭（反正要在事务中运行）；
1.SUPPORTS ------ 如果老婆做饭了，你就吃老婆做的饭；如果老婆没有做饭，你就不吃（不一定非要在事务中运行）；
2.MANDATORY ------ 非要吃老婆做的饭，老婆要是没有做饭，你就大发脾气，典型的家暴男；
3.REQUIRES_NEW ------ 劳资非要吃自己做的饭，就算老婆把饭做好了，你也不吃老婆做的；
4.NOT_SUPPORTED ------ 劳资就是不吃饭，就算老婆把饭做好了，我也不吃；
5.NEVER ------ 劳资就是不吃饭，如果老婆把饭做好了，我还要发脾气；
6.NESTED ------ 暂不做解释，后面会详解；
本文主要是想用代码实现这几种传播机制的具体使用；
有两张表：
school表
student表
我们如何去测试两个方法是否使用的同一个事务呢？就看是否共用同一个数据库连接或者共用同一个会话；
支持使用当前事务，如果当前事务不存在，创建一个新事务。
schoolService.updateSchool()方法：
@Transactional
public void updateSchool(){
School school = new School();
school.setId(1);
school.setName("湖南大学");
school.setLocation("湖南");
//更新id为1的学校名称为湖南大学，地址为湖南
schoolMapper.updateByPrimaryKeySelective(school);
//调用另一个方法更新学生信息
studentService.updateStudent();
System.out.println(1/0);
}studentService.updateStudent()方法，加了事务的，默认REQUIRED：
@Transactional
public void updateStudent(){
Student student = new Student();
student.setSid(1);
student.setAge(25);
//更新sid为1的学生年龄为25
studentMapper.updateByPrimaryKeySelective(student);
}如上所示：updateSchool方法是加了事务的，调用完studentService.updateStudent方法后，会报错，如果updateSchool和updateStudent共用同一个事务，updateSchool报错，自身回滚，肯定会带着updateStudent一起回滚；如果不是共用同一个事务，那么updateStudent会执行成功并提交，不会回滚；
结果：
updateSchool成功回滚了
updateStudent也成功回滚了
看过我写的深入理解@Transactional注解的使用和原理就知道，两个方法会共用同一个数据库连接，也就共用同一个事务，两个方法一起提交或者回滚；
schoolService.updateSchool()方法：
public void updateSchool(){
School school = new School();
school.setId(1);
school.setName("湖南大学");
school.setLocation("湖南");
//更新id为1的学校名称为湖南大学，地址为湖南
schoolMapper.updateByPrimaryKeySelective(school);
//调用另一个方法更新学生信息
studentService.updateStudent();
}studentService.updateStudent()方法：
@Transactional
public void updateStudent(){
Student student = new Student();
student.setSid(1);
student.setAge(25);
//更新sid为1的学生年龄为25
studentMapper.updateByPrimaryKeySelective(student);
//报错
System.out.println(1/0);
}如上所示：updateSchool方法是没有加事务的，调用studentService.updateStudent方法，updateStudent方法加了事务，并且会报错，如果updateStudent没有新建事务的话，不会回滚，如果是建了事务，就会回滚；
结果：
1.控制台提示报错
2. updateSchool方法没有回滚（将北京大学刚改为湖南大学）
3.updateStudent方法回滚了（将age更新为25）
验证通过；
支持使用当前事务，如果当前事务不存在，则不使用事务。
updateSchool方法，加事务，更新id为1的name为“湖南大学”，location为“湖南”，输出1/0，肯定会报错的；
@Transactional
public void updateSchool(){
School school = new School();
school.setId(1);
school.setName("湖南大学");
school.setLocation("湖南");
schoolMapper.updateByPrimaryKeySelective(school);
studentService.updateStudent();
System.out.println(1/0);
}updateStudent方法更新id为1的age为25；
@Transactional(propagation = Propagation.SUPPORTS)
public void updateStudent(){
Student student = new Student();
student.setSid(1);
student.setAge(25);
studentMapper.updateByPrimaryKeySelective(student);
}如上所示：updateSchool方法是加了事务的，studentService.updateStudent方法也加了事务，而且传播机制是SUPPORTS，如果updateSchool和updateStudent共用同一个事务，updateSchool报错，自身回滚，肯定会带着updateStudent一起回滚；如果不是共用同一个事务，那么updateStudent会执行成功并提交，不会回滚；
结果：
1.控制台提示报错
2. updateSchool方法回滚（将北京大学刚改为湖南大学）
3.updateStudent方法回滚（将age改为25）
显然，updateSchool和updateSchool共用同一个事务，正好验证了传播机制为supports，如果当前有事务，就支持使用当前事务；
updateSchool方法更新id为1的name为“湖南大学”，location为“湖南”，将@Transactional注释掉了，没有加事务
//@Transactional
public void updateSchool(){
School school = new School();
school.setId(1);
school.setName("湖南大学");
school.setLocation("湖南");
schoolMapper.updateByPrimaryKeySelective(school);
studentService.updateStudent();
}updateStudent方法更新id为1的age为25，事务传播机制为SUPPORTS，打印1/0，将报错
@Transactional(propagation = Propagation.SUPPORTS)
public void updateStudent(){
Student student = new Student();
student.setSid(1);
student.setAge(25);
studentMapper.updateByPrimaryKeySelective(student);
System.out.println(1/0);
}如上所示：updateSchool方法没有加事务，studentService.updateStudent方法加了事务，而且传播机制是SUPPORTS，如果updateStudent没有事务，报错就不会回滚，如果有事务，就会回滚；
结果：
1.控制台报错
2.updateSchool方法没有回滚，无事务执行（无事务这个说法其实不准确，任何操作数据库肯定是有事务的）；
3.updateStudent方法也没有回滚，也是无事务执行的；
显然： 事务传播机制为SUPPORTS的方法，支持使用当前事务，如果当前事务不存在，则不使用事务。
中文翻译为强制，支持使用当前事务，如果当前事务不存在，则抛出Exception。
updateSchool方法更新id为1的name为“湖南大学”，location为“湖南”，打印1/0，会报错；
@Transactional
public void updateSchool(){
School school = new School();
school.setId(1);
school.setName("湖南大学");
school.setLocation("湖南");
schoolMapper.updateByPrimaryKeySelective(school);
studentService.updateStudent();
System.out.println(1/0);
}updateStudent方法更新id为1的age为25，事务传播机制为MANDATORY
@Transactional(propagation = Propagation.MANDATORY)
public void updateStudent(){
Student student = new Student();
student.setSid(1);
student.setAge(25);
studentMapper.updateByPrimaryKeySelective(student);
}如上所示：updateSchool方法加事务，studentService.updateStudent方法加了事务，而且传播机制是MANDATORY，如果两者共用一个事务，都会回滚；
结果：
1.控制台报错
2. updateSchool方法回滚（将北京大学刚改为湖南大学）
3.updateStudent方法回滚（将age改为25）
显然： 传播机制为MANDATORY，如果当前有事务，就使用当前事务；
updateSchool方法更新id为1的name为“湖南大学”，location为“湖南”，没有事务；
//@Transactional
public void updateSchool(){
School school = new School();
school.setId(1);
school.setName("湖南大学");
school.setLocation("湖南");
schoolMapper.updateByPrimaryKeySelective(school);
studentService.updateStudent();
}updateStudent方法更新id为1的age为25，事务传播机制为MANDATORY；
@Transactional(propagation = Propagation.MANDATORY)
public void updateStudent(){
Student student = new Student();
student.setSid(1);
student.setAge(25);
studentMapper.updateByPrimaryKeySelective(student);
}如上所示：updateSchool方法没有加事务，studentService.updateStudent方法加了事务，而且传播机制是MANDATORY，就看执行到updateStudent就不会报错；
结果：
1.控制台报错
org.springframework.transaction.IllegalTransactionStateException: No existing transaction found for transaction marked with propagation 'mandatory'
2.updateSchool方法没有回滚（将北京大学刚改为湖南大学）
3.pdateStudent方法直接报错： No existing transaction found for transaction marked with propagation 'mandatory'，传播机制为mandatory的，必须有当前事务存在，不存在就报错；
综上：传播机制为MANDATORY，支持使用当前事务，如果当前事务不存在，则抛出Exception。
新建一个新事务；如果当前事务存在，把当前事务挂起。
updateSchool方法更新id为1的name为“湖南大学”，location为“湖南”，没有事务；
//@Transactional
public void updateSchool(){
School school = new School();
school.setId(1);
school.setName("湖南大学");
school.setLocation("湖南");
schoolMapper.updateByPrimaryKeySelective(school);
studentService.updateStudent();
}updateStudent方法更新id为1的age为25，事务传播机制为REQUIRES_NEW，打印1/0，报错；
@Transactional(propagation = Propagation.MANDATORY)
public void updateStudent(){
Student student = new Student();
student.setSid(1);
student.setAge(25);
studentMapper.updateByPrimaryKeySelective(student);
System.out.println(1/0);
}如上所示：updateSchool方法没有加事务，studentService.updateStudent方法加了事务，而且传播机制是REQUIRES_NEW，如果updateStudent方法新建了事务，打印1/0，报错就会回滚，如果没有新建事务，updateStudent方法就不会回滚；
结果：
1.控制台报错
2.updateSchool方法没有回滚，无事务执行（无事务这个说法其实不准确，任何操作数据库肯定是有事务的）；
3. updateStudent方法回滚（将age改为25）
显然：传播机制为REQUIRES_NEW的，当前没有事务，就新建一个事务，在事务中运行；
updateSchool方法更新id为1的name为“湖南大学”，location为“湖南”，有事务,打印1/0，报错；
@Transactional
public void updateSchool(){
School school = new School();
school.setId(1);
school.setName("湖南大学");
school.setLocation("湖南");
schoolMapper.updateByPrimaryKeySelective(school);
studentService.updateStudent();
System.out.println(1/0);
}updateStudent方法更新id为1的age为25，事务传播机制为REQUIRES_NEW；
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void updateStudent(){
Student student = new Student();
student.setSid(1);
student.setAge(25);
studentMapper.updateByPrimaryKeySelective(student);
}如上所示：updateSchool方法有加事务，studentService.updateStudent方法加了事务，而且传播机制是REQUIRES_NEW，如果updateStudent方法新建了另一个事务，updateSchool报错，updateStudent不会回滚，如果不是新建一个事务而是共用一个事务，就会一起回滚；
结果：
1.控制台报错
2.updateSchool方法回滚（将北京大学刚改为湖南大学）
3. updateStudent没有回滚（将age改为25）
显然：updateStudent新建了另外一个事务，和updateSchool并不是共用一个事务；
总结：传播机制是REQUIRES_NEW，新建一个新事务；如果当前事务存在，把当前事务挂起。
使用场景：被调用方法，不想因为调用方出错而回滚，可以使用REQUIRES_NEW；
无事务执行，如果当前事务存在，把当前事务挂起。
updateSchool方法更新id为1的name为“湖南大学”，location为“湖南”，没有事务,打印1/0，报错；
//@Transactional
public void updateSchool(){
School school = new School();
school.setId(1);
school.setName("湖南大学");
school.setLocation("湖南");
schoolMapper.updateByPrimaryKeySelective(school);
studentService.updateStudent();
}updateStudent方法更新id为1的age为25，事务传播机制为NOT_SUPPORTED；
@Transactional(propagation = Propagation.NOT_SUPPORTED)
public void updateStudent(){
Student student = new Student();
student.setSid(1);
student.setAge(25);
studentMapper.updateByPrimaryKeySelective(student);
System.out.println(1/0);
}如上所示：updateSchool方法没有事务，studentService.updateStudent方法加了事务，而且传播机制是NOT_SUPPORTED，如果updateStudent没有事务，那么在执行打印1/0报错后，也就不会回滚；
结果：
1.控制台报错
2.updateSchool方法不回滚（将北京大学刚改为湖南大学）
3. updateStudent没有回滚（将age改为25）
显然：两个方法都没有在事务中运行，都没有回滚，所以，如果当前没有事务，NOT_SUPPORTED并不会新建一个事务，也是无事务执行；
updateSchool方法更新id为1的name为“湖南大学”，location为“湖南”，有事务；
@Transactional
public void updateSchool(){
School school = new School();
school.setId(1);
school.setName("湖南大学");
school.setLocation("湖南");
schoolMapper.updateByPrimaryKeySelective(school);
studentService.updateStudent();
}updateStudent方法更新id为1的age为25，事务传播机制为NOT_SUPPORTED，打印1/0，报错；
@Transactional(propagation = Propagation.NOT_SUPPORTED)
public void updateStudent(){
Student student = new Student();
student.setSid(1);
student.setAge(25);
studentMapper.updateByPrimaryKeySelective(student);
System.out.println(1/0);
}如上所示：updateSchool方法有事务，studentService.updateStudent方法加了事务，而且传播机制是NOT_SUPPORTED，如果updateStudent没有事务，那么在执行打印1/0报错后，也就不会回滚，而updateSchool检测到报错，如果当前事务有效，updateSchool就会回滚；
结果：
1.控制台报错
2.updateSchool方法回滚（将北京大学刚改为湖南大学）
3. updateStudent没有回滚（将age改为25）
显然：当前有事务的情况下，传播机制为NOT_SUPPORTED的方法无事务运行；
总结：事务传播机制为NOT_SUPPORTED，无事务执行，如果当前存在事务，把当前事务挂起；
使用场景：被调用方法想无事务运行，但又不影响调用方的事务，可以用NOT_SUPPORTED；
无事务执行，如果当前有事务则抛出Exception。
这个和MANDATORY就是两个完全相反的极端，一个强制不要事务，一个强制要事务，不满足都会报错；
updateSchool方法更新id为1的name为“湖南大学”，location为“湖南”，没有事务；
//@Transactional
public void updateSchool(){
School school = new School();
school.setId(1);
school.setName("湖南大学");
school.setLocation("湖南");
schoolMapper.updateByPrimaryKeySelective(school);
studentService.updateStudent();
}
updateStudent方法更新id为1的age为25，事务传播机制为NEVER，打印1/0，报错；
@Transactional(propagation = Propagation.NEVER)
public void updateStudent(){
Student student = new Student();
student.setSid(1);
student.setAge(25);
studentMapper.updateByPrimaryKeySelective(student);
System.out.println(1/0);
}如上所示：updateSchool方法没有事务，studentService.updateStudent方法加了事务，而且传播机制是NEVER，打印1/0，会报错，如果updateStudent是无事务执行，那么就不会回滚
结果：
1.控制台报错
2.updateSchool方法不回滚（将北京大学刚改为湖南大学）
3.updateStudent没有回滚（将age改为25）
显然：updateSchool和updateStudent都没有回滚，都是无事务执行，所以，传播机制为NEVER，如果当前没有事务，则无事务执行；
updateSchool方法更新id为1的name为“湖南大学”，location为“湖南”，有事务；
@Transactional
public void updateSchool(){
School school = new School();
school.setId(1);
school.setName("湖南大学");
school.setLocation("湖南");
schoolMapper.updateByPrimaryKeySelective(school);
studentService.updateStudent();
}updateStudent方法更新id为1的age为25，事务传播机制为NEVER；
@Transactional(propagation = Propagation.NEVER)
public void updateStudent(){
Student student = new Student();
student.setSid(1);
student.setAge(25);
studentMapper.updateByPrimaryKeySelective(student);
}如上所示：updateSchool方法有事务，studentService.updateStudent方法加了事务，而且传播机制是NEVER，当前有事务，就看执行updateStudent方法时到底报不报错；
结果：
1.控制台报错
2.updateSchool方法回滚（将北京大学刚改为湖南大学）
3. updateStudent直接报错
org.springframework.transaction.IllegalTransactionStateException: Existing transaction found for transaction marked with propagation 'never'
显然：传播机制为NEVER，如果当前有事务，则报错；
总结：这种传播机制感觉没啥用途，哈哈，反正我是基本没用过；
嵌套事务，如果当前事务存在，那么在嵌套的事务中执行。如果当前事务不存在，则表现跟REQUIRED一样。
这个直接说，如果父事务回滚，子事务也会跟着回滚；如果子事务回滚，并抛出异常，父事务肯定会跟着回滚；
如果当前没有事务，就和REQUIRED,新建一个事务运行；
关于@Transactional注解的原理和事务传播机制的原理可以看我上一篇文章：
我发现ActiveRecord::Base.transaction在复杂方法中非常有效。我想知道是否可以在如下事务中从AWSS3上传/删除文件:S3Object.transactiondo#writeintofiles#raiseanexceptionend引发异常后，每个操作都应在S3上回滚。S3Object这可能吗？？ 最佳答案 虽然S3API具有批量删除功能，但它不支持事务，因为每个删除操作都可以独立于其他操作成功/失败。该API不提供任何批量上传功能(通过PUT或POST)，因此每个上传操作都是通过一个独立的API调用完成的
我有一个涉及多台机器、消息队列和事务的问题。因此，例如用户点击网页，点击将消息发送到另一台机器，该机器将付款添加到用户的帐户。每秒可能有数千次点击。事务的所有方面都应该是容错的。我以前从未遇到过这样的事情，但一些阅读表明这是一个众所周知的问题。所以我的问题。我假设安全的方法是使用两阶段提交，但协议(protocol)是阻塞的，所以我不会获得所需的性能，我是否正确？我通常写Ruby，但似乎Redis之类的数据库和Rescue、RabbitMQ等消息队列系统对我的帮助不大——即使我实现某种两阶段提交，如果Redis崩溃，数据也会丢失，因为它本质上只是内存。所有这些让我开始关注erlang和
MIMO技术的优缺点优点通过下面三个增益来总体概括：阵列增益。阵列增益是指由于接收机通过对接收信号的相干合并而活得的平均SNR的提高。在发射机不知道信道信息的情况下，MIMO系统可以获得的阵列增益与接收天线数成正比复用增益。在采用空间复用方案的MIMO系统中，可以获得复用增益，即信道容量成倍增加。信道容量的增加与min(Nt,Nr)成正比分集增益。在采用空间分集方案的MIMO系统中，可以获得分集增益，即可靠性性能的改善。分集增益用独立衰落支路数来描述，即分集指数。在使用了空时编码的MIMO系统中，由于接收天线或发射天线之间的间距较远，可认为它们各自的大尺度衰落是相互独立的，因此分布式MIMO
我已经开始使用mysql2gem。我试图弄清楚一些基本的事情——其中之一是如何明确地执行事务(对于批处理操作，比如多个INSERT/UPDATE查询)。在旧的ruby-mysql中，这是我的方法:client=Mysql.real_connect(...)inserts=["INSERTINTO...","UPDATE..WHEREid=..",#etc]client.autocommit(false)inserts.eachdo|ins|beginclient.query(ins)rescue#handleerrorsorabortentirelyendendclient.commi
保存成功后可以回滚吗？让我有一个带有属性名称、电子邮件等的用户模型。例如u=User.newu.name="test_name"u.email="test@email.com"u.save现在记录将成功保存在数据库中，之后我想回滚我的事务(不是销毁或删除)。有什么想法吗？ 最佳答案 您可以通过交易来做到这一点，请参阅http://markdaggett.com/blog/2011/12/01/transactions-in-rails/例子:User.transactiondoUser.create(:username=>'Nemu
我目前正在上一门数据库类(class)，其中一个实验室问题让我困惑于如何实现上述内容，事实上，如果可能的话。我试过搜索docs但是定义的交易方式比较模糊。这是我第一次尝试在没有Rails的情况下进行任何数据库操作，所以我有点迷茫。我已经成功地创建了一个到我的postgresql数据库的连接并且可以执行语句，我需要做的最后一件事是根据一个简单的条件回滚一个事务。请允许我向您展示代码:require'pg'@conn=PG::Connection.open(:dbname=>'db_15_11_labs')@conn.prepare('insert','INSERTINTOhouse(ho
如何使用Rails中的事务block一次性更新/保存模型的多个实例？我想更新数百条记录的值；每条记录的值都不同。这不是一个属性的批量更新情况。Model.update_all(attr:value)在这里不合适。MyModel.transactiondothings_to_update.eachdo|thing|thing.score=rand(100)+rand(100)thing.saveendendsave似乎发布了它自己的事务，而不是将更新分批处理到周围的事务中。我希望所有更新都在一次大交易中进行。我怎样才能做到这一点？ 最佳答案
给定以下代码:defcreate@something=Something.new(params[:something])thing=@something.thing#anothermodel#modificationofattributesonboth'something'and'thing'omitted#doIneedtowrapitinsideatransactionblock?@something.savething.saveendcreate方法是隐式包装在ActiveRecord事务中，还是需要将其包装到事务block中？如果我确实需要包装它，这是最好的方法吗？
我正在使用Ruby-Tk为OSX开发一个桌面应用程序，我想为该应用程序提供一个AppleEvents接口(interface)。这意味着应用程序将定义它将响应的AppleScript命令的字典(对应于发送到应用程序的Apple事件)，并且用户/其他应用程序可以使用AppleScript命令编写Ruby-Tk应用程序的脚本。其他脚本语言支持此类功能——Python通过位于http://appscript.svn.sourceforge.net/viewvc/appscript/py-aemreceive/的py-aemreceive库和Tcl通过位于http://tclae.source
Method#unbind返回对该方法的UnboundMethod引用，稍后可以使用UnboundMethod#bind将其绑定(bind)到另一个对象.classFooattr_reader:bazdefinitialize(baz)@baz=bazendendclassBardefinitialize(baz)@baz=bazendendf=Foo.new(:test1)g=Foo.new(:test2)h=Bar.new(:test3)f.method(:baz).unbind.bind(g).call#=>:test2f.method(:baz).unbind.bind(h).