Spring 事务管理案例
事务管理简介
Spring 事务管理有两种方式:一种是编程式事务管理,即通过编写代码实现事物管理,包括定义事务的开始,程序正常执行后的事物提交,异常时进行的事务回滚。另一种是基于AOP技术实现的声明式事务管理,其主要思想是将事务管理作为一个“切面”代码单独编写,我们只用关心核心业务逻辑代码,然后通过AOP技术将事务管理的“切面”代码织入到业务类中,声明式事务管理有包括基于AOP方式的事务管理和基于 @Transactional注解方式的事务管理,声明式事务管理极大的简化了编程式事务管理的操作流程,不再需要重复地执行定义事物的开始,程序正常执行后事务提交,异常时进行事物回滚这些繁琐的操作,而基于 @Transactional注解的声明式事务又进一步简化了基于AOP的事务管理,减少了Spring配置代码。
声明式事务的缺点在于**只能作用到方法级别**,无法做到像编程式事务那样能控制到代码块级别。
- 事务传播行为
事务规则也就是事务传播行为,用于解决业务层方法之间的相互调用的问题题。常见的事物传播行为可分为以下几种:
名称 | 说明 |
---|---|
REQUIRED | 表示当前方法必须运行在一个事物环境中,如果一个现有的事物正在运行,该方法将运行在这个事务中,否则,就要开始一个新的事务 |
REQUIRESNEW | 表示当前方法必须运行在自己的事务里 |
SUPPORTS | 表示当前方法不需要事务处理环境,但如果有一个事务正在运行的话,则这个方法也可以运行在这个事务中 |
MANDATORY | 表示当前方法必须运行在一个事务上下文中,否则就抛出异常 |
NEVER | 表示当前方法不应该运行在一个事务上下文中,否则就抛出异常 |
事务管理的主要任务是事务的创建,事务的回滚和事务的提交,是否需要创建事务及如何创建事务,是由事务传播行为控制的,通常数据的读取可以不需要事务管理,或者可以指定为只读事务,而对于数据的增加,删除和修改操作,则有必要进行事务管理。如果没有指定事务的传播行为,Spring默认采用REQUIRED。
转账案例
转账环境搭建
- 创建表sql(三个账户,初始化金额都为1000)
CREATE TABLE `account` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(20) NOT NULL,
`money` double DEFAULT NULL,<br>
PRIMARY KEY (`id`)<br>
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;<br>
INSERT INTO `account` VALUES ('1', 'aaa', '1000');<br>
INSERT INTO `account` VALUES ('2', 'bbb', '1000');<br>
INSERT INTO `account` VALUES ('3', 'ccc', '1000');<br>
- 项目所需jar包
因为我的jdk是1.8,如果spring的版本用spring3.X的话,后面会出现参数不匹配异常java.lang.IllegalArgumentException,所以我换成了Spring4。
- 数据库连接参数
- 日志文件log4j.properties
log4j.rootLogger=INFO,logfile,stdout
#write log into file
log4j.appender.logfile=org.apache.log4j.DailyRollingFileAppender
log4j.appender.logfile.Threshold=warn
log4j.appender.logfile.File=${webapp.root}\\logs\\Transaction.log
log4j.appender.logfile.DatePattern=.yyyy-MM-dd
log4j.appender.logfile.layout=org.apache.log4j.PatternLayout
log4j.appender.logfile.layout.ConversionPattern=[Transaction] %d{yyyy-MM-dd HH\:mm\:ss} %X{remoteAddr} %X{remotePort} %m %n
#display in console
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Threshold=info
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=[Transaction] %d{yyyy-MM-dd HH\:mm\:ss} %X{remoteAddr} %X{remotePort} %m %n
- 创建业务层接口和实现类
package com.zzh.demo1;
public interface AccountService {
/**
*
* @param out :转出账号
* @param in :转入账号
* @param money :转账金额
*/
public void transfer(String out,String in,Double money);
}
package com.zzh.demo1;
public class AccountServiceImpl implements AccountService {
//注入DAO类
private AccountDao accountDao;
public void setAccountDao(AccountDao accountDao) {
this.accountDao = accountDao;
}
@Override
public void transfer(String out, String in, Double money) {
accountDao.outMoney(out, money);
accountDao.inMoney(in, money);
}
}
- 创建DAO层接口和实现类
package com.zzh.demo1;
public interface AccountDao {
/**
* @param out :转出账号
* @param money :转出金额
*/
public void outMoney(String out,Double money);
/**
* @param in :转入账号
* @param money :转入金额
*/
public void inMoney(String in,Double money);
}
这里让Dao层实现类继承JdbcDaoSupport,这样一来就可以将JdbcTemplate注入其中,不过我是直接将DataSource连接池注入其中,这时我的DAO实现类就可以创建一个JdbcTemplate,然后操作数据库的相关内容。
package com.zzh.demo1;
import org.springframework.jdbc.core.support.JdbcDaoSupport;
/**
* DAO层接口实现类
* 这里使用的是JdbcDaoSupport模板
*
*/
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);
}
}
当然也可以不选择让DAO层继承JdbcDaoSupport,而是把JdbcTemplate作为他的属性进行操作,通过setter方法利用JdbcTemplate的构造方法将dataSource传入。
package com.zzh.demo1;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
public class AccountDaoImpl implements AccountDao {
private JdbcTemplate jdbcTemplate;
public void setDataSource(DataSource dataSource){
this.jdbcTemplate = new JdbcTemplate(dataSource);
}
@Override
public void outMoney(String out, Double money) {
String sql = "update account set money = money - ? where name = ?";
this.jdbcTemplate.update(sql,money,out);
}
@Override
public void inMoney(String in, Double money) {
String sql = "update account set money = money + ? where name = ?";
this.jdbcTemplate.update(sql, money,in);
}
}
- 配置applicationContext.xml
要将c3p0的连接池注入DAO层实现类中,使其可以创建JdbcTemplate。
<?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/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.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 name="jdbcUrl" value="${jdbc.url}"/>
<property name="user" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
</bean>
<!-- 配置业务层 -->
<bean id="accountService" class="com.zzh.demo1.AccountServiceImpl">
<property name="accountDao" ref="accountDao"/>
</bean>
<!-- 配置DAO层,注入连接池就可以得到jdbc模板-->
<bean id="accountDao" class="com.zzh.demo1.AccountDaoImpl">
<property name="dataSource" ref="dataSource"/>
</bean>
</beans>
- 测试转账效果
让测试运行于Spring测试环境中,并引入配置文件
注意Junit使用spring时,若spring没加载到log4j就会报以下警告:
log4j:WARN No appenders could be found for logger(org.springframework.test.context.junit4.SpringJUnit4ClassRunner).log4j:WARN Please initialize the log4j system properly.
测试业务层类,在用注解 @Resource(name="accountService")和private AccountService accountService;默认按名称进行装配,名称可以通过name属性进行指定,如果没有指定name属性,当注解写在字段上时,默认取字段名进行安装名称查找,如果注解写在setter方法上默认取属性名进行装配。当找不到与名称匹配的bean时才按照类型进行装配。但是需要注意的是,如果name属性一旦指定,就只会按照名称进行装配。 @Resource注解在字段上,这样就不用写setter方法了,并且这个注解是属于J2EE的,减少了与spring的耦合。
package com.zzh.demo1;
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;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class SpringTest {
@Resource(name="accountService")
private AccountService accountService;
@Test
public void demo1(){
accountService.transfer("aaa", "bbb", 200d);
}
}
我们让aaa向bbb转账200,查看结果转账成功。
此时如果我们故意在业务层实现类转账过程当中制造异常,如下所示:
查看结果:
可以看到aaa账户的钱减少了,而bbb账户的钱没有增加。因为现在还没有进行事务管理,所以出现了转出执行了,而转入没有执行这样的情况。而我们所希望的是转入与转出能够同时成功或者同时失败,这时我们就需要进行相应的事务管理了。
编程式事务管理
PlatformTransactionManager接口
这个接口具体的实现类主要有用SpringJdbc或者Mybatis进行管理的类DataSourceTransactionManager,用Hibernate来进行事务管理的类HibernateTransactionManager配置SpringJdbc事务管理器
将dataSource连接池注入管理器中,这时因为jdbc进行管理时需要获得连接对象,然后用connection.setAutoCommit(false)使其不自动提交,执行完后要conmmit,有异常的话要rollback。能获取这个连接的就是dataSource连接池,而DataSourceTransactionManager事务管理器是真正进行事务管理的类,而连接池又能获取到连接对象,所以要将其注入。
<!-- 配置SpringJdbc的事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>
配置事务管理模板
如果直接用事务管理器来管理的话,代码会很繁琐,Spring为了简化事务管理的代码,提供了一个事务管理模板类org.springframework.transaction.support.TransactionTemplate。而真正进行事务管理的还是transactionManager,所以要将其注入事务管理模板中。
<!-- 配置事务管理模板 -->
<bean id = "transactionTemplat" class="org.springframework.transaction.support.TransactionTemplate">
<property name="transactionManager" ref="transactionManager"/>
</bean>
业务层实现类中注入事务管理模板
在编程式事务管理中,需要我们在使用事务的时候,手动的编写代码。也就是哪个类需要进行事务管理,就将模板注入其中。
//注入事务管理模板
private TransactionTemplate transactionTemplate;
public void setTransactionTemplate(TransactionTemplate transactionTemplate) {
this.transactionTemplate = transactionTemplate;
}
然后在配置文件中业务层类里注入模板Bean
<bean id="accountService" class="com.zzh.demo1.AccountServiceImpl">
<property name="accountDao" ref="accountDao"/>
<!-- 注入事务管理模板 -->
<property name="transactionTemplate" ref="transactionTemplate"/>
</bean>
* 利用模板进行转账
业务类的 transfer方法中的转入和转出此时存在于一个事务中,需要我们用模板的execute方法传入TransactionCallback接口,这里我选择new 一个匿名内部类TransactionCallbackWithoutResult。这个匿名内部类里的一个方法叫做doInTransactionWithoutResult,在里面进行事务的相关操作。
这里要有为注意我划红线的部分,在JDK 1.8以下的版本会报错,也就是必须在方法的局部变量前加上final关键字:
这是因为**匿名内部类访问外部的局部变量时该变量必须是final,加上final之后会导致局部变量提升为一种隐式的成员变量,而在匿名类中需要传递进来final关键字,java希望的是保证内部实现和外在表现的一致性**,正因如此,我内部类 操作事务时使用了外部类的out,in和money局部变量,所以必须要加。
而我使用的是JDK 1.8却没有final也没报错是因为**java8中已经没有匿名内部类和局部内部类只能访问final变量的限制了**。
测试结果
先将金额都改为1000,然后转账,事务回滚了。也就是达到了一个事务里的操作同时成功或者同时失败。
声明式事务管理
在编程式的事务管理中,我们需要手动的去修改业务层的代码,这样对以后的开发是不太友好的。而声明式事务管理是基于AOP技术实现,其主要思想是将事务管理作为一个“切面”代码单独编写,我们只用关心核心业务逻辑代码,然后通过AOP技术将事务管理的“切面”代码织入到业务类中。
基于TransactionProxyFactoryBean的方式
- 配置事务管理器
<?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/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.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 name="jdbcUrl" value="${jdbc.url}"/>
<property name="user" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
</bean>
<!-- 配置业务层 -->
<bean id="accountService" class="com.zzh.demo2.AccountServiceImpl">
<property name="accountDao" ref="accountDao"/>
</bean>
<!-- 配置DAO层,注入连接池就可以得到jdbc模板-->
<bean id="accountDao" class="com.zzh.demo2.AccountDaoImpl">
<property name="dataSource" ref="dataSource"/>
</bean>
<!-- 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>
</beans>
- 配置业务层代理
因为要在业务层上进行事务管理,我们可以产生一个代理类来对业务层的transfer方法进行增强。这个代理类叫做事务代理工厂类,它可以为业务层类产生一个代理对象。其中属性包括目标对象target即为我们需要去代理的类,然后是注入事务管理器进行事务管理,也就是对代理对象进行事务增强。而进行事务管理还需要一些具体的信息比如传播行为和隔离级别等等,所以还需配置transactionAttribute属性,然后再向这个属性中传入参数props,也就是键值对,key代表的是方法,这里只有一个方法transfer,也可以写一个 * 代表类中所有方法。而prop的值可以是PROPAGATION(事务的传播行为),ISOLATIONf(事务的隔离级别) -Exception(发生哪些异常回滚事务) +Exception(发生哪些事务不回滚)。在这里我只配了PROPAGATION_REQUIRED,这个传播行为代表业务层方法中的转入转出调用的时候,是处在一个事务之中。
<!-- 配置业务层代理 -->
<bean id="accountServiceProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
<!-- 配置目标对象 -->
<property name="target" ref="accountService"/>
<!-- 注入事务管理器 -->
<property name="transactionManager" ref="transactionManager"/>
<!-- 注入事务的属性 -->
<property name="transactionAttributes">
<props>
<prop key="transfer">PROPAGATION_REQUIRED</prop>
</props>
</property>
</bean>
业务层
采取了AOP思想,业务层就不再需要配置多余的代码了。
package com.zzh.demo2;
public class AccountServiceImpl implements AccountService {
//注入DAO类
private AccountDao accountDao;
public void setAccountDao(AccountDao accountDao) {
this.accountDao = accountDao;
}
@Override
public void transfer( String out, String in, Double money) {
accountDao.outMoney(out, money);
int i = 1/0;
accountDao.inMoney(in, money);
}
}
向测试类中注入代理类
在编程式事务管理中, @ Resource是业务类,而现在业务类是没有被增强过的类,所以要替换为业务类增强后的代理类即 @Resource(name="accountServiceProxy")。
package com.zzh.demo2;
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;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext2.xml")
public class SpringDemo2 {
/**
* 注入代理类
*/
@Resource(name="accountServiceProxy")
private AccountService accountService;
@Test
public void demo(){
accountService.transfer("aaa", "bbb", 200d);
}
}
- 测试
当没有异常时进行转账:
当设置异常之后,钱数没有发生改变,事务回滚了:
- 添加readOnly之后
当设置为只读后,就不允许进行修改了
基于AspectJ的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: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/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.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 name="jdbcUrl" value="${jdbc.url}"/>
<property name="user" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
</bean>
<!-- 配置业务层 -->
<bean id="accountService" class="com.zzh.demo3.AccountServiceImpl">
<property name="accountDao" ref="accountDao"/>
</bean>
<!-- 配置DAO层,注入连接池就可以得到jdbc模板-->
<bean id="accountDao" class="com.zzh.demo3.AccountDaoImpl">
<property name="dataSource" ref="dataSource"/>
</bean>
<!-- 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>
</beans>
- 配置事务的通知
需要有事务的管理器,事务相关的属性,属性里面的method即为哪些方法要来执行你的事务,跟这个方法相关的还有相应的事务传播行为和隔离级别等等。
<!-- 配置事务的增强 -->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="transfer" propagation="REQUIRED"/>
</tx:attributes>
</tx:advice>
- 配置切面
在切点当中的表达式第一个 * 代表方法的返回值,AccountService后的+代表他的子类,最后的 * (..)代表任意的方法和参数。切面则由切点和增强构成,即在这个切点上运用这个增强。代表切面的标签有两个,一个是 代表多个切入点和多个通知,另一个是 代表一个切入点和一个通知,这个例题里只有一个增强“txAdvice”,所以就使用了asvisor标签。
<!-- 配置切面 -->
<aop:config>
<!-- 配置切点 -->
<aop:pointcut expression="execution(* com.zzh.demo3.AccountService+.*(..))" id="pointcut1"/>
<!-- 配置切面 -->
<aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut1"/>
</aop:config>
- aop自动代理
我划线的部分不再需要修改,因为这种基于AspectJ的方式是属于自动代理,也就是在XML中没有显式配置 不代表不使用自动代理,这条配置默认属性为“false”,表示只代理接口(JDK动态代理),所以如果只想代理接口,可以不用显式写出。也就是说现在的 这个类在生成的时候就是一个代理对象了,所以 @Resource(name="accountService")已经是被增强过了。如果还对自动代理不清楚,请看我另一篇文章: [Spring之AOP由浅入深](http://www.cnblogs.com/zhaozihan/p/5953063.html)
- 测试
事务发生了回滚
基于注解配置声明式事务
- 配置事务管理器
<?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/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.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 name="jdbcUrl" value="${jdbc.url}"/>
<property name="user" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
</bean>
<!-- 配置业务层 -->
<bean id="accountService" class="com.zzh.demo4.AccountServiceImpl">
<property name="accountDao" ref="accountDao"/>
</bean>
<!-- 配置DAO层,注入连接池就可以得到jdbc模板-->
<bean id="accountDao" class="com.zzh.demo4.AccountDaoImpl">
<property name="dataSource" ref="dataSource"/>
</bean>
<!-- 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>
</beans>
- 开启注解事务
<tx:annotation-driven transaction-manager="transactionManager"/>
哪个类需要使用事务管理,就在那个类头加上 @Transactional注解即可。
package com.zzh.demo4;
import org.springframework.transaction.annotation.Transactional;
@Transactional
public class AccountServiceImpl implements AccountService {
//注入DAO类
private AccountDao accountDao;
public void setAccountDao(AccountDao accountDao) {
this.accountDao = accountDao;
}
@Override
public void transfer( String out, String in, Double money) {
accountDao.outMoney(out, money);
int i = 1/0;
accountDao.inMoney(in, money);
}
}
- @Transactional 注解中的属性
直接在注解后面即可添加相应的传播行为,隔离级别等等
@Transactional(propagation=Propagation.REQUIRED,isolation=Isolation.DEFAULT)
- 测试结果
事务发生了回滚
Github地址:案例源码
Spring 事务管理案例的更多相关文章
- spring事务管理方式,aop
达内12 note unit 09 01 1.spring事务管理 2.spring提供了对事务管理支持 spring采用aop机制完成事务控制 可以实现在不修改原有组件代码情况下实现事务控制功能. ...
- Spring事务管理的四种方式(以银行转账为例)
Spring事务管理的四种方式(以银行转账为例) 一.事务的作用 将若干的数据库操作作为一个整体控制,一起成功或一起失败. 原子性:指事务是一个不可分割的工作单位,事务中的操作要么都发生,要么都不 ...
- Spring事务管理的demo
事务是逻辑上的一组操作,这组操作要么全部成功,要么全部失败,最为典型的就是银行转账的案例: A要向B转账,现在A,B各自账户中有1000元,A要给B转200元,那么这个转账就必须保证是一个事务,防止中 ...
- SSM(spring mvc+spring+mybatis)学习路径——1-2、spring事务管理
目录 1-2 Spring事务管理 概念介绍 事务回顾 事务的API介绍 Spring 事务管理 转账案例 编程式事务管理 声明式事务管理 使用XML配置声明式事务 基于tx/aop 使用注解配置声明 ...
- 【Java EE 学习 52】【Spring学习第四天】【Spring与JDBC】【JdbcTemplate创建的三种方式】【Spring事务管理】【事务中使用dbutils则回滚失败!!!??】
一.JDBC编程特点 静态代码+动态变量=JDBC编程. 静态代码:比如所有的数据库连接池 都实现了DataSource接口,都实现了Connection接口. 动态变量:用户名.密码.连接的数据库. ...
- spring事务管理器设计思想(二)
上文见<spring事务管理器设计思想(一)> 对于第二个问题,涉及到事务的传播级别,定义如下: PROPAGATION_REQUIRED-- 如果当前没有事务,就新建一个事务.这是最常见 ...
- spring事务管理器设计思想(一)
在最近做的一个项目里面,涉及到多数据源的操作,比较特殊的是,这多个数据库的表结构完全相同,由于我们使用的ibatis框架作为持久化层,为了防止每一个数据源都配置一套规则,所以重新实现了数据源,根据线程 ...
- 事务管理(下) 配置spring事务管理的几种方式(声明式事务)
配置spring事务管理的几种方式(声明式事务) 概要: Spring对编程式事务的支持与EJB有很大的区别.不像EJB和Java事务API(Java Transaction API, JTA)耦合在 ...
- Spring事务管理器的应对
Spring抽象的DAO体系兼容多种数据访问技术,它们各有特色,各有千秋.像Hibernate是非常优秀的ORM实现方案,但对底层SQL的控制不太方便:而iBatis则通过模板化技术让你方便地控制SQ ...
随机推荐
- 记一次 在 HP zbook G3 笔记本上安装Ubuntu16.04LTS 的 心(填)路(坑)旅程
背景 同事MM申请的新笔记本暂时没有用,问我需不需要用. 本着 “宇宙都是xx的”(厚颜无耻~~)思想就接受了. 拿到本本一看,HP zbook G3, 配置还不错(500G SSD, 16G mem ...
- JavaScript常见集合操作
JavaScript常见集合操作 集合的遍历 FOR循环(效率最高) 优点:JavaScript最普遍的for循环,执行效率最高 缺点:无法遍历对象 for(let i=0;i<array.le ...
- Oracle数据库物理结构
Oracle数据库物理结构 oracle的数据,实际上是以文件的形式来保存的,文件中出了保存用户的数据之外,还需要保存管理数据和日志数据等等.作为一个DBA,必须需要知道自己的数据分别保存在什么位置上 ...
- Linux nohup和&的功效
nohup和&究竟有啥区别?不少同学进行了回复,但并不是所有同学都理解得全对,今天把自己挖的坑自己填了. 测试代码如下: 是一个输出hello与循环轮数的死循环程序,每输出一行就休眠1秒. 使 ...
- Python Web框架——Flask
简介 Flask是一个基于Python开发并且依赖jinja2模板和Werkzeug WSGI服务的一个微型框架,对于Werkzeug本质是Socket服务端,其用于接收http请求并对请求进行预处理 ...
- python 爬预警没解析前的
- 使用打印方法时,要先引用命名空间: Using System.Drawing.Pringing
使用打印方法时,要先引用命名空间: Using System.Drawing.Pringing PrintDocument类的重要属性和方法:属性:DocumentName 设置打印文档时要显示的文 ...
- Sqlserver2012的数据导入到sqlserver2008或sqlserver2008R2
我采取的是sql语句的方式 将Sqlserver2012的表结构导出成sql语句,数据也导出成sql语句 一.点击数据库名称右键=========>属性 二.导出表结构与数据为sql语句 htt ...
- JSP中的<jsp:include...>和<%@include %>
jsp中include有两种写法, 都是包含一个页面或者一个文件的意思, 写法略有不同 <jsp:include page = "url" />或者<jsp:in ...
- Debian Mount nfs 出错的解决
系统未安装 nfs 客户端 #aptitude install nfs-common 解决!