PS:今天上午，非常郁闷，有很多简略基础的问题搞得我有些迷茫，哎，代码几天不写就忘。目前又不当COO，还是得用心记代码哦！
事务配置
- 首先在/WEB-INF/applicationContext.xml添加以下内容：
<!-- 配置事务管理器 -->
<
bean
id
=
"transactionManager"
class
=
"org.springframework.orm.hibernate3.HibernateTransactionManager"
>
<
property
name
=
"sessionFactory"
>
<
ref
bean
=
"mySessionFactory"
/>
</
property
>
</
bean
>
注：这是作为大众应用的事务管理器Bean。这个会是事前配置好的，不需各个模块各自去配。
- 下面就开始配置各个模块所必须的部份，在各自的applicationContext-XXX-beans.xml配置的对于事务管理的详细信息。
首先就是配置事务的传播特性，如下：
<!-- 配置事务传播特性 -->
<
tx
:
advice
id
=
"TestAdvice"
transaction
-
manager
=
"transactionManager"
>
<
tx
:
attributes
>
<
tx
:
method
name
=
"save*"
propagation
=
"REQUIRED"
/>
<
tx
:
method
name
=
"del*"
propagation
=
"REQUIRED"
/>
<
tx
:
method
name
=
"update*"
propagation
=
"REQUIRED"
/>
<
tx
:
method
name
=
"add*"
propagation
=
"REQUIRED"
/>
<
tx
:
method
name
=
"find*"
propagation
=
"REQUIRED"
/>
<
tx
:
method
name
=
"get*"
propagation
=
"REQUIRED"
/>
<
tx
:
method
name
=
"apply*"
propagation
=
"REQUIRED"
/>
</
tx
:
attributes
>
</
tx
:
advice
>
<!-- 配置介入事务的类 -->
<
aop
:
config
>
<
aop
:
pointcut
id
=
"allTestServiceMethod"
expression
=
"execution(* com.test.testAda.test.model.service.*.*(..))"
/>
<
aop
:
advisor
pointcut
-
ref
=
"allTestServiceMethod"
advice
-
ref
=
"TestAdvice"
/>
</
aop
:
config
>
需要注意的地方:
（1） advice（建议）的定名：由于每一个模块都市有自己的Advice，所以在定名上需要作出规范，开端的构想就是模块名+Advice（只是一种定名规范）。
（2） tx:attribute标签所配置的是作为事务的方法的定名类型。
如<tx:method name="save*" propagation="REQUIRED"/>
其中*为通配符，即代表以save为扫尾的所有方法，即表示符合此定名规矩的方法作为一个事务。
propagation="REQUIRED"代表支持以后事务，如果以后没有事务，就新建一个事务。这是最常见的选择。
（3） aop:pointcut标签配置介入事务的类，由于是在Service中停止数据库业务操纵，配的应当是包含那些作为事务的方法的Service类。
首先应当特别注意的是id的定名，同样由于每一个模块都有自己事务切面，所以我觉得开端的定名规矩因为 all+模块名+ServiceMethod。而且每一个模块之间不同之处还在于以下一句：
expression="execution(* com.test.testAda.test.model.service.*.*(..))"
其中第一个*代表返回值，第二*代表service下子包，第三个*代表方法名，“（..）”代表方法参数。
（4） aop:advisor标签就是把上面我们所配置的事务管理两部份属性整合起来作为全部事务管理。
图解：
下面附上配置声明式事务的一些相关的资料，以下资料均来源于互联网：
附一、Spring事务类型详解
附二、对spring事务类型详解的一点补充（关于嵌套事务）
附三、Transaction后缀给声明式事务管理带来的好处
附四、Spring中的四种声明式事务的配置
附一、Spring事务类型详解
<prop key="load*">PROPAGATION_REQUIRED,readOnly</prop><prop key="store*">PROPAGATION_REQUIRED</prop>
估计有好多友人还没有弄清楚里面的值的意思，仔细看完下面应当知道自己什么情况下面应当应用什么样的声明。^_^
Spring中经常使用事务类型：
PROPAGATION_REQUIRED--支持以后事务，如果以后没有事务，就新建一个事务。这是最常见的选择。
PROPAGATION_SUPPORTS--支持以后事务，如果以后没有事务，就以非事务方式执行。
PROPAGATION_MANDATORY--支持以后事务，如果以后没有事务，就抛出异常。
PROPAGATION_REQUIRES_NEW--新建事务，如果以后存在事务，把以后事务挂起。
PROPAGATION_NOT_SUPPORTED--以非事务方式执行操纵，如果以后存在事务，就把以后事务挂起。
PROPAGATION_NEVER--以非事务方式执行，如果以后存在事务，则抛出异常。
PROPAGATION_NESTED--如果以后存在事务，则在嵌套事务内执行。如果以后没有事务，则停止与PROPAGATION_REQUIRED类似的操纵。
附二、对spring事务类型详解的一点补充（关于嵌套事务）
· PROPAGATION_REQUIRED--支持以后事务，如果以后没有事务，就新建一个事务。这是最常见的选择。
· PROPAGATION_SUPPORTS--支持以后事务，如果以后没有事务，就以非事务方式执行。
· PROPAGATION_MANDATORY--支持以后事务，如果以后没有事务，就抛出异常。
· PROPAGATION_REQUIRES_NEW--新建事务，如果以后存在事务，把以后事务挂起。
· PROPAGATION_NOT_SUPPORTED--以非事务方式执行操纵，如果以后存在事务，就把以后事务挂起。
· PROPAGATION_NEVER--以非事务方式执行，如果以后存在事务，则抛出异常。
可能大家对PROPAGATION_NESTED还不怎么懂得，觉得有必要再补充一下^_^！
PROPAGATION_NESTED: 嵌套事务类型，是相对上面提到的六种情况（上面的六种应当称为平面事务类型），打个比方我现在有一个事务重要有一下几部份：
1，从A用户帐户里面减去100元钱
2，往B用户帐户里面添加100元钱
这样看和以前不同的事务可能没有什么区别，那我现在有点特别的要求就是，A用户有3个帐户，B用户有2个帐户，现在我的要求就是只要再A用户的3个帐户里面恣意一个减去100元，往B用户的两个帐户中恣意一个里面增长100元就可以了！
一旦你有这样的要求那嵌套事务类型就非常合适你！我们可以这样理解，
一：将“从A用户帐户里面减去100元钱” 和 “往B用户帐户里面增长100元钱”我们暂时认为是一级事务操纵
二：将从A用户的3个帐户的恣意一个帐户里面减钱看做是“从A用户帐户里面减去100元钱”这个一级事务的子事务（二级事务），同样把后面存钱的看成是另一个的二级事务。
问题一：当二级事务被rollback一级事务会不会被rollback？
谜底是不会的，二级事务的rollback只针对自己。
问题二：什么时候这个一级事务会commit，什么时候会被rollback呢？
我们重要看二级里面涌现的情况，当所有的二级事务被commit了并且一级事务没有失败的操纵，那全部事务就算是一个胜利的事务，这种情况全部事务会被commit。
当恣意一个二级事务没有被commit那全部事务就是失败的，全部事务会被roolback。
还是拿上面的例子来说明吧！如果我在a的三个帐户里面减钱的操纵都被二级事务给rollback了，也就是3个帐户里面都没有减钱胜利，全部事务就失败了就会被rollback。如果A用户帐户三个帐户里面有一个可以扣钱而且B用户的两个帐户里面也有一个帐户可以增长钱，那全部事务就算胜利的，会被 commit。
看了一下觉得上面的例子似乎不是很深刻，看这个情况（A用户的3个帐户都是有信用额度的，也就是说可以超支，但是超支有金额限制）。不过原理是一样的，简略点也好说明一点，祝你好运！^_^
附三、Transaction后缀给声明式事务管理带来的好处
精良的面向对象的程序，一般都应用接口和实现分离的模式。我在《事务管理最佳实践全面剖析》一文中提出，用*Transaction和*Dao后缀这样的情势，辨别方法的不同用处。
这样，可以提示接口的实现者和方法的应用者注意到它们对于数据库连接和事务的依附。
现实上，应用*Transaction后缀这样的定名方式，对于声明式事务管理也是很有用处的。如，Spring的事务管理中，我们一般应用方法名的匹配来应用声明式事务。
一、请看下面的Spring配置：
<
bean
id
=
"txProxyTemplate"
abstract
=
"true"
class
=
"org.springframework.transaction.interceptor.TransactionProxyFactoryBean"
>
<
property
name
=
"transactionManager"
ref
=
"transactionManager"
/>
<
property
name
=
"transactionAttributes"
>
<
props
>
<
prop
key
=
"*"
>
readOnly
</
prop
>
<
prop
key
=
"add*"
>
PROPAGATION_REQUIRED,-Exception
</
prop
>
<
prop
key
=
"save*"
>
PROPAGATION_REQUIRED,-Exception
</
prop
>
<
prop
key
=
"modify*"
>
PROPAGATION_REQUIRED,-Exception
</
prop
>
<
prop
key
=
"update*"
>
PROPAGATION_REQUIRED,-Exception
</
prop
>
<
prop
key
=
"delete*"
>
PROPAGATION_REQUIRED,-Exception
</
prop
>
<
prop
key
=
"remove*"
>
PROPAGATION_REQUIRED,-Exception
</
prop
>
<
prop
key
=
"query*"
>
PROPAGATION_REQUIRED, readOnly,-Exception
</
prop
>
<
prop
key
=
"load*"
>
PROPAGATION_REQUIRED, -Exception
</
prop
>
</
props
>
</
property
>
</
bean
>
这是来自于实在项目中的Spring声明式事务配置。我们对每一个业务层的实现类都应用了这样的事务配置。
我们对所有业务服务Service方法应用了只读事务。对以add,save,modify,update,delete,remove,load扫尾的方法都应用了事务。
但是，现实上，虽然我们开发的软件一个“信息管理系统”，是围绕数据库开发的。但是，在Service层，我们还是有很多不操纵数据库的方法。
如，单纯根据业务逻辑停止盘算的，实用缓存停止盘算的，执行email发送，文件上传等等任务的方法，在这种配置下都不分青红皂白的应用了事务。
SpringAOP生成的代理对象代理了我们的服务实现类，所有的方法执行前后都被拦截，用来得到和关闭数据库连接，设置、提交和回滚事务。而不管这个方法是不是用到了这个数据库。
如果遵照我提出的这个方法，应用*Transaction后缀来标识需要处理事务的方法，那么我们应用Spring声明式事务时，就可以非常准确、有效的应用事务了！
二、请看下面的Spring事务配置：
<!-- UninstallWcmsJbpmProcessDefinition -->
<
bean
id
=
"uninstallWcmsJbpmProcessDefinition"
parent
=
"txProxyTemplate"
>
<
property
name
=
"target"
>
<
ref
bean
=
"uninstallWcmsJbpmProcessDefinitionTarget"
/>
</
property
>
<
property
name
=
"transactionAttributes"
>
<
props
>
<
prop
key
=
"uninstall*Wcms*Transaction"
>
PROPAGATION_REQUIRED,-Exception
</
prop
>
</
props
>
</
property
>
</
bean
>
我们对这个类中以uninstall扫尾，中间包含Wcms，最后以Transaction开头，这样的规矩定名的方法，应用了事务。
三、部份源代码：
（一）2个应用了Spring声明式事务的方法：
/**
*应用SPring的ibatis，重要要配置iBatis的Spring声明式事务。
*@throwsException
*<prop key="uninstall*Wcms*Transaction">PROPAGATION_REQUIRED,-Exception</prop>
*1，还要删除所有 频道---消息--工作流表中标记不为1的记录。
*/
publicvoid uninstallAllWcmsProcessDefinitionsTransaction()
throws
Exception{
/**
*
*
*/
this
.getWcmsSystemChannelProcessdefinitionDao().deleteAll();
this
.getWcmsSystemChannelNewsinfoDao().deleteAllProcessingWcmsSystemChannelNewsinfoModule();
}
/**
*<prop key="uninstall*Wcms*Transaction">PROPAGATION_REQUIRED,-Exception</prop>
*@paramname
*@throwsException
*/
publicvoid uninstallWcmsSystemChannelProcessdefinitionTransaction(String name)
throws
Exception{
this
.getWcmsSystemChannelProcessdefinitionDao().deleteByProcessdefinitionName(name);
this
.getWcmsSystemChannelNewsinfoDao().deleteAllProcessingWcmsSystemChannelNewsinfoModuleByProcessdefinitionName(name);
}
（二）用到的Dao类，用来现实访问数据库的
2
个DAO对象。
/**
*SPring管理的ibatis功能
*/
private
IWcmsSystemChannelProcessdefinitionDao wcmsSystemChannelProcessdefinitionDao;
private
IWcmsSystemChannelNewsinfoDao wcmsSystemChannelNewsinfoDao;
|
附四、Spring中的四种声明式事务的配置
让我们言归正传吧。
以下两个bean的配置是下面要用到的。
<!-- 定义事务管理器（声明式的事务） -->
<
bean
id
=
"transactionManager"
class
=
"org.springframework.orm.hibernate3.HibernateTransactionManager"
>
<
property
name
=
"sessionFactory"
>
<
ref
local
=
"sessionFactory"
/>
</
property
>
</
bean
>
<!-- *******业务逻辑层(是对各个DAO层的正面封装)重要用到<<门面模式>>****** -->
<
bean
id
=
"fundService"
class
=
"com.jack.fund.service.serviceimpl.FundService"
>
<
property
name
=
"operdao"
>
<
ref
bean
=
"operatorDAO"
/>
</
property
>
<
property
name
=
"producedao"
>
<
ref
bean
=
"fundProduceDAO"
/>
</
property
>
<
property
name
=
"customerdao"
>
<
ref
bean
=
"customerDAO"
/>
</
property
>
<
property
name
=
"accountdao"
>
<
ref
bean
=
"accountDAO"
/>
</
property
>
<
property
name
=
"fundaccountdao"
>
<
ref
bean
=
"fundAccountDAO"
/>
</
property
>
<
property
name
=
"fundtransdao"
>
<
ref
bean
=
"fundTransDAO"
/>
</
property
>
</
bean
>
可能还有其他很多模块。<bean id="fundService"/>可能只是其中的模块。
第一种：配置声明式事务的方法如下。也是我们最经常使用的方法了，它实用于你的库表比较少的情况下。
<
bean
id
=
"fundServiceDAOProxy"
class
=
"org.springframework.transaction.interceptor.TransactionProxyFactoryBean"
>
<!-- 配置事务管理器 -->
<
property
name
=
"transactionManager"
>
<
ref
bean
=
"transactionManager"
/>
</
property
>
<!-- 此属性指定目标类本省是不是是代理的对象，如果目标类没有实现任何类，就设为true代表自己 -->
<
property
name
=
"proxyTargetClass"
>
<
value
>
false
</
value
>
</
property
>
<
property
name
=
"proxyInterfaces"
>
<
value
>
com.jack.fund.service.IFundService
</
value
>
</
property
>
<!-- 目标bean -->
<
property
name
=
"target"
>
<
ref
bean
=
"fundService"
/>
</
property
>
<!-- 配置事务属性 -->
<
property
name
=
"transactionAttributes"
>
<
props
>
<
prop
key
=
"delete*"
>
PROPAGATION_REQUIRED
</
prop
>
<
prop
key
=
"add*"
>
PROPAGATION_REQUIRED
</
prop
>
<
prop
key
=
"update*"
>
PROPAGATION_REQUIRED
</
prop
>
<
prop
key
=
"save*"
>
PROPAGATION_REQUIRED
</
prop
>
<
prop
key
=
"find*"
>
PROPAGATION_REQUIRED,readOnly
</
prop
>
</
props
>
</
property
>
</
bean
>
以下可能还有其他的xxxServiceDAOProxy.大家可以看出针对每一个功能模块配置一个业务代理服务。如果模块多谎话，就显得代码有点多了，发现他们只是略微一点不一样。这时我们就应当想到继承的思惟。用第二种方法。
第二种：配置声明式事务的方法如下。这种情况合适相对比较多的模块时应用。
<!-- 利用继承的思惟简化配置，要把abstract="true" -->
<
bean
id
=
"transactionBase"
class
=
"org.springframework.transaction.interceptor.TransactionProxyFactoryBean"
lazy
-
init
=
"true"
abstract
=
"true"
>
<!-- 配置事务管理器 -->
<
property
name
=
"transactionManager"
>
<
ref
bean
=
"transactionManager"
/>
</
property
>
<!-- 配置事务属性 -->
<
property
name
=
"transactionAttributes"
>
<
props
>
<
prop
key
=
"delete*"
>
PROPAGATION_REQUIRED
</
prop
>
<
prop
key
=
"add*"
>
PROPAGATION_REQUIRED
</
prop
>
<
prop
key
=
"update*"
>
PROPAGATION_REQUIRED
</
prop
>
<
prop
key
=
"save*"
>
PROPAGATION_REQUIRED
</
prop
>
<
prop
key
=
"find*"
>
PROPAGATION_REQUIRED,readOnly
</
prop
>
</
props
>
</
property
>
</
bean
>
而详细的模块可以简略的这样配置。只要指明它的parent（父类）就可以了。父类一般把abstract="true"，因为在容器加载的时候不需要初始化，等到用的时候再有它的子类调用的时候，再去初始化。
<
bean
id
=
"fundServiceDAOProxy"
parent
=
"transactionBase"
>
<
property
name
=
"target"
>
<
ref
bean
=
"fundService"
/>
</
property
>
</
bean
>
这样配置的话，如果有多个像fundService这样模块时，可以少些很多重复的代码。
第三种：配置声明式事务的方法如下。重要利用BeanNameAutoProxyCreator自动创建事务代理
<
bean
id
=
"transactionInterceptor"
class
=
"org.springframework.transaction.interceptor.TransactionInterceptor"
>
<
property
name
=
"transactionManager"
>
<
ref
bean
=
"transactionManager"
/>
</
property
>
<!-- 配置事务属性 -->
<
property
name
=
"transactionAttributes"
>
<
props
>
<
prop
key
=
"delete*"
>
PROPAGATION_REQUIRED
</
prop
>
<
prop
key
=
"add*"
>
PROPAGATION_REQUIRED
</
prop
>
<
prop
key
=
"update*"
>
PROPAGATION_REQUIRED
</
prop
>
<
prop
key
=
"save*"
>
PROPAGATION_REQUIRED
</
prop
>
<
prop
key
=
"find*"
>
PROPAGATION_REQUIRED,readOnly
</
prop
>
</
props
>
</
property
>
</
bean
>
<
bean
class
=
"org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator"
>
<
property
name
=
"beanNames"
>
<
list
>
<
value
>
fundService
</
value
>
</
list
>
</
property
>
<
property
name
=
"interceptorNames"
>
<
list
>
<
value
>
transactionInterceptor
</
value
>
</
list
>
</
property
>
</
bean
>
这种方法重要利用了拦截器的原理。
前三种方法一般都必需指定详细的模块bean.如果模块过多话，比如一个大型的网站一般有几十个模块。我们就得考虑用第四种的配置方式了。自动创建事务代理的方式了。
第四种：配置声明式事务的方法如下。
<
bean
id
=
"transactionInterceptor"
class
=
"org.springframework.transaction.interceptor.TransactionInterceptor"
>
<
property
name
=
"transactionManager"
>
<
ref
bean
=
"transactionManager"
/>
</
property
>
<!-- 自动代理 -->
<
bean
id
=
"autoproxy"
class
=
"org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator"
>
<!-- 可以是Service或DAO层（最好是针对业务层*Service） -->
<
property
name
=
"beanNames"
>
<
list
>
<
value
>
*Service
</
value
>
</
list
>
</
property
>
<
property
name
=
"interceptorNames"
>
<
list
>
<
value
>
transactionInterceptor
</
value
>
</
list
>
</
property
>
</
bean
>
自动代理还有一种用法就是结合正规表达式和advice应用。
<
bean
id
=
"transactionInterceptor"
class
=
"org.springframework.transaction.interceptor.TransactionInterceptor"
>
<
property
name
=
"transactionManager"
>
<
ref
bean
=
"transactionManager"
/>
</
property
>
<
bean
id
=
"autoProxyCreator"
class
=
"org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"
/>
<
bean
id
=
"regexpMethodPointcutAdvisor"
class
=
"org.springframework.aop.support.RegexpMethodPointcutAdvisor"
>
<
property
name
=
"advice"
>
<
ref
bean
=
"transactionInterceptor"
/>
</
property
>
<
property
name
=
"pattern"
>
<
value
>
.*
</
value
>
</
property
>
</
bean
>
这个方法可以针对详细的模块停止拦截并停止事务处理。
在你的现实项目中，你可以根据你的情况选用不同的方法。
文章结束给大家分享下程序员的一些笑话语录： 雅虎最擅长的不是开通新业务，是关闭旧业务。