AI 助理
备案控制台
开发者社区 数据库 文章 正文

Spring事务

2016-12-23 947
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 一、Spring事务接口 spring事务提供了三个主要的接口PlatformTransactionManager、TransactionDefination定义事务隔离级别、TransactionDefination定义事务传播行为、TransactionStatus接口。

一、Spring事务接口

spring事务提供了三个主要的接口PlatformTransactionManager、TransactionDefination定义事务隔离级别、TransactionDefination定义事务传播行为、TransactionStatus接口。

PlatformTransactionManager：事务管理器。

TransactionDefination：定义事务隔离级别：READ_UNCOMMITED、READ_COMMITTED、REPEATABLE_READ、SERIALIZABLE。mysql数据库默认的是REPEATABLE_READ级别4.

TransactionDefination：定义事务传播行为：PROPAGATION_REQUIRED、PROPAGATION_SUPPORTS、PROPAGATION_MANDATORY、PROPAGATION_REQUIRES_REW、PROPAGATION_NOT_SUPPORTED、PROPAGATION_NEVER、PROPAGATION_NESTED等

二、spring事务管理--转账案例

2.1、环境搭建

    引入相关jar包、jdbc.properties、log4j.properties等

    AccountService接口、AccountServiceImpl实现类

    AccountDao接口、AccountDaoImpl实现类

AccountService.java接口

 
 
  1: package com.spring.demo1;

 
 
  2: 

 
 
  3: public interface AccountService {

 
 
  4:   public void transfer(String OutName,String InName,Double money);

 
 
  5: }

 
 
  6: 
 
 
AccountDao.java接口：
 
 
 
 
  1: package com.spring.demo1;

 
 
  2: public interface AccountDao {

 
 
  3:   public void outMoney(String OutName,Double money);

 
 
  4:   public void inMoney(String InName,Double money);

 
 
  5: }

 
 
  6: 
 
 
AccountDaoImpl.java
 
 
 
 
  1: package com.spring.demo1;

 
 
  2: 

 
 
  3: import org.springframework.jdbc.core.support.JdbcDaoSupport;

 
 
  4: public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao  {

 
 
  5: 

 
 
  6:   public void inMoney(String InName, Double money) {

 
 
  7:     // TODO Auto-generated method stub

 
 
  8:     String sql="update account set money=money + ? where name= ?";

 
 
  9:     this.getJdbcTemplate().update(sql,money,InName);

 
 
 10:   }

 
 
 11: 

 
 
 12:   public void outMoney(String OutName, Double money) {

 
 
 13:     // TODO Auto-generated method stub

 
 
 14:     String sql="update account set money=money - ? where name= ?";

 
 
 15:     this.getJdbcTemplate().update(sql,money,OutName);

 
 
 16:   }

 
 
 17: 

 
 
 18: }

 
 
 19: 
 
 
 
 
 
2.2、编程式事务管理
 
 
ApplicationContex.xml
 
 
 
 
  1: <?xml version="1.0" encoding="UTF-8" ?>

 
 
  2: <beans xmlns="http://www.springframework.org/schema/beans"

 
 
  3:   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"

 
 
  4:   xmlns:context="http://www.springframework.org/schema/context"

 
 
  5:   xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"

 
 
  6:   xsi:schemaLocation="http://www.springframework.org/schema/beans 

 
 
  7:        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

 
 
  8:        http://www.springframework.org/schema/context 

 
 
  9:        http://www.springframework.org/schema/context/spring-context-3.0.xsd

 
 
 10:        http://www.springframework.org/schema/tx 

 
 
 11:        http://www.springframework.org/schema/tx/spring-tx-3.0.xsd

 
 
 12:        http://www.springframework.org/schema/aop

 
 
 13:        http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">

 
 
 14:     

 
 
 15:     

 
 
 16:    <!-- 引入外部的属性文件 -->

 
 
 17:   <context:property-placeholder location="classpath:jdbc.properties" />

 
 
 18:      

 
 
 19:      <!-- 配置c3p0连接池 

 
 
 20:   <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"

 
 
 21:     p:driverClass="${jdbc.driverClass}"

 
 
 22:     p:jdbcUrl="${jdbc.url}"

 
 
 23:     p:user="${jdbc.username}"

 
 
 24:     p:password="${jdbc.password}" />-->

 
 
 25:   

 
 
 26:   <!-- 配置dbcp连接池 -->

 
 
 27:   <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"

 
 
 28:     destroy-method="close" 

 
 
 29:     p:driverClassName="${jdbc.driverClass}"

 
 
 30:     p:url="${jdbc.url}"

 
 
 31:     p:username="${jdbc.username}"

 
 
 32:     p:password="${jdbc.password}" />

 
 
 33: 

 
 
 34:   <!-- 配置Jdbc模板  -->

 
 
 35:   <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"

 
 
 36:     p:dataSource-ref="dataSource" />

 
 
 37:   

 
 
 38:   <!-- 业务层 -->

 
 
 39:   <bean id="accountService" class="com.spring.demo4.AccountServiceImpl" p:accountDao-ref="accountDao"/>

 
 
 40: 

 
 
 41:   <!-- Dao类 -->

 
 
 42:   <bean id="accountDao" class="com.spring.demo4.AccountDaoImpl" p:dataSource-ref="dataSource" />

 
 
 43:   

 
 
 44:   <!-- 配置事务管理器 -->

 
 
 45:   <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager" 

 
 
 46:     p:dataSource-ref="dataSource" />

 
 
 47:   

 
 
 48:   <!-- 定义一个事务管理模板 ：spring为了简化事务管理的代码而提供的类-->

 
 
 49:   <bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate"

 
 
 50:     p:transactionManager-ref="transactionManager" />

 
 
 51:   

 
 
 52: </beans>

 
 
 53: 
 
 
AccountServiceImpl.java
 
 
 
 
  1: package com.spring.demo1;

 
 
  2: 

 
 
  3: import org.springframework.transaction.TransactionStatus;

 
 
  4: import org.springframework.transaction.support.TransactionCallback;

 
 
  5: import org.springframework.transaction.support.TransactionCallbackWithoutResult;

 
 
  6: import org.springframework.transaction.support.TransactionTemplate;

 
 
  7: import com.sun.istack.internal.FinalArrayList;

 
 
  8: public class AccountServiceImpl implements AccountService {

 
 
  9: 

 
 
 10:   //注入转账的DAO类

 
 
 11:   

 
 
 12:   private AccountDao accountDao;

 
 
 13:   public void setAccountDao(AccountDao accountDao) {

 
 
 14:     this.accountDao = accountDao;

 
 
 15:   }

 
 
 16:   

 
 
 17:   //注入事务管理的模板

 
 
 18:   private TransactionTemplate transactionTemplate;

 
 
 19:   public void setTransactionTemplate(TransactionTemplate transactionTemplate) {

 
 
 20:     this.transactionTemplate = transactionTemplate;

 
 
 21:   }

 
 
 22:   

 
 
 23:   public AccountDao getAccountDao() {

 
 
 24:     return accountDao;

 
 
 25:   }

 
 
 26: 

 
 
 27:   public TransactionTemplate getTransactionTemplate() {

 
 
 28:     return transactionTemplate;

 
 
 29:   }

 
 
 30: 

 
 
 31:   public void transfer(final String OutName,final String InName,final Double money) {

 
 
 32:     // TODO Auto-generated method stub

 
 
 33:     transactionTemplate.execute(new TransactionCallbackWithoutResult() {      

 
 
 34:       @Override

 
 
 35:       protected void doInTransactionWithoutResult(TransactionStatus transactionStatus) {

 
 
 36:         // TODO Auto-generated method stub

 
 
 37:         accountDao.outMoney(OutName, money);

 
 
 38:         accountDao.inMoney(InName, money);

 
 
 39:       }

 
 
 40:     });

 
 
 41:   

 
 
 42:   }

 
 
 43: 

 
 
 44: }

 
 
 45: 
 
 
测试类:springtestdemo1.java
 
 
 
 
  1: package com.spring.demo1;

 
 
  2: 

 
 
  3: import javax.annotation.Resource;

 
 
  4: import org.junit.Test;

 
 
  5: import org.junit.runner.RunWith;

 
 
  6: import org.springframework.test.context.ContextConfiguration;

 
 
  7: import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

 
 
  8: @RunWith(SpringJUnit4ClassRunner.class)

 
 
  9: @ContextConfiguration("classpath:applicationContext.xml")

 
 
 10: public class springtestdemo1 {

 
 
 11:   //测试业务层类：

 
 
 12:   @Resource(name="accountService")

 
 
 13:   private AccountService accountService;

 
 
 14:   @Test

 
 
 15:   public void demo1(){

 
 
 16:     accountService.transfer("aaa", "bbb", 200d);

 
 
 17:   }

 
 
 18: }

 
 
 19: 
 
 
运行结果：
 
 
2016-12-23_15-33-17 2016-12-23_15-33-56 
 
 
当修改一下AccountServiceImpl.java的代码
 
 
 
 
  1: accountDao.outMoney(OutName, money);

 
 
  2: int i=1 / 0;

 
 
  3: accountDao.inMoney(InName, money);
 
 
当不引入事务管理的运行结果: 发现用户aaa已经少了300块,但是用户bbb却没有增加.
 
 
2016-12-23_15-33-17 2016-12-23_15-34-24 
 
 
当引入事务管理的运行结果: 这时候,用户aaa和bbb不会出现不一致的情况
 
 
2016-12-23_15-33-17 2016-12-23_15-33-56 
 
 
 
 
 
2.3、声明式事务管理方式一：TransactionProxyFactoryBean
 
 
ApplicationContext2.xml
 
 
 
 
  1: <?xml version="1.0" encoding="UTF-8" ?>

 
 
  2: <beans xmlns="http://www.springframework.org/schema/beans"

 
 
  3:   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"

 
 
  4:   xmlns:context="http://www.springframework.org/schema/context"

 
 
  5:   xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"

 
 
  6:   xsi:schemaLocation="http://www.springframework.org/schema/beans 

 
 
  7:        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

 
 
  8:        http://www.springframework.org/schema/context 

 
 
  9:        http://www.springframework.org/schema/context/spring-context-3.0.xsd

 
 
 10:        http://www.springframework.org/schema/tx 

 
 
 11:        http://www.springframework.org/schema/tx/spring-tx-3.0.xsd

 
 
 12:        http://www.springframework.org/schema/aop

 
 
 13:        http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">

 
 
 14:     

 
 
 15:    <!-- 引入外部的属性文件 -->

 
 
 16:   <context:property-placeholder location="classpath:jdbc.properties" />

 
 
 17:      

 
 
 18:      <!-- 配置c3p0连接池 

 
 
 19:   <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"

 
 
 20:     p:driverClass="${jdbc.driverClass}"

 
 
 21:     p:jdbcUrl="${jdbc.url}"

 
 
 22:     p:user="${jdbc.username}"

 
 
 23:     p:password="${jdbc.password}" />-->

 
 
 24:   

 
 
 25:   <!-- 配置dbcp连接池 -->

 
 
 26:   <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"

 
 
 27:     destroy-method="close" 

 
 
 28:     p:driverClassName="${jdbc.driverClass}"

 
 
 29:     p:url="${jdbc.url}"

 
 
 30:     p:username="${jdbc.username}"

 
 
 31:     p:password="${jdbc.password}" />

 
 
 32: 

 
 
 33:   <!-- 配置Jdbc模板  -->

 
 
 34:   <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"

 
 
 35:     p:dataSource-ref="dataSource" />

 
 
 36:   

 
 
 37:   <!-- 业务层 -->

 
 
 38:   <bean id="accountService" class="com.spring.demo4.AccountServiceImpl" p:accountDao-ref="accountDao"/>

 
 
 39: 

 
 
 40:   <!-- Dao类 -->

 
 
 41:   <bean id="accountDao" class="com.spring.demo4.AccountDaoImpl" p:dataSource-ref="dataSource" />

 
 
 42:   

 
 
 43:   <!-- 配置事务管理器 -->

 
 
 44:   <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager" 

 
 
 45:     p:dataSource-ref="dataSource" />

 
 
 46:   

 
 
 47:   <!-- 配置业务层的代理 -->

 
 
 48:         <!-- prop的格式：

 
 
 49:             PROPAGATION:事务的传播行为

 
 
 50:             ISOLATION : 事务的隔离级别

 
 
 51:             readOnly:   只读

 
 
 52:             -Exception :发生哪些异常，回滚事务

 
 
 53:             +Exception:发生哪些异常，事务不回滚

 
 
 54:          -->

 
 
 55:   <bean id="accountServiceProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">

 
 
 56:     <!-- 配置目标对象 -->

 
 
 57:     <property name="target" ref="accountService" />

 
 
 58:     <!-- 事务事务管理器 -->

 
 
 59:     <property name="transactionManager" ref="transactionManager" />

 
 
 60:     <!-- 注入事务的一些属性 -->

 
 
 61:     <property name="transactionAttributes" >

 
 
 62:       <props>

 
 
 63:         <prop key="transfer">PROPAGATION_REQUIRED,+java.lang.ArithmeticException</prop>

 
 
 64:       </props>

 
 
 65:     </property>

 
 
 66:   </bean>  

 
 
 67: </beans>
 
 
AccountServiceImpl.java
 
 
 
 
  1: package com.spring.demo2;

 
 
  2: import org.springframework.transaction.TransactionStatus;

 
 
  3: import org.springframework.transaction.support.TransactionCallback;

 
 
  4: import org.springframework.transaction.support.TransactionCallbackWithoutResult;

 
 
  5: import org.springframework.transaction.support.TransactionTemplate;

 
 
  6: import com.sun.istack.internal.FinalArrayList;

 
 
  7: public class AccountServiceImpl implements AccountService {

 
 
  8:   //注入转账的DAO类  

 
 
  9:   private AccountDao accountDao;

 
 
 10:   public void setAccountDao(AccountDao accountDao) {

 
 
 11:     this.accountDao = accountDao;

 
 
 12:   }    

 
 
 13:   public void transfer(String OutName, String InName, Double money) {

 
 
 14:     // TODO Auto-generated method stub

 
 
 15:     accountDao.outMoney(OutName, money);

 
 
 16:     int i=1/0;

 
 
 17:     accountDao.inMoney(InName, money);  

 
 
 18:   }

 
 
 19: }

 
 
 20: 
 
 
测试类：springtestdemo2.java
 
 
 
 
  1: package com.spring.demo2;

 
 
  2: import javax.annotation.Resource;

 
 
  3: import org.junit.Test;

 
 
  4: import org.junit.runner.RunWith;

 
 
  5: import org.springframework.test.context.ContextConfiguration;

 
 
  6: import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

 
 
  7: /**

 
 
  8:  * 声明式

 
 
  9:  * 

 
 
 10:  * @author su

 
 
 11:  *

 
 
 12:  */

 
 
 13: @RunWith(SpringJUnit4ClassRunner.class)

 
 
 14: @ContextConfiguration("classpath:applicationContext2.xml")

 
 
 15: public class springtestdemo2 {

 
 
 16:   //测试业务层类：

 
 
 17:   /**

 
 
 18:    * 

 
 
 19:    * 注入代理类：因为代理类已经增强了

 
 
 20:    */

 
 
 21:   //@Resource(name="accountService")

 
 
 22:   @Resource(name="accountServiceProxy")

 
 
 23:   private AccountService accountService;

 
 
 24:   @Test

 
 
 25:   public void test(){

 
 
 26:     accountService.transfer("aaa", "bbb", 300d);

 
 
 27:   }

 
 
 28: }
 
 
运行结果图上。
 
 
2.4、声明式事务管理方式二：基于AspectJ的xml配置
 
 
ApplicationContex3.xml
 
 
 
 
  1: <?xml version="1.0" encoding="UTF-8" ?>

 
 
  2: <beans xmlns="http://www.springframework.org/schema/beans"

 
 
  3:   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"

 
 
  4:   xmlns:context="http://www.springframework.org/schema/context"

 
 
  5:   xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"

 
 
  6:   xsi:schemaLocation="http://www.springframework.org/schema/beans 

 
 
  7:        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

 
 
  8:        http://www.springframework.org/schema/context 

 
 
  9:        http://www.springframework.org/schema/context/spring-context-3.0.xsd

 
 
 10:        http://www.springframework.org/schema/tx 

 
 
 11:        http://www.springframework.org/schema/tx/spring-tx-3.0.xsd

 
 
 12:        http://www.springframework.org/schema/aop

 
 
 13:        http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">

 
 
 14:     

 
 
 15:     <!-- 引入外部的属性文件 -->

 
 
 16:   <context:property-placeholder location="classpath:jdbc.properties" />

 
 
 17:      

 
 
 18:      <!-- 配置c3p0连接池 

 
 
 19:   <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"

 
 
 20:     p:driverClass="${jdbc.driverClass}"

 
 
 21:     p:jdbcUrl="${jdbc.url}"

 
 
 22:     p:user="${jdbc.username}"

 
 
 23:     p:password="${jdbc.password}" />-->

 
 
 24:   

 
 
 25:   <!-- 配置dbcp连接池 -->

 
 
 26:   <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"

 
 
 27:     destroy-method="close" 

 
 
 28:     p:driverClassName="${jdbc.driverClass}"

 
 
 29:     p:url="${jdbc.url}"

 
 
 30:     p:username="${jdbc.username}"

 
 
 31:     p:password="${jdbc.password}" />

 
 
 32: 

 
 
 33:   <!-- 配置Jdbc模板  -->

 
 
 34:   <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"

 
 
 35:     p:dataSource-ref="dataSource" />

 
 
 36:   

 
 
 37:   <!-- 业务层 -->

 
 
 38:   <bean id="accountService" class="com.spring.demo4.AccountServiceImpl" p:accountDao-ref="accountDao"/>

 
 
 39: 

 
 
 40:   <!-- Dao类 -->

 
 
 41:   <bean id="accountDao" class="com.spring.demo4.AccountDaoImpl" p:dataSource-ref="dataSource" />

 
 
 42:   

 
 
 43:   <!-- 配置事务管理器 -->

 
 
 44:   <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager" 

 
 
 45:     p:dataSource-ref="dataSource" />

 
 
 46:   

 
 
 47:   <!-- 配置事务的通知：(事务的增强增强) -->

 
 
 48:   <tx:advice id="txAdvice" transaction-manager="transactionManager">

 
 
 49:     <tx:attributes>

 
 
 50:       <!-- propagation：事务的传播行为

 
 
 51:         isolation：  事务的隔离级别

 
 
 52:         read-only:只读

 
 
 53:         rollback-for:发生哪些异常回滚

 
 
 54:         no-rollback-for:发生哪些异常不回滚

 
 
 55:        -->

 
 
 56:       <tx:method name="transfer" propagation="REQUIRED"/>

 
 
 57:     </tx:attributes>

 
 
 58:   </tx:advice>

 
 
 59:   

 
 
 60:   <!-- 配置切面 -->

 
 
 61:   <aop:config>

 
 
 62:     <!-- 配置切入点 -->

 
 
 63:     <aop:pointcut expression="execution(* com.spring.demo3.AccountService+.*(..))" id="pointcut1" />

 
 
 64:     <!-- 配置切面 -->

 
 
 65:     <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut1" />

 
 
 66:   </aop:config>

 
 
 67: </beans>
 
 
AccountServiceImpl.java
 
 
 
 
  1: package com.spring.demo3;

 
 
  2: import org.springframework.transaction.TransactionStatus;

 
 
  3: import org.springframework.transaction.annotation.Transactional;

 
 
  4: import org.springframework.transaction.support.TransactionCallback;

 
 
  5: import org.springframework.transaction.support.TransactionCallbackWithoutResult;

 
 
  6: import org.springframework.transaction.support.TransactionTemplate;

 
 
  7: import com.sun.istack.internal.FinalArrayList;

 
 
  8: public class AccountServiceImpl implements AccountService {

 
 
  9:   //注入转账的DAO类  

 
 
 10:   private AccountDao accountDao;

 
 
 11:   public void setAccountDao(AccountDao accountDao) {

 
 
 12:     this.accountDao = accountDao;

 
 
 13:   }  

 
 
 14:   public void transfer(String OutName, String InName, Double money) {

 
 
 15:     // TODO Auto-generated method stub

 
 
 16:      accountDao.outMoney(OutName, money);

 
 
 17: //    int i=1/0;

 
 
 18:      accountDao.inMoney(InName, money);  

 
 
 19:   }

 
 
 20: }
 
 
测试类：springtestdemo3.java
 
 
 
 
  1: package com.spring.demo3;

 
 
  2: 

 
 
  3: import javax.annotation.Resource;

 
 
  4: import org.junit.Test;

 
 
  5: import org.junit.runner.RunWith;

 
 
  6: import org.springframework.test.context.ContextConfiguration;

 
 
  7: import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

 
 
  8: /**

 
 
  9:  * 声明式：基于AspectJ的XML的配置

 
 
 10:  * 

 
 
 11:  * @author su

 
 
 12:  *

 
 
 13:  */

 
 
 14: @RunWith(SpringJUnit4ClassRunner.class)

 
 
 15: @ContextConfiguration("classpath:applicationContext3.xml")

 
 
 16: public class springtestdemo3 {

 
 
 17:   //测试业务层类：

 
 
 18:   @Resource(name="accountService")

 
 
 19:   private AccountService accountService;

 
 
 20:   @Test

 
 
 21:   public void test(){

 
 
 22:     accountService.transfer("aaa", "bbb", 300d);

 
 
 23:   }

 
 
 24: }
 
 
 
 
 
2.5、声明式事务管理方式三：基于@Transactional注解
 
 
ApplicationContext4.xml
 
 
 
 
  1: <?xml version="1.0" encoding="UTF-8" ?>

 
 
  2: <beans xmlns="http://www.springframework.org/schema/beans"

 
 
  3:   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"

 
 
  4:   xmlns:context="http://www.springframework.org/schema/context"

 
 
  5:   xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"

 
 
  6:   xsi:schemaLocation="http://www.springframework.org/schema/beans 

 
 
  7:        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

 
 
  8:        http://www.springframework.org/schema/context 

 
 
  9:        http://www.springframework.org/schema/context/spring-context-3.0.xsd

 
 
 10:        http://www.springframework.org/schema/tx 

 
 
 11:        http://www.springframework.org/schema/tx/spring-tx-3.0.xsd

 
 
 12:        http://www.springframework.org/schema/aop

 
 
 13:        http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">

 
 
 14:        

 
 
 15:     <!-- 引入外部的属性文件 -->

 
 
 16:   <context:property-placeholder location="classpath:jdbc.properties" />

 
 
 17:      

 
 
 18:     <!-- 配置c3p0连接池 

 
 
 19:   <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"

 
 
 20:     p:driverClass="${jdbc.driverClass}"

 
 
 21:     p:jdbcUrl="${jdbc.url}"

 
 
 22:     p:user="${jdbc.username}"

 
 
 23:     p:password="${jdbc.password}" />-->

 
 
 24:   

 
 
 25:   <!-- 配置dbcp连接池 -->

 
 
 26:   <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"

 
 
 27:     destroy-method="close" 

 
 
 28:     p:driverClassName="${jdbc.driverClass}"

 
 
 29:     p:url="${jdbc.url}"

 
 
 30:     p:username="${jdbc.username}"

 
 
 31:     p:password="${jdbc.password}" />  

 
 
 32: 

 
 
 33:   <!-- 配置Jdbc模板  -->

 
 
 34:   <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"

 
 
 35:     p:dataSource-ref="dataSource" />

 
 
 36:   

 
 
 37:   <!-- 业务层 -->

 
 
 38:   <bean id="accountService" class="com.spring.demo4.AccountServiceImpl" p:accountDao-ref="accountDao"/>

 
 
 39: 

 
 
 40:   <!-- Dao类 -->

 
 
 41:   <bean id="accountDao" class="com.spring.demo4.AccountDaoImpl" p:dataSource-ref="dataSource" />

 
 
 42:   

 
 
 43:   <!-- 配置事务管理器 -->

 
 
 44:   <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager" 

 
 
 45:     p:dataSource-ref="dataSource" />

 
 
 46:   

 
 
 47:   <!-- 开启注解事务 -->

 
 
 48:   <tx:annotation-driven transaction-manager="transactionManager"/>  

 
 
 49: </beans>
 
 
AccountServiceImpl.java
 
 
 
 
  1: package com.spring.demo4;

 
 
  2: import org.springframework.transaction.TransactionStatus;

 
 
  3: import org.springframework.transaction.annotation.Isolation;

 
 
  4: import org.springframework.transaction.annotation.Propagation;

 
 
  5: import org.springframework.transaction.annotation.Transactional;

 
 
  6: import org.springframework.transaction.support.TransactionCallback;

 
 
  7: import org.springframework.transaction.support.TransactionCallbackWithoutResult;

 
 
  8: import org.springframework.transaction.support.TransactionTemplate;

 
 
  9: import com.sun.istack.internal.FinalArrayList;

 
 
 10: /**

 
 
 11:  * @Transactional:注解中的属性

 
 
 12:  * propagation:事务的传播行为

 
 
 13:  * isolation:  事务的隔离级别

 
 
 14:  * readOnly:只读

 
 
 15:  * rollbackFor:发生哪些异常回滚

 
 
 16:  * noRollbackFor:发生哪些异常不回滚

 
 
 17:  * 

 
 
 18:  * @author su

 
 
 19:  *

 
 
 20:  */

 
 
 21: @Transactional(propagation=Propagation.REQUIRED,isolation=Isolation.DEFAULT,readOnly=false)

 
 
 22: public class AccountServiceImpl implements AccountService {

 
 
 23: 

 
 
 24:   //注入转账的DAO类

 
 
 25:   

 
 
 26:   private AccountDao accountDao;

 
 
 27:   public void setAccountDao(AccountDao accountDao) {

 
 
 28:     this.accountDao = accountDao;

 
 
 29:   }

 
 
 30:   

 
 
 31:   public void transfer(String OutName, String InName, Double money) {

 
 
 32:     // TODO Auto-generated method stub

 
 
 33:     accountDao.outMoney(OutName, money);

 
 
 34: //    int i=1/0;

 
 
 35:     accountDao.inMoney(InName, money);  

 
 
 36:   }

 
 
 37: }
 
 
测试类：springtestdemo4.java
 
 
 
 
  1: package com.spring.demo4;

 
 
  2: import javax.annotation.Resource;

 
 
  3: import org.junit.Test;

 
 
  4: import org.junit.runner.RunWith;

 
 
  5: import org.springframework.test.context.ContextConfiguration;

 
 
  6: import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

 
 
  7: /**

 
 
  8:  * 声明式：基于注解的事务管理方式

 
 
  9:  * 

 
 
 10:  * @author su

 
 
 11:  *

 
 
 12:  */

 
 
 13: @RunWith(SpringJUnit4ClassRunner.class)

 
 
 14: @ContextConfiguration("classpath:applicationContext4.xml")

 
 
 15: public class springtestdemo4 {

 
 
 16: 

 
 
 17:   //测试业务层类：

 
 
 18:   @Resource(name="accountService")

 
 
 19:   private AccountService accountService;

 
 
 20:   @Test

 
 
 21:   public void test(){

 
 
 22:     accountService.transfer("aaa", "bbb", 300d);

 
 
 23:   }

 
 
 24: }
 

当神已无能为力，那便是魔渡众生

                        
                    

                    
                        

                            

    
文章标签：

    

        

            Spring
        

        

            Java
        

        

            数据格式
        

        

            XML
        

        

            数据库连接
        

        

            SQL
        

        

            关系型数据库
        

        

            MySQL
        

        

            数据库
        

    



                            

    
关键词：

    

        

            Spring事务
        

    



                            
                        

                        
                        
                    
                

                


                

                    

                        

                            
                                
                            
                            

                        

                        liurio
                        

                        

                    

                    

                        

                            

                            
目录

                        

                        

                    

                

                

                    

                


                

    
相关文章

    

        

            

                

                    游客aimstvzg73tkk
                    
                

                |
                
2月前

                |
                

                    SQL
                    Java
                    关系型数据库
                

            

            

                

                    
                        Spring事务传播机制：7种姿势教你玩转"事务接力赛"
                    
                    
事务传播机制是Spring框架中用于管理事务行为的重要概念，它决定了在方法调用时事务如何传递与执行。通过7种传播行为，开发者可以灵活控制事务边界，适应不同业务场景。例如：REQUIRED默认加入或新建事务，REQUIRES_NEW独立开启新事务，NESTED支持嵌套回滚等。合理使用传播机制不仅能保障数据一致性，还能提升系统性能与健壮性。掌握这“七种人格”，才能在复杂业务中游刃有余。

                    

                        

                            

                                游客aimstvzg73tkk
                                
                            

                            121
                            0
                            
                        

                    

                

                
            

        

        

            

                

                    爱吃烤鸡翅的酸菜鱼
                    
                

                |
                
3月前

                |
                

                    Java
                    关系型数据库
                    数据库
                

            

            

                

                    
                        深度剖析【Spring】事务：万字详解，彻底掌握传播机制与事务原理
                    
                    
在Java开发中，Spring框架通过事务管理机制，帮我们轻松实现了这种“承诺”。它不仅封装了底层复杂的事务控制逻辑（比如手动开启、提交、回滚事务），还提供了灵活的配置方式，让开发者能专注于业务逻辑，而不用纠结于事务细节。

                    

                        

                            

                                爱吃烤鸡翅的酸菜鱼
                                
                            

                            706
                            1
                            
                        

                    

                

                
            

        

        

            

                

                    游客bhmgxanbwhyfe
                    
                

                |
                
8月前

                |
                

                    Java
                    Spring
                

            

            

                

                    
                        Spring中事务失效的场景
                    
                    
因为Spring事务是基于代理来实现的，所以某个加了@Transactional的⽅法只有是被代理对象调⽤时， 那么这个注解才会⽣效 , 如果使用的是被代理对象调用, 那么@Transactional会失效 
同时如果某个⽅法是private的，那么@Transactional也会失效，因为底层cglib是基于⽗⼦类来实现 的，⼦类是不能重载⽗类的private⽅法的，所以⽆法很好的利⽤代理，也会导致@Transactianal失效
如果在业务中对异常进行了捕获处理 , 出现异常后Spring框架无法感知到异常, @Transactional也会失效 

                    

                        

                            

                                游客bhmgxanbwhyfe
                                
                            

                            187
                            1
                            
                        

                    

                

                
            

        

        

            

                

                    Quan_Chen
                    
                

                |
                
8月前

                |
                

                    Java
                    关系型数据库
                    数据库
                

            

            

                

                    
                        微服务——SpringBoot使用归纳——Spring Boot事务配置管理——常见问题总结
                    
                    
本文总结了Spring Boot中使用事务的常见问题，虽然通过`@Transactional`注解可以轻松实现事务管理，但在实际项目中仍有许多潜在坑点。文章详细分析了三个典型问题：1) 异常未被捕获导致事务未回滚，需明确指定`rollbackFor`属性；2) 异常被try-catch“吃掉”，应避免在事务方法中直接处理异常；3) 事务范围与锁范围不一致引发并发问题，建议调整锁策略以覆盖事务范围。这些问题看似简单，但一旦发生，排查难度较大，因此开发时需格外留意。最后，文章提供了课程源代码下载地址，供读者实践参考。

                    

                        

                            

                                Quan_Chen
                                
                            

                            203
                            0
                            
                        

                    

                

                
            

        

        

            

                

                    Quan_Chen
                    
                

                |
                
8月前

                |
                

                    Java
                    关系型数据库
                    数据库
                

            

            

                

                    
                        微服务——SpringBoot使用归纳——Spring Boot事务配置管理——Spring Boot 事务配置
                    
                    
本文介绍了 Spring Boot 中的事务配置与使用方法。首先需要导入 MySQL 依赖，Spring Boot 会自动注入 `DataSourceTransactionManager`，无需额外配置即可通过 `@Transactional` 注解实现事务管理。接着通过创建一个用户插入功能的示例，展示了如何在 Service 层手动抛出异常以测试事务回滚机制。测试结果表明，数据库中未新增记录，证明事务已成功回滚。此过程简单高效，适合日常开发需求。

                    

                        

                            

                                Quan_Chen
                                
                            

                            1107
                            0
                            
                        

                    

                

                
            

        

        

            

                

                    Quan_Chen
                    
                

                |
                
8月前

                |
                

                    Java
                    数据库
                    微服务
                

            

            

                

                    
                        微服务——SpringBoot使用归纳——Spring Boot事务配置管理——事务相关
                    
                    
本文介绍Spring Boot事务配置管理，阐述事务在企业应用开发中的重要性。事务确保数据操作可靠，任一异常均可回滚至初始状态，如转账、购票等场景需全流程执行成功才算完成。同时，事务管理在Spring Boot的service层广泛应用，但根据实际需求也可能存在无需事务的情况，例如独立数据插入操作。

                    

                        

                            

                                Quan_Chen
                                
                            

                            224
                            0
                            
                        

                    

                

                
            

        

        

            

                

                    大数据文摘
                    
                

                |
                
6月前

                |
                

                    人工智能
                    Java
                    数据库连接
                

            

            

                

                    
                        Spring事务失效场景
                    
                    
本文深入探讨了Spring框架中事务管理可能失效的几种常见场景及解决方案，包括事务方法访问级别不当、方法内部自调用、错误的异常处理、事务管理器或数据源配置错误、数据库不支持事务以及不合理的事务传播行为或隔离级别。通过合理配置和正确使用`@Transactional`注解，开发者可以有效避免这些问题，确保应用的数据一致性和完整性。

                    

                        

                            

                                大数据文摘
                                
                            

                            347
                            10
                            
                        

                    

                

                
            

        

        

            

                

                    flzjkl
                    
                

                |
                
5月前

                |
                

                    Java
                    关系型数据库
                    MySQL
                

            

            

                

                    
                        【Spring】【事务】初学者直呼学会了的Spring事务入门
                    
                    
本文深入解析了Spring事务的核心概念与使用方法。Spring事务是一种数据库事务管理机制，通过确保操作的原子性、一致性、隔离性和持久性（ACID），维护数据完整性。文章详细讲解了声明式事务（@Transactional注解）和编程式事务（TransactionTemplate、PlatformTransactionManager）的区别与用法，并探讨了事务传播行为（如REQUIRED、REQUIRES_NEW等）及隔离级别（如READ_COMMITTED、REPEATABLE_READ）。

                    

                        

                            

                                flzjkl
                                
                            

                            444
                            1
                            
                        

                    

                

                
            

        

        

            

                

                    游客bhmgxanbwhyfe
                    
                

                |
                
8月前

                |
                

                    SQL
                    Java
                    数据库连接
                

            

            

                

                    
                        Spring中的事务是如何实现的
                    
                    
1. Spring事务底层是基于数据库事务和AOP机制的
2. ⾸先对于使⽤了@Transactional注解的Bean，Spring会创建⼀个代理对象作为Bean
3. 当调⽤代理对象的⽅法时，会先判断该⽅法上是否加了@Transactional注解
4. 如果加了，那么则利⽤事务管理器创建⼀个数据库连接
5. 并且修改数据库连接的autocommit属性为false，禁⽌此连接的⾃动提交，这是实现Spring事务⾮ 常重要的⼀步 
6. 然后执⾏当前⽅法，⽅法中会执⾏sql 
7. 执⾏完当前⽅法后，如果没有出现异常就直接提交事务
8. 如果出现了异常，并且这个异常是需要回滚的就会回滚事务

                    

                        

                            

                                游客bhmgxanbwhyfe
                                
                            

                            136
                            6
                            
                        

                    

                

                
            

        

        

            

                

                    互联网课堂
                    
                

                |
                
8月前

                |
                

                    JavaScript
                    Java
                    开发者
                

            

            

                

                    
                        Spring事务失效，常见的情况有哪些？
                    
                    
本文总结了Spring事务失效的7种常见情况，包括未启用事务管理功能、方法非public类型、数据源未配置事务管理器、自身调用问题、异常类型错误、异常被吞以及业务和事务代码不在同一线程中。同时提供了两种快速定位事务相关Bug的方法：通过查看日志（设置为debug模式）或调试代码（在TransactionInterceptor的invoke方法中设置断点）。文章帮助开发者更好地理解和解决Spring事务中的问题。

                    

                        

                            

                                互联网课堂
                                
                            

                            329
                            7
                            
                        

                    

                

                
            

        

    



            

            

                
                
                    
                    

    

        

            
热门文章

        

        

            
最新文章

        

    

    

        

            

                
  • 
                    
                        
    
                            
    1
    
                            
                            
    Spring AI Alibaba Admin 开源！以数据为中心的 Agent 开发平台
    
                            
    
                        
    
                        
                
    • 
                
  • 
                    
                        
    
                            
    2
    
                            
                            
    基于 Spring AI Alibaba + Nacos 的分布式 Multi-Agent 构建指南
    
                            
    
                        
    
                        
                
    • 
                
  • 
                    
                        
    
                            
    3
    
                            
                            
    spring boot应用优化，6s内启动，内存减半
    
                            
    
                        
    
                        
                
    • 
                
  • 
                    
                        
    
                            
                            
    4
    
                            
    Spring Boot：WEB项目，以WAR包形式部署到外部tomcat部署
    
                            
    
                        
    
                        
                
    • 
                
  • 
                    
                        
    
                            
                            
    5
    
                            
    重新学习之spring第二个程序，配置AOP面向切面编程
    
                            
    
                        
    
                        
                
    • 
                
  • 
                    
                        
    
                            
                            
    6
    
                            
    spring security3教程系列--扩展验证码
    
                            
    
                        
    
                        
                
    • 
                
  • 
                    
                        
    
                            
                            
    7
    
                            
    SpringBoot 使用【druid-spring-boot-starter】集成 druid 监控数据库
    
                            
    
                        
    
                        
                
    • 
                
  • 
                    
                        
    
                            
                            
    8
    
                            
    Spring Cloud同步场景分布式事务怎样做？试试Seata
    
                            
    
                        
    
                        
                
    • 
                
  • 
                    
                        
    
                            
                            
    9
    
                            
    Spring3 MVC请求参数获取的几种场景
    
                            
    
                        
    
                        
                
    • 
                
  • 
                    
                        
    
                            
                            
    10
    
                            
    Spring Cloud Gateway系例—GatewayFilter 工厂
    
                            
    
                        
    
                        
                
    • 
            
    
            
    
                
            
    
        
    
        
    
            
    
                
  • 
                    
                        
    
                            
    1
    
                            
                            
    基于SpringBoot+Vue+uniapp的淘乐乐员工购物商城的详细设计和实现(源码+lw+部署文档+讲解等)
    
                            
    146
    
                        
    
                        
                
    • 
                
  • 
                    
                        
    
                            
    2
    
                            
                            
    基于SpringBoot+Vue+uniapp的家具销售库存管理信息系统的详细设计和实现(源码+lw+部署文档+讲解等)
    
                            
    134
    
                        
    
                        
                
    • 
                
  • 
                    
                        
    
                            
    3
    
                            
                            
    基于SpringBoot+Vue+uniapp的智能交互式在线网上花店的详细设计和实现(源码+lw+部署文档+讲解等)
    
                            
    230
    
                        
    
                        
                
    • 
                
  • 
                    
                        
    
                            
                            
    4
    
                            
    基于SpringBoot+Vue+uniapp的高校就业管理系统的详细设计和实现(源码+lw+部署文档+讲解等)
    
                            
    105
    
                        
    
                        
                
    • 
                
  • 
                    
                        
    
                            
                            
    5
    
                            
    基于SpringBoot+Vue+uniapp的高校运动会管理系统的详细设计和实现(源码+lw+部署文档+讲解等)
    
                            
    178
    
                        
    
                        
                
    • 
                
  • 
                    
                        
    
                            
                            
    6
    
                            
    基于SpringBoot+Vue+uniapp的玉安农副产品销售系统的详细设计和实现(源码+lw+部署文档+讲解等)
    
                            
    97
    
                        
    
                        
                
    • 
                
  • 
                    
                        
    
                            
                            
    7
    
                            
    基于SpringBoot+Vue+uniapp的校园失物招领网站的详细设计和实现(源码+lw+部署文档+讲解等)
    
                            
    190
    
                        
    
                        
                
    • 
                
  • 
                    
                        
    
                            
                            
    8
    
                            
    基于SpringBoot+Vue+uniapp的社区团购网站的详细设计和实现(源码+lw+部署文档+讲解等)
    
                            
    114
    
                        
    
                        
                
    • 
                
  • 
                    
                        
    
                            
                            
    9
    
                            
    基于SpringBoot+Vue+uniapp的小码创客教育教学资源库的详细设计和实现(源码+lw+部署文档+讲解等)
    
                            
    126
    
                        
    
                        
                
    • 
                
  • 
                    
                        
    
                            
                            
    10
    
                            
    基于SpringBoot+Vue+uniapp的健身管理系统的详细设计和实现(源码+lw+部署文档+讲解等)
    
                            
    100
    
                        
    
                        
                
    • 
            
    
            
    
                
            
    
        
    
    
    

    
                    
                    
    
    
    
        
    相关课程
    
        更多
    
    
    
    
        
  • 
                全面讲解Spring Cloud Alibaba技术栈（知识精讲+项目实战）第二阶段
            
    • 
        
  • 
                精通Spring Cloud Alibaba
            
    • 
        
  • 
                微服务框架 Spring Cloud 快速入门
            
    • 
        
  • 
                Java Web开发系列课程 - Spring框架入门
            
    • 
        
  • 
                Spring Boot 2.5.x开发实战
            
    • 
        
  • 
                Spring Cloud微服务架构设计与开发实战
            
    • 
    
    

    
                    
    
    
    
        
    相关电子书
    
        更多
    
    
    
    
        
  • 
                云栖社区特邀专家徐雷Java Spring Boot开发实战系列课程（第20讲）：经典面试题与阿里等名企内部招聘求职面试技巧
            
    • 
        
  • 
                微服务架构模式与原理Spring Cloud开发实战
            
    • 
        
  • 
                阿里特邀专家徐雷Java Spring Boot开发实战系列课程（第18讲）：制作Java Docker镜像与推送到DockerHub和阿里云Docker仓库
            
    • 
    
    

    
                    
                    
                    
                    
    
                        
    
    
    
        
    下一篇
    
    
    
    获取百炼API-KEY