目录
1.AOP简介
1.1什么是AOP
1.2AOP作用
1.3AOP核心概念
@Repository
public class BookDaoImpl implements BookDao {
public void save() {
//记录程序当前执行执行(开始时间)
Long startTime = System.currentTimeMillis();
//业务执行万次
for (int i = 0;i<10000;i++) {
System.out.println("book dao save ...");
}
//记录程序当前执行时间(结束时间)
Long endTime = System.currentTimeMillis();
//计算时间差
Long totalTime = endTime-startTime;
//输出信息
System.out.println("执行万次消耗时间:" + totalTime + "ms");
}
public void update(){
System.out.println("book dao update ...");
}
public void delete(){
System.out.println("book dao delete ...");
}
public void select(){
System.out.println("book dao select ...");
}
}
对于计算万次执行消耗的时间只有 save 方法有,为什么 delete 和 update 方法也会有呢 ?delete 和 update 方法有,那什么 select 方法为什么又没有呢 ?这个案例中其实就使用了 Spring 的 AOP ,在不惊动 ( 改动 ) 原有设计 ( 代码 ) 的前提下,想给谁添加功 能 就给谁添加。这个也就是 Spring 的理念:
AOP实现原理图:
连接点(JoinPoint):程序执行过程中的任意位置,粒度为执行方法、抛出异常、设置变量等在 SpringAOP 中,理解为方法的执行切入点(Pointcut):匹配连接点的式子在 SpringAOP 中,一个切入点可以描述一个具体方法,也可也匹配多个方法一个具体的方法 : 如 com.itheima.dao 包下的 BookDao 接口中的无形参无返回值的 save 方 法匹配多个方法 : 所有的 save 方法,所有的 get 开头的方法,所有以 Dao 结尾的接口中的任意方法,所有带有一个参数的方法连接点范围要比切入点范围大,是切入点的方法也一定是连接点,但是是连接点的方法就不一定要被增强,所以可能不是切入点。通知(Advice):在切入点处执行的操作,也就是共性功能在 SpringAOP 中,功能最终以方法的形式呈现
2.AOP入门案例
2.1需求分析
2.2思路分析
1. 导入坐标 (pom.xml)2. 制作连接点 ( 原始操作, Dao 接口与实现类 )3. 制作共性功能 ( 通知类与通知 )4. 定义切入点5. 绑定切入点与通知关系 ( 切面 )
2.3环境准备
创建一个Maven项目
pom.xml添加Spring依赖
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.10.RELEASE</version>
</dependency>
</dependencies>
package com.itheima.dao;
public interface BookDao {
public void save();
public void update();
}
package com.itheima.dao.impl;
import com.itheima.dao.BookDao;
import org.springframework.stereotype.Repository;
@Repository
public class BookDaoImpl implements BookDao {
@Override
public void save() {
System.out.println(System.currentTimeMillis());
System.out.println("book dao save ...");
}
@Override
public void update() {
System.out.println(System.currentTimeMillis());
System.out.println("book dao update ...");
}
}
package com.itheima.config;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
@Configuration
@ComponentScan("com.itheima")
public class SpringConfig {
}
package com.itheima;
import com.itheima.config.SpringConfig;
import com.itheima.dao.BookDao;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class App {
public static void main(String[] args) {
ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfig.class);
BookDao bookDao = applicationContext.getBean(BookDao.class);
bookDao.save();
}
}
2.4AOP实现步骤
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.4</version>
</dependency>
因为spring-context中已经导入了spring-aop ,所以不需要再单独导入spring-aop
public class MyAdvice {
public void method(){
System.out.println(System.currentTimeMillis());
}
}
public class MyAdvice {
//设置切入点,要求配置在方法上方
@Pointcut("execution(void com.itheima.dao.BookDao.update())")
private void pt(){}
public void method(){
System.out.println(System.currentTimeMillis());
}
}
public class MyAdvice {
//设置切入点,要求配置在方法上方
@Pointcut("execution(void com.itheima.dao.BookDao.update())")
private void pt(){}
//设置在切入点pt()的前面运行当前操作(前置通知)
// @Before("pt()")
public void method(){
System.out.println(System.currentTimeMillis());
}
}
@Component
//设置当前类为切面类类
@Aspect
public class MyAdvice {
//设置切入点,要求配置在方法上方
@Pointcut("execution(void com.itheima.dao.BookDao.update())")
private void pt(){}
//设置在切入点pt()的前面运行当前操作(前置通知)
// @Before("pt()")
public void method(){
System.out.println(System.currentTimeMillis());
}
}
@Configuration
@ComponentScan("com.itheima")
//开启注解开发AOP功能
@EnableAspectJAutoProxy
public class SpringConfig {
}
public class App {
public static void main(String[] args) {
ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
BookDao bookDao = ctx.getBean(BookDao.class);
bookDao.update();
}
}
3.AOP工作流程
3.1AOP工作流程
流程1:Spring容器启动
容器启动就需要去加载 bean, 哪些类需要被加载呢 ?需要被增强的类,如 :BookServiceImpl通知类,如 :MyAdvice注意此时 bean 对象还没有创建成功
流程2:读取所有切面配置中的切入点
上面这个例子中有两个切入点的配置,但是第一个ptx()并没有被使用,所以不会被读取。
流程3:初始化bean
判定bean对应的类中的方法是否匹配到任意切入点注意第 1 步在容器启动的时候, bean 对象还没有被创建成功。要被实例化 bean 对象的类中的方法和切入点进行匹配
匹配失败,创建原始对象,如UserDao匹配失败说明不需要增强,直接调用原始对象的方法即可。匹配成功,创建原始对象(目标对象)的代理对象,如: BookDao匹配成功说明需要对其进行增强对哪个类做增强,这个类对应的对象就叫做目标对象因为要对目标对象进行功能增强,而采用的技术是动态代理,所以会为其创建一个代理对象最终运行的是代理对象的方法,在该方法中会对原始方法进行功能增强
流程4:获取bean执行方法
验证思路1. 要执行的方法,不被定义的切入点包含,即不要增强,打印当前类的 getClass() 方法2. 要执行的方法,被定义的切入点包含,即要增强,打印出当前类的 getClass() 方法3. 观察两次打印的结果
步骤1:修改App类,获取类的类型
public class App {
public static void main(String[] args) {
ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
BookDao bookDao = ctx.getBean(BookDao.class);
// bookDao.update();
System.out.println(bookDao);
System.out.println(bookDao.getClass());
}
}
@Component
//设置当前类为切面类类
@Aspect
public class MyAdvice {
//设置切入点,要求配置在方法上方
@Pointcut("execution(void com.itheima.dao.BookDao.update1())")
private void pt(){}
//设置在切入点pt()的前面运行当前操作(前置通知)
// @Before("pt()")
public void method(){
System.out.println(System.currentTimeMillis());
}
@Component
//设置当前类为切面类类
@Aspect
public class MyAdvice {
//设置切入点,要求配置在方法上方
@Pointcut("execution(void com.itheima.dao.BookDao.update())")
private void pt(){}
//设置在切入点pt()的前面运行当前操作(前置通知)
// @Before("pt()")
public void method(){
System.out.println(System.currentTimeMillis());
}
3.2AOP核心概念
AOP 的核心概念目标对象、连接点、切入点通知类、通知切面代理SpringAOP 的本质或者可以说底层实现是通过代理模式。
4.AOP配置管理
4.1AOP切入点表达式
4.1.1语法格式
对于切入点表达式的语法为:
execution(public User com.itheima.service.UserService.findById(int))
execution :动作关键字,描述切入点的行为动作,例如 execution 表示执行到指定切入点public: 访问修饰符 , 还可以是 public , private 等,可以省略User :返回值,写返回值类型com.itheima.service :包名,多级包使用点连接UserService: 类 / 接口名称findById :方法名int: 参数,直接写参数的类型,多个类型用逗号隔开异常名:方法定义中抛出指定异常,可以省略
4.1.2通配符
4.1.3书写技巧
所有代码按照标准规范开发,否则以下技巧全部失效描述切入点通 常描述接口 ,而不描述实现类 , 如果描述到实现类,就出现紧耦合了访问控制修饰符针对接口开发均采用 public 描述( 可省略访问控制修饰符描述 )返回值类型对于增删改类使用精准类型加速匹配,对于查询类使用 * 通配快速描述包名 书写 尽量不使用 .. 匹配 ,效率过低,常用 * 做单个包描述匹配,或精准匹配接口名 / 类名 书写名称与模块相关的 采用 * 匹配 ,例如 UserService 书写成 *Service ,绑定业务层接口名方法名 书写以 动词 进行 精准匹配 ,名词采用 匹配,例如 getById 书写成 getBy ,selectAll 书写成selectAll参数规则较为复杂,根据业务方法灵活调整通常 不使用异常 作为 匹配 规则
4.2AOP通知类型
4.2.1类型介绍
共提供了 5 种通知类型 :前置通知后置通知环绕通知 ( 重点 )返回后通知 ( 了解 )抛出异常后通知 ( 了解 )
知识点3:@AfterThrowing
知识点4:@Around
环绕通知注意事项1. 环绕通知必须依赖形参 ProceedingJoinPoint 才能实现对原始方法的调用,进而实现原始方法调用前后同时添加通知2. 通知中如果未使用 ProceedingJoinPoint 对原始方法进行调用将跳过原始方法的执行3. 对原始方 法的调用可以不接收返回值,通知方法设置成 void 即可,如果接收返回值,最好设定为 Object 类型4. 原始方法的返回值如果是 void 类型,通知方法的返回值类型可以设置成 void, 也可以设置成Object5. 由于无法预知原始方法运行后是否会抛出异常,因此环绕通知方法必须要处理 Throwable 异常
4.3业务层接口执行效率
4.3.1需求分析
需求 : 任意业务层接口执行均可显示其执行效率(执行时长)具体实现的思路 :(1) 开始执行方法之前记录一个时间(2) 执行方法(3) 执行完方法之后记录一个时间(4) 用后一个时间减去前一个时间的差值,就是我们需要的结果
4.3.2环境准备
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.10.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.2.10.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.2.10.RELEASE</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.4</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.47</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.16</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.6</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>1.3.0</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
</dependencies>
package com.itheima.service;
import com.itheima.domain.Account;
import java.util.List;
public interface AccountService {
void save(Account account);
void delete(Integer id);
void update(Account account);
List<Account> findAll();
Account findById(Integer id);
}
package com.itheima.service.impl;
import com.itheima.dao.AccountDao;
import com.itheima.domain.Account;
import com.itheima.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class AccountServiceImpl implements AccountService {
@Autowired
private AccountDao accountDao;
public void save(Account account) {
accountDao.save(account);
}
public void update(Account account){
accountDao.update(account);
}
public void delete(Integer id) {
accountDao.delete(id);
}
public Account findById(Integer id) {
return accountDao.findById(id);
}
public List<Account> findAll() {
return accountDao.findAll();
}
}
package com.itheima.domain;
import java.io.Serializable;
public class Account implements Serializable {
private Integer id;
private String name;
private Double money;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Double getMoney() {
return money;
}
public void setMoney(Double money) {
this.money = money;
}
@Override
public String toString() {
return "Account{" +
"id=" + id +
", name='" + name + '\'' +
", money=" + money +
'}';
}
}
package com.itheima.dao;
import com.itheima.domain.Account;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;
import java.util.List;
public interface AccountDao {
@Insert("insert into tbl_account(name,money)values(#{name},#{money})")
void save(Account account);
@Delete("delete from tbl_account where id = #{id} ")
void delete(Integer id);
@Update("update tbl_account set name = #{name} , money = #{money} where id = #{id} ")
void update(Account account);
@Select("select * from tbl_account")
List<Account> findAll();
@Select("select * from tbl_account where id = #{id} ")
Account findById(Integer id);
}
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring_db?useSSL=false
jdbc.username=root
jdbc.password=root
package com.itheima.config;
import org.springframework.context.annotation.*;
@Configuration
@ComponentScan("com.itheima")
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class})
public class SpringConfig {
}
package com.itheima.config;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.springframework.context.annotation.Bean;
import javax.sql.DataSource;
public class MybatisConfig {
@Bean
public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();
ssfb.setTypeAliasesPackage("com.itheima.domain");
ssfb.setDataSource(dataSource);
return ssfb;
}
@Bean
public MapperScannerConfigurer mapperScannerConfigurer(){
MapperScannerConfigurer msc = new MapperScannerConfigurer();
msc.setBasePackage("com.itheima.dao");
return msc;
}
}
package com.itheima.config;
import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.sql.DataSource;
public class JdbcConfig {
@Value("${jdbc.driver}")
private String driver;
@Value("${jdbc.url}")
private String url;
@Value("${jdbc.username}")
private String userName;
@Value("${jdbc.password}")
private String password;
@Bean
public DataSource dataSource(){
DruidDataSource ds = new DruidDataSource();
ds.setDriverClassName(driver);
ds.setUrl(url);
ds.setUsername(userName);
ds.setPassword(password);
return ds;
}
}
package com.itheima.service;
import com.itheima.config.SpringConfig;
import com.itheima.domain.Account;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import java.util.List;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class AccountServiceTestCase {
@Autowired
private AccountService accountService;
@Test
public void testFindById(){
Account ac = accountService.findById(2);
}
@Test
public void testFindAll(){
List<Account> all = accountService.findAll();
}
}
4.3.3功能开发
该类要被 Spring 管理,需要添加 @Component要标识该类是一个 AOP 的切面类,需要添加 @Aspect配置切入点表达式,需要添加一个方法,并添加 @Pointcut
@Component
@Aspect
public class ProjectAdvice {
//匹配业务层的所有方法
@Pointcut("execution(* com.itheima.service.*Service.*(..))")
private void servicePt(){}
public void runSpeed(){
}
}
@Component
@Aspect
public class ProjectAdvice {
//匹配业务层的所有方法
@Pointcut("execution(* com.itheima.service.*Service.*(..))")
private void servicePt(){}
//@Around("ProjectAdvice.servicePt()") 可以简写为下面的方式
@Around("servicePt()")
public void runSpeed(){
}
}
@Component
@Aspect
public class ProjectAdvice {
//匹配业务层的所有方法
@Pointcut("execution(* com.itheima.service.*Service.*(..))")
private void servicePt(){}
//@Around("ProjectAdvice.servicePt()") 可以简写为下面的方式
@Around("servicePt()")
public void runSpeed(ProceedingJoinPoint pjp){
long start = System.currentTimeMillis();
for(int i = 0; i < 100; i++){
pjp.proceed();
}
long end = System.currentTimeMillis();
System.out.println("业务层接口万次执行时间: "+(end-start)+"ms");
}
}
步骤6:程序优化
@Component
@Aspect
public class ProjectAdvice {
//匹配业务层的所有方法
@Pointcut("execution(* com.itheima.service.*Service.*(..))")
private void servicePt(){}
//设置环绕通知,在原始操作的运行前后记录执行时间
@Around("ProjectAdvice.servicePt()")
public void runSpeed(ProceedingJoinPoint pjp) throws Throwable {
//获取执行的签名对象
Signature signature = pjp.getSignature();
String className = signature.getDeclaringTypeName();
String methodName = signature.getName();
long start = System.currentTimeMillis();
for (int i = 0; i < 10000; i++) {
pjp.proceed();
}
long end = System.currentTimeMillis();
System.out.println("万次执行:"+ className+"."+methodName+"---->" +(end-start) + "ms");
}
}
4.4AOP通知获取数据
4.4.1获取参数
@Component
@Aspect
public class MyAdvice {
@Pointcut("execution(* com.itheima.dao.BookDao.findName(..))")
private void pt(){}
//JoinPoint:用于描述切入点的对象,必须配置成通知方法中的第一个参数,可用于获取原始方法调用的参数
// @Before("pt()")
public void before(JoinPoint jp) {
Object[] args = jp.getArgs();
System.out.println(Arrays.toString(args));
System.out.println("before advice ..." );
}
// @After("pt()")
public void after(JoinPoint jp) {
Object[] args = jp.getArgs();
System.out.println(Arrays.toString(args));
System.out.println("after advice ...");
}
//ProceedingJoinPoint:专用于环绕通知,是JoinPoint子类,可以实现对原始方法的调用
// @Around("pt()")
public Object around(ProceedingJoinPoint pjp) {
Object[] args = pjp.getArgs();
System.out.println(Arrays.toString(args));
args[0] = 666;
Object ret = null;
try {
ret = pjp.proceed(args);
} catch (Throwable t) {
t.printStackTrace();
}
return ret;
}
//设置返回后通知获取原始方法的返回值,要求returning属性值必须与方法形参名相同
@AfterReturning(value = "pt()",returning = "ret")
public void afterReturning(JoinPoint jp,String ret) {
System.out.println("afterReturning advice ..."+ret);
}
//设置抛出异常后通知获取原始方法运行时抛出的异常对象,要求throwing属性值必须与方法形参名相同
@AfterThrowing(value = "pt()",throwing = "t")
public void afterThrowing(Throwable t) {
System.out.println("afterThrowing advice ..."+t);
}
}
public class App {
public static void main(String[] args) {
ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
BookDao bookDao = ctx.getBean(BookDao.class);
String name = bookDao.findName(100,"itheima");
System.out.println(name);
}
}
运行App类,可以获取如下内容,说明参数100已经被获取
使用JoinPoint的方式获取参数适用于前置、后置、返回后、抛出异常后通知。
环绕通知获取方式
// ProceedingJoinPoint:专用于环绕通知,是JoinPoint子类,可以实现对原始方法的调用
@Around("pt()")
public Object around(ProceedingJoinPoint pjp) {
Object[] args = pjp.getArgs();
System.out.println(Arrays.toString(args));
args[0] = 666;
Object ret = null;
try {
ret = pjp.proceed(args);
} catch (Throwable t) {
t.printStackTrace();
}
return ret;
}
4.4.2获取返回值
对于返回值,只有返回后AfterReturing和环绕Around 这两个通知类型可以获取,具体如何获取 ?对于@Around使用pjp.proceed()可以获得原始方法的返回值,并且我们可以进行修改对于@AfterReturning,需要在注解处进行声明,retuning="ret",目标方法参数为ret。
注意 :(1) 参数名的问题(2)afterReturning 方法参数类型的问题参数类型可以写成 String ,但是为了能匹配更多的参数类型,建议写成 Object 类型(3)afterReturning 方法参数的顺序问题
4.4.3获取异常
在AOP中的 catch 方法中就可以获取到异常,至于获取到异常以后该如何处理,这个就和你的业务需求有关 了。注意:
在原始方法中抛出异常,在目标方法中注解使用throwing="t",对异常进行接收
运行 App 后,查看控制台,就能看的异常信息被打印到控制台
5.AOP总结
5.1 AOP的核心概念
概念: AOP(Aspect Oriented Programming) 面向切面编程,一种编程范式作用:在不惊动原始设计的基础上为方法进行功能 增强核心概念代理( Proxy ): SpringAOP 的核心本质是采用代理模式实现的连接点( JoinPoint ):在 SpringAOP 中,理解为任意方法的执行切入点( Pointcut ):匹配连接点的式子,也是具有共性功能的方法描述通知( Advice ):若干个方法的共性功能,在切入点处执行,最终体现为一个方法切面( Aspect ):描述通知与切入点的对应关系目标对象( Target ):被代理的原始对象成为目标对象
5.2 切入点表达式
切入点表达式标准格式:动作关键字 ( 访问修饰符 返回值 包名 . 类 / 接口名 . 方法名(参数)异常名) execution(* com.itheima.service.*Service.*(..))切入点表达式描述通配符:作用:用于快速描述,范围描述* :匹配任意符号(常用).. :匹配多个连续的任意符号(常用)+ :匹配子类类型切入点表达式书写技巧1. 按 标准规范 开发 2. 查询操作的返回值建议使用 * 匹配 3. 减少使用 .. 的形式描述包 4. 对接口进行描述 ,使用 * 表示模块名,例如 UserService 的匹配描述为 *Service 5. 方法名书写保留动词,例如 get ,使用 * 表示名词,例如 getById 匹配描述为 getBy* 6. 参数根据实际情况灵活调整
5.3 五种通知类型
前置通知后置通知环绕通知(重点)环绕通知依赖形参ProceedingJoinPoint 才能实现对原始方法的调用环绕通知可以隔离原始方法的调用执行环绕通知返回值设置为Object 类型环绕通知中可以对原始方法调用过程中出现的异常进行处理返回后通知抛出异常后通知
5.4 通知中获取参数
获取切入点方法的参数,所有的通知类型都可以获取参数JoinPoint:适用于前置、后置、返回后、抛出异常后通知ProceedingJoinPoint:适用于环绕通知获取切入点方法返回值,前置和抛出异常后通知是没有返回值,后置通知可有可无,所以不做研究返回后通知环绕通知获取切入点方法运行异常信息,前置和返回后通知是不会有,后置通知可有可无,所以不做研究抛出异常后通知环绕通知
6.AOP事务管理
6.1Spring事务简介
6.1.1相关概念介绍
从名称上可以看出,我们只需要给它一个 DataSource 对象,它就可以帮你去在业务层管理事务。其内部采用的是 JDBC 的事务。所以说如果你持久层采用的是 JDBC 相关的技术,就可以采用这个 事务管理 器来管理你的事务。而 Mybatis 内部采用的就是 JDBC 的事务,所以后期我们Spring 整合 Mybatis 就 采用的这个 DataSourceTransactionManager 事务管理器。
6.1.3转账案例-环境搭建
步骤2:创建项目导入jar包
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.10.RELEASE</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.16</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.6</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.47</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.2.10.RELEASE</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>1.3.0</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.2.10.RELEASE</version>
</dependency>
</dependencies>
import java.io.Serializable;
public class Account implements Serializable {
private Integer id;
private String name;
private Double money;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Double getMoney() {
return money;
}
public void setMoney(Double money) {
this.money = money;
}
@Override
public String toString() {
return "Account{" +
"id=" + id +
", name='" + name + '\'' +
", money=" + money +
'}';
}
}
public interface AccountDao {
@Update("update tbl_account set money = money + #{money} where name = #{name}")
void inMoney(@Param("name") String name, @Param("money") Double money);
@Update("update tbl_account set money = money - #{money} where name = #{name}")
void outMoney(@Param("name") String name, @Param("money") Double money);
}
public interface AccountService {
/**
* 转账操作
* @param out 传出方
* @param in 转入方
* @param money 金额
*/
public void transfer(String out,String in ,Double money) ;
}
@Service
public class AccountServiceImpl implements AccountService {
@Autowired
private AccountDao accountDao;
public void transfer(String out,String in ,Double money) {
accountDao.outMoney(out,money);
accountDao.inMoney(in,money);
}
}
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring_db?useSSL=false
jdbc.username=root
jdbc.password=root
public class JdbcConfig {
@Value("${jdbc.driver}")
private String driver;
@Value("${jdbc.url}")
private String url;
@Value("${jdbc.username}")
private String userName;
@Value("${jdbc.password}")
private String password;
@Bean
public DataSource dataSource(){
DruidDataSource ds = new DruidDataSource();
ds.setDriverClassName(driver);
ds.setUrl(url);
ds.setUsername(userName);
ds.setPassword(password);
return ds;
}
}
public class MybatisConfig {
@Bean
public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();
ssfb.setTypeAliasesPackage("com.itheima.domain");
ssfb.setDataSource(dataSource);
return ssfb;
}
@Bean
public MapperScannerConfigurer mapperScannerConfigurer(){
MapperScannerConfigurer msc = new MapperScannerConfigurer();
msc.setBasePackage("com.itheima.dao");
return msc;
}
}
@Configuration
@ComponentScan("com.itheima")
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class})
public class SpringConfig {
}
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class AccountServiceTest {
@Autowired
private AccountService accountService;
@Test
public void testTransfer() throws IOException {
accountService.transfer("Tom","Jerry",100D);
}
}
程序运行分析:由上到下进行分析,首先在测试类中,我们需要对业务层的转账操作进行事务管
理,transfer()方法是对数据层的outMoney()和inMoney()进行调用,数据层使用注解开发并且使用
@Parm注解对参数进行定位,在domain中,Account继承了Serializable接口从而实现了数据序列
化,在SpringConfig中,四个注解分别声明了该类是配置类,扫描指定的类到IOC容器中,声明数
据源文件,导入其他两个配置类,MybatisCofing是整合Mybatis所需的xml配置文件,使用配置类
进行替代,而JdbcCofig是为了加载jdbc.properties配置文件,该类的形式是为了解耦。
6.1.4事务管理
以上的程序并没有转账进行事务管理,当程序报错时会出现进出不对账。
public interface AccountService {
/**
* 转账操作
* @param out 传出方
* @param in 转入方
* @param money 金额
*/
//配置当前接口方法具有事务
@Transactional
public void transfer(String out,String in ,Double money) ;
}
注意 :@Transactional 可以写在接口类上、接口方法上、实现类上和实现类方法上写在接口类上,该接口的所有实现类的所有方法都会有事务写在接口方法上,该接口的所有实现类的该方法都会有事务写在实现类上,该类中的所有方法都会有事务写在实现类方法上,该方法上有事务建议写在实现类或实现类的方法上
public class JdbcConfig {
@Value("${jdbc.driver}")
private String driver;
@Value("${jdbc.url}")
private String url;
@Value("${jdbc.username}")
private String userName;
@Value("${jdbc.password}")
private String password;
@Bean
public DataSource dataSource(){
DruidDataSource ds = new DruidDataSource();
ds.setDriverClassName(driver);
ds.setUrl(url);
ds.setUsername(userName);
ds.setPassword(password);
return ds;
}
//配置事务管理器,mybatis使用的是jdbc事务
@Bean
public PlatformTransactionManager transactionManager(DataSource dataSource){
DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
transactionManager.setDataSource(dataSource);
return transactionManager;
}
}
@Configuration
@ComponentScan("com.itheima")
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class})
//开启注解式事务驱动
@EnableTransactionManagement
public class SpringConfig {
}
6.2 Spring事务角色
AccountDao 的 outMoney 因为是修改操作,会开启一个事务 T1AccountDao 的 inMoney 因为是修改操作,会开启一个事务 T2AccountService 的 transfer 没有事务,运行过程中如果没有抛出异常,则T1 和 T2 都正常提交,数据正确如果在两个方法中间抛出异常,T1 因为执行成功提交事务, T2 因为抛异常不会被执行就会导致数据出现错误
2. 开启Spring的事务管理后
transfer 上添加了 @Transactional 注解,在该方法上就会有一个事务 TAccountDao 的 outMoney 方法的事务 T1 加入到 transfer 的事务 T 中AccountDao 的 inMoney 方法的事务 T2 加入到 transfer 的事务 T 中这样就保证他们在同一个事务中,当业务层中出现异常,整个事务就会回滚,保证数据的准确性。
事务管理员:发起事务方,在Spring中通常指代业务层开启事务的方法
6.3 Spring事务属性
上面这些属性都可以在 @Transactional 注解的参数上进行设置。readOnly: true 只读事务, false 读写事务,增删改要设为 false, 查询设为 true 。timeout: 设置超时时间单位秒,在多长时间之内事务没有提交成功就自动回滚, -1 表示不设置超 时时间。rollbackFor: 当出现指定异常进行事务回滚noRollbackFor: 当出现指定异常不进行事务回滚思考:出现异常事务会自动回滚,这个是我们之前就已经知道的noRollbackFor 是设定对于指定的异常不回滚,这个好理解rollbackFor 是指定回滚异常,对于异常事务不应该都回滚么,为什么还要指定 ?这块需要更正一个知识点,并不是所有的异常都会回滚事务,比如下面的代码就不会回滚(比如IOException)出现这个问题的原因是, Spring 的事务只会对 Error 异常 和 RuntimeException 异常 及其子类进行事务回顾,其他的异常类型是不会回滚的,对应 IOException 不符合上述条件所以不回滚此时就可以使用 rollbackFor 属性来设置出现 IOException 异常不回滚rollbackForClassName等同于rollbackFor,只不过属性为异常的类全名字符串
noRollbackForClassName 等同于 noRollbackFor ,只不过属性为异常的类全名字符串isolation设置事务的隔离级别DEFAULT : 默认隔离级别 , 会采用数据库的隔离级别READ_UNCOMMITTED : 读未提交READ_COMMITTED : 读已提交REPEATABLE_READ : 重复读取SERIALIZABLE: 串行化
6.3.2 转账业务追加日志案例
2.事务传播行为的可选值
要想实现上述的结果,我们只需让日志在一个单独的事务中,使用@Transactional注解中的propagation = Propagation.REQUIRES_NEW属性。
public interface LogService {
//propagation设置事务属性:传播行为设置为当前操作需要新事务
@Transactional(propagation = Propagation.REQUIRES_NEW)
void log(String out, String in, Double money);
}