SpringDay3

最新推荐文章于 2024-10-30 18:07:32 发布

谁在下棋

最新推荐文章于 2024-10-30 18:07:32 发布

阅读量1.3k

点赞数 28

文章标签： java spring

本文链接：https://blog.csdn.net/m0_37187944/article/details/139742384

版权

一、AOP

1.1 什么是AOP

AOP是在不改原有代码的前提下对其功能进行增强。

AOP(Aspect Oriented Programming)面向切面编程，一种编程范式，指导开发者如何组织程序结构。OOP(Object Oriented Programming)面向对象编程。

OOP是一种编程思想，那么AOP也是一种编程思想，编程思想主要的内容就是指导程序员该如何编写程序，所以它们两个是不同的编程范式。

作用：在不惊动原始设计的基础上为其进行功能增强；代理模式就可以实现这样的功能。

1.2 AOP核心概念1

为了能更好的理解AOP的相关概念，我们准备了一个环境，整个环境的内容我们暂时可以不用关注，最主要的类为: BookDaoImpl

@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方法中有计算万次执行消耗的时间。当在 App 类中从容器中获取 bookDao 对象后，分别执行其 save , delete , update 和 select 方法后会有如下的打印结果 :

这个时候，我们就应该有些疑问?
对于计算万次执行消耗的时间只有save方法有，为什么delete和update方法也会有呢?
delete和update方法有，那什么select方法为什么又没有呢?
其实就使用了Spring的AOP，在不改动原有设计(代码)的前提下，想给谁添加功能就给谁添加。

(1)前面一直在强调，Spring的AOP是对一个类的方法在不进行任何修改的前提下实现增强。对于上面的案例中BookDaoImpl中有save , update , delete和select方法,这些方法我们给起了一个名字叫连接点。

(2)在BookDaoImpl的四个方法中，update和delete只有打印没有计算万次执行消耗时间，但是在运行的时候已经有该功能，那也就是说update和delete方法都已经被增强，所以对于需要增强的方法我们给起了一个名字叫切入点。

(3)执行BookDaoImpl的update和delete方法的时候都被添加了一个计算万次执行消耗时间的功能，将这个功能抽取到一个方法中，换句话说就是存放共性功能的方法，我们给起了个名字叫通知。

(4)通知是要增强的内容，会有多个，切入点是需要被增强的方法，也会有多个，那哪个切入点需要添加哪个通知，就需要提前将它们之间的关系描述清楚，那么对于通知和切入点之间的关系描述，我们给起了个名字叫切面。

(5)通知是一个方法，方法不能独立存在需要被写在一个类中，这个类我们给起个名字叫通知类。

AOP核心概念：

连接点(JoinPoint)：程序执行过程中的任意位置，粒度为执行方法、抛出异常、设置变量等在SpringAOP中，理解为方法的执行。

切入点(Pointcut):匹配连接点的式子。

连接点范围要比切入点范围大，是切入点的方法也一定是连接点，但是是连接点的方法就不一定要被增强，所以可能不是切入点。

通知(Advice):在切入点处执行的操作，也就是共性功能。

通知类：定义通知的类。

切面(Aspect):描述通知与切入点的对应关系。

1.3 AOP入门案例

需求 : 使用 SpringAOP 的注解方式完成在方法执行的前打印出当前系统时间。

环境准备：

1.创建一个Maven项目
2.pom.xml添加Spring依赖
3.添加BookDao和BookDaoImpl类
public interface BookDao { 
    public void save(); 
    public void update(); 
}
@Repository 
public class BookDaoImpl implements BookDao { 
    public void save() { 
        System.out.println(System.currentTimeMillis()); 
        System.out.println("book dao save ..."); 
    }
    public void update(){ 
        System.out.println("book dao update ..."); 
    } 
}
4.创建Spring的配置类
@Configuration 
@ComponentScan("com.itheima") 
public class SpringConfig { }

5.编写App运行类
public class App { 
    public static void main(String[] args) { 
        ApplicationContext ctx = new 
AnnotationConfigApplicationContext(SpringConfig.class); 
        BookDao bookDao = ctx.getBean(BookDao.class); 
        bookDao.save(); 
    } 
}

AOP实现步骤：


1.导入坐标(pom.xml)，添加依赖。
<dependency> 
    <groupId>org.aspectj</groupId> 
    <artifactId>aspectjweaver</artifactId> 
    <version>1.9.4</version> 
</dependency>
2.制作连接点(原始操作，Dao接口与实现类)
环境准备的时候，BookDaoImpl已经准备好，不需要做任何修改

3.制作共性功能(通知类与通知)
public class MyAdvice { 
    public void method(){ 
        System.out.println(System.currentTimeMillis()); 
    } 
}

4.定义切入点
切入点定义依托一个不具有实际意义的方法进行，即无参数、无返回值、方法体无实际逻辑。
public class MyAdvice { 
    @Pointcut("execution(void com.itheima.dao.BookDao.update())") 
    private void pt(){}
 
    public void method(){ 
        System.out.println(System.currentTimeMillis()); 
    } 
}
5.绑定切入点与通知关系(切面)
//@Before("pt()") 
绑定切入点与通知关系，并指定通知添加到原始连接点的具体执行位置
@Before翻译过来是之前，也就是说通知会在切入点方法执行之前执行
public class MyAdvice { 
    @Pointcut("execution(void com.itheima.dao.BookDao.update())") 
    private void pt(){} 

    @Before("pt()") 
    public void method(){ 
    System.out.println(System.currentTimeMillis()); 
    } 
}

6.将通知类配给容器并标识其为切面类
@Component
@Aspect 
public class MyAdvice { 
    @Pointcut("execution(void com.itheima.dao.BookDao.update())") 
    private void pt(){}
 
    @Before("pt()") 
    public void method(){ 
        System.out.println(System.currentTimeMillis()); 
    } 
}

7.Spring的配置类开启注解格式AOP功能
@Configuration 
@ComponentScan("com.itheima") 
@EnableAspectJAutoProxy 
public class SpringConfig { }

8.运行程序
public class App { 
    public static void main(String[] args) { 
        ApplicationContext ctx = new 
AnnotationConfigApplicationContext(SpringConfig.class); 
        BookDao bookDao = ctx.getBean(BookDao.class);
        bookDao.update(); 
    } 
}

看到在执行update方法之前打印了系统时间戳，说明对原始方法进行了增强，AOP编程成功。

1.4 AOP工作流程

由于AOP是基于Spring容器管理的bean做的增强，所以整个工作过程需要从Spring加载bean说起

1.Spring容器启动
容器启动就需要去加载bean,哪些类需要被加载呢?
需要被增强的类，如:BookServiceImpl
通知类，如:MyAdvice

2.读取所有切面配置中的切入点（只读取配置的切入点），如下图

3.初始化bean，判定bean对应的类中的方法是否匹配到任意切入点
注意第1步在容器启动的时候，bean对象还没有被创建成功。
对要被实例化bean对象的类中的方法和切入点进行匹配。
匹配失败，创建原始对象（如下图的UserDao）
    匹配失败说明不需要增强，直接调用原始对象的方法即可。
匹配成功，创建原始对象（目标对象）的代理对象（如下图的BookDao）
    匹配成功说明需要对其进行增强
    对哪个类做增强，这个类对应的对象就叫做目标对象
    因为要对目标对象进行功能增强，而采用的技术是动态代理，所以会为其创建一个代理对象
    最终运行的是代理对象的方法，在该方法中会对原始方法进行功能增强

4.获取bean执行方法
获取的bean是原始对象时，调用方法并执行，完成操作
获取的bean是代理对象时，根据代理对象的运行模式运行原始方法与增强的内容，完成操作。

验证容器中是否为代理对象

为了验证IOC容器中创建的对象和我们刚才所说的结论是否一致，首先先把结论理出来:

如果目标对象中的方法会被增强，那么容器中将存入的是目标对象的代理对象
如果目标对象中的方法不被增强，那么容器中将存入的是目标对象本身。

要执行的方法，不被定义的切入点包含，即不要增强，打印当前类的getClass()方法
要执行的方法，被定义的切入点包含，即要增强，打印出当前类的getClass()方法
观察两次打印的结果


1.修改App类,获取类的类型
public class App { 
    public static void main(String[] args) { 
        ApplicationContext ctx = 
new AnnotationConfigApplicationContext(SpringConfig.class); 
        BookDao bookDao = ctx.getBean(BookDao.class); 
        System.out.println(bookDao); 
        System.out.println(bookDao.getClass()); 
    } 
}

2.修改MyAdvice类，不增强，运行程序（update改成update1）
@Component
@Aspect 
public class MyAdvice { 
    @Pointcut("execution(void com.itheima.dao.BookDao.update1())") 
    private void pt(){}
 
    @Before("pt()") 
    public void method(){ 
        System.out.println(System.currentTimeMillis()); 
    } 
}

3.修改MyAdvice类，增强，运行程序
@Component
@Aspect 
public class MyAdvice { 
    @Pointcut("execution(void com.itheima.dao.BookDao.update())") 
    private void pt(){}
 
    @Before("pt()") 
    public void method(){ 
        System.out.println(System.currentTimeMillis()); 
    } 
}

1.5 AOP核心概念2

在上面介绍AOP的工作流程中，我们提到了两个核心概念，分别是:

目标对象：原始功能去掉共性功能对应的类产生的对象，这种对象是无法直接完成最终工作的。

代理：目标对象无法直接完成工作，需要对其进行功能回填，通过原始对象的代理对象实现。

目标对象就是要增强的类[如:BookServiceImpl类]对应的对象，也叫原始对象，不能说它不能运行，只能说它在运行的过程中对于要增强的内容是缺失的。

SpringAOP是在不改变原有设计(代码)的前提下对其进行增强的，它的底层采用的是代理模式实现的，所以要对原始对象进行增强，就需要对原始对象创建代理对象，在代理对象中的方法把通知[如:MyAdvice中的method方法]内容加进去，就实现了增强,这就是我们所说的代理(Proxy)。

1.6 AOP配置管理

1.6.1 切入点表达式

对于AOP中切入点表达式，我们总共会学习三个内容，分别是语法格式、通配符和书写技巧。

1.6.1.1 语法格式

切入点:要进行增强的方法
切入点表达式:要进行增强的方法的描述方式

对于切入点的描述，有两种方式，先来看下面例子：
public interface BookDao { 
    public void save(); 
    public void update(); 
}

public class BookDaoImpl implements BookDao { 
    public void save() { 
        System.out.println(System.currentTimeMillis()); 
        System.out.println("book dao save ..."); 
    }
    public void update(){ 
        System.out.println("book dao update ..."); 
    } 
}

方式一：执行com.itheima.dao包下的BookDao接口中的update方法
execution(void com.itheima.dao.BookDao.update())

方式二：执行com.itheima.dao.impl包下的BookDaoImpl类中的update方法
execution(void com.itheima.dao.impl.BookDaoImpl.update())

因为调用接口方法的时候最终运行的还是其实现类的方法，所以上面两种描述方式都是可以的。

对于切入点表达式的语法为:
    动作关键字(访问修饰符 返回值 包名.类/接口名.方法名(参数) 异常名）

例如：execution(public User com.itheima.service.UserService.findById(int))

execution：动作关键字，描述切入点的行为动作，例如execution表示执行到指定切入点
public:访问修饰符,还可以是public，private等，可以省略
User：返回值，写返回值类型，可以为void
com.itheima.service：包名，多级包使用点连接
UserService:类/接口名称
findById：方法名
int:参数，直接写参数的类型，多个类型用逗号隔开
异常名：方法定义中抛出指定异常，可以省略

1.6.1.2 通配符

切入点表达式就是要找到需要增强的方法，所以它就是对一个具体方法的描述，但是方法的定义会有很多，所以如果每一个方法对应一个切入点表达式，想想这块就会觉得将来编写起来会比较麻烦，有没有更简单的方式呢?

可以使用通配符描述切入点，简化切入点表达式。

1.'*'符号：单个独立的任意符号，可以独立出现，也可以作为前缀或者后缀的匹配符出现
    execution（public * com.itheima.*.UserService.find*(*))
匹配com.itheima包下的任意包中的UserService类或接口中所有find开头的带有一个参数的方法

2.'..'符号：多个连续的任意符号，可以独立出现，常用于简化包名与参数的书写
    execution（public User com..UserService.findById(..))
匹配com包下的任意包中的UserService类或接口中所有名称为findById的方法

3.'+'符号：专用于匹配子类类型
    execution(* *..*Service+.*(..))
这个使用率较低，描述子类的，做JavaEE开发，继承机会就一次，使用都很慎重，所以很少
用它。*Service+，表示所有以Service结尾的接口的子类。

1.6.1.3 书写技巧

所有代码按照标准规范开发，否则以下技巧全部失效
        描述切入点通常描述接口，而不描述实现类,如果描述到实现类，就出现紧耦合了
        访问控制修饰符针对接口开发均采用public描述（可省略访问控制修饰符描述）
        返回值类型对于增删改类使用精准类型加速匹配，对于查询类使用*通配快速描述
        包名书写尽量不使用..匹配，效率过低，常用*做单个包描述匹配，或精准匹配
        接口名/类名书写名称与模块相关的采用*匹配，例如UserService书写成*Service
        方法名以动词进行精准匹配，名词采用匹配，例getById书写成getBy,selectAll书写selectAll
        参数规则较为复杂，根据业务方法灵活调整
        通常不使用异常作为匹配规则

1.6.2 AOP通知类型

1.6.2.1 类型介绍

AOP通知描述了抽取的共性功能，根据共性功能抽取的位置不同，最终运行代码时要将其加入到合理的位置，通知具体要添加到切入点的哪里? AOP共提供了5种通知类型:

前置通知、后置通知、环绕通知(重点)、返回后通知(了解)、抛出异常后通知(了解)

环绕通知,环绕通知功能比较强大，它可以追加功能到方法执行的前后，这也是比较常用的方式，它可以实现其他四种通知类型的功能。

返回后通知是需要在原始方法select 正常执行后才会被执行，如果业务方法执行的过程中出现了异常，那么返回后通知是不会被执行。后置通知是不管原始方法有没有抛出异常都会被执行。

1.6.2.2 环境准备

1.创建一个Maven项目
2.pom.xml添加Spring依赖
3.添加BookDao和BookDaoImpl类
public interface BookDao { 
    public int select(); 
    public void update(); 
}
@Repository 
public class BookDaoImpl implements BookDao { 
    public void update(){ 
        System.out.println("book dao update ..."); 
    } 
    public int select() {
        System.out.println("book dao select is running ..."); 
        return 100;
    }
}

4.创建Spring的配置类
@Configuration 
@ComponentScan("com.itheima") 
@EnableAspectJAutoProxy 
public class SpringConfig { }

5.创建通知类
@Component 
@Aspect 
public class MyAdvice { 
    @Pointcut("execution(void com.itheima.dao.BookDao.update())") 
    private void pt(){} 

    public void before() {
        System.out.println("before advice ..."); 
    }
    public void after() { 
        System.out.println("after advice ..."); 
    }
    public void around(){ 
        System.out.println("around before advice ..."); 
        System.out.println("around after advice ..."); 
    }
    public void afterReturning() { 
        System.out.println("afterReturning advice ..."); 
    }
    public void afterThrowing() { 
        System.out.println("afterThrowing advice ..."); 
    } 
}

6.编写运行App
public class App { 
    public static void main(String[] args) { 
        ApplicationContext ctx = 
new AnnotationConfigApplicationContext(SpringConfig.class); 
        BookDao bookDao = ctx.getBean(BookDao.class); 
        bookDao.update(); 
    } 
}

1.6.2.3 前置通知使用

@Component 
@Aspect 
public class MyAdvice { 
    @Pointcut("execution(void com.itheima.dao.BookDao.update())") 
    private void pt(){} 

    @Before("pt()") //此处也可以写成 @Before("MyAdvice.pt()"),不建议 
    public void before() { 
        System.out.println("before advice ..."); 
    } 
}

运行程序：
before advice ...
book dao update ...

1.6.2.4 后置通知使用

@Component 
@Aspect 
public class MyAdvice { 
    @Pointcut("execution(void com.itheima.dao.BookDao.update())") 
    private void pt(){} 

    @Before("pt()") //此处也可以写成 @Before("MyAdvice.pt()"),不建议 
    public void before() { 
        System.out.println("before advice ..."); 
    } 
    @After("pt()") 
    public void after() { 
        System.out.println("after advice ..."); 
    }
}

运行程序：
before advice ...
book dao update ...
after advice ...

1.6.2.5 环绕通知使用

@Component 
@Aspect 
public class MyAdvice { 
    @Pointcut("execution(void com.itheima.dao.BookDao.update())") 
    private void pt(){} 

    @Around("pt()") 
    public void around(){ 
        System.out.println("around before advice ..."); 
        System.out.println("around after advice ..."); 
    }
}

运行程序：
around before advice ...
around after advice ...

运行结果中，通知的内容打印出来，但是原始方法的内容却没有被执行。
因为环绕通知需要在原始方法的前后进行增强，所以环绕通知就必须要能对原始操作进行调用

优化更改：
@Component 
@Aspect 
public class MyAdvice { 
    @Pointcut("execution(void com.itheima.dao.BookDao.update())") 
    private void pt(){} 

    @Around("pt()") 
    public void around(ProceedingJoinPoint pjp) throws Throwable{ 
        System.out.println("around before advice ..."); 
        //表示对原始操作的调用
        pjp.proceed();
        System.out.println("around after advice ..."); 
    }
}

运行程序：
around before advice ...
book dao update ...
around after advice ...



原始方法有返回值的怎么处理？
@Component 
@Aspect 
public class MyAdvice { 
    @Pointcut("execution(void com.itheima.dao.BookDao.update())") 
    private void pt(){} 

    @Pointcut("execution(int com.itheima.dao.BookDao.select())") 
    private void pt2(){}

    @Around("pt2()") 
    public void  aroundSelect(ProceedingJoinPoint pjp) throws Throwable{ 
        System.out.println("around before advice ..."); 
        //表示对原始操作的调用
        pjp.proceed();
        System.out.println("around after advice ..."); 
    }
}
修改App类，调用select方法，并运行程序
bookDao.update();
改为
int num = bookDao.select();
System.out.println(num);

运行会报错：Null return value from advice does not match primitive return type for：
public abstract int com.itheima.dao.BookDao.select()
空的返回不匹配原始方法的int返回
改为有返回值的方法即可：
    @Around("pt2()") 
    public Object  aroundSelect(ProceedingJoinPoint pjp) throws Throwable{ 
        System.out.println("around before advice ..."); 
        //表示对原始操作的调用
        Object ret = pjp.proceed();
        System.out.println("around after advice ..."); 
        return ret;
    }

运行程序：
around before advice ...
book dao select is running ...
around after advice ...
100

因为环绕通知是可以控制原始方法执行的，所以我们把增强的代码写在调用原始方法的不同位置就可以实现不同的通知类型的功能

1.6.2.6 返回后通知使用

@Component 
@Aspect 
public class MyAdvice { 
    @Pointcut("execution(void com.itheima.dao.BookDao.update())") 
    private void pt(){} 

    @Pointcut("execution(int com.itheima.dao.BookDao.select())") 
    private void pt2(){}

    @AfterReturning("pt2()") 
    public void  afterReturning{ 
        System.out.println("afterReturning advice ...");
    }
}

public class App { 
    public static void main(String[] args) { 
        ApplicationContext ctx = 
new AnnotationConfigApplicationContext(SpringConfig.class); 
        BookDao bookDao = ctx.getBean(BookDao.class); 
        int num = bookDao.select();
        System.out.println(num);
    } 
}

运行程序：
book dao select is running ...
afterReturning advice ...
100

1.6.2.7 异常后通知使用

异常后通知是需要原始方法抛出异常，可以在select()方法中添加一行代码int i = 1/0即
可。如果没有抛异常，异常后通知将不会被执行。

@Component 
@Aspect 
public class MyAdvice { 
    @Pointcut("execution(void com.itheima.dao.BookDao.update())") 
    private void pt(){} 

    @Pointcut("execution(int com.itheima.dao.BookDao.select())") 
    private void pt2(){}

    @AfterReturning("pt2()") 
    public void afterThrowing() { 
        System.out.println("afterThrowing advice ..."); 
    }
}

运行程序：
book dao select is running ...
afterThrowing advice ...
抛出异常

1.7 AOP通知获取数据

目前我们写AOP仅仅是在原始方法前后追加一些操作，接下来我们要说说AOP中数据相关的内容，我们将从获取参数、获取返回值和获取异常三个方面来研究切入点的相关信息。

获取切入点方法的参数，所有的通知类型都可以获取参数

JoinPoint：适用于前置、后置、返回后、抛出异常后通知
ProceedingJoinPoint：适用于环绕通知

获取切入点方法返回值，前置和抛出异常后通知是没有返回值，后置通知可有可无不做研究。

获取切入点方法运行异常信息，前置和返回后通知是不会有，后置通知可有可无不做研究。

1.7.1 环境准备

1.创建一个Maven项目。
2.pom.xml添加Spring依赖
3.添加BookDao和BookDaoImpl类
public interface BookDao { 
    public String findName(int id); 
}
@Repository 
public class BookDaoImpl implements BookDao { 
    public String findName(int id) { 
        System.out.println("id:"+id); 
        return "itcast"; 
    } 
}

4.创建Spring的配置类
@Configuration 
@ComponentScan("com.itheima") 
@EnableAspectJAutoProxy 
public class SpringConfig { }

5.编写通知类
@Component 
@Aspect 
public class MyAdvice { 
    @Pointcut("execution(* com.itheima.dao.BookDao.findName(..))") 
    private void pt(){} 
    @Before("pt()")
    public void before() {
        System.out.println("before advice ..."); 
    }
    @After("pt()")
    public void after() { 
        System.out.println("after advice ..."); 
    }
    @Around("pt()")
    public void around() throws Throwable{ 
        Object ret = pjp.proceed(); 
        return ret;
    }
    @AfterReturning("pt()")
    public void afterReturning() { 
        System.out.println("afterReturning advice ..."); 
    }
    @AfterThrowing("pt()")
    public void afterThrowing() { 
        System.out.println("afterThrowing advice ..."); 
    } 
}

6.编写运行App
public class App { 
    public static void main(String[] args) { 
        ApplicationContext ctx = 
new AnnotationConfigApplicationContext(SpringConfig.class); 
        String name = bookDao.findName(100); 
        System.out.println(name); 
    } 
}

1.7.2 获取参数

一、非环绕通知获取方式：
@Component 
@Aspect 
public class MyAdvice { 
    @Pointcut("execution(void com.itheima.dao.BookDao.findName(..))") 
    private void pt(){} 

    @Before("pt()")  
    public void before(JoinPoint jp) { 
        Object[] args = jp.getArgs(); 
        System.out.println(Arrays.toString(args));
        System.out.println("before advice ..."); 
    } 
}

运行程序：
[100]//因为参数的个数是不固定的，使用数组来获取参数更通配
before advice ...
id:100
itcast

二、环绕通知获取方式：
@Component 
@Aspect 
public class MyAdvice { 
    @Pointcut("execution(void com.itheima.dao.BookDao.findName(..))") 
    private void pt(){} 

    @Around("pt()") 
    public Object around(ProceedingJoinPoint pjp) throws Throwable { 
        Object[] args = pjp.getArgs(); 
        System.out.println(Arrays.toString(args)); 
        Object ret = pjp.proceed(); 
        return ret; 
    }
}

运行程序：
[100]
id:100
itcast

1.7.3 获取返回值

获取切入点方法返回值，前置和抛出异常后通知是没有返回值，后置通知可有可无不做研究。
对于返回值，只有返回后AfterReturing和环绕Around这两个通知类型可以获取

一、环绕通知
@Component 
@Aspect 
public class MyAdvice { 
    @Pointcut("execution(void com.itheima.dao.BookDao.findName(..))") 
    private void pt(){} 

    @Around("pt()") 
    public Object around(ProceedingJoinPoint pjp) throws Throwable { 
        Object[] args = pjp.getArgs(); 
        System.out.println(Arrays.toString(args)); 
        args[0] = 666;
        Object ret = pjp.proceed(args); 
        return ret; 
    }
}
上面ret就是方法的返回值，我们是可以直接获取，不但可以获取，如果需要还可以进行修改

pjp.proceed()方法是有两个构造方法，分别是:
无参的pjp.proceed()
有参数pjp.proceed(args)
调用无参数的proceed，当原始方法有参数，会在调用的过程中自动传入参数
所以调用这两个方法的任意一个都可以完成功能
但是当需要修改原始方法的参数时，就只能采用带有参数的方法
如上arg[0]=666修改了原始方法的参数，采用pjp.proceed(args)

二、返回后通知获取返回值
@Component 
@Aspect 
public class MyAdvice { 
    @Pointcut("execution(void com.itheima.dao.BookDao.findName(..))") 
    private void pt(){} 
    @AfterReturning(value = "pt()",returning = "ret") 
    public void afterReturning(Object ret) { 
        System.out.println("afterReturning advice ..."+ret); 
    }
}

运行程序：
id:100
afterReturning advice ...itcast
itcast

返回后通知获取返回值注意问题：

(1)参数名的问题

(2)afterReturning方法参数类型的问题

参数类型可以写成String，但是为了能匹配更多的参数类型，建议写成Object类型

(3)afterReturning方法参数的顺序问题

1.7.4 获取异常

获取切入点方法运行异常信息，前置和返回后通知是不会有，后置通知可有可无不做研究
对于获取抛出的异常，只有抛出异常后AfterThrowing和环绕Around这两个通知类型可以获取

一、环绕通知获取异常
@Component 
@Aspect 
public class MyAdvice { 
    @Pointcut("execution(* com.itheima.dao.BookDao.findName(..))") 
    private void pt(){} 

    @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 throwable){ 
            t.printStackTrace(); 
        }
        return ret; 
    }//其他的略 
}

二、抛出异常后通知获取异常
@Component 
@Aspect 
public class MyAdvice { 
    @Pointcut("execution(* com.itheima.dao.BookDao.findName(..))") 
    private void pt(){} 

    @AfterThrowing(value = "pt()",throwing = "t") 
    public void afterThrowing(Throwable t) { 
        System.out.println("afterThrowing advice ..."+t); 
    }
}

@Repository 
public class BookDaoImpl implements BookDao { 
    public String findName(int id,String password) { 
        System.out.println("id:"+id); 
        if(true){ 
            throw new NullPointerException(); 
        }    
        return "itcast"; 
    } 
}

运行程序：
id:100
afterThrowing advice ...java.lang.NullPointerException
抛出异常代码

1.8 AOP事务管理

1.8.1 Spring事务简介

事务作用：在数据层保障一系列的数据库操作同成功同失败
Spring事务作用：在数据层或业务层保障一系列的数据库操作同成功同失败

例如：
转账业务会有两次数据层的调用，一次是加钱一次是减钱；把事务放在数据层，加钱和减钱就有两个事务；没办法保证加钱和减钱同时成功或者同时失败；这个时候就需要将事务放在业务层进行处理。

Spring为了管理事务，提供了一个平台事务管理器PlatformTransactionManager

PlatformTransactionManager只是一个接口，Spring还为其提供了一个具体的实现:

从名称上可以看出，只需要给它一个DataSource对象，它就可以帮你去在业务层管理事务。其内部采用的是JDBC的事务。所以说如果你持久层采用的是JDBC相关的技术，就可以采用这个事务管理器来管理你的事务。而Mybatis内部采用的就是JDBC的事务，所以后期我们Spring整合Mybatis就采用的这个DataSourceTransactionManager事务管理器。

1.8.2 环境准备

1.创建数据库表
create database spring_db character set utf8; 
use spring_db; 
create table tbl_account( 
    id int primary key auto_increment, 
    name varchar(35), 
    money double 
);
insert into tbl_account values(1,'Tom',1000); 
insert into tbl_account values(2,'Jerry',1000);

2.导入pom.xml相关依赖(略)

3.根据表创建模型类
public class Account implements Serializable { 
    private Integer id; 
    private String name; 
    private Double money; 
    //setter...getter...toString...方法略 
}

4.创建Dao接口（Mybatis注解方式）
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);
}

5.创建Service接口和实现类
public interface AccountService { 
    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); 
    }
}

6.添加jdbc.properties文件：resources目录下添加，用于配置数据库连接四要素
//useSSL:关闭MySQL的SSL连接
jdbc.driver=com.mysql.jdbc.Driver 
jdbc.url=jdbc:mysql://localhost:3306/spring_db?useSSL=false 
jdbc.username=root 
jdbc.password=root

7.创建JdbcConfig配置类
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; 
    } 
}

8.创建Mybatis配置类
public class MybatisConfig { 
    //定义bean，SqlSessionFactoryBean，用于产生SqlSessionFactory对象 
    @Bean 
    public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
        SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean(); 
        //设置模型类的别名扫描 
        ssfb.setTypeAliasesPackage("com.itheima.domain"); 
        //设置数据源 
        ssfb.setDataSource(dataSource); 
        return ssfb; 
    }
    //定义bean，返回MapperScannerConfigurer对象 
    @Bean 
    public MapperScannerConfigurer mapperScannerConfigurer(){
        //MapperScannerConfigurer对象也是MyBatis提供的专用于整合的jar包中的类，用来
        //处理原始配置文件中的mappers相关配置，加载数据层的Mapper接口类 
        MapperScannerConfigurer msc = new MapperScannerConfigurer(); 
        msc.setBasePackage("com.itheima.dao"); 
        return msc; 
    } 
}

9.创建SpringConfig配置类
@Configuration 
@ComponentScan("com.itheima") 
@PropertySource("jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class}) 
public class SpringConfig { }


8.编写测试类
@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); 
    } 
}

1.8.3 Spring事务管理

上述环境，运行单元测试类，会执行转账操作，Tom的账户会减少100，Jerry的账户会加100。

这是正常情况下的运行结果，但是如果在转账的过程中出现了异常，如:

5.创建Service接口和实现类
public interface AccountService { 
    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);
        int i = 1/0; 
        accountDao.inMoney(in,money); 
    }
}

这个时候就模拟了转账过程中出现异常的情况，正确的操作应该是转账出问题了，Tom应该还是900，Jerry应该还是1100，但是真正运行后会发现，并没有像我们想象的那样，Tom账户为800而 Jerry还是1100，100块钱凭空消失了。

当程序出问题后，我们需要让事务进行回滚，而且这个事务应该是加在业务层上，而Spring的事务管理就是用来解决这类问题的。

1.在需要被事务管理的方法上添加注解
public interface AccountService { 
    public void transfer(String out,String in ,Double money);  
}

@Service 
public class AccountServiceImpl implements AccountService { 
    @Autowired 
    private AccountDao accountDao;
    @Transactional 
    public void transfer(String out,String in ,Double money) {
        accountDao.outMoney(out,money);
        int i = 1/0; 
        accountDao.inMoney(in,money); 
    }
}

@Transactional可以写在接口类上、接口方法上、实现类上和实现类方法上
    写在接口类上，该接口的所有实现类的所有方法都会有事务
    写在接口方法上，该接口的所有实现类的该方法都会有事务
    写在实现类上，该类中的所有方法都会有事务
    写在实现类方法上，该方法上有事务
    建议写在实现类或实现类的方法上

2.在JdbcConfig类中配置事务管理器
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; 
    }
    @Bean//配置事务管理器，mybatis使用的是jdbc事务
    public PlatformTransactionManager transactionManager(DataSource dataSource){
        DataSourceTransactionManager transactionManager = 
new DataSourceTransactionManager(); 
        transactionManager.setDataSource(dataSource); 
        return transactionManager; 
    } 
}

3.开启事务注解,在SpringConfig的配置类中开启
@Configuration @ComponentScan("com.itheima") 
@PropertySource("classpath:jdbc.properties") 
@Import({JdbcConfig.class,MybatisConfig.class 
//开启注解式事务驱动 
@EnableTransactionManagement 
public class SpringConfig { }

4.运行测试类
会发现在转换的业务出现错误后，事务是同成功同失败的，保证数据的正确性。

1.8.4 Spring事务角色

重点要理解两个概念，分别是事务管理员和事务协调员。

1.未开启Spring事务之前:

AccountDao的outMoney因为是修改操作，会开启一个事务T1
AccountDao的inMoney因为是修改操作，会开启一个事务T2
当AccountService的transfer没有事务，
运行过程中如果没有抛出异常，则T1和T2都正常提交，数据正确
如果在两个方法中间抛出异常，T1因为执行成功提交事务，T2因为抛异常不会被执行就会导致数据出现错误。

2. 开启Spring的事务管理后：

transfer上添加了@Transactional注解，在该方法上就会有一个事务T
AccountDao的outMoney方法的事务T1加入到transfer的事务T中
AccountDao的inMoney方法的事务T2加入到transfer的事务T中
这样就保证他们在同一个事务中，当业务层中出现异常，整个事务就会回滚，保证数据的准确性。

事务管理员：发起事务方，在Spring中通常指代业务层开启事务的方法。
事务协调员：加入事务方，在Spring中通常指代数据层方法，也可以是业务层方法。

注意：目前的事务管理是基于DataSourceTransactionManager和SqlSessionFactoryBean使用的是同一个数据源。MyBatis配置类和JDBC配置类中的dataSource是同一个。

1.8.5 Spring事务属性

事务属性怎样使用呢？看下面案例：

public interface AccountService { 
    public void transfer(String out,String in ,Double money);  
}
@Service 
public class AccountServiceImpl implements AccountService { 
    @Autowired 
    private AccountDao accountDao;
    @Transactional 
    public void transfer(String out,String in ,Double money) throws IOException{
        accountDao.outMoney(out,money); 
        //int i = 1/0; //这个异常事务会回滚 
        if(true){ 
            throw new IOException(); //这个异常事务就不会回滚     
        }
        accountDao.inMoney(in,money); 
    }
}

Spring的事务只会对Error异常和RuntimeException异常及其子类进行事务回顾，
其他的异常类型是不会回滚的，对应IOException不符合上述条件所以不回滚。

此时就可以使用rollbackFor属性来设置出现IOException异常回滚

public interface AccountService { 
    public void transfer(String out,String in ,Double money);  
}
@Service 
public class AccountServiceImpl implements AccountService { 
    @Autowired 
    private AccountDao accountDao;
    @Transactional(rollbackFor = {IOException.class}) 
    public void transfer(String out,String in ,Double money) throws IOException{
        accountDao.outMoney(out,money); 
        //int i = 1/0; //这个异常事务会回滚 
        if(true){ 
            throw new IOException(); //此时这个异常事务也会回滚     
        }
        accountDao.inMoney(in,money); 
    }
}

怎样理解传播属性？看下面案例

需求：无论转账是否成功，均进行转账操作日志留痕

数据库表及模型类省略
public interface LaoDao{
    @Insert("insert into tbl_log(info,createDate) value(#{info},now())")
    void log(String info);
}

public interface LogService{
    @Transactional 
    void log(String out,String in,Double money);
}
@Service 
public class LogServiceImpl implements LogService{ 
    @Autowired 
    private LogDao logDao
    public void log(String out,String in ,Double money){
        logDao.log("转账操作由"+out+"到"+in+",金额："+money);
    }
}

public interface AccountService { 
    @Transactional
    public void transfer(String out,String in ,Double money);  
}
@Service 
public class AccountServiceImpl implements AccountService { 
    @Autowired 
    private AccountDao accountDao;
    @Autowired 
    private LogSerbice logService;

    public void transfer(String out,String in ,Double money) {
        try{
            accountDao.outMoney(out,money);
            accountDao.inMoney(in,money);     
        }finally{
            logService.log(out,in,money)
        }
    }
}

@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); 
    } 
}

运行程序：发现日志没有记录，和需求不符。
原因：转账操作和日志记录在同一个事务里面。

优化：
public interface LogService{
    //propagation设置事务属性：传播行为设置为当前操作需要新事务
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    void log(String out,String in,Double money);
}

此时无论转账是否成功，均进行转账操作日志记录。