Spring 事务管理

最新推荐文章于 2023-03-08 18:05:01 发布
最新推荐文章于 2023-03-08 18:05:01 发布
阅读量387 收藏
点赞数
分类专栏： JavaWeb 文章标签： spring 事务
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dongyuxu342719/article/details/76019977
版权
一、3个主要的接口
1、PlatformTransactionManager
其中DataSourceManager用于spring JDBC或iBatis进行持久化数据时
HibernateTransactionManager用于Hibernate3.0进行持久化数据时
JpaTransactionManager
JdoTransactionManager
JtaTransactionManager


2、TransactionDefinition
如果不考虑事务的隔离级别，可能会导致脏读、不可重复读、幻读。
脏读：一个事务读取了另一个事务改写但还未提交的数据，如果这些数据被回滚，则读到的数据是无效的。
不可重复读：在同一个事务中，多次读取同一数据返回的结果有所不同。
幻读：一个事务读取了几行记录后，另一个事务插入了一些记录，幻读就发生了，再后来的查询中，第一个事务就会发现有些原来没有的记录。
事务隔离级别
DEFAULT            底层数据库默认的隔离级别，比如Mysql默认是REPEATABLE_READ
READ_UNCONNITED    允许读取还未提可能交的数据，会导致脏读、不可重复读、幻读。
READ_COMMITTED     允许，在并发事务已经提交后读取，可以防止脏读，但不可重复读，和幻读还会发生
REPEATABLE_READ    对相同字段多除非数据被事务改变。次读取的数据是一致的，可防止脏读和不可重复读，但幻读仍可发生。
SERIALIZABLE       完全服从数据库的ACID原则，不会发生脏读、不可重复读、幻读。在所以隔离级别中最慢。


事务的传播行为(七种)
web->service层->Dao层
Dao1(),Dao2()
事务是加在业务层的，service中的方法可能会调用到Dao层的多个方法。也可能会出现service层多个方法调用Dao层多个方法。然后web层同时调用service层不同方法。这时候就要确定这时候使用的是哪个事务，即事务是如何传播的。
第一类：web层调用的不同方法在同一事务中进行
1)PROPAGATION_REQUIRED:支持当前事务，如果不存在就创建一个事务，即不同的调用在同一个事务中
2)PROPAGATION_SUPPORTS:支持当前事务，如果不存在，就不使用事务
3)PROPAGATION_MANDATORY:支持当前事务，如果不存在，抛出异常。
第二类：web层调用的不同方法在不同事务中进行
4)PROPAGATION_REQUIRES_NEW:如果有事务存在，就挂起当前事务，创建一个新事务。即不同方法在不同事务中进行
5)PROPAGATION_NOT_SUPPORTED:以非事务方式运行，如果有事务就挂起当前事务
6)PROPAGATION_NEVER:以非事务方式运行，如果有事务存在，就抛出异常
第三类：web层调用的不同方法在前面的方法中使用的事务设置保存点，第二个方法在发生异常时即可以回到保存点的位置，也可以回到最初始的状态。
7)PROPAGATION_NESTED:如果当前事务存在，则嵌套事务执行


3、TransactionStatus

在该接口中提供了一些方法获取事务的状态

比如haveSavePoint();是否有保存点
isComplete();是否完成
等等

Spring 事务管理
-编程式的事务管理：这种方式在实际应用中很少使用，通过TransactionTemplate手动管理事务。
-声明式的事务管理：开发中一般使用这种方式，spring的声明式事务是通过AOP实现的。

新建一个web项目进行spring事务的测试
新建表Account
CREATE TABLE `account` (                                                                                                                                                                                                                         
           `id` int(11) NOT NULL auto_increment,                                                                                                                                                                                                          
           `account` varchar(10) collate utf8_bin default NULL,                                                                                                                                                                                           
           `money` double default NULL,                                                                                                                                                                                                                   
           KEY `id` (`id`)                                                                                                                                                                                                                                
         ) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8 COLLATE=utf8_bin
项目中引入必要的Jar包
包括c3p0连接池的jar包c3p0-0.9.2.1.jar
spring-jdbc-4.0.2.RELEASE.jar
spring-test-4.0.2.RELEASE.jar
spring-tx-4.0.2.RELEASE.jar
spring-beans-4.0.2.RELEASE.jar
spring-context-4.0.2.RELEASE.jar
spring-core-4.0.2.RELEASE.jar
spring-expression-4.0.2.RELEASE.jar
mysql-connector-java-5.1.30.jar
commons-logging-1.1.3.jar
log4j-1.2.17.jar
junit-4.11.jar

hamcrest-core-1.3.jar

spring-aop-4.0.2.RELEASE.jar

mchange-commons-java-0.2.3.4.jar

日志的配置文件log4j.properties

#定义LOG输出级别
log4j.rootLogger=debug
#定义日志输出目的地为控制台
log4j.appender.Console=org.apache.log4j.ConsoleAppender
log4j.appender.Console.Target=System.out
#可以灵活地指定日志输出格式，下面一行是指定具体的格式
log4j.appender.Console.layout = org.apache.log4j.PatternLayout
log4j.appender.Console.layout.ConversionPattern=[%c] - %m%n

#文件大小到达指定尺寸的时候产生一个新的文件
log4j.appender.File = org.apache.log4j.RollingFileAppender
#指定输出目录
log4j.appender.File.File = logs/ssm.log
#定义文件最大大小
log4j.appender.File.MaxFileSize = 10MB
# 输出所以日志，如果换成DEBUG表示输出DEBUG以上级别日志
log4j.appender.File.Threshold = ALL
log4j.appender.File.layout = org.apache.log4j.PatternLayout
log4j.appender.File.layout.ConversionPattern =[%p] [%d{yyyy-MM-dd HH\:mm\:ss}][%c]%m%n

核心配置文件applicationContext.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:jee="http://www.springframework.org/schema/jee"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
		http://www.springframework.org/schema/beans/spring-beans-3.1.xsd 
		http://www.springframework.org/schema/tx 
		http://www.springframework.org/schema/tx/spring-tx-3.1.xsd 
		http://www.springframework.org/schema/jee 
		http://www.springframework.org/schema/jee/spring-jee-3.1.xsd 
		http://www.springframework.org/schema/context 
		http://www.springframework.org/schema/context/spring-context-3.1.xsd 
		http://www.springframework.org/schema/aop 
		http://www.springframework.org/schema/aop/spring-aop-3.1.xsd">

	<!-- 引入外部配置文件 -->
	<context:property-placeholder location="classpath:jdbc.properties"/>
	<!-- 配置c3p0连接池 -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="driverClass" value="${jdbc.driverClass}"></property>
		<property name="jdbcUrl" value="${jdbc.url}"></property>
		<property name="user" value="${jdbc.username}"></property>
		<property name="password" value="${jdbc.password}"></property>
	</bean>
	<!-- 配置业务类-->
    <bean id="accountService" class="com.terisadeng.spring.demo1.service.impl.AccountServiceImpl">
    	<property name="accountDao" ref="accountDao"></property>
    </bean>
    <!-- 配置Dao层 -->
    <bean id="accountDao" class="com.terisadeng.spring.demo1.dao.impl.AccountDaoImpl">
    	<!-- 注入连接池对象，来获取jdbc模板类操作数据库 -->
    	<property name="dataSource" ref="dataSource"></property>
    </bean>
    
</beans>

jdbc属性文件jdbc.properties 

jdbc.driverClass=com.mysql.jdbc.driver
jdbc.url=jdbc:mysql:///spring_transaction
jdbc.username=root
jdbc.password=root

Service层代码

package com.terisadeng.spring.demo1.service.impl;

import com.terisadeng.spring.demo1.dao.AccountDao;
import com.terisadeng.spring.demo1.service.AccountService;

public class AccountServiceImpl implements AccountService
{
    private AccountDao accountDao;

    @Override
    public void transfer(String out, String in, double money)
    {
        accountDao.outMoney(out, money);
        accountDao.inMoney(in, money);
    }

    public AccountDao getAccountDao()
    {
        return accountDao;
    }

    public void setAccountDao(AccountDao accountDao)
    {
        this.accountDao = accountDao;
    }
}
Dao层代码 

package com.terisadeng.spring.demo1.dao.impl;

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

import com.terisadeng.spring.demo1.dao.AccountDao;

public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao
{

    @Override
    public void outMoney(String out, double money)
    {
        String sql="update Account set money=money-? where name=?";
        this.getJdbcTemplate().update(sql, money,out);
    }

    @Override
    public void inMoney(String in, double money)
    {
        String sql="update Account set money=money+? where name=?";
        this.getJdbcTemplate().update(sql, money,in);
    }

}

测试类代码 

import javax.annotation.Resource;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import com.terisadeng.spring.demo1.service.AccountService;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class SpringDemo1
{
    @Resource(name="accountService")
    private AccountService accountService;
    
    @Test
    public void demo1(){
        accountService.transfer("aaa", "bbb", 200);
    }
}

1、代码中使用声明式的事务管理

applicationContext.xml添加配置

<bean id=transactionManager class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
	<!--引入数据源-->
	<property name="dataSource" ref="dataSource"></property>
</bean>

<!-- 配置事务管理的模板，简化事务操作 -->
<bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">
	<property name="transactionManager" ref="transactionManager"></property>
</bean>
因为事务是在业务层控制的，这里使用事务模板简化事务的操作，就要将事务的模板对象引入service层，所以修改service层配置
<bean id="accountService" class="com.terisadeng.spring.demo1.service.impl.AccountServiceImpl">
	<property name="accountDao" ref="accountDao"></property>
	<property name="transactionTemplate" ref="transactionTemplate"></property>
</bean>
service层代码修改如下 

package com.terisadeng.spring.demo1.service.impl;

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

import com.terisadeng.spring.demo1.dao.AccountDao;
import com.terisadeng.spring.demo1.service.AccountService;

public class AccountServiceImpl implements AccountService
{
    private AccountDao accountDao;
    
    private TransactionTemplate transactionTemplate;

    

    @Override
    public void transfer(final String out,final String in,final double money)
    {
        transactionTemplate.execute(new TransactionCallbackWithoutResult()
        {
            
            @Override
            protected void doInTransactionWithoutResult(TransactionStatus arg0)
            {
                accountDao.outMoney(out, money);
                int i=1/1;
                accountDao.inMoney(in, money);
            }
        });
        
    }

    public AccountDao getAccountDao()
    {
        return accountDao;
    }

    public void setAccountDao(AccountDao accountDao)
    {
        this.accountDao = accountDao;
    }
    
    public void setTransactionTemplate(TransactionTemplate transactionTemplate)
    {
        this.transactionTemplate = transactionTemplate;
    }
}
2、代码中使用XML进行声明式的事务管理

applicationContext.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:jee="http://www.springframework.org/schema/jee"      
	xmlns:aop="http://www.springframework.org/schema/aop"                                                            
	xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans                                                  
		http://www.springframework.org/schema/beans/spring-beans-3.1.xsd                                               
		http://www.springframework.org/schema/tx                                                                       
		http://www.springframework.org/schema/tx/spring-tx-3.1.xsd                                                     
		http://www.springframework.org/schema/jee                                                                      
		http://www.springframework.org/schema/jee/spring-jee-3.1.xsd                                                   
		http://www.springframework.org/schema/context                                                                  
		http://www.springframework.org/schema/context/spring-context-3.1.xsd                                           
		http://www.springframework.org/schema/aop                                                                      
		http://www.springframework.org/schema/aop/spring-aop-3.1.xsd">                                                 
                                                                                                                   
	<!-- 引入外部配置文件 -->                                                                                                
	<context:property-placeholder location="classpath:jdbc.properties"/>                                             
	<!-- 配置c3p0连接池 -->                                                                                               
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">                                         
		<property name="driverClass" value="${jdbc.driverClass}"></property>                                           
		<property name="jdbcUrl" value="${jdbc.url}"></property>                                                       
		<property name="user" value="${jdbc.username}"></property>                                                     
		<property name="password" value="${jdbc.password}"></property>                                                 
	</bean>                                                                                                          
	<!-- 配置业务类-->                                                                                                    
    <bean id="accountService" class="com.terisadeng.spring.demo2.service.impl.AccountServiceImpl">                 
    	<property name="accountDao" ref="accountDao"></property>                                                     
    </bean>                                                                                                        
    <!-- 配置Dao层 -->                                                                                                
    <bean id="accountDao" class="com.terisadeng.spring.demo2.dao.impl.AccountDaoImpl">                             
    	<!-- 注入连接池对象，来获取jdbc模板类操作数据库 -->                                                                             
    	<property name="dataSource" ref="dataSource"></property>                                                     
    </bean>                                                                                                        
                                                                                                                   
	<!-- 配置事务管理器 -->                                                                                                 
	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">          
		<property name="dataSource" ref="dataSource"></property>	                                                     
	</bean>                                                                                                          
	                                                                                                                 
	<!-- 对业务层进行事务的管理，使用代理来对service进行增强 -->                                                                           
	<bean id="accountServiceProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">  
		<!-- 配置目标对象 -->                                                                                                
		<property name="target" ref="accountService"></property>                                                       
		<!--注入事务管理器-->                                                                                                 
		<property name="transactionManager" ref="transactionManager"></property>                                       
		<!-- 注入事务的属性 -->                                                                                               
		<property name="transactionAttributes">                                                                        
			<props>                                                                                                      
				<!-- prop的格式：                                                                                              
						* PROPAGATION	:事务的传播行为。                                                                                
						* ISOLATION		:事务的隔离级别。                                                                                
						* readOnly		:只读。                                                                                     
						* -Exception	:发生哪些异常回滚事务。                                                                             
						* +Exception 	:发生哪些异常事务不回滚。 -->                                                                        
				<!-- 这里写transfer方法是因为业务层只有这一个方法需要进行事务管理，实际开发可以根据需要定义，比如*代表所有方法 -->		                                     
				<prop key="transfer">PROPAGATION_REQUIRED</prop>                                                           
			</props>                                                                                                     
		</property>                                                                                                    
	</bean>                                                                                                          
</beans>
Service层修改如下： 
package com.terisadeng.spring.demo2.service.impl;             
                                                                                                
import com.terisadeng.spring.demo2.dao.AccountDao;            
import com.terisadeng.spring.demo2.service.AccountService;    
                                                              
public class AccountServiceImpl implements AccountService     
{                                                             
    private AccountDao accountDao;                            
                                                              
                                                              
    @Override                                                 
    public void transfer( String out, String in, double money)
    {                                                         
        accountDao.outMoney(out, money);                      
        int d=1/0;                                            
        accountDao.inMoney(in, money);                        
                                                              
    }                                                         
                                                              
    public AccountDao getAccountDao()                         
    {                                                         
        return accountDao;                                    
    }                                                         
                                                              
    public void setAccountDao(AccountDao accountDao)          
    {                                                         
        this.accountDao = accountDao;                         
    }                                                         
                                                              
}
测试类代码如下： 
import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.terisadeng.spring.demo2.service.AccountService;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext2.xml")
public class SpringDemo2
{
    /**
     * 注入代理类：因为代理类进行了增强，包含事务操作
     */
    @Resource(name="accountServiceProxy")
    //@Resource(name="accountService")
    private AccountService accountService;
    @Test
    public void demo2(){
        accountService.transfer("aaa", "bbb", 200);
    }
}
3、Spring的声明式事务管理的第二种方式(基于AspectJ的XML方式的配置)         
applicationContext.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:jee="http://www.springframework.org/schema/jee"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
		http://www.springframework.org/schema/beans/spring-beans-3.1.xsd 
		http://www.springframework.org/schema/tx 
		http://www.springframework.org/schema/tx/spring-tx-3.1.xsd 
		http://www.springframework.org/schema/jee 
		http://www.springframework.org/schema/jee/spring-jee-3.1.xsd 
		http://www.springframework.org/schema/context 
		http://www.springframework.org/schema/context/spring-context-3.1.xsd 
		http://www.springframework.org/schema/aop 
		http://www.springframework.org/schema/aop/spring-aop-3.1.xsd">

	<!-- 引入外部配置文件 -->
	<context:property-placeholder location="classpath:jdbc.properties"/>
	<!-- 配置c3p0连接池 -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="driverClass" value="${jdbc.driverClass}"></property>
		<property name="jdbcUrl" value="${jdbc.url}"></property>
		<property name="user" value="${jdbc.username}"></property>
		<property name="password" value="${jdbc.password}"></property>
	</bean>
	<!-- 配置业务类-->
    <bean id="accountService" class="com.terisadeng.spring.demo3.service.impl.AccountServiceImpl">
    	<property name="accountDao" ref="accountDao"></property>
    </bean>
    <!-- 配置Dao层 -->
    <bean id="accountDao" class="com.terisadeng.spring.demo3.dao.impl.AccountDaoImpl">
    	<!-- 注入连接池对象，来获取jdbc模板类操作数据库 -->
    	<property name="dataSource" ref="dataSource"></property>
    </bean>
	
	<!-- 配置事务管理器 -->
	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	
	<!-- 配置事务的通知:(事务的增强) -->
	<tx:advice id="txAdvice" transaction-manager="transactionManager">
		<tx:attributes>
			<!-- 
				propagation:事务的传播行为
				isolation  :事务的隔离级别
				read-only  :只读。
				rollback-for:发生哪些异常回滚
				no-rollback-for:发生哪些异常不回滚。
				timeout	   :过期信息
			 -->
			<tx:method name="transfer" propagation="REQUIRED"/>
		</tx:attributes>
	</tx:advice>
	
	<!-- 配置切面 -->
	<aop:config>
		<!-- 配置切入点 -->
		<aop:pointcut expression="execution(* com.terisadeng.spring.demo3.service.AccountService+.*(..))" id="pointcut1"/>
		<!-- 配置切面 -->
		<aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut1"/>
	</aop:config>
</beans>
Service层与Dao不需要修改任何东西，这种方式的代理对象是自动生成的
测试代码如下: 
import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.terisadeng.spring.demo3.service.AccountService;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext3.xml")
public class SpringDemo3
{

    @Resource
    private AccountService accountService;
    @Test
    public void demo3(){
        accountService.transfer("aaa", "bbb", 200);
    }
}
4、基于注解方式的配置
applicationContext.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:jee="http://www.springframework.org/schema/jee"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
		http://www.springframework.org/schema/beans/spring-beans-3.1.xsd 
		http://www.springframework.org/schema/tx 
		http://www.springframework.org/schema/tx/spring-tx-3.1.xsd 
		http://www.springframework.org/schema/jee 
		http://www.springframework.org/schema/jee/spring-jee-3.1.xsd 
		http://www.springframework.org/schema/context 
		http://www.springframework.org/schema/context/spring-context-3.1.xsd 
		http://www.springframework.org/schema/aop 
		http://www.springframework.org/schema/aop/spring-aop-3.1.xsd">

	<!-- 引入外部配置文件 -->
	<context:property-placeholder location="classpath:jdbc.properties"/>
	<!-- 配置c3p0连接池 -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="driverClass" value="${jdbc.driverClass}"></property>
		<property name="jdbcUrl" value="${jdbc.url}"></property>
		<property name="user" value="${jdbc.username}"></property>
		<property name="password" value="${jdbc.password}"></property>
	</bean>
	<!-- 配置业务类-->
    <bean id="accountService" class="com.terisadeng.spring.demo4.service.impl.AccountServiceImpl">
    	<property name="accountDao" ref="accountDao"></property>
    </bean>
    <!-- 配置Dao层 -->
    <bean id="accountDao" class="com.terisadeng.spring.demo4.dao.impl.AccountDaoImpl">
    	<!-- 注入连接池对象，来获取jdbc模板类操作数据库 -->
    	<property name="dataSource" ref="dataSource"></property>
    </bean>
	
	<!-- 配置事务管理器 -->
	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	
	<!-- 开启注解事务 -->
	<tx:annotation-driven transaction-manager="transactionManager"/>
</beans>
Service层代码修改如下: 
package com.terisadeng.spring.demo4.service.impl;

import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import com.terisadeng.spring.demo4.dao.AccountDao;
import com.terisadeng.spring.demo4.service.AccountService;
/**
 * @Transaction注解中的属性:
 * propagation  :事务的传播行为
 * isolation    :事务的隔离级别
 * read-Only    :只读
 * rollback-for :发生哪些异常回滚
 * no-rollback-for:发生哪些异常不回滚
 * 
 */
@Transactional(propagation=Propagation.REQUIRED,isolation=Isolation.DEFAULT)
public class AccountServiceImpl implements AccountService
{
    private AccountDao accountDao;


    @Override
    public void transfer( String out, String in, double money)
    {
        accountDao.outMoney(out, money);
        int d=1/0;
        accountDao.inMoney(in, money);
  
    }

    public AccountDao getAccountDao()
    {
        return accountDao;
    }

    public void setAccountDao(AccountDao accountDao)
    {
        this.accountDao = accountDao;
    }
    
}
测试代码如下: 
import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.terisadeng.spring.demo4.service.AccountService;

//基于注解的事务配置方式

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext4.xml")
public class SpringDemo4
{

    @Resource
    private AccountService accountService;
    @Test
    public void demo4(){
        accountService.transfer("aaa", "bbb", 200);
    }
}
Spring将事务管理分成了两类：
*编程式事务管理：
*手动编写代码进行事务管理.(很少使用)
*声明式事务管理：
*基于TransactionProxyFactoryBean的方式.(很少使用)
*需要为每个进行事务管理的类配置一个TransactionProxyFactoryBean进行增强.
*基于AspectJ的XML方式.(经常使用)
*一旦配置好之后,类上不需要添加任何东西
*基于注解方式.(经常使用)
*配置简单,需要在业务层类上添加一个@Transactional的注解.

Terisadeng
关注
专栏目录
Log4j配置maxBackupIndex与maxFileSize注意
PickRecalled
12-11 6815
错误信息如下： log4j:WARN No such property [maxBackupIndex] in org.apache.log4j.DailyRollingFileAppender. log4j:WARN No such property [maxFileSize] in org.apache.log4j.DailyRollingFileAppender.  根据错误提示我...
spring事务管理
10-27
### Spring事务管理详解 #### 一、Spring事务管理概述 Spring框架提供了强大的事务管理功能，使得开发者能够更方便地管理应用程序中的事务。Spring事务管理主要包括两种类型：编程式事务管理和声明式事务管理。 -...
logback无法删除太久远的日志文件？logback删除日志文件源码分析
最新发布
Java陈小白
03-08 2302
最近发现logback配置滚动日志，但是本地日志文件甚至还有2年前的日志文件，服务器是却是正常的！网上搜索了一波没有发现，只找到说不能删除太久远的旧日志文件。
解决 maxfilesize property is manatory 的问题
Deroser的博客
03-29 6964
问题配置如下图所示： <?xml version="1.0" encoding="UTF-8"?> <configuration> <appender name="File" class="ch.qos.logback.core.rolling.RollingFileAppender"> <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolic
maxfilesize property is manatory ；springboot 项目集成cloud 的eureka 后出现日志错误
qq_36878632的博客
02-07 1876
上照片： 这是因为这个字段没有加载进去 由于logback的属性在application.yml 配置的 没有加载上 logback 的相关配置创建在一个新的bootstap.yml内 启动时就会加载上了，测试可行；
logback按照文件大小切割日志
Aruis26的博客
04-12 6639
在日志的处理方面，logback是一套比较主流的日志框架，SpringBoot默认使用的就是logback。通过配置logback.xml,可以灵活的实现我们对日志的各种格式需求。 在使用中发现1.1.*版本和1.2.*有些区别，前面的版本貌似不支持单纯的按照日志文件大小来切割日志，后面的版本需要配置最大保存时间等参数，以及在格式上需要加随机数%i来实现。此格式与所需的日志格式有点冲突，于是想到了...
springBoot如何如何设置fileMazSize()
Crazy大魔丸的博客
08-04 381
@Configuration@ComponentScanpublic class Config extends CommonConfig{ @Bean public static ConfigUtil commonUtil() { String path=System.getProperty("configPath"); ConfigUtil
Spring事务管理Demo
05-01
Spring事务管理的目的是确保数据的一致性和完整性，尤其是在多操作、多资源的环境中。本Demo将深入探讨Spring如何实现事务的管理。 首先，Spring提供了两种主要的事务管理方式：编程式事务管理和声明式事务管理。 ...
Spring事务管理开发必备jar包
03-07
本资源包提供了进行Spring事务管理开发所需的所有关键库，包括框架基础、核心组件、AOP（面向切面编程）支持、日志处理、编译工具以及与数据库交互的相关jar包。下面将对这些知识点进行详细解释： 1. **Spring框架*...
Spring事务管理
09-24
Spring事务管理是Java开发中一个至关重要的概念，特别是在企业级应用开发中，它确保了数据的一致性和完整性。Spring框架提供了强大的事务管理机制，能够帮助开发者处理事务的开始、提交、回滚以及隔离级别等事务特性...
springboot项目根据yml或者properties属性设置logback多环境配置
top_explore的博客
05-08 4881
实现思路 通过在logback配置文件中引入yml或properties中的属性，从而实现通过yml或者properties配置实现logback属性配置。 实现步骤 以application.yml,application-dev.yml文件为例 1.在application.yml文件中设置活跃文件来引用dev。 spring: profiles:...
spring boot application properties配置详解
weixin_30701575的博客
08-28 873
# =================================================================== # COMMON SPRING BOOT PROPERTIES # # This sample file is provided as a guideline. Do NOT copy it in its # entirety to your...
springboot logback 日志配置。
yuanquanl的博客
06-15 8471
下面的引用 SizeAndTimeBasedRollingPolicy  只能是1.2版本以上 ，如果是spring starter 中已经引用了，直接修改日志版本号即可 即在pom中加入：    1.2.1 注意1：TimeBasedRollingPolicy 和 SizeAndTimeBasedRollingPolicy  的区别。 使用TimeBasedRolling
logback 中SizeAndTimeBasedRollingPolicy 的maxFileSize不生效的问题
再见，多谢你们的鱼
01-20 1万+
当我将其设置成 <maxFileSize>1KB</maxFileSize> 的时候死活不生效。就是不给我按照大小分割。 将logback的日志信息打印如下: Archive files will be limited to [1 KB] each. 明明是生效了啊，怎么回事呢？ 原来，是这个1KB设置的太小了，logback"来不及切割"，因为我其实就想测一下这个按照大小分割的功能，所有设置了1KB。 按照前人经验，得设置成10MB，才能看出来。 因此我直接写了个循环，把log
Spring-Boot (二) application.properties配置文件内容
热门推荐
t0m的专栏
11-10 7万+
Spring-Boot官方开发指导文档 默认创建spring-boot项目后，会在resources目录下生成一个空的application.properties配置文件，springboot启动时加载该配置文件。 application.properties(或者application.yml)中包含系统属性、环境变量、命令参数这类信息。 下面简要说一部分spring-boot项目中a
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值