专栏首页AlbertYang的编程之路Spring第三天:Spring的AOP的注解开发、Spring的声明式事务、JdbcTemplate

Spring第三天:Spring的AOP的注解开发、Spring的声明式事务、JdbcTemplate

1.Spring的AOP基于AspectJ的注解开发

1.1Spring基于ApsectJ的注解的AOP开发

1.1.1创建项目,引入jar包

1.1.2引入配置文件

1.1.3编写目标类并配置

目标类:

packagecom.albertyy.demo1;
/**  
*   
* 项目名称:SpringDay03_AOP  
* 类名称:OrderDao  
* 类描述:  
* 创建人:yangyangyang 
* 创建时间:2018年12月7日 下午2:58:44  
* 修改人:yangyangyang 
* 修改时间:2018年12月7日 下午2:58:44  
* 修改备注:  
* @version 
*   
*/
publicclass OrderDao{
 publicvoid save(){
         System.out.println("保存订单...");
     }
 publicvoid update(){
         System.out.println("修改订单...");
     }
 public Stringdelete(){
         System.out.println("删除订单...");
 return"李君莫";
     }
 publicvoid find(){
         System.out.println("查询订单...");
//       intd = 1/0;
     }
}

在配置文件配置中配置目标类:

<!-- 配置目标类 -->
 <bean id="orderDao" class="com.albertyy.demo1.OrderDao">
 </bean>

1.1.4编写切面类并配置

public class MyAspectAnno{
     public void before(){
         System.out.println("前置增强.....");
     }
}    
<!-- 配置切面类-->
 <bean id="myAspect" class="com.albertyy.demo1.MyAspectAnno">
 </bean>

1.1.5使用注解的AOP对象目标类进行增强

l 在配置文件中打开注解的AOP开发

<!-- 在配置文件中开启注解的AOP的开发 -->
 <aop:aspectj-autoproxy/>
l 在切面类上使用注解
/**  
*   
* 项目名称:SpringDay03_AOP  
* 类名称:MyAspectAnno  
* 类描述:注解的切面类  
* 创建人:yangyangyang 
* 创建时间:2018年12月7日 下午3:00:55  
* 修改人:yangyangyang 
* 修改时间:2018年12月7日 下午3:00:55  
* 修改备注:  
* @version 
*   
*/
@Aspect
publicclassMyAspectAnno {
 @Before(value="execution(*com.albertyy.demo1.OrderDao.save(..))")
 publicvoid before(){
         System.out.println("前置增强.....");
     }
}

1.1.6编写测试类

packagecom.albertyy.demo1;
importjavax.annotation.Resource;
import org.junit.Test;
importorg.junit.runner.RunWith;
importorg.springframework.test.context.ContextConfiguration;
importorg.springframework.test.context.junit4.SpringJUnit4ClassRunner;
/**  
*   
* 项目名称:SpringDay03_AOP  
* 类名称:SpringDemo1  
* 类描述:Spring的AOP的注解开发  
* 创建人:yangyangyang  
* 创建时间:2018年12月7日 下午2:59:42  
* 修改人:yangyangyang  
* 修改时间:2018年12月7日 下午2:59:42  
* 修改备注:  
*@version   
*   
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class SpringDemo1 {
     @Resource(name="orderDao")
     private OrderDao orderDao;
     @Test
     public void demo1(){
         orderDao.save();
         orderDao.update();
         orderDao.delete();
         orderDao.find();
     }
}

1.2Spring的注解的AOP的通知类型

1.2.1@Before :前置通知

@Before(value="execution(*com.albertyy.demo1.OrderDao.save(..))")
 publicvoid before(){
         System.out.println("前置增强.....");
     }

1.2.2@AfterReturning :后置通知

// 后置通知:
 @AfterReturning(value="execution(*com.albertyy.demo1.OrderDao.delete(..))",returning="result")
 publicvoidafterReturning(Object result){
         System.out.println("后置增强....."+result);
     }

1.2.3@Around :环绕通知

// 环绕通知:
 @Around(value="execution(*com.albertyy.demo1.OrderDao.update(..))")
 public Objectaround(ProceedingJoinPoint joinPoint) throwsThrowable{
         System.out.println("环绕前增强.....");
         Objectobj  = joinPoint.proceed();
         System.out.println("环绕后增强.....");
 returnobj;
     }

1.2.4@AfterThrowing :异常抛出通知

// 异常抛出通知:
 @AfterThrowing(value="execution(*com.albertyy.demo1.OrderDao.find(..))",throwing="e")
 publicvoidafterThrowing(Throwable e){
         System.out.println("异常抛出增强....."+e.getMessage());
     }

1.2.5@After :最终通知

// 最终通知
 @After(value="execution(*com.albertyy.demo1.OrderDao.find(..))")
 publicvoid after(){
         System.out.println("最终增强.......");
     }

1.3Spring的注解的AOP的切入点的配置

packagecom.albertyy.demo1;
importorg.aspectj.lang.ProceedingJoinPoint;
importorg.aspectj.lang.annotation.After;
importorg.aspectj.lang.annotation.AfterReturning;
importorg.aspectj.lang.annotation.AfterThrowing;
importorg.aspectj.lang.annotation.Around;
importorg.aspectj.lang.annotation.Aspect;
importorg.aspectj.lang.annotation.Before;
importorg.aspectj.lang.annotation.Pointcut;
/**  
*   
* 项目名称:SpringDay03_AOP  
* 类名称:MyAspectAnno  
* 类描述:注解的切面类  
* 创建人:yangyangyang 
* 创建时间:2018年12月7日 下午3:00:55  
* 修改人:yangyangyang 
* 修改时间:2018年12月7日 下午3:00:55  
* 修改备注:  
* @version 
*   
*/
@Aspect
publicclassMyAspectAnno {
 @Before(value="MyAspectAnno.pointcut2()")
 publicvoid before(){
         System.out.println("前置增强.....");
     }
 // 后置通知:
 @AfterReturning(value="MyAspectAnno.pointcut4()",returning="result")
 publicvoidafterReturning(Object result){
         System.out.println("后置增强....."+result);
     }
 // 环绕通知:
 @Around(value="MyAspectAnno.pointcut3()")
 public Objectaround(ProceedingJoinPoint joinPoint) throwsThrowable{
         System.out.println("环绕前增强.....");
         Objectobj  = joinPoint.proceed();
         System.out.println("环绕后增强.....");
 returnobj;
     }
 // 异常抛出通知:
 @AfterThrowing(value="MyAspectAnno.pointcut1()",throwing="e")
 publicvoidafterThrowing(Throwable e){
         System.out.println("异常抛出增强....."+e.getMessage());
     }
 // 最终通知
 @After(value="MyAspectAnno.pointcut1()")
 publicvoid after(){
         System.out.println("最终增强.......");
     }
 // 切入点注解:
 @Pointcut(value="execution(*com.albertyy.demo1.OrderDao.find(..))")
 privatevoidpointcut1(){}
 @Pointcut(value="execution(*com.albertyy.demo1.OrderDao.save(..))")
 privatevoidpointcut2(){}
 @Pointcut(value="execution(*com.albertyy.demo1.OrderDao.update(..))")
 privatevoidpointcut3(){}
 @Pointcut(value="execution(*com.albertyy.demo1.OrderDao.delete(..))")
 privatevoidpointcut4(){}
}

2.Spring的JDBC的模板的使用

2.1Spring的JDBC的模板

Spring是EE开发的一站式的框架,有EE开发的每层的解决方案。Spring对持久层也提供了解决方案:ORM模块和JDBC的模板

Spring提供了很多的模板用于简化开发:

2.1.1JDBC模板使用的入门

l 创建项目,引入jar包

n 引入基本开发包:

n 数据库驱动

n Spring的JDBC模板的jar包

2.1.2创建数据库和表

create database spring4_day03;
use spring4_day03;
create table account(
    id intprimary key auto_increment,
    namevarchar(20),
    moneydouble
);

2.1.3使用JDBC的模板:保存数据

packagecom.albertyy.jdbc.demo1;
importorg.junit.Test;
importorg.springframework.jdbc.core.JdbcTemplate;
importorg.springframework.jdbc.datasource.DriverManagerDataSource;
/**  
*   
* 项目名称:SpringDay03_JDBC  
* 类名称:JdbcDemo1  
* 类描述:JDBC模板的使用  
* 创建人:yangyangyang 
* 创建时间:2018年12月7日 下午4:13:47  
* 修改人:yangyangyang 
* 修改时间:2018年12月7日 下午4:13:47  
* 修改备注:  
* @version 
*   
*/
publicclass JdbcDemo1{
 @Test
 // jdbc模板的使用类似于Dbutils.
 publicvoid demo1(){
 // 创建连接池:
         DriverManagerDataSourcedataSource = newDriverManagerDataSource();
 dataSource.setDriverClassName("com.mysql.jdbc.Driver");
 dataSource.setUrl("jdbc:mysql:///spring4_day03");
 dataSource.setUsername("root");
 dataSource.setPassword("123456");
 // 创建jdbc模板
         JdbcTemplatejdbcTemplate = newJdbcTemplate();
 jdbcTemplate.setDataSource(dataSource);
 jdbcTemplate.update("insertinto account values (null,?,?)", "君陌",10000d);
     }
}

2.2将连接池和模板交给Spring管理

2.2.1引入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">
 <!-- 配置Spring的内置的连接池======================== -->
 <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
 <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
 <property name="url" value="jdbc:mysql:///spring4_day03"/>
 <property name="username" value="root"/>
 <property name="password" value="123456"/>
 </bean>
 <!-- 配置Spring的JDBC的模板=========================-->
 <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
 <property name="dataSource" ref="dataSource" />
 </bean>
</beans>

2.2.2使用Jdbc的模板

l 引入spring_aop的jar包

packagecom.albertyy.jdbc.demo1;
importjavax.annotation.Resource;
importorg.junit.Test;
importorg.junit.runner.RunWith;
importorg.springframework.jdbc.core.JdbcTemplate;
importorg.springframework.test.context.ContextConfiguration;
importorg.springframework.test.context.junit4.SpringJUnit4ClassRunner;
/**  
*   
* 项目名称:SpringDay03_JDBC  
* 类名称:JdbcDemo2  
* 类描述: 将连接池和模板交给Spring管理 
* 创建人:yangyangyang 
* 创建时间:2018年12月7日 下午4:35:27  
* 修改人:yangyangyang 
* 修改时间:2018年12月7日 下午4:35:27  
* 修改备注:  
* @version 
*   
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
publicclass JdbcDemo2{
 @Resource(name="jdbcTemplate")
 privateJdbcTemplate jdbcTemplate;
 @Test
 // 保存操作
 publicvoid demo1(){
 jdbcTemplate.update("insertinto account values (null,?,?)", "张小花儿",10000d);
     }
}

2.3使用开源的数据库连接池:

2.3.1DBCP的使用

l 引入jar包

l 配置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:///spring4_day03"/>
 <property name="username" value="root"/>
 <property name="password" value="123456"/>
 </bean>
 <!-- 配置Spring的JDBC的模板=========================-->
 <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
 <property name="dataSource" ref="dataSource" />
 </bean>

2.3.2C3P0的使用

l 引入c3p0连接池jar包

l 配置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:///spring4_day03"/>
 <property name="user" value="root"/>
 <property name="password" value="123456"/>
 </bean>
 <!-- 配置Spring的JDBC的模板=========================-->
 <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
 <property name="dataSource" ref="dataSource" />
 </bean>

2.4抽取配置到属性文件

2.4.1定义一个属性文件jdbc.properties

jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql:///spring4_day03
jdbc.username=root
jdbc.password=123456

2.4.2在Spring的配置文件中引入属性文件

l 第一种:

<!-- 第一种方式通过一个bean标签引入的(很少用) -->
<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
 <property name="location" value="classpath:jdbc.properties"/>
</bean>

l 第二种:

<!-- 第二种方式通过context标签引入的 -->
 <context:property-placeholder location="classpath:jdbc.properties"/>

2.4.3引入属性文件的值

<!-- 配置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>

2.4.4测试

@Test
 // 保存操作
 publicvoid demo1(){
 jdbcTemplate.update("insertinto account values (null,?,?)", "十三先生",10000d);
     }

2.5使用JDBC的模板完成CRUD的操作

2.5.1保存操作

@Test
 // 保存操作
 publicvoid demo1(){
 jdbcTemplate.update("insertinto account values (null,?,?)", "陈皮皮",10000d);
     }

2.5.2修改操作

@Test
 // 修改操作
 publicvoid demo2(){
 jdbcTemplate.update("updateaccount set name = ? ,money = ? where id = ?", "叶红鱼",2000d,1);
     }

2.5.3删除操作

@Test
 // 删除操作
 publicvoid demo3(){
 jdbcTemplate.update("deletefrom account where id = ?", 6);
     }

2.5.4查询操作

l 查询某个属性

@Test
 // 查询操作:
 publicvoid demo4(){
         Stringname = jdbcTemplate.queryForObject("selectname from account where id = ?", String.class, 5);
 System.out.println(name);
     }
 @Test
 // 统计查询
 publicvoid demo5(){
         Longcount = jdbcTemplate.queryForObject("selectcount(*) from account", Long.class);
 System.out.println(count);
     }

l 查询返回对象或集合

@Test
 // 封装到一个对象中
 publicvoid demo6(){
         Accountaccount = jdbcTemplate.queryForObject("select* from account where id = ?", newMyRowMapper(), 5);
 System.out.println(account);
     }
 @Test
 // 查询多条记录
 publicvoid demo7(){
         List<Account>list = jdbcTemplate.query("select* from account", newMyRowMapper());
 for (Account account : list) {
 System.out.println(account);
         }
     }

l 数据封装

classMyRowMapper implementsRowMapper<Account>{
 @Override
 public AccountmapRow(ResultSet rs, introwNum) throwsSQLException {
              Accountaccount = newAccount();
 account.setId(rs.getInt("id"));
 account.setName(rs.getString("name"));
 account.setMoney(rs.getDouble("money"));
 returnaccount;
         }
     }

3.Spring的事务管理

3.1事务的基本概念

3.1.1什么事务

l 事务:逻辑上的一组操作,组成这组操作的各个单元,要么全都成功,要么全都失败。

3.1.2事务的特性

l 原子性:事务不可分割.

l 一致性:事务执行前后数据完整性保持一致。

l 隔离性:一个事务的执行不应该受到其他事务的干扰。

l 持久性:一旦事务结束,数据就持久化到数据库。

3.1.3如果不考虑隔离性引发安全性问题

l 读问题

n 脏读 :一个事务读到另一个事务未提交的数据

n 不可重复读 :一个事务读到另一个事务已经提交的update的数据,导致一个事务中多次查询结果不一致

n 虚读、幻读 :一个事务读到另一个事务已经提交的insert的数据,导致一个事务中多次查询结果不一致。

l 写问题

n 丢失更新

3.1.4解决读问题

l 设置事务的隔离级别

n Read uncommitted :未提交读,任何读问题都解决不了。

n Read committed :已提交读,解决脏读,但是不可重复读和虚读有可能发生。

n Repeatable read :重复读,解决脏读和不可重复读,但是虚读有可能发生。

n Serializable :解决所有读问题。

3.2Spring的事务管理的API

3.2.1PlatformTransactionManager:平台事务管理器

l 平台事务管理器:接口,是Spring用于管理事务的真正的对象。

n DataSourceTransactionManager :底层使用JDBC管理事务

n HibernateTransactionManager :底层使用Hibernate管理事务

3.2.2TransactionDefinition :事务定义信息

l 事务定义:用于定义事务的相关的信息,隔离级别、超时信息、传播行为、是否只读

3.2.3TransactionStatus:事务的状态

l 事务状态:用于记录在事务管理过程中,事务的状态的对象。

3.2.4事务管理的API的关系:

Spring进行事务管理的时候,首先平台事务管理器根据事务定义信息进行事务的管理,在事务管理过程中,产生各种状态,将这些状态的信息记录到事务状态的对象中。

3.3Spring的事务的传播行为

l Spring中提供了七种事务的传播行为:

n 保证多个操作在同一个事务中

u PROPAGATION_REQUIRED :默认值,如果A中有事务,使用A中的事务,如果A没有,创建一个新的事务,将操作包含进来。

u PROPAGATION_SUPPORTS :支持事务,如果A中有事务,使用A中的事务。如果A没有事务,不使用事务。

u PROPAGATION_MANDATORY :如果A中有事务,使用A中的事务。如果A没有事务,抛出异常。

n 保证多个操作不在同一个事务中

u PROPAGATION_REQUIRES_NEW :如果A中有事务,将A的事务挂起(暂停),创建新事务,只包含自身操作。如果A中没有事务,创建一个新事务,包含自身操作。

u PROPAGATION_NOT_SUPPORTED :如果A中有事务,将A的事务挂起。不使用事务管理。

u PROPAGATION_NEVER :如果A中有事务,报异常。

n 嵌套式事务

u PROPAGATION_NESTED :嵌套事务,如果A中有事务,按照A的事务执行,执行完成后,设置一个保存点,执行B中的操作,如果没有异常,执行通过,如果有异常,可以选择回滚到最初始位置,也可以回滚到保存点。

3.4Spring的事务管理

l 创建Service的接口和实现类

packagecom.albertyy.tx.demo1;
/**
 * 转账的业务层的实现类
 * @author yxy
 *
 */
publicclassAccountServiceImpl implementsAccountService {
 // 注入DAO:
 privateAccountDao accountDao;
 publicvoidsetAccountDao(AccountDao accountDao) {
 this.accountDao = accountDao;
     }
 @Override
 /**
      * from:转出账号 to:转入账号 money:转账金额
      */
 publicvoid transfer(final String from, final String to, final Double money) {
 accountDao.outMoney(from, money);
 intd = 1 / 0;
 accountDao.inMoney(to, money);
    }
}

l 创建DAO的接口和实现类

packagecom.albertyy.tx.demo1;
importorg.springframework.jdbc.core.support.JdbcDaoSupport;
/**
 * 转账的DAO的实现类
 * @author yxy
 *
 */
publicclass AccountDaoImpl extendsJdbcDaoSupport implementsAccountDao {
 @Override
 publicvoidoutMoney(String from, Double money) {
 this.getJdbcTemplate().update("updateaccount set money = money - ? where name = ?", money,from);
     }
 @Override
 publicvoidinMoney(String to, Double money) {
 this.getJdbcTemplate().update("updateaccount set money = money + ? where name = ?", money ,to);
     }
}

l 配置Service和DAO:交给Spring管理

<!-- 配置Service -->
 <bean id="accountService" class="com.albertyy.tx.demo1.AccountServiceImpl">
 <property name="accountDao" ref="accountDao"/>
 </bean>
 <!-- 配置DAO -->
 <bean id="accountDao" class="com.albertyy.tx.demo1.AccountDaoImpl">
 </bean>

l 在DAO中编写扣钱和加钱方法:

n 配置连接池和JDBC的模板

<!-- 配置连接池和JDBC的模板 -->
 <!-- 第二种方式通过context标签引入的 -->
 <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>

n 在DAO注入Jdbc的模板:

<!-- 配置DAO=================-->
 <bean id="accountDao" class="com.albertyy.tx.demo1.AccountDaoImpl">
 <property name="dataSource" ref="dataSource"/>
</bean>

l 测试

packagecom.albertyy.tx.demo1;
importjavax.annotation.Resource;
importorg.junit.Test;
importorg.junit.runner.RunWith;
importorg.springframework.test.context.ContextConfiguration;
importorg.springframework.test.context.junit4.SpringJUnit4ClassRunner;
/**
 * 测试转账的环境
 * @author yxy
 *
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:tx.xml")
publicclassSpringDemo1 {
 @Resource(name="accountService")
 privateAccountService accountService;
 @Test
 publicvoid demo1(){
 accountService.transfer("张丫丫", "莫山山", 100d);
     }
}

3.5Spring的事务管理:第一类:编程式事务(需要手动编写代码)--了解

3.5.1第一步:配置平台事务管理器

<!-- 配置平台事务管理器=============================-->
 <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
 <property name="dataSource" ref="dataSource"/>
 </bean>

3.5.2第二步:配置事务管理的模板类

l 配置事务的管理的模板类

<!-- 配置事务管理的模板 -->
 <bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">
 <property name="transactionManager" ref="transactionManager"/>
 </bean>

3.5.3第三步:在业务层注入事务管理的模板

 <!-- 配置Service============= -->
 <bean id="accountService" class="com.albertyy.tx.demo1.AccountServiceImpl">
 <property name="accountDao" ref="accountDao"/>
 <!-- 注入事务管理的模板 -->
 <property name="trsactionTemplate" ref="transactionTemplate"></property>
 </bean>

3.5.4编写事务管理的代码

@Override
 /**
      * from:转出账号 to:转入账号 money:转账金额
      */
 publicvoid transfer(final String from, final String to, final Double money) {
 trsactionTemplate.execute(newTransactionCallbackWithoutResult() {
 @Override
 protectedvoiddoInTransactionWithoutResult(TransactionStatus transactionStatus) {
 accountDao.outMoney(from, money);
 intd = 1 / 0;
 accountDao.inMoney(to, money);
              }
         });
     }

3.5.5测试:

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:tx.xml")
publicclassSpringDemo1 {
 @Resource(name="accountService")
 privateAccountService accountService;
 @Test
 publicvoid demo1(){
 accountService.transfer("张丫丫", "莫山山", 100d);
     }
}

3.6Spring的事务管理:第二类:声明式事务管理(通过配置实现)---AOP

3.6.1XML方式的声明式事务管理

l 第一步:引入aop的开发包

l 第二步:恢复没有配置事务的转账环境

l 第三步:配置事务管理器

<!-- 配置事务管理器 -->
 <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
 <property name="dataSource" ref="dataSource"/>
 </bean>

l 第四步:配置增强

 <!-- 配置事务的增强=============================== -->
 <tx:advice id="txAdvice" transaction-manager="transactionManager">
 <tx:attributes>
 <!-- 事务管理的规则 -->
 <!--<tx:method name="save*" propagation="REQUIRED"isolation="DEFAULT"/>
              <tx:methodname="update*" propagation="REQUIRED"/>
              <tx:methodname="delete*" propagation="REQUIRED"/>
              <tx:methodname="find*" read-only="true"/> -->
 <tx:method name="*" propagation="REQUIRED"read-only="false"/>
 </tx:attributes>
 </tx:advice>

l 第五步:AOP的配置

<!-- aop的配置 -->
 <aop:config>
 <aop:pointcut expression="execution(*com.albertyy.tx.demo2.AccountServiceImpl.*(..))" id="pointcut1"/>
 <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut1"/>
 </aop:config>

l 测试

packagecom.albertyy.tx.demo2;
importjavax.annotation.Resource;
importorg.junit.Test;
importorg.junit.runner.RunWith;
importorg.springframework.test.context.ContextConfiguration;
importorg.springframework.test.context.junit4.SpringJUnit4ClassRunner;
/**
 * 测试转账的环境
 * @author yxy
 *
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:tx2.xml")
publicclassSpringDemo1 {
 @Resource(name="accountService")
 privateAccountService accountService;
 @Test
 publicvoid demo1(){
 accountService.transfer("张丫丫", "莫山山", 100d);
     }
}

3.6.2注解方式的声明式事务管理

l 第一步:引入aop的开发包

l 第二步:恢复没有配置事务的转账环境

l 第三步:配置事务管理器

<!-- 配置事务管理器 -->
 <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
 <property name="dataSource" ref="dataSource"/>
 </bean>

l 第四步:开启注解事务

<!-- 开启注解事务 -->
 <tx:annotation-driven transaction-manager="transactionManager"/>

l 第五步:在业务层添加注解

@Transactional
publicclassAccountServiceImpl implementsAccountService {
l 第六步:测试
packagecom.albertyy.tx.demo3;
importjavax.annotation.Resource;
importorg.junit.Test;
importorg.junit.runner.RunWith;
importorg.springframework.test.context.ContextConfiguration;
importorg.springframework.test.context.junit4.SpringJUnit4ClassRunner;
/**
 * 测试转账的环境
 * @author yxy
 *
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:tx3.xml")
publicclassSpringDemo1 {
 @Resource(name="accountService")
 privateAccountService accountService;
 @Test
 publicvoid demo1(){
 accountService.transfer("陈皮皮", "莫山山", 100d);
     }
}

源码:链接: https://pan.baidu.com/s/1dTOhQI8DOy5lKWAiCxnfzg提取码: swbh

本文分享自微信公众号 - AlbertYang(AlbertYang666),作者:AlbertYang

原文出处及转载信息见文内详细说明,如有侵权,请联系 yunjia_community@tencent.com 删除。

原始发表时间:2018-12-07

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • 设计模式(3)[JS版]-JavaScript中的构造函数模式是什么?

    构造函数用于创建特定类型的对象一不仅声明了使用的对象,构造函数还可以接受参数以便第一次创建对象的时候设置对象的成员值。你可以自定义自己的构造函数,然后在里面声明...

    AlbertYang
  • Struts2第四天:Struts2的拦截器和标签库

    n Interceptor:拦截器,拦截是客户端对Action的访问。更细粒度化的拦截。(拦截Action中的具体的方法)。

    AlbertYang
  • JavaScript 进阶教程(1)--面向对象编程

    一本书、一辆汽车、一个人都可以是对象,一个数据库、一张网页、一个与远程服务器的连接也可以是对象。当实物被抽象成对象,实物之间的关系就变成了对象之间的关系,从而就...

    AlbertYang
  • hibernate链接数据库链接池c3p0配置

    <bean id="dataSourceLocal" name="dataSource" class="com.mchange.v2.c3p0.ComboPo...

    xiangzhihong
  • 大神带你 20 分钟学会 Ansible !

    小小科
  • Ansible极简教程

    KangVcar
  • 安静100分钟理解js面向对象

    <!DOCTYPE html> <html> <head> <meta charset="utf-8"> <title></title> </head>...

    前朝楚水
  • 《Python入门09》揭秘python面向对象的编程~

    Python和C++、Java是一样的,它是一种面向对象的计算机语言。在前几章,主要介绍了Python内置的主要对象类型(数、字符串、列表、元组和字典),大致...

    ShuYini
  • 面试官:spring的BeanFatory和FactoryBean区别

    BeanFactory是bean工厂,是 IoC 容器的核心接口,提供了获取bean,或者判断bean类型的各种接口。它的职责包括:实例化、定位、配置应用程序中...

    苏三说技术
  • Python进阶-生产者-消费者

    生产者-消费者问题的实现使用了 Queue 对象,以及随机生产(消费)的商品的数量。生产者和消费者独立并且并发地执行线程。

    小团子

扫码关注云+社区

领取腾讯云代金券