Spring 的事务管理

最新推荐文章于 2024-11-26 14:51:42 发布
原创 最新推荐文章于 2024-11-26 14:51:42 发布 · 置顶 · 255 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#Spring #Spring 事务管理

 

1.回顾事务

  • 事务：一组业务操作ABCD，要么全部成功，要么全部不成功。
  • 特性：ACID

       原子性：整体

       一致性：完成

       隔离性：并发

       持久性：结果

  • 隔离问题：

       脏读：一个事务读到另一个事务没有提交的数据

       不可重复读：一个事务读到另一个事务已提交的数据（update）

       虚读(幻读)：一个事务读到另一个事务已提交的数据（insert）

  • 隔离级别：

     

隔离级别
read uncommitted读未提交。存在3个问题
read committed

读已提交。解决脏读，存在2个问题

repeatable read

可重复读。解决：脏读、不可重复读，存在1个问题

serializable

串行化。都解决，单事务

 

  • mysql 事务操作--简单

ABCD 一个事务

Connection conn = null;

try{

  //1 获得连接

  conn = ...;

  //2 开启事务

  conn.setAutoCommit(false);

  A

  B

  C

  D

  //3 提交事务

  conn.commit();

} catche(){

  //4 回滚事务

  conn.rollback();

}

  • mysql 事务操作--Savepoint

需求：AB（必须），CD（可选）

Connection conn = null;

Savepoint savepoint = null;  //保存点，记录操作的当前位置，之后可以回滚到指定的位置。（可以回滚一部分）

try{

  //1 获得连接

  conn = ...;

  //2 开启事务

  conn.setAutoCommit(false);

  A

  B

  savepoint = conn.setSavepoint();

  C

  D

  //3 提交事务

  conn.commit();

} catche(){

  if(savepoint != null){   //CD异常

     // 回滚到CD之前

     conn.rollback(savepoint);

     // 提交AB

     conn.commit();

  } else{   //AB异常

     // 回滚AB

     conn.rollback();

  }

}

 

2. 事务管理介绍

   2.1导入jar包

         transaction  -->  tx

   2.2 三个顶级接口

三个顶级接口
PlatformTransactionManager

平台事务管理器，spring要管理事务，必须使用事务管理器

进行事务配置时，必须配置事务管理器。

TransactionDefinition

事务详情（事务定义、事务属性），spring用于确定事务具体详情，  例如：隔离级别、是否只读、超时时间 等

进行事务配置时，必须配置详情。spring将配置项封装到该对象实例。

TransactionStatus

事务状态，spring用于记录当前事务运行状态。  例如：是否有保存点，事务是否完成。

       spring底层根据状态进行相应操作。

2.2.1 PlatformTransactionManager  事务管理器

  • 导入jar包：需要时平台事务管理器的实现类

  • 常见的事务管理器

       DataSourceTransactionManager  ，jdbc开发时事务管理器，采用JdbcTemplate

       HibernateTransactionManager，hibernate开发时事务管理器，整合hibernate

  • api详解
api详解
TransactionStatus getTransaction(TransactionDefinition definition)事务管理器 通过“事务详情”，获得“事务状态”，从而管理事务
void commit(TransactionStatus status)根据状态提交
void rollback(TransactionStatus status)根据状态回滚

2.2.2 TransactionStatus

2.22 TransactionDefinition

  • 传播行为：在两个业务之间如何共享事务。
传播行为：在两个业务之间如何共享事务。
required 必须PROPAGATION_REQUIRED【默认值】

               支持当前事务，A如果有事务，B将使用该事务。

               如果A没有事务，B将创建一个新的事务。

supports支持PROPAGATION_SUPPORTS

              支持当前事务，A如果有事务，B将使用该事务。

               如果A没有事务，B将以非事务执行。

mandatory强制PROPAGATION_MANDATORY

             支持当前事务，A如果有事务，B将使用该事务。

             如果A没有事务，B将抛异常。
requires_new必须新的PROPAGATION_REQUIRES_NEW

             如果A有事务，将A的事务挂起，B创建一个新的事务

             如果A没有事务，B创建一个新的事务

not_supported不支持PROPAGATION_NOT_SUPPORTED

             如果A有事务，将A的事务挂起，B将以非事务执行

             如果A没有事务，B将以非事务执行

never从不PROPAGATION_NEVER

            如果A有事务，B将抛异常

            如果A没有事务，B将以非事务执行

nested 嵌套PROPAGATION_NESTED             A和B底层采用保存点机制，形成嵌套事务。

     掌握：PROPAGATION_REQUIRED、PROPAGATION_REQUIRES_NEW、PROPAGATION_NESTED

2.3 案例：转账

     2.3.1 搭建环境

     2.3.1.1 创建表

create database spring;
use spring;
create table account(
  id int primary key auto_increment,
  username varchar(50),
  money int
);
insert into account(username,money) values('jack','10000');
insert into account(username,money) values('rose','10000');

 

 

 

             2.3.1.2 导入jar包

核心：4+1

aop ： 4 (aop联盟、spring aop、aspectj规范、spring aspect)

数据库：2  （jdbc/tx）

驱动：mysql

连接池：c3p0

 

             2.3.1.3  dao 层

public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao {

	@Override
	public void out(String outer, Integer money) {
		this.getJdbcTemplate().update("update account set money = money - ? where username = ?", money,outer);
	}

	@Override
	public void in(String inner, Integer money) {
		this.getJdbcTemplate().update("update account set money = money + ? where username = ?", money,inner);
	}

}

             2.3.1.3  service层

public class AccountServiceImpl implements AccountService {

	private AccountDao accountDao;
	public void setAccountDao(AccountDao accountDao) {
		this.accountDao = accountDao;
	}
	@Override
	public void transfer(String outer, String inner, Integer money) {
		accountDao.out(outer, money);
		//断电
//		int i = 1/0;
		accountDao.in(inner, money);
	}

}

             2.3.1.4 spring配置

<?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://www.springframework.org/schema/aop"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
       					 http://www.springframework.org/schema/beans/spring-beans.xsd
       					 http://www.springframework.org/schema/aop
       					 http://www.springframework.org/schema/aop/spring-aop.xsd
       					 http://www.springframework.org/schema/context 
       					 http://www.springframework.org/schema/context/spring-context.xsd">
       					 
     <!-- datasource -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
		<property name="jdbcUrl" value="jdbc:mysql://localhost:3306/spring_tx"></property>
		<property name="user" value="root"></property>
		<property name="password" value="123456"></property>
	</bean>

     <!-- dao -->
     <bean id="accountDao" class="com.dao.impl.AccountDaoImpl">
     	<property name="dataSource" ref="dataSource"></property>
     </bean>
     <!-- service -->
	  <bean id="accountService" class="com.service.impl.AccountServcieImpl">
	  	<property name="accountDao" ref="accountDao"></property>
	  </bean>
</beans>

             2.3.1.5 测试

	@Test
	public void demo01(){
		String xmlPath = "applicationContext.xml";
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
		AccountService accountService =  (AccountService) applicationContext.getBean("accountService");
		accountService.transfer("jack", "rose", 1000);
	}

 

 

        2.3.2 手动管理事务（了解）

  • spring底层使用 TransactionTemplate 事务模板进行操作
  • 操作

1.service 需要获得 TransactionTemplate

2.spring 配置模板，并注入给service

3.模板需要注入事务管理器

4.配置事务管理器：DataSourceTransactionManager ，需要注入DataSource

        2.3.2.1 DAO 类

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

public class AccountDaoImple extends JdbcDaoSupport implements AccountDao {

	@Override
	public void out(String outer, int money) {
		this.getJdbcTemplate().update("update account set money = money - ? where name = ?",money,outer);
	}

	@Override
	public void in(String inner, int money) {
		this.getJdbcTemplate().update("update account set money = money + ? where name = ?", money,inner);
	}
}

        2.3.2 .2修改service

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

public class AccountServiceImpl implements AccountService {
	private AccountDao accountDao;
	public void setAccountDao(AccountDao accountDao) {
		this.accountDao = accountDao;
	}

	//需要spring注入模板
	private TransactionTemplate transactionTemplate;
	public void setTransactionTemplate(TransactionTemplate transactionTemplate) {
		this.transactionTemplate = transactionTemplate;
	}
	@Override
	public void transfer(final String outer,final String inner,final Integer money) {
		transactionTemplate.execute(new TransactionCallbackWithoutResult() {
			
			@Override
			protected void doInTransactionWithoutResult(TransactionStatus arg0) {
				accountDao.out(outer, money);
				//断电
//				int i = 1/0;
				accountDao.in(inner, money);
			}
		});
	}
}

        2.3.2.3 修改spring配置

<?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: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.xsd
       					   http://www.springframework.org/schema/aop 
       					   http://www.springframework.org/schema/aop/spring-aop.xsd
       					   http://www.springframework.org/schema/context 
       					   http://www.springframework.org/schema/context/spring-context.xsd">

	<!-- 创建数据源 -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
		<property name="jdbcUrl" value="jdbc:mysql://localhost:3306/spring_tx"></property>
		<property name="user" value="root"></property>
		<property name="password" value="123456"></property>
	</bean>
	
	<!-- 配置dao -->
	<bean id="accountDao" class="com.dao.impl.AccountDaoImpl">
     	<property name="dataSource" ref="dataSource"></property>
     </bean>
	
	<!-- 配置service -->
     <bean id="accountService" class="com.service.impl.AccountServcieImpl">
	  	<property name="accountDao" ref="accountDao"></property>
	  	<property name="transactionTemplate" ref="transactionTemplate"></property>
	  </bean>
	
	<!-- 创建模板 -->
	  <bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">
	  	<property name="transactionManager" ref="txManager"></property>
	  </bean>
	
	<!-- 配置事务管理器 ,管理器需要事务，事务从Connection获得，连接从连接池DataSource获得 -->
	<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource"></property>
	</bean>
</beans>

        2.3.2.4 测试

package com.Test;

import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.service.AccountServcie;

public class TestApp {
	
	@Test
	public void Demo() {
		String xmlPath = "applicationContext.xml";
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
		AccountServcie accountServcie = (AccountServcie) applicationContext.getBean("accountService");
		accountServcie.transfer("rose", "jack", 1000);
	}
}

2.3.3工厂bean 生成代理：半自动

  • spring提供 管理事务的代理工厂bean TransactionProxyFactoryBean

     1.getBean() 获得代理对象

     2.spring 配置一个代理

2.3.3.1 DAO 类

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

public class AccountDaoImple extends JdbcDaoSupport implements AccountDao {

	@Override
	public void out(String outer, int money) {
		this.getJdbcTemplate().update("update account set money = money - ? where name = ?",money,outer);
	}

	@Override
	public void in(String inner, int money) {
		this.getJdbcTemplate().update("update account set money = money + ? where name = ?", money,inner);
	}
}

2.3.3.2 Service 类

package com.service.impl;

import com.dao.AccountDao;
import com.service.AccountServcie;

public class AccountServiceImpl implements AccountService {

	private AccountDao accountDao;

	public void setAccountDao(AccountDao accountDao) {
		this.accountDao = accountDao;
	}

	@Override
	public void transfer(String outer, String inner, int money) {
		accountDao.out(outer, money);
		int i = 1 / 0;
		accountDao.in(inner, money);
	}
}

2.3.3.3 spring 配置

<?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: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.xsd
       					   http://www.springframework.org/schema/aop 
       					   http://www.springframework.org/schema/aop/spring-aop.xsd
       					   http://www.springframework.org/schema/context 
       					   http://www.springframework.org/schema/context/spring-context.xsd">

	<!-- 创建数据源 -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
		<property name="jdbcUrl" value="jdbc:mysql://localhost:3306/spring_tx"></property>
		<property name="user" value="root"></property>
		<property name="password" value="123456"></property>
	</bean>c
	
	<!-- 配置dao -->
     <bean id="accountDao" class="com.dao.impl.AccountDaoImpl">
     	<property name="dataSource" ref="dataSource"></property>
     </bean>
	
	<!-- 配置service -->
	  <bean id="accountService" class="com.service.impl.AccountServcieImpl">
	  	<property name="accountDao" ref="accountDao"></property>
	  	<property name="transactionTemplate" ref="transactionTemplate"></property>
	  </bean>
	
	<!-- 配置事务管理器 -->
	<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	
	<!-- 4 service 代理对象 
		4.1 proxyInterfaces 接口 
		4.2 target 目标类
		4.3 transactionManager 事务管理器
		4.4 transactionAttributes 事务属性（事务详情）
			prop.key ：确定哪些方法使用当前事务配置
			prop.text:用于配置事务详情
				格式：PROPAGATION,ISOLATION,readOnly,-Exception,+Exception
					传播行为		隔离级别	是否只读		异常回滚		异常提交
				例如：
					<prop key="transfer">PROPAGATION_REQUIRED,ISOLATION_DEFAULT</prop> 默认传播行为，和隔离级别
					<prop key="transfer">PROPAGATION_REQUIRED,ISOLATION_DEFAULT,readOnly</prop> 只读
					<prop key="transfer">PROPAGATION_REQUIRED,ISOLATION_DEFAULT,+java.lang.ArithmeticException</prop>  有异常扔提交 -->
	<bean id="proxyAccountService" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
		<property name="proxyInterfaces" value="cn.lm.tx02.AccountService"></property>
		<property name="target" ref="accountServiceImplId"></property>
		<property name="transactionManager" ref="txManager"></property>
		<property name="transactionAttributes">
			<props>
				<prop key="transfer">PROPAGATION_REQUIRED,ISOLATION_DEFAULT</prop>
			</props>
		</property>
	</bean>
</beans>

2.3.3.4 测试

package com.Test;

import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.service.AccountServcie;

public class TestApp {
	
	@Test
	public void Demo() {
		String xmlPath = "applicationContext.xml";
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
		AccountServcie accountServcie = (AccountServcie) applicationContext.getBean("proxyAccountService");
		accountServcie.transfer("rose", "jack", 1000);
	}
}

 

2.3.4 AOP 配置基于xml【掌握】

  • 在spring xml 配置aop 自动生成代理，进行事务的管理

     1.配置管理器

     2.配置事务详情

     3.配置aop

2.3.4 .1 DAO

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

public class AccountDaoImple extends JdbcDaoSupport implements AccountDao {

	@Override
	public void out(String outer, int money) {
		this.getJdbcTemplate().update("update account set money = money - ? where name = ?",money,outer);
	}

	@Override
	public void in(String inner, int money) {
		this.getJdbcTemplate().update("update account set money = money + ? where name = ?", money,inner);
	}
}

2.3.4 .2 Service

public class AccountServiceImpl implements AccountService {

	private AccountDao accountDao;

	public void setAccountDao(AccountDao accountDao) {
		this.accountDao = accountDao;
	}

	@Override
	public void transfer(String outer, String inner, int money) {
		accountDao.out(outer, money);
		int i = 1 / 0;
		accountDao.in(inner, money);
	}
}

2.3.4 .3 Service 配置文件

<?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: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.xsd
       					   http://www.springframework.org/schema/aop 
       					   http://www.springframework.org/schema/aop/spring-aop.xsd
       					   http://www.springframework.org/schema/context 
       					   http://www.springframework.org/schema/context/spring-context.xsd
       					   http://www.springframework.org/schema/tx 
       					   http://www.springframework.org/schema/tx/spring-tx.xsd">

	<!-- 创建数据源 -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
		<property name="jdbcUrl" value="jdbc:mysql://localhost:3306/spring_tx"></property>
		<property name="user" value="root"></property>
		<property name="password" value="123456"></property>
	</bean>
	
	<!-- 配置dao -->
     <bean id="accountDao" class="com.dao.impl.AccountDaoImpl">
     	<property name="dataSource" ref="dataSource"></property>
     </bean>
	
	<!-- 配置service -->
	  <bean id="accountService" class="com.service.impl.AccountServcieImpl">
		<property name="accountDao" ref="accountDao"></property>
	  </bean>
	
	<!-- 配置事务管理器 -->
	<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	
	<!-- 配置 事务详情（事务通知）  ， 在aop筛选基础上，对ABC三个确定使用什么样的事务。例如：AC读写、B只读 等
	<tx:attributes> 用于配置事务详情（属性属性）
		<tx:method name=""/> 详情具体配置
			propagation 传播行为 ， REQUIRED：必须；REQUIRES_NEW:必须是新的
			isolation 隔离级别 -->
	<tx:advice id="txAdvice" transaction-manager="txManager">
		<tx:attributes>
			<tx:method name="transfer" propagation="REQUIRED" isolation="DEFAULT"/>
		</tx:attributes>
	</tx:advice>
	
	<!-- AOP编程，目标类有ABCD（4个连接点），切入点表达式 确定增强的连接器，从而获得切入点：ABC -->
	<aop:config>
		<aop:advisor advice-ref="txAdvice" pointcut="execution(* com.service..*.*(..))"/>
	</aop:config>
</beans>

2.3.4 .4 测试

package com.Test;

import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.service.AccountServcie;

public class TestApp {
	
	@Test
	public void Demo() {
		String xmlPath = "applicationContext.xml";
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
		AccountServcie accountServcie = (AccountServcie) applicationContext.getBean("accountService");
		accountServcie.transfer("rose", "jack", 1000);
	}
}

 

2.3.5  AOP配置基于注解【掌握】

  • 配置事务管理器，将并事务管理器交予spring
  • 在目标类或目标方法添加注解即可 @Transactional

2.3.5.1 Service 层

package com.service.impl;

import org.springframework.transaction.annotation.Transactional;

import com.dao.AccountDao;
import com.service.AccountServcie;

@Transactional()
public class AccountServcieImpl implements AccountServcie{
	private AccountDao accountDao;
	public void setAccountDao(AccountDao accountDao) {
		this.accountDao = accountDao;
	}
	@Override
	public void transfer(String outer, String inner, Integer money) {
		accountDao.in(inner, money);
		// 断点
		//int i = 1/0;
		
		accountDao.out(outer, money);
	}

}

2.3.5.2 Spring 配置

<?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://www.springframework.org/schema/aop"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
       					 http://www.springframework.org/schema/beans/spring-beans.xsd
       					 http://www.springframework.org/schema/aop
       					 http://www.springframework.org/schema/aop/spring-aop.xsd
       					 http://www.springframework.org/schema/context 
       					 http://www.springframework.org/schema/context/spring-context.xsd
       					 http://www.springframework.org/schema/tx
       					 http://www.springframework.org/schema/tx/spring-tx.xsd">
       					 
     <!-- 1 datasource -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
		<property name="jdbcUrl" value="jdbc:mysql://localhost:3306/spring_tx"></property>
		<property name="user" value="root"></property>
		<property name="password" value="123456"></property>
	</bean>

     <!-- 2 dao -->
     <bean id="accountDao" class="com.dao.impl.AccountDaoImpl">
     	<property name="dataSource" ref="dataSource"></property>
     </bean>
     <!-- 3 service -->
	  <bean id="accountService" class="com.service.impl.AccountServcieImpl">
		<property name="accountDao" ref="accountDao"></property>
	  </bean>
	  
	<!-- 4 事务管理 -->
	<!-- 4.1 事务管理器 -->

	<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	<!-- 4.2 将管理器交予spring 
		* transaction-manager 配置事务管理器
		* proxy-target-class
			true ： 底层强制使用cglib 代理
	-->
	<tx:annotation-driven transaction-manager="txManager"/>

</beans>

 

2.3.5.3  事物配置详情

@Transactional(propagation=Propagation.REQUIRED , isolation = Isolation.DEFAULT)
public class AccountServiceImpl implements AccountService {

 

【Spring】Spring DataSourceTransactionManager
九师兄
03-23 1319
1.概述 首先参考 Spring：@Transactional 注解使用讲解 然后看看：Spring: 事务传播机制 2. 拓扑图 简化一下 3.PlatformTransactionManager public interface PlatformTransactionManager { /** * * 获取事务 ， 它还会设置数据属性 根据指定的传播行为，返回当前活动的事务或创建新事务。 */ TransactionStatus getTransaction(@Nullable T
Spring事务剖析-DataSourceTransactionManager
taotao1428的博客
07-05 4660
1.4 DataSourceTransactionManager 该类基于DataSource实现TransactionManager，也使用的比较多 1.4.1 doGetTransaction 获取事务对象 protected Object doGetTransaction() { // datasourceTM的实现中，transaction的类型是DataSourceTransactionObject DataSourceTransactionObject txObject = ne
spring 之 TransactionManager使用详解
微赚淘客开发者博客
01-06 2717
在企业级应用开发中，数据库事务管理是至关重要的一部分。Spring框架通过其强大的事务管理特性，简化了事务管理的复杂性，提高了开发效率。Spring的Transaction Manager为我们提供了强大且灵活的事务管理能力，使得在大型应用中更容易处理事务。通过使用Transaction Manager，我们可以确保数据的完整性和一致性，同时提高应用的性能和可维护性。
Spring4.x❹ Spring的事务管理 DataSourceTransactionManager
优快云
09-11 5243
1 Spring事务管理？ 2 Spring 事务管理案例 2.1 实体类 2.2 dao 2.3 service 2.4 Spring配置文件 2.5 test 3 service中的事务管理 3.1 XMl配置文件的方式进行事务管理 3.2 注解的方式进行事务管理 4本文相关代码参考 更多Spring开发在框架开发 1 Spring事务管理？ 事务...
Spring 事务及事务传播机制(1)
asdssadddd的博客
05-09 1190
定义:事务是指逻辑上的一组操作, 构成这组操作的各个单元, 要么全部执行, 要么全部不执行。
spring事务管理
10-27
### Spring事务管理详解 #### 一、Spring事务管理概述 Spring框架提供了强大的事务管理功能，使得开发者能够更方便地管理应用程序中的事务。Spring事务管理主要包括两种类型：编程式事务管理和声明式事务管理。 -...
Spring事务管理Demo
05-01
Spring事务管理的目的是确保数据的一致性和完整性，尤其是在多操作、多资源的环境中。本Demo将深入探讨Spring如何实现事务的管理。 首先，Spring提供了两种主要的事务管理方式：编程式事务管理和声明式事务管理。 ...
Spring事务管理-积分功能实现
最新发布
03-23
基于tx命名空间的声明式事务管理案例
Spring事务管理开发必备jar包
03-07
本资源包提供了进行Spring事务管理开发所需的所有关键库，包括框架基础、核心组件、AOP（面向切面编程）支持、日志处理、编译工具以及与数据库交互的相关jar包。下面将对这些知识点进行详细解释： 1. **Spring框架*...
Spring事务管理
Delu3376451753的博客
11-26 1104
我们接着继续学习@Transactional注解当中的第二个属性propagation，这个属性是用来配置事务的传播行为的。什么是事务的传播行为呢？就是当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行事务控制。例如：两个事务方法，一个A方法，一个B方法。在这两个方法上都添加了@Transactional注解，就代表这两个方法都具有事务，而在A方法当中又去调用了B方法。
0045 Spring中使用DataSourceTransactionManager进行事务管理的xml配置
weixin_30466421的博客
03-20 641
在一个业务的实现过程中，可能需要多条sql完成对数据库的操作，比如账户登录，需要匹配用户名和密码，然后要增加积分，还要记录登录的ip和时间，这可能需要三个sql语句，这三个语句应当是一个整体，任意一个sql执行不成功，都表示这个业务没有执行完成，这就有了事务的概念。 事务是数据库中的概念，就是对数据库的一组操作，由一条或多条sql组成。 事务具有同步的特点，一条sql执行失败，其他sql都不会执行...
Spring技术内幕——DataSourceTransactionManager
qqqqq1993qqqqq的博客
09-17 1万+
Spring的事务处理中，通用的事务处理流程框架是由抽象事务管理器AbstractPlatformTransactionManager来提供的，而具体的底层事务处理实现，由PlatformTransactionManager的具体实现类来实现，如 DataSourceTransactionManager 、JtaTransactionManager和 HibernateTransactionMan
Spring中使用DataSourceTransactionManager手动提交或回滚事务
yxhxj2006的专栏
03-21 1万+
      在使用spring进行web开发时，虽然spring提供的注解方式可以方便的处理很多原来需要手动提交或回滚的事务，但是注解方式有自己使用的局限，比如在类的内部调用方法时，注解方式处理的事务就无法被触发，此时可能需要手动处理相关数据库的事务。本文记录在spring开发时使用Spring提供的DataSourceTransactionManager进行事务提交或回滚处理。主要步骤如下：1、...
Spring使用自带的DataSourceTransactionManager声明式事务(xml)模板
weixin_44257023的博客
10-17 1235
我这里用的是Druid连接池 applicationConttext.xml: <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframe
Spring3.1.0实现原理分析(二十二).Dao事务分析之事务管理器DataSourceTransactionManager
热门推荐
roberts939299的专栏
08-25 3万+
大家好，开篇先来谈谈spring事务的优点吧，即spring事务的存在价值。首先它提供了非侵入式编码的事务实现，这个是通过aop实现的，具体的实现过程之前也写博客分析了。 另外，spring还提供了一套标准的事务管理工作流程。简单的说，事务管理一共可分为三个步骤，分别是初始化事务、提交事务、回滚事务，然后每个步骤又可细分为若干小步骤。spring事务工作流相当于为用户屏蔽了具体orm框架的底层处理逻辑，基于spring开发的程序，即便更换了orm框架，即便从本地事务切换到全局事务，也只需要简单
【web】Spring中使用DataSourceTransactionManager手动提交或回滚事务
三言两语
01-08 1万+
在使用spring进行web开发时，虽然spring提供的注解方式可以方便的处理很多原来需要手动提交或回滚的事务，但是注解方式有自己使用的局限，比如在类的内部调用方法时，注解方式处理的事务就无法被触发，此时可能需要手动处理相关数据库的事务。本文记录在spring开发时使用Spring提供的DataSourceTransactionManager进行事务提交或回滚处理。主要步骤如下： 1、注入Da
Spring声明式事物DataSourceTransactionManager的使用与jdbcTemplate的使用
苏凯的博客
10-14 1万+
1.配置事物 applicationContext-tran.xml &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;beans xmlns="http://www.springframework.org/schema/beans" xmlns:p="http://www.springframework.org/schema/p" xmlns...
Spring 事务管理 DataSourceTransactionManager 和 DataSourceTransactionManager
wanglingxxx的博客
04-20 1万+
如果一个方法中既用了HibernateTemplate，又用了JdbcTemplate，应该怎么配单实例的db事务呢（多例免谈）用DataSouceTransactionManager是不行的，而用HibernateTransactionManager就可以保证 原因的话看下它们源代码，会发现HibernateTransactionManager中的处理可以保证SessionFactoryUti
SpringBoot手动开启事务：DataSourceTransactionManager
学长抄作业（codeying）博客codeying.top
03-26 1万+
文章目录DataSourceTransactionManager DataSourceTransactionManager 添加事务： 传统JDBC事务管理，使用DataSource从数据源中获取connection 通过api进行CRUD，之后手动commit、rollback。 应用spring提供的编程式的事务管理 使用spring的声明式事务处理 Spring的事务处理中，通用的事务处理流程是由抽象事务管理器AbstractPlatformTransactionManager来提供的，而具体的底
Spring事务管理配置方式演示
标题所揭示的知识点是Spring事务管理的配置方式。Spring作为Java领域一个极为重要的框架，其事务管理是企业级开发中不可或缺的一部分。事务管理是保证数据库操作的原子性、一致性、隔离性和持久性的关键技术。在...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

dayaoK

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值