spring的编程式事务和声明式事务管理（xml方式和注解方式）

最新推荐文章于 2022-11-25 14:25:48 发布
最新推荐文章于 2022-11-25 14:25:48 发布
阅读量542 收藏 1
点赞数
CC 4.0 BY-SA版权
分类专栏： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/mengyue113/article/details/80384933
本文深入探讨Spring框架中的事务管理机制，包括事务的四大特性（ACID）、常见的并发问题及解决方案，并详细介绍了编程式事务管理、XML配置式声明事务管理和注解式声明事务管理的具体实现。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1.事务

     1.1.事务的四大特性ACID

        （1）原子性（Atomicity）事务所包含的操作，要么全部成功，要么全部失败回滚，具有不可分割性。

        （2）一致性（Consistency）事务执行前和执行之后都必须处于一致性状态。

        （3）隔离性（Isolation）多个并发事务之间要相互隔离。

        （4）持久性（Durability）事务一旦提交，数据库中的数据就被持久化。

     1.2.事务的并发问题

         （1）脏读：当一个事务在修改数据还未提交时，另一个事务来访问该事务。

         （2）不可重复读：一个事务在多次查询的间隔，被另一个事务修改并提交了数据，查询到不同的结果。

         （3）幻读（虚读）：一个事务在对所有数据进行修改时，另外一个事务插入了一条数据，导致修改完之后，发现仍有一条记录没有被修改。以为自己产生了幻觉。

     1.3.事务的隔离级别

           （1）Read uncommitted（读未提交）

           （2）Read committed（读已提交）：避免脏读

           （3）Repeatable read（可重复度）：避免脏读 不可重复读

           （4）Serializable（串行化）：避免幻读

2.spring的事务管理

    2.1.准备数据表


    2.2.准备转账的业务代码

package work.yuegege.domain;

public class Account {
	private int id;
	private String name;
	private double account;
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public double getAccount() {
		return account;
	}
	public void setAccount(double account) {
		this.account = account;
	}
	@Override
	public String toString() {
		return "Account [id=" + id + ", name=" + name + ", account=" + account
				+ "]";
	}
}
   
package work.yuegege.dao;

public interface TransactionAccountDao {
	public void addAccount(String name,double account);
	
	public void subAccount(String name,double account);

}


package work.yuegege.daoImpl;

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

import work.yuegege.dao.TransactionAccountDao;

public class TransactionAccountDaoImpl extends JdbcDaoSupport implements TransactionAccountDao{

	@Override
	public void addAccount(String name, double account) {
		super.getJdbcTemplate().update("update account set money=money+? where user=?",account,name);
		
	}

	@Override
	public void subAccount(String name, double account) {
		super.getJdbcTemplate().update("update account set money=money-? where user=?",account,name);
		
	}
	

}

package work.yuegege.service;

public interface AccountService {
	public void transaction(String from ,String to,double money);

}

  2.3.编程式事务管理

package work.yuegege.service;

import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.TransactionCallbackWithoutResult;
import org.springframework.transaction.support.TransactionTemplate;

import work.yuegege.dao.TransactionAccountDao;

public class AccountServiceImpl implements AccountService {

	private TransactionAccountDao transactionAccountDao;
	
	private TransactionTemplate transactionTemplate;
	
	public void transaction(final String from , final String to , final double money) {
		
		//这里运用编程式事务管理 TransactionTemplate封装了事务的打开，回滚，和事务的关闭方法。
		//但这种方法不适合多业务的操作，因为每个业务都需要将代码放在execute()方法中。
		transactionTemplate.execute(new TransactionCallbackWithoutResult() {
			
			@Override
			protected void doInTransactionWithoutResult(TransactionStatus arg0) {
				transactionAccountDao.subAccount(from, money);
				int i=1/0;
				transactionAccountDao.addAccount(to, money);
			}
		});
	}
	public void setTransactionAccountDao(TransactionAccountDao transactionAccountDao) {
		this.transactionAccountDao = transactionAccountDao;
	}
	
	public void setTransactionTemplate(TransactionTemplate transactionTemplate) {
		this.transactionTemplate = transactionTemplate;
	}
}

    applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns="http://www.springframework.org/schema/beans" 
xmlns:p="http://www.springframework.org/schema/p" 
xmlns:context="http://www.springframework.org/schema/context" 
xmlns:aop="http://www.springframework.org/schema/aop" 
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.3.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd ">
	<!-- 1.配置连接池 -->
	<bean name="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="jdbcUrl" value="jdbc:mysql:///students"></property>
		<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
		<property name="user" value="root"></property>
		<property name="password" value="root"></property>
	</bean>
	
	<!--2.将JDBCTemplate放入spring容器 -->
	<!-- <bean name="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"> 
		<property name="dataSource" ref="dataSource"></property>
	</bean> -->
	
	<!-- 编程式事务管理 -->
		<!--1.配置核心事务管理器  -->
		<bean name="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
			<property name="dataSource" ref="dataSource"></property>
		</bean>
		
		<!--2.配置事务模板对象  -->
		<bean name="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">
			<property name="transactionManager" ref="transactionManager"></property>
		</bean>
	
	<!--3.将AccountDaoImpl放入spring容器 -->
	<bean name="transactionAccountDao" class="work.yuegege.daoImpl.TransactionAccountDaoImpl">
		<!-- <property name="jbbcTemplate" ref="jdbcTemplate"></property> -->
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	<!--4.将AccountServiceImpl放入spring容器  -->
	<bean name="accountService" class="work.yuegege.service.AccountServiceImpl">
		<property name="transactionAccountDao" ref="transactionAccountDao"></property>
		<property name="transactionTemplate" ref="transactionTemplate"></property>
	</bean>
	
	
	
	
	
	 
</beans>

  编写测试类

	@Test
	public void test8(){
		ApplicationContext applicationContext=new ClassPathXmlApplicationContext("work/yuegege/test/applicationContext.xml");
		AccountService accountService=(AccountService) applicationContext.getBean("accountService");
		accountService.transaction("lucy", "mengyue", 500);
		System.out.println("转账成功");
	}

 结果：



因为转账过程发生了异常，所以回滚。转账没有成功

2.4.xml方式配置spring的声明式事务管理

package work.yuegege.service;

import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.TransactionCallbackWithoutResult;
import org.springframework.transaction.support.TransactionTemplate;

import work.yuegege.dao.TransactionAccountDao;

public class AccountServiceImpl implements AccountService {

	private TransactionAccountDao transactionAccountDao;
	
	public void transaction(final String from , final String to , final double money) {
		
		transactionAccountDao.subAccount(from, money);
		int i=1/0;
		transactionAccountDao.addAccount(to, money);
			
	}
	public void setTransactionAccountDao(TransactionAccountDao transactionAccountDao) {
		this.transactionAccountDao = transactionAccountDao;
	}
	
}

 applicationContext.xml的配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
	xmlns="http://www.springframework.org/schema/beans" 
	xmlns:p="http://www.springframework.org/schema/p" 
	xmlns:context="http://www.springframework.org/schema/context" 
	xmlns:aop="http://www.springframework.org/schema/aop" 
	xmlns:tx="http://www.springframework.org/schema/tx" 
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.3.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd ">
	<!-- 1.配置连接池 -->
	<bean name="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="jdbcUrl" value="jdbc:mysql:///students"></property>
		<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
		<property name="user" value="root"></property>
		<property name="password" value="root"></property>
	</bean>
	
	<!--2.配置核心事务管理器  -->
	<bean name="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
			<property name="dataSource" ref="dataSource"></property>
	</bean>
	
	<!--3.配置事务通知  -->
	<!-- isolation 表示事务的隔离级别    propagation事务的传播行为：默认值为：REQUIRED 
	 	read-only 表示是否只读   默认值：false -->
	<tx:advice id="txAdvice" transaction-manager="transactionManager">
		<tx:attributes>
			<tx:method name="transaction" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false"/>
		</tx:attributes>
	</tx:advice>
	
	<!--4.将通知织入目标对象  -->
	<aop:config>
		<!--配置切点 -->
		<aop:pointcut expression="execution(* work.yuegege.service.*ServiceImpl.*(..))" id="txPointCut"/>
		<!--配置切面 -->
		<aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
	</aop:config>
	
	<!-- 将TransactionAccountDaoImpl放入spring容器-->
	<bean name="transactionAccountDao" class="work.yuegege.daoImpl.TransactionAccountDaoImpl">
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	
	<!--将accountService放入spring容器  -->
	<bean name="accountService" class="work.yuegege.service.AccountServiceImpl">
		<property name="transactionAccountDao" ref="transactionAccountDao"></property>
	</bean>
		 
</beans>

编写测试类：

//xml方式进行声明式事务管理测试
	@Test
	public void test9(){
		ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
		AccountService accountService=(AccountService) applicationContext.getBean("accountService");
		accountService.transaction("lucy", "mengyue", 500);
		System.out.println("转账成功");
	}

结果与上面一样。


2.5.注解方式配置spring的声明式事务管理

   2.5.1.注入TransactionAccountDaoImpl和JdbcTemplate

        在上面的业务代码中加上红色的注解

import javax.annotation.Resource;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.support.JdbcDaoSupport;
import org.springframework.stereotype.Component;

import work.yuegege.dao.TransactionAccountDao;

@Component("transactionAccountDao")
public class TransactionAccountDaoImpl implements TransactionAccountDao{
    
	
	private JdbcTemplate jdbcTemplate;
	
	@Resource(name = "jdbcTemplate")
	public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
		this.jdbcTemplate = jdbcTemplate;
	}

  2.5.2.注入AccountServiceImpl和事务

@Component("accountService")
public class AccountServiceImpl implements AccountService {
	@Resource(name="transactionAccountDao")
	private TransactionAccountDao transactionAccountDao;
	
	@Transactional(isolation=Isolation.REPEATABLE_READ,propagation=Propagation.REQUIRED,readOnly=false)
	public void transaction(final String from , final String to , final double money) {

   2.5.3.applicationContext.xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
	xmlns="http://www.springframework.org/schema/beans" 
	xmlns:p="http://www.springframework.org/schema/p" 
	xmlns:context="http://www.springframework.org/schema/context" 
	xmlns:aop="http://www.springframework.org/schema/aop" 
	xmlns:tx="http://www.springframework.org/schema/tx" 
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.3.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd ">
	<!-- 1.配置连接池 -->
	<bean name="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="jdbcUrl" value="jdbc:mysql:///students"></property>
		<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
		<property name="user" value="root"></property>
		<property name="password" value="root"></property>
	</bean>
	
	<context:component-scan base-package="work.yuegege.*"></context:component-scan>
	
	<!-- 开启注解管理事务 -->
	<tx:annotation-driven/>
	
	<!--2.将JDBCTemplate放入spring容器 -->
	<bean name="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"> 
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	
	<!--配置核心事务管理器  -->
	<bean name="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
			<property name="dataSource" ref="dataSource"></property>
	</bean>
 
</beans>

    2.5.4.测试类

@Test
	public void test10(){
		ApplicationContext applicationContext=new ClassPathXmlApplicationContext("work/yuegege/service/applicationContext.xml");
		AccountService accountService=(AccountService) applicationContext.getBean("accountService");
		accountService.transaction("lucy", "mengyue", 500);
		System.out.println("转账成功");
	}

    2.5.5结果

结果与上面一样。






        





        


【Spring笔记08】Spring中的事务（编程式、声明式）
✅ Java 开发工程师，从事 Web 应用程序的研发，擅长 Spring、SpringBoot 等技术。 ✅ 热爱编程，业余时间学习新知识，通过 优快云 记录学习心得和笔记内容。
06-01 615
这篇文章，主要介绍Spring中的两种事务，编程式事务和基于XML方式的声明式事务。 目录 一、Spring中事务 1.1、什么是事务 1.2、Spring两种事务 （1）数据源配置 1.3、编程式事务 1.4、声明式事务 （1）XML中添加【tx】命名空间 （2）配置事务管理器 （3）配置事务通知 （4）配置事务切面 （5）编写事务处理类方法 （6）编写测试类 一、Spring中事务 1.1、什么是事务 事务，是指将很多件事情看成一个整体，这些事情要么全部执行成功，要么.
浅谈spring事务管理的2种方式：编程式事务管理和声明式事务管理；以及@Transactional(rollbackFor=Exception.class)注解用法
Syntacticsugar's blog
11-09 694
spring 支持编程式事务管理以及声明式事务管理这两种方式； 1、编程式事务： 编程式事务有2种方式： 一种是spring官方推荐使用 TransactionTemplate ，另一种方式就是在PlatformTransactionManager上进行操作； 2、声明式事务： 声明式事务管理建立在AOP之上的。其本质是对方法前后进行拦截，然后在目标方法开始之前创建或者加入一个事务，在执行完目标方...
Spring事务管理实现方式:编程式事务和声明式事务
qq_42848910的博客
08-01 420
1.编程式事务：编码方式实现事务管理（代码演示为JDBC事务管理） Spring实现编程式事务，依赖于2大类，分别是PlatformTransactionManager，与模版类TransactionTemplate（推荐使用）。下面分别详细介绍Spring是如何通过该类实现事务管理。 1）PlatformTransactionManager 事务管理器配置 <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"&
Spring事务管理－编程式事务、声明式事务
xktxoo的博客
09-10 5634
事务管理是应用系统中必不可少的一部分，它保证了用户的每一次操作都是可靠的，即便是出现了异常情况，也不至于破坏后台数据的完整性。 　　Spring提供了丰富的事务管理功能，Spring的事务管理分为编程式事务管理和声明式事务管理两种方式。编程式事务管理指通过编码的方式实现事务管理，声明式事务基于AOP，将业务逻辑与事务处理解耦。声明式事务对代码侵入较少，在实际使用中使用比较广泛。一、包依赖；二、编程式事务；三、声明式
Spring事务管理：编程式和声明式
琦彦
10-29 5754
Spring的事务管理:   Spring的事务管理分成两类: * 编程式事务管理: -------手动编写代码完成事务管理. * 声明式事务管理: -------不需要手动编写代码,配置. 事务操作的环境搭建: CREATE TABLE `account` (   `id` int(11) NOT NULL AUTO_INCREMENT,   `name` varchar(...
Spring的事务机制包括声明式事务和编程式事务。
程序哈哈的博客
04-04 180
编程式事务需要你在代码中直接加入处理事务的逻辑,可能需要在代码中显式调用beginTransaction()、commit()、rollback()等事务管理相关的方法,如在执行a方法时候需要事务处理,你需要在a方法开始时候开启事务,处理完后。在方法结束时候,关闭事务. 声明式事务是建立在AOP之上的。其本质是对方法前后进行拦截，然后在目标方法开始之前创建或者加入一个事务，在执行完目标方法之后根据...
Spring声明式事务管理（xml和纯注解方式）
differ_li的博客
03-23 383
案例环境准备： 数据库表、实体类； dao层： /** * 账户的持久层实现类 * 此版本dao，只需要给它的父类注入一个数据源 */ public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao { @Override public Account findAccountById(Inte...
SpringBoot 注解事务声明式事务的方式
08-29
在Spring Boot中，注解事务管理提供了一种更简洁的方式来处理事务，相比于传统的XML配置，它使得代码更加整洁，降低了依赖于外部配置的复杂性。本文将深入探讨Spring Boot中如何使用注解进行声明式事务的管理。 ...
Spring实战之使用注解实现声明式事务操作示例
08-25
声明式事务是指使用注解或 XML 配置来定义事务边界的方式。使用注解来实现声明式事务，可以使用 @Transactional 注解来标注事务边界。在 Spring 框架中，我们可以使用 <tx:annotation-driven /> 元素来启用注解驱动...
spring编程式事务与声明式事务详解
06-26
Spring 编程式事务与声明式事务详解 本文将详细解释 Spring...本文通过详细分析 Spring 的编程式事务管理及声明式事务管理，帮助读者理解事务管理的重要性和实现方式。读者可以根据自己的需求选择合适的事务管理方式。
全面分析 Spring 的编程式事务管理及声明式事务管理
04-18
本文将全面分析Spring中的编程式事务管理和声明式事务管理，旨在帮助开发者深入理解这两种事务管理方式，并在实际项目中合理选择。 **编程式事务管理** 编程式事务管理是通过代码直接控制事务的开始、提交、回滚等...
spring 声明式事务管理xml方式实现
李卫康的博客
07-31 1100
事务控制概述： 编程式事务控制          自己手动控制事务，就叫做编程式事务控制。          Jdbc代码：                    Conn.setAutoCommite(false);  // 设置手动控制事务          Hibernate代码：                    Session.beginTransaction();
spring声明式事务xml配置和注解配置
yuge1123的博客
06-30 1万+
导入spring jar包本篇文章只是为了巩固之前学的知识，如果描述有误欢迎指出使用注解的方式来用声明式事务然后在要用到事务的类上面增加一个@Transactional注解就行了，使用注解的方式看似简单，其实如果service类比较多的话需要每个类上面都加这个注解，而使用xml配置文件的话，就只需要配置一次即可， 本篇文章只是为了巩固之前学的知识，如果描述有误欢迎指出 <!--aop包--...
java中事物的注解_编程式事务、XML配置事务、注解实现事务
weixin_39747087的博客
12-21 152
Spring2.0框架的事务处理有两大类:1 编码式事务 , 这个不说.2 声明式事务 , 就说这个.声明式事务又有三种实现方法:1(第一种)最早的方法,用TransactionProxyFactoryBean,他是一个有AOP代理功能的FactoryBean.他返回的对象有事务.还要在spring的配置文件XML中配置,比较麻烦,不详细说.pic.dao.transaction_test.T...
Spring事务传播机制&&编程式事务&&声明式事务&&基于注解的声明式事务控制
qq_43408367的博客
02-22 1667
在Web项目中，可以使用ServletContextListener监听Web应用的启动，我们可以在Web应用启动时，就加载Spring的配置文件，创建应用上下文对象ApplicationContext，在将其存储到最大的域servletContext域中，这样就可以在任意位置从域中获得应用上下文ApplicationContext对象了。声明式事务：采用配置的方式来实现的事务控制，业务代码与事务代码实现解耦合，使用的AOP思想。事务管理器通过读取事务定义参数进行事务管理，然后会产生一系列的事务状态。
@Transactional注解与编程式事务
chenzoff的专栏
11-25 537
使用@Transactional注解在开发时确实很方便，但是稍微不注意就可能出现长事务问题。所以对于复杂业务逻辑，我这里更建议你使用编程式事务来管理事务，当然，如果你非要使用@Transactional，可以根据上文提到的两种方案进行方法拆分。
spring的声明式事务（xml和注解的方式）和编程式事务
qq_35240226的博客
11-14 380
  配置事务管理器     &lt;!-- 配置事务管理器 --&gt;     &lt;bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"&gt;      &lt;property name="dataSource" ref="dat.
Spring中基于xml和注解的声明式事务配置
qq_44341488的博客
08-02 261
基于xml <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://w...
Spring事务管理实现方式之编程式事务与声明式事务详解
热门推荐
半山闲人的专栏
04-12 5万+
1.编程式事务：编码方式实现事务管理（代码演示为JDBC事务管理） Spring实现编程式事务，依赖于2大类，分别是上篇文章提到的PlatformTransactionManager，与模版类TransactionTemplate（推荐使用）。下面分别详细介绍Spring是如何通过该类实现事务管 2.声明式事务：可知编程式事务每次实现都要单独实现，但业务量大功能复杂时，使用编程式事务无疑是痛苦的，而声明式事务不同，声明式事务属于无侵入式，不会影响业务逻辑的实现。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值