Spring v4.2框架–事务&JDBC模板
1.Spring的AOP注解开发（基于AspectJ）
1）小试牛刀
-
a.导入spring的基本开发包
-
-
b.导入aop的jar包
-
-
c.引入配置文件
-
- log4j的配置文件：log4j.properties
-
-
### direct log messages to stdout ### log4j.appender.stdout=org.apache.log4j.ConsoleAppender log4j.appender.stdout.Target=System.err log4j.appender.stdout.layout=org.apache.log4j.PatternLayout log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n ### direct messages to file mylog.log ### log4j.appender.file=org.apache.log4j.FileAppender log4j.appender.file.File=c\:mylog.log log4j.appender.file.layout=org.apache.log4j.PatternLayout log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n ### set log levels - for more verbose logging change 'info' to 'debug' ### # error warn info debug trace log4j.rootLogger= info, stdout
-
-
-
spring的配置文件：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: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"> </beans>
-
-
d.编写目标类（被增强的对象）
-
package com.nike.spring.demo1; public class OrderDao { public void save(){ System.out.println("保存订单。。。"); } public void update(){ System.out.println("修改订单。。。"); } public void delete(){ System.out.println("删除订单。。。"); } public void find(){ System.out.println("查找订单。。。"); } } -
-
把目标类交给spring管理
-
<!-- 配置目标类 --> <bean id="orderDao" class="com.nike.spring.demo1.OrderDao" />
-
-
e.编写切面类并配置
-
-
package com.nike.spring.demo1; /** * 使用注解开发切面类 * @author 猪猪 * */ public class MyAspectAnno { public void before(){ System.out.println("前置通知。。。"); } public void after(){ System.out.println("后置通知。。。"); } } -
<!-- 配置切面类 --> <bean id="myAspectAnno" class="com.nike.spring.demo1.MyAspectAnno"/>
-
-
f.使用注解的AOP对目标类进行增强
-
-
在配置文件打开注解的AOP开发
-
<!-- 在配置文件打开注解的AOP开发 --> <aop:aspectj-autoproxy/> -
在切面类上使用注解
-
package com.nike.spring.demo1; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Before; /** * 使用注解开发切面类 * @author 猪猪 * */ @Aspect //告知spring这是一个切面类 public class MyAspectAnno { @Before(value="execution(* com.nike.spring.demo1.OrderDao.save(..))") public void before(){ System.out.println("前置通知。。。"); } public void after(){ System.out.println("后置通知。。。"); } }
-
-
g.编写测试类
-
-
引入spring的junit测试架包：spring-test-4.2.4.RELEASE.jar
-
package com.nike.spring.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; /** * Spring的AOP注解开发 * @author 猪猪 * */ @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration("classpath:applicationContext.xml") public class SpringDemo1 { @Resource(name="orderDao") private OrderDao dao; @Test public void demo01(){ dao.save(); dao.find(); dao.update(); dao.delete(); } }
-
2）AOP注解的通知类型
-
@Before：前置通知
-
@AfterReturning：后置增强
-
-
@AfterReturning("execution(* com.nike.spring.demo1.OrderDao.delete(..))") public void afterReturning(){ System.out.println("后置通知。。。"); }
/** * 有返回值的后置增强 */ @AfterReturning(value="execution(* com.nike.spring.demo1.OrderDao.delete(..))",returning="result") public void afterReturning(Object result){ System.out.println("后置通知。。。"+result); } -
-
@Around：环绕增强
-
-
@Around(value="execution(* com.nike.spring.demo1.OrderDao.update(..))") public Object around(ProceedingJoinPoint point) throws Throwable{ System.out.println("环绕前。。。。。。"); Object proceed = point.proceed(); System.out.println("环绕后。。。。。。"); return proceed; }
-
-
@AfterThrowing：异常抛出通知
-
-
@AfterThrowing(value="execution(* com.nike.spring.demo1.OrderDao.find(..))") public void afterThrowing(){ System.out.println("异常抛出增强。。。。。"); } -
可以获取异常信息
-
@AfterThrowing(value="execution(* com.nike.spring.demo1.OrderDao.find(..))",throwing="ex") public void afterThrowing(Throwable ex){ System.out.println("异常抛出增强。。。。。"+ex.getMessage()); }
-
-
@After：最终增强
-
-
@After(value="execution(* com.nike.spring.demo1.OrderDao.find(..))") public void after(){ System.out.println("最终增强。。。。。。。"); }
-
3）AOP注解中的切入点注解
package com.nike.spring.demo1;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
/**
* 使用注解开发切面类
* @author 猪猪
*
*/
@Aspect //告知spring这是一个切面类
public class MyAspectAnno {
@Before(value="MyAspectAnno.pointcut2()")
public void before(){
System.out.println("前置通知。。。");
}
/**
* 有返回值的后置增强
*/
@AfterReturning(value="MyAspectAnno.pointcut4()",returning="result")
public void afterReturning(Object result){
System.out.println("后置通知。。。"+result);
}
@Around(value="MyAspectAnno.pointcut3()")
public Object around(ProceedingJoinPoint point) throws Throwable{
System.out.println("环绕前。。。。。。");
Object proceed = point.proceed();
System.out.println("环绕后。。。。。。");
return proceed;
}
@AfterThrowing(value="MyAspectAnno.pointcut1()",throwing="ex")
public void afterThrowing(Throwable ex){
System.out.println("异常抛出增强。。。。。"+ex.getMessage());
}
@After(value="MyAspectAnno.pointcut1()")
public void after(){
System.out.println("最终增强。。。。。。。");
}
//切入点注解
@Pointcut(value="execution(* com.nike.spring.demo1.OrderDao.find(..))")
private void pointcut1(){}
@Pointcut(value="execution(* com.nike.spring.demo1.OrderDao.save(..))")
private void pointcut2(){}
@Pointcut(value="execution(* com.nike.spring.demo1.OrderDao.update(..))")
private void pointcut3(){}
@Pointcut(value="execution(* com.nike.spring.demo1.OrderDao.delete(..))")
private void pointcut4(){}
}
2.Spring的JDBC模板的使用
Spring对持久层页提供了解决方案：ORM模块和JdbcTemplate
Spring提供了很多持久层的模板简化编程：
| ORM持久化技术 | 模板类 |
|---|---|
| JDBC | org.springframework.jdbc.core.JdbcTemplate |
| Hibernate3.0 | org.springframework.orm.hibernate3.HibernateTemplate |
| IBatis(MyBatis) | org.springframework.orm.ibatis.SqlMapClientTemplate |
| JPA | org.springframework.orm.jpa.JpaTemplate |
1）入门程序
-
a.创建项目，引入jar包
-
-
引入基本开发包：6个
-
引入数据库驱动jar包：mysql-connector-java-5.1.7-bin.jar
-
spring的jdbc模板jar包：
-
spring的单元测试的包：spring-test-4.2.4.RELEASE.jar
-
-
-
b.创建数据库和表
-
-
CREATE DATABASE spring4_day03; USE spring4_day03; CREATE TABLE account( id INT PRIMARY KEY AUTO_INCREMENT, NAME VARCHAR(30), money DOUBLE );
-
-
c.向数据库插入数据
-
-
/** * JdbcTemplate的使用类似于DbUtils */ @Test public void demo01(){ //创建数据库连接池 DriverManagerDataSource dataSource = new DriverManagerDataSource(); dataSource.setDriverClassName("com.mysql.jdbc.Driver"); dataSource.setUrl("jdbc:mysql://localhost:3306/spring4_day03"); dataSource.setUsername("root"); dataSource.setPassword("971102"); //创建jdbc模板 JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource); jdbcTemplate.update("insert into account values(null,?,?)", "王彬彬",800000); }
-
-
d.将连接池和JdbcTemplate都交给spring管理
-
-
创建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" 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"> </beans> -
配置spring的内置连接池
-
<!-- 配置spring的内置连接池 --> <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"> <!-- 属性注入 --> <property name="driverClassName" value="com.mysql.jdbc.Driver"/> <property name="url" value="jdbc:mysql://localhost:3306/spring4_day03"/> <property name="username" value="root"/> <property name="password" value="971102"/> </bean> <!-- 配置JdbcTemplate --> <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"> <property name="dataSource" ref="dataSource"/> </bean> -
编写测试类
-
package com.nike.spring.jdbc.demo1; import javax.annotation.Resource; import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.jdbc.core.JdbcTemplate; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration("classpath:applicationContext.xml") public class JdbcDemo2 { @Resource(name="jdbcTemplate") private JdbcTemplate template; @Test public void demo01(){ template.update("insert into account values(null,?,?)", "李世民",465451); } }
-
-
使用DBCP连接池
-
-
导入DBCP的jar包
-
-
配置DBCP连接池
-
<!-- 配置DBCP连接池 --> <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"> <!-- 注入属性 --> <property name="driverClassName" value="com.mysql.jdbc.Driver"/> <property name="url" value="jdbc:mysql://localhost:3306/spring4_day03"/> <property name="username" value="root"/> <property name="password" value="971102"/> </bean> <!-- 配置JdbcTemplate --> <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"> <property name="dataSource" ref="dataSource"/> </bean> -
编写测试类
-
@Test public void demo02(){ template.update("insert into account values(null,?,?)", "薛平贵",154451); }
-
-
使用C3P0数据库连接池
-
-
导入C3P0的jar包
-
com.springsource.com.mchange.v2.c3p0-0.9.1.2.jar
-
配置C3P0连接池
-
<!-- 配置C3P0连接池 --> <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"> <!-- 属性注入 --> <property name="driverClass" value="com.mysql.jdbc.Driver"/> <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/spring4_day03"/> <property name="user" value="root"/> <property name="password" value="971102"/> </bean> <!-- 配置JdbcTemplate --> <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"> <property name="dataSource" ref="dataSource"/> </bean> -
引入外部属性文件jdbc.properties
-
jdbc.driverClass=com.mysql.jdbc.Driver jdbc.jdbcUrl=jdbc:mysql://localhost:3306/spring4_day03 jdbc.user=root jdbc.password=971102 -
在配置文件中引入配置文件：2种方式
-
第一种：通过一个bean标签引入（很少使用）
-
<!-- 引入属性文件 --> <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"> <property name="location" value="classpath:jdbc.properties"/> </bean> -
第二种：通过context标签引入属性文件
-
<context:property-placeholder location="classpath:jdbc.properties"/> -
属性文件的使用
-
<!-- 配置C3P0连接池 --> <!-- 引入属性文件 --> <context:property-placeholder location="classpath:jdbc.properties"/> <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"> <!-- 属性注入 --> <property name="driverClass" value="${jdbc.driverClass}"/> <property name="jdbcUrl" value="${jdbc.jdbcUrl}"/> <property name="user" value="${jdbc.user}"/> <property name="password" value="${jdbc.password}"/> </bean> <!-- 配置JdbcTemplate --> <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"> <property name="dataSource" ref="dataSource"/> </bean> -
模板的crud操作
-
package com.nike.spring.demo1; import java.sql.ResultSet; import java.sql.SQLException; import java.util.List; import javax.annotation.Resource; import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.jdbc.core.JdbcTemplate; import org.springframework.jdbc.core.RowMapper; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; import com.nike.spring.domain.Account; @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration("classpath:applicationContext.xml") public class JdbcDemo2 { @Resource(name="jdbcTemplate") private JdbcTemplate template; //增 @Test public void demo01(){ template.update("insert into account values(null,?,?)", "猪八戒",54451); } //改 @Test public void demo02(){ template.update("update account set money=? where id=?",100,1); } //删 @Test public void demo03(){ template.update("delete from account where id=?",5); } //查询单个用户单个字段值 @Test public void demo04(){ String name = template.queryForObject("select name from account where id=?",String.class,4); System.out.println(name); } //统计个数 @Test public void demo05(){ Long num = template.queryForObject("select count(1) from account",Long.class); System.out.println(num); } @Test //查询单个对象 public void demo06(){ Account user = template.queryForObject("select id,name,money from account where id=?",new RowMapper<Account>(){ @Override public Account mapRow(ResultSet rs, int rowNum) throws SQLException { Account user = new Account(); user.setId(rs.getInt("id")); user.setName(rs.getString("name")); user.setMoney(rs.getDouble("money")); return user; }} ,2); System.out.println(user); } @Test //查询多个用户 public void demo07(){ List<Account> query = template.query("select * from account",new RowMapper<Account>(){ @Override public Account mapRow(ResultSet rs, int arg1) throws SQLException { Account user = new Account(); user.setId(rs.getInt("id")); user.setName(rs.getString("name")); user.setMoney(rs.getDouble("money")); return user; } }); System.out.println(query); } }
-
3.Spring的事务管理
a.事务
- 事务的概念
-
- 逻辑上的一组操作，组成这组操作的各个单元，要么全都成功，要么全都失败；
- 事务的特性
-
- 原子性：事务不可分割
- 一致性：事务执行前后数据的完整性要保持一致
- 隔离性：一个事务的执行不应该受到其他事务的干扰
- 持久性：一个事务结束，数据就持久化到数据库
- 如果不考虑事务的隔离性，就会引发安全性问题
-
- 读问题
-
- 脏读：一个事务读到另一个事务未提交的数据
- 幻读：一个事务读到另一个事务已经提交的insert的数据，导致一个事务中的多次查询结果不一致
- 不可重复读：一个事务读到另一个事务已经提交的update的数据，导致一个事务中的多次查询结果不一致
- 解决读问题（设置事务的隔离级别）
-
- Read uncommitted(读未提交)：不能解决任何读问题，会引发脏读问题
- Read committed(读已提交)：可解决脏读问题
- Repeatable read(可重复读)：可解决脏读，不可重复读问题
- Serializable(可串行化)：可解决所有读问题，不允许事务并发
- 写问题
-
- 丢失更新
b.spring提供了两大类的事务管理方式（编程式事务，声明式事务）
- 事务管理API
-
- PlatformTransactionManager：平台事务管理器
-
- 接口，spring用于管理事务的真正的对象，已知实现类有：DataSourceTransactionManager，HibernateTransactionManager；
- TransactionDefinition：事务定义信息
-
- 用于定义事务相关信息，比如隔离级别，超时信息，传播行为，是否只读。
- TransactionStatus：事务状态
-
- 用于记录在事务管理过程中事务的状态的对象
- 事务管理API的关系：
-
- spring进行事务管理的时候，首先平台事务管理器会根据事务定义信息来进行事务管理，在事务管理过程中，就会产生各种状态，将这些状态的信息记录到事务状态的对象中
- 事务的传播行为：spring中提供了7种事务传播行为
- 如果遇到特别复杂的业务逻辑，有可能出现业务层之间的方法相互调用。
- 事务的传播行为主要用来解决业务层方法相互调用的问题。
- 7种传播行为分成3类：
-
- 保证多个操作在同一个事务中
-
- PROPAGATION_REQUIRED:Ⓜ️默认值，如果A中有事务，使用A中的事务，如果A中没有事务，创建一个新的事务，将操作包含到事务中。
- PROPAGATION_SUPPORTS：支持事务，如果A中有事务，就使用A中的事务，如果A中没有事务，就不使用事务。
- PROPAGATION_MANDATORY：如果A中有事务，就是用A中的事务，如果A中没有事务，抛出异常，不执行。
- 保证多个操作不在同一个事务中
-
- PROPAGATION_REQUIRES_NEW：如果A中有事务，就会将A中的事务挂起，创建新的事务，只包含自身的操作，如果A中没有事务，创建一个新事务，包含自身的操作。
- PROPAGATION_NOT_SUPPORTED：如果A中有事务，就会将A中的事务挂起。不使用事务管理。
- PROPAGATION_NEVER：如果A中有事务，直接报异常。
- 嵌套式事务
-
- PROPAGATION_NESTED：如果A中有事务，按照A的事务执行，执行完成后，设置一个保存点，执行B中的操作，如果没有异常，则执行通过，如果有异常，可以选择回滚到最初始的位置，也可以回滚到保存点。
c.转账环境的搭建
-
创建了业务层的接口和实现类
-
创建了dao层的接口和实现类
-
配置service和dao，交给spring管理
-
在DAO中编写账户转入转出的方法
-
<!-- 配置service --> <bean id="accountService" class="com.nike.tx.demo1.AccountServiceImpl"> <property name="accountDao" ref="accountDao"></property> </bean> <!-- 配置dao --> <bean id="accountDao" class="com.nike.tx.demo1.AccountDaoImpl"> <property name="dataSource" ref="dataSource"/> </bean> <!-- 配置连接池和jdbc模板 --> <!-- 配置C3P0连接池 --> <!-- 引入属性文件 --> <context:property-placeholder location="classpath:jdbc.properties"/> <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"> <!-- 属性注入 --> <property name="driverClass" value="${jdbc.driverClass}"/> <property name="jdbcUrl" value="${jdbc.jdbcUrl}"/> <property name="user" value="${jdbc.user}"/> <property name="password" value="${jdbc.password}"/> </bean>
package com.nike.tx.demo1;
import org.springframework.jdbc.core.support.JdbcDaoSupport;
public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao {
@Override
public void outMoney(String from, Double money) {
this.getJdbcTemplate().update("update account set money=money-? where name=?",money,from);
}
@Override
public void inMoney(String to, Double money) {
this.getJdbcTemplate().update("update account set money=money+? where name=?",money,to);
}
}
package com.nike.tx.demo1;
/**
* 转账Dao接口
* @author 猪猪
*/
public interface AccountDao {
/**
* 账户转出
* @param from 转出账户
* @param money 转账金额
*/
void outMoney(String from,Double money);
/**
* 账户转入
* @param to 转入账户
* @param money 转账金额
*/
void inMoney(String to,Double money);
}
package com.nike.tx.demo1;
public class AccountServiceImpl implements AccountService{
//注入Dao
private AccountDao accountDao;
public void setAccountDao(AccountDao accountDao) {
this.accountDao = accountDao;
}
@Override
public void transfer(String from, String to, Double money) {
accountDao.outMoney(from, money);
accountDao.inMoney(to, money);
}
}
package com.nike.tx.demo1;
/**
* 转账的业务层接口
* @author 猪猪
*/
public interface AccountService {
/**
* 转账的方法
* @param from 转出账号
* @param to 转入账号
* @param money 转账金额
*/
void transfer(String from,String to,Double money);
}
d.进行测试
编程式事务管理
（1）配置平台事务管理器
<!-- 配置平台事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"></property>
</bean>
（2）spring提供了事务的模板类
配置事务的管理的模板类
<!-- 配置事务管理的模板 -->
<bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">
<property name="transactionManager" ref="transactionManager"></property>
</bean>
（3）在业务层注入事务的管理模板
<!-- 配置service -->
<bean id="accountService" class="com.nike.tx.demo1.AccountServiceImpl">
<property name="accountDao" ref="accountDao"/>
<!-- 注入事务管理的模板 -->
<property name="template" ref="transactionTemplate"/>
</bean>
（4）编写事务管理的代码
package com.nike.tx.demo1;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.TransactionCallbackWithoutResult;
import org.springframework.transaction.support.TransactionTemplate;
public class AccountServiceImpl implements AccountService{
//注入事务管理的模板
private TransactionTemplate template;
//注入Dao
private AccountDao accountDao;
public void setTemplate(TransactionTemplate template) {
this.template = template;
}
public void setAccountDao(AccountDao accountDao) {
this.accountDao = accountDao;
}
@Override
public void transfer(String from, String to, Double money) {
template.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus arg0) {
accountDao.outMoney(from, money);
int i = 1/0;
accountDao.inMoney(to, money);
}
});
}
}
e.声明式事务–AOP
-
声明式事务xml
-
- 引入AOP开发包
- 回复转账环境
- 配置声明式事务
-
声明式事务注解
-
<!-- 配置平台事务管理器 --> <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <property name="dataSource" ref="dataSource"></property> </bean> -
配置增强（切面）
-
<!-- 配置事务的增强 --> <tx:advice transaction-manager="transactionManager"> <tx:attributes> <!-- 事务管理规则 --> <tx:method name="transfer" propagation="REQUIRED"/> </tx:attributes> </tx:advice> -
AOP配置把增强应用到类上
-
<!-- AOP的配置 --> <aop:config> <aop:pointcut expression="execution(* com.nike.tx.demo2.AccountServiceImpl.*(..))" id="pc1"/> <aop:advisor advice-ref="txAdvice" pointcut-ref="pc1"/> </aop:config>
声明式事务–注解
<!-- 配置平台事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"></property>
</bean>
开启注解事务
<!-- 开启注解事务 -->
<tx:annotation-driven transaction-manager="transactionManager"/>
在业务层上添加事务管理
@Transactional
public class AccountServiceImpl implements AccountService{
996
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
