失眠网 > Spring详解 | AOP面向切面 | 无知的我费曼笔记（图文排版无水印）

Spring详解 | AOP面向切面 | 无知的我费曼笔记（图文排版无水印）

时间：2019-10-29 01:20:08

无知的我正在复盘Spring。。。

笔记特点是

重新整理了涉及资料的一些语言描述、排版而使用了自己更容易理解的描述。。提升了总结归纳性同样是回答了一些常见关键问题。。

文章目录

AOP简介什么是AOP?AOP作用AOP核心概念 AOP入门案例需求分析思路分析环境准备AOP实现步骤步骤1:添加依赖步骤2:定义接口与实现类步骤3:定义通知类和通知步骤4:定义切入点步骤5:制作切面步骤6:将通知类配给容器并标识其为切面类步骤7:开启注解格式AOP功能步骤8:运行程序知识点小结1：@EnableAspectJAutoProxy知识点小结2：@Aspect知识点小结3：@Pointcut知识点小结4：@Before AOP工作流程AOP工作流程流程1:Spring容器启动流程2:读取所有切面配置中的切入点流程3:初始化bean流程4:获取bean执行方法验证容器中是否为代理对象验证思路步骤1:修改App类,获取类的类型步骤2:修改MyAdvice类，不增强步骤3:运行程序步骤4:修改MyAdvice类，增强步骤5:运行程序 AOP配置管理AOP切入点表达式语法格式通配符书写技巧 AOP通知类型类型介绍环境准备通知类型的使用前置通知后置通知环绕通知基本使用注意事项返回后通知异常后通知通知类型总结知识点1：@After知识点2：@AfterReturning知识点3：@AfterThrowing知识点4：@Around 案例-业务层接口执行效率需求分析环境准备功能开发步骤1:开启SpringAOP的注解功能步骤2:创建AOP的通知类步骤3:添加环绕通知步骤4:完成核心业务，记录万次执行的时间步骤5:运行单元测试类步骤6:程序优化步骤7:运行单元测试类 AOP通知获取数据环境准备获取参数非环绕通知获取方式环绕通知获取方式获取返回值环绕通知获取返回值返回后通知获取返回值获取异常环绕通知获取异常抛出异常后通知获取异常百度网盘密码数据兼容处理需求分析环境准备具体实现步骤1:开启SpringAOP的注解功能步骤2:编写通知类步骤3:添加环绕通知步骤4:完成核心业务，处理参数中的空格步骤5:运行程序步骤6:优化测试 AOP总结AOP的核心概念切入点表达式五种通知类型通知中获取参数

AOP简介

什么是AOP?

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

// OOP(Object Oriented Programming)面向对象编程

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

AOP作用

在不惊动原始设计的基础上为其进行功能增强（比如代理模式）

AOP核心概念

案例说明使用了Spring的AOP思想。如下

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

当在App类中从容器中获取bookDao对象后，

分别执行其save,delete,update和select方法后会有如下的打印结果

引出以下问题

对于计算万次执行消耗的时间只有save方法有，为什么delete和update方法也会有呢?delete和update方法有，那什么select方法为什么又没有呢?

这是因为无入侵式/无侵入式

Spring AOP机制?

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

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

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

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

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

以上的总结

连接点(JoinPoint)：程序执行过程中的任意位置，粒度为执行方法、抛出异常、设置变量等在SpringAOP中，理解为方法的执行切入点(Pointcut):匹配连接点的式子在SpringAOP中，一个切入点可以描述一个具体方法，也可也匹配多个方法一个具体的方法:如com.itheima.dao包下的BookDao接口中的无形参无返回值的save方法匹配多个方法:所有的save方法，所有的get开头的方法，所有以Dao结尾的接口中的任意方法，所有带有一个参数的方法连接点范围要比切入点范围大，是切入点的方法也一定是连接点，但是是连接点的方法就不一定要被增强，所以可能不是切入点。通知(Advice):在切入点处执行的操作，也就是共性功能在SpringAOP中，功能最终以方法的形式呈现通知类：定义通知的类切面(Aspect):描述通知与切入点的对应关系。

小结与提问

什么是AOP?AOP的作用是什么?AOP中核心概念分别指的是什么? 连接点切入点通知通知类切面

AOP入门案例

需求分析

案例设定：测算接口执行效率，但是这个案例稍微复杂了点，我们对其进行简化。

简化设定：在方法执行前输出当前系统时间。

对于SpringAOP的开发有两种方式，XML 和注解，我们使用哪个呢?

因为现在注解使用的比较多，所以本次课程就采用注解完成AOP的开发。

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

思路分析

1.导入坐标(pom.xml)
2.制作连接点(原始操作，Dao接口与实现类)
3.制作共性功能(通知类与通知)
4.定义切入点
5.绑定切入点与通知关系(切面)

环境准备

创建一个Maven项目

pom.xml添加Spring依赖

<dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.2.10.RELEASE</version></dependency></dependencies>

添加BookDao和BookDaoImpl类

public interface BookDao {public void save();public void update();}@Repositorypublic 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 ...");}}

创建Spring的配置类

@Configuration@ComponentScan("com.itheima")public class SpringConfig {}

编写App运行类

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

最终创建好的项目结构如下:

模拟运行的结果

目前打印save方法的时候，因为方法中有打印系统时间，所以运行的时候是可以看到系统时间对于update方法来说，就没有该功能我们要使用SpringAOP的方式在不改变update方法的前提下让其具有打印系统时间的功能。

AOP实现步骤

步骤1:添加依赖

pom.xml

<dependency><groupId>org.aspectj</groupId><artifactId>aspectjweaver</artifactId><version>1.9.4</version></dependency>

为什么导入spring-aop

因为spring-context中已经导入了spring-aop,所以不需要再单独导入spring-aop导入AspectJ的jar包。AspectJ是AOP思想的一个具体实现。为什么？Spring有自己的AOP实现，但是相比于AspectJ来说比较麻烦，所以我们直接采用Spring整合ApsectJ的方式进行AOP开发。

步骤2:定义接口与实现类

环境准备的时候，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:制作切面

切面是用来描述通知和切入点之间的关系，如何进行关系的绑定?

public class MyAdvice {@Pointcut("execution(void com.itheima.dao.BookDao.update())")private void pt(){}@Before("pt()")public void method(){System.out.println(System.currentTimeMillis());}}

绑定切入点与通知关系，并指定通知添加到原始连接点的具体执行位置
说明:@Before翻译过来是之前，也就是说通知会在切入点方法执行之前执行，除此之前还有其他四种类型，后面会讲。

步骤6:将通知类配给容器并标识其为切面类

@Component@Aspectpublic class MyAdvice {@Pointcut("execution(void com.itheima.dao.BookDao.update())")private void pt(){}@Before("pt()")public void method(){System.out.println(System.currentTimeMillis());}}

步骤7:开启注解格式AOP功能

@Configuration@ComponentScan("com.itheima")@EnableAspectJAutoProxypublic class SpringConfig {}

步骤8:运行程序

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

知识点小结1：@EnableAspectJAutoProxy

知识点小结2：@Aspect

知识点小结3：@Pointcut

知识点小结4：@Before

AOP工作流程

流程1:Spring容器启动

容器启动就需要去加载bean,哪些类需要被加载呢?需要被增强的类，如:BookServiceImpl通知类，如:MyAdvice注意此时bean对象还没有创建成功

流程2:读取所有切面配置中的切入点

上面这个例子中有两个切入点的配置，但是第一个ptx()并没有被使用，所以不会被读取。

流程3:初始化bean

判定bean对应的类中的方法是否匹配到任意切入点

注意第1步在容器启动的时候，bean对象还没有被创建成功。

要被实例化bean对象的类中的方法和切入点进行匹配

匹配失败，创建原始对象,如UserDao匹配失败说明不需要增强，直接调用原始对象的方法即可。匹配成功，创建原始对象（目标对象）的代理对象,如:BookDao匹配成功说明需要对其进行增强对哪个类做增强，这个类对应的对象就叫做目标对象因为要对目标对象进行功能增强，而采用的技术是动态代理，所以会为其创建一个代理对象最终运行的是代理对象的方法，在该方法中会对原始方法进行功能增强

流程4:获取bean执行方法

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

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

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

如果目标对象中的方法会被增强，那么容器中将存入的是目标对象的代理对象如果目标对象中的方法不被增强，那么容器中将存入的是目标对象本身。所以得到下面验证思路

验证思路

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

步骤1:修改App类,获取类的类型

步骤2:修改MyAdvice类，不增强

因为定义的切入点中，被修改成update1,所以BookDao中的update方法在执行的时候，就不会被增强，

所以容器中的对象应该是目标对象本身。

@Component@Aspectpublic class MyAdvice {@Pointcut("execution(void com.itheima.dao.BookDao.update1())")private void pt(){}@Before("pt()")public void method(){System.out.println(System.currentTimeMillis());}}

步骤3:运行程序

步骤4:修改MyAdvice类，增强

因为定义的切入点中，被修改成update,所以BookDao中的update方法在执行的时候，就会被增强，

所以容器中的对象应该是目标对象的代理对象

步骤5:运行程序

至此对于刚才的结论，我们就得到了验证

**需要注意的是 **不能直接打印对象，

这是因为从上面两次结果中可以看出，直接打印对象走的是对象的toString方法，不管是不是代理对象打印的结果都是一样的，原因是内部对toString方法进行了重写。

AOP配置管理

AOP切入点表达式

语法格式

首先明确两个概念

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

对于切入点的描述，我们其实是有两种方式的

比如前面的例子

描述方式一：执行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：返回值，写返回值类型com.itheima.service：包名，多级包使用点连接UserService:类/接口名称findById：方法名int:参数，直接写参数的类型，多个类型用逗号隔开异常名：方法定义中抛出指定异常，可以省略

通配符

*:单个独立的任意符号，以独立出现，也可以作为前缀或者后缀的匹配符出现

execution（public * com.itheima.*.UserService.find*(*))

匹配com.itheima包下的任意包中的UserService类或接口中所有find开头的带有一个参数的方法

..：多个连续的任意符号，可以独立出现，常用于简化包名与参数的书写

execution（public User com..UserService.findById(..))

匹配com包下的任意包中的UserService类或接口中所有名称为findById的方法

+：专用于匹配子类类型（很少用）

execution(* *..*Service+.*(..))

*Service+，表示所有以Service结尾的接口的子类。

举例说明。如下

execution(void com.itheima.dao.BookDao.update())匹配接口，能匹配到execution(void com.itheima.dao.impl.BookDaoImpl.update())匹配实现类，能匹配到execution(* com.itheima.dao.impl.BookDaoImpl.update())返回值任意，能匹配到execution(* com.itheima.dao.impl.BookDaoImpl.update(*))返回值任意，但是update方法必须要有一个参数，无法匹配，要想匹配需要在update接口和实现类添加参数execution(void com.*.*.*.*.update())返回值为void,com包下的任意包三层包下的任意类的update方法，匹配到的是实现类，能匹配execution(void com.*.*.*.update())返回值为void,com包下的任意两层包下的任意类的update方法，匹配到的是接口，能匹配execution(void *..update())返回值为void，方法名是update的任意包下的任意类，能匹配execution(* *..*(..))匹配项目中任意类的任意方法，能匹配，但是不建议使用这种方式，影响范围广execution(* *..u*(..))匹配项目中任意包任意类下只要以u开头的方法，update方法能满足，能匹配execution(* *..*e(..))匹配项目中任意包任意类下只要以e结尾的方法，update和save方法能满足，能匹配execution(void com..*())返回值为void，com包下的任意包任意类任意方法，能匹配，*代表的是方法execution(* com.itheima.*.*Service.find*(..))将项目中所有业务层方法的以find开头的方法匹配execution(* com.itheima.*.*Service.save*(..))将项目中所有业务层方法的以save开头的方法匹配

//后面两种更符合平常切入点表达式的编写规则

书写技巧

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

AOP通知类型

类型介绍

共提供了5种通知类型

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

为了更好的理解这几种通知类型，我们来看一张图

(1)前置通知，追加功能到方法执行前,类似于在代码1或者代码2添加内容

(2)后置通知,追加功能到方法执行后,不管方法执行的过程中有没有抛出异常都会执行，类似于在代码5添加内容

(3)返回后通知,追加功能到方法执行后，只有方法正常执行结束后才进行,类似于在代码3添加内容，如果方法执行抛出异常，返回后通知将不会被添加

(4)抛出异常后通知,追加功能到方法抛出异常后，只有方法执行出异常才进行,类似于在代码4添加内容，只有方法抛出异常后才会被添加

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

环境准备

创建一个Maven项目

pom.xml添加Spring依赖

<dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.2.10.RELEASE</version></dependency><dependency><groupId>org.aspectj</groupId><artifactId>aspectjweaver</artifactId><version>1.9.4</version></dependency></dependencies>

添加BookDao和BookDaoImpl类

public interface BookDao {public void update();public int select();}@Repositorypublic 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;}}

创建Spring的配置类

@Configuration@ComponentScan("com.itheima")@EnableAspectJAutoProxypublic class SpringConfig {}

创建通知类

@Component@Aspectpublic 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 ...");}}

编写App运行类

最终创建好的项目结构如下:

通知类型的使用

前置通知

修改MyAdvice,在before方法上添加@Before注解

@Component@Aspectpublic 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 ...");}}

后置通知

@Component@Aspectpublic class MyAdvice {@Pointcut("execution(void com.itheima.dao.BookDao.update())")private void pt(){}@Before("pt()")public void before() {System.out.println("before advice ...");}@After("pt()")public void after() {System.out.println("after advice ...");}}

环绕通知

基本使用

@Component@Aspectpublic 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 ...");}}

问题运行结果中，通知的内容打印出来，但是原始方法的内容却没有被执行。

这是因为环绕通知需要在原始方法的前后进行增强，所以环绕通知就必须要能对原始操作进行调用，具体如何实现?

@Component@Aspectpublic 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 ...");}}

说明:proceed()为什么要抛出异常?

原因很简单，看下源码就知道了

再次运行，程序可以看到原始方法已经被执行了

注意事项

(1)原始方法有返回值的处理

修改MyAdvice,对BookDao中的select方法添加环绕通知，

@Component@Aspectpublic 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方法

运行后会报错，错误内容为:

Exception in thread “main” org.springframework.aop.AopInvocationException:Null return value from advice does not match primitive return type for: public abstract int com.itheima.dao.BookDao.select()

at org.springframework.aop.framework.JdkDynamicAopProxy.invoke(JdkDynamicAopProxy.java:226)

at com.sun.proxy.$Proxy19.select(Unknown Source)

at com.itheima.App.main(App.java:12)

错误大概的意思是:空的返回不匹配原始方法的int返回

void就是返回Null原始方法就是BookDao下的select方法

所以如果我们使用环绕通知的话，要根据原始方法的返回值来设置环绕通知的返回值，具体解决方案为:

@Component@Aspectpublic 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 Object aroundSelect(ProceedingJoinPoint pjp) throws Throwable {System.out.println("around before advice ...");//表示对原始操作的调用Object ret = pjp.proceed();System.out.println("around after advice ...");return ret;}}

说明:

为什么返回的是Object而不是int的主要原因是Object类型更通用。

在环绕通知中是可以对原始方法返回值就行修改的。

返回后通知

@Component@Aspectpublic 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 ...");}}

**注意：**返回后通知是需要在原始方法select正常执行后才会被执行，如果select()方法执行的过程中出现了异常，那么返回后通知是不会被执行。后置通知是不管原始方法有没有抛出异常都会被执行。这个案例大家下去可以自己练习验证下。

异常后通知

@Component@Aspectpublic 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 ...");}}

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

环绕通知是如何实现其他通知类型的功能的?

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

通知类型总结

知识点1：@After

知识点2：@AfterReturning

知识点3：@AfterThrowing

知识点4：@Around

环绕通知注意事项

环绕通知必须依赖形参ProceedingJoinPoint才能实现对原始方法的调用，进而实现原始方法调用前后同时添加通知通知中如果未使用ProceedingJoinPoint对原始方法进行调用将跳过原始方法的执行对原始方法的调用可以不接收返回值，通知方法设置成void即可，如果接收返回值，最好设定为Object类型原始方法的返回值如果是void类型，通知方法的返回值类型可以设置成void,也可以设置成Object由于无法预知原始方法运行后是否会抛出异常，因此环绕通知方法必须要处理Throwable异常

介绍完这么多种通知类型，具体该选哪一种呢?

我们可以通过一些案例加深下对通知类型的学习。

案例-业务层接口执行效率

需求分析

需求:任意业务层接口执行均可显示其执行效率（执行时长）
这个案例的目的是查看每个业务层执行的时间，这样就可以监控出哪个业务比较耗时，将其查找出来方便优化。

具体实现的思路:

(1) 开始执行方法之前记录一个时间

(2) 执行方法

(3) 执行完方法之后记录一个时间

(4) 用后一个时间减去前一个时间的差值，就是我们需要的结果。

所以要在方法执行的前后添加业务，经过分析我们将采用环绕通知。

**说明:**原始方法如果只执行一次，时间太快，两个时间差可能为0，所以我们要执行万次来计算时间差。

环境准备

创建一个Maven项目

pom.xml添加Spring依赖

<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>

添加AccountService、AccountServiceImpl、AccountDao与Account类

public interface AccountService {void save(Account account);void delete(Integer id);void update(Account account);List<Account> findAll();Account findById(Integer id);}@Servicepublic class AccountServiceImpl implements AccountService {@Autowiredprivate 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();}}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);}public class Account implements Serializable {private Integer id;private String name;private Double money;//setter..getter..toString方法省略}

resources下提供一个jdbc.properties

jdbc.driver=com.mysql.jdbc.Driverjdbc.url=jdbc:mysql://localhost:3306/spring_db?useSSL=falsejdbc.username=rootjdbc.password=root

创建相关配置类

//Spring配置类:SpringConfig@Configuration@ComponentScan("com.itheima")@PropertySource("classpath:jdbc.properties")@Import({JdbcConfig.class,MybatisConfig.class})public class SpringConfig {}//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;@Beanpublic DataSource dataSource(){DruidDataSource ds = new DruidDataSource();ds.setDriverClassName(driver);ds.setUrl(url);ds.setUsername(userName);ds.setPassword(password);return ds;}}//MybatisConfig配置类public class MybatisConfig {@Beanpublic SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();ssfb.setTypeAliasesPackage("com.itheima.domain");ssfb.setDataSource(dataSource);return ssfb;}@Beanpublic MapperScannerConfigurer mapperScannerConfigurer(){MapperScannerConfigurer msc = new MapperScannerConfigurer();msc.setBasePackage("com.itheima.dao");return msc;}}

编写Spring整合Junit的测试类

@RunWith(SpringJUnit4ClassRunner.class)@ContextConfiguration(classes = SpringConfig.class)public class AccountServiceTestCase {@Autowiredprivate AccountService accountService;@Testpublic void testFindById(){Account ac = accountService.findById(2);}@Testpublic void testFindAll(){List<Account> all = accountService.findAll();}}

最终创建好的项目结构如下:

功能开发

步骤1:开启SpringAOP的注解功能

在Spring的主配置文件SpringConfig类中添加注解

@EnableAspectJAutoProxy

步骤2:创建AOP的通知类

该类要被Spring管理，需要添加@Component

要标识该类是一个AOP的切面类，需要添加@Aspect

配置切入点表达式，需要添加一个方法，并添加@Pointcut

@Component@Aspectpublic class ProjectAdvice {//配置业务层的所有方法@Pointcut("execution(* com.itheima.service.*Service.*(..))")private void servicePt(){}public void runSpeed(){} }

步骤3:添加环绕通知

在runSpeed()方法上添加@Around

@Component@Aspectpublic class ProjectAdvice {//配置业务层的所有方法@Pointcut("execution(* com.itheima.service.*Service.*(..))")private void servicePt(){}//@Around("ProjectAdvice.servicePt()") 可以简写为下面的方式@Around("servicePt()")public Object runSpeed(ProceedingJoinPoint pjp){Object ret = pjp.proceed();return ret;} }

**注意:**目前并没有做任何增强

步骤4:完成核心业务，记录万次执行的时间

步骤5:运行单元测试类

**注意:**因为程序每次执行的时长是不一样的，所以运行多次最终的结果是不一样的。

步骤6:程序优化

引出问题多个方法一起执行测试的时候，控制台都打印的是:

业务层接口万次执行时间:xxxms

我们没有办法区分到底是哪个接口的哪个方法执行的具体时间，具体如何优化?

@Component@Aspectpublic class ProjectAdvice {//配置业务层的所有方法@Pointcut("execution(* com.itheima.service.*Service.*(..))")private void servicePt(){}//@Around("ProjectAdvice.servicePt()") 可以简写为下面的方式@Around("servicePt()")public void runSpeed(ProceedingJoinPoint pjp){//获取执行签名信息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");} }

步骤7:运行单元测试类

补充说明

当前测试的接口执行效率仅仅是一个理论值，并不是一次完整的执行过程。

这块只是通过该案例把AOP的使用进行了学习，具体的实际值是有很多因素共同决定的。

AOP通知获取数据

对于这五种类型都会有参数，返回值和异常吗?

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

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

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

返回后通知环绕通知

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

抛出异常后通知环绕通知

环境准备

创建一个Maven项目

pom.xml添加Spring依赖

添加BookDao和BookDaoImpl类

public interface BookDao {public String findName(int id);}@Repositorypublic class BookDaoImpl implements BookDao {public String findName(int id) {System.out.println("id:"+id);return "itcast";}}

创建Spring的配置类

@Configuration@ComponentScan("com.itheima")@EnableAspectJAutoProxypublic class SpringConfig {}

编写通知类

@Component@Aspectpublic 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 Object 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 ...");}}

编写App运行类

最终创建好的项目结构如下:

获取参数

非环绕通知获取方式

在方法上添加JoinPoint,通过JoinPoint来获取参数

@Component@Aspectpublic class MyAdvice {@Pointcut("execution(* 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 ..." );}//...其他的略}

运行App类，可以获取如下内容，说明参数100已经被获取

引出问题方法的参数只有一个，为什么获取的是一个数组?

因为参数的个数是不固定的，所以使用数组更通配些。

引出问题如果将参数改成两个会是什么效果呢?。如下举例说明

(1)修改BookDao接口和BookDaoImpl实现类

public interface BookDao {public String findName(int id,String password);}@Repositorypublic class BookDaoImpl implements BookDao {public String findName(int id,String password) {System.out.println("id:"+id);return "itcast";}}

(2)修改App类，调用方法传入多个参数

(3)运行App，查看结果,说明两个参数都已经被获取到

环绕通知获取方式

环绕通知使用的是ProceedingJoinPoint，因为ProceedingJoinPoint是JoinPoint类的子类，所以对于ProceedingJoinPoint类中应该也会有对应的getArgs()方法，我们去验证下:

@Component@Aspectpublic class MyAdvice {@Pointcut("execution(* 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;}//其他的略}

运行App后查看运行结果，说明ProceedingJoinPoint也是可以通过getArgs()获取参数

pjp.proceed()方法是有两个构造方法，分别是:
调用无参数的proceed，当原始方法有参数，会在调用的过程中自动传入参数所以调用这两个方法的任意一个都可以完成功能

引出问题但是当需要修改原始方法的参数时，就只能采用带有参数的方法,如下:

@Component@Aspectpublic class MyAdvice {@Pointcut("execution(* 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;}//其他的略}

作用是可以在环绕通知中对原始方法的参数进行拦截过滤，避免由于参数的问题导致程序无法正确运行，保证代码的健壮性。

获取返回值

对于返回值，只有返回后AfterReturing和环绕Around这两个通知类型可以获取，具体如何获取?

环绕通知获取返回值

@Component@Aspectpublic class MyAdvice {@Pointcut("execution(* 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就是方法的返回值，我们是可以直接获取，不但可以获取，如果需要还可以进行修改。

返回后通知获取返回值

@Component@Aspectpublic class MyAdvice {@Pointcut("execution(* com.itheima.dao.BookDao.findName(..))")private void pt(){}@AfterReturning(value = "pt()",returning = "ret")public void afterReturning(Object ret) {System.out.println("afterReturning advice ..."+ret);}//其他的略}

(1)参数名的问题

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

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

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

运行App后查看运行结果，说明返回值已经被获取到

获取异常

对于获取抛出的异常，只有抛出异常后AfterThrowing和环绕Around这两个通知类型可以获取，具体如何获取?

环绕通知获取异常

这块比较简单，以前我们是抛出异常，现在只需要将异常捕获，就可以获取到原始方法的异常信息了

@Component@Aspectpublic 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;}//其他的略}

在catch方法中就可以获取到异常，至于获取到异常以后该如何处理，这个就和你的业务需求有关了。

抛出异常后通知获取异常

@Component@Aspectpublic 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);}//其他的略}

如何让原始方法抛出异常，方式有很多，

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

运行App后，查看控制台，就能看的异常信息被打印到控制台

百度网盘密码数据兼容处理

需求分析

需求: 对百度网盘分享链接输入密码时尾部多输入的空格做兼容处理。

问题描述:

点击链接，会提示，请输入提取码，如下图所示

当我们从别人发给我们的内容中复制提取码的时候，有时候会多复制到一些空格，直接粘贴到百度的提取码输入框

但是百度那边记录的提取码是没有空格的

这个时候如果不做处理，直接对比的话，就会引发提取码不一致，导致无法访问百度盘上的内容

所以多输入一个空格可能会导致项目的功能无法正常使用。

此时我们就想能不能将输入的参数先帮用户去掉空格再操作呢?

答案是可以的，我们只需要在业务方法执行之前对所有的输入参数进行格式处理——trim()

是对所有的参数都需要去除空格么?

也没有必要，一般只需要针对字符串处理即可。

以后涉及到需要去除前后空格的业务可能会有很多，这个去空格的代码是每个业务都写么?

可以考虑使用AOP来统一处理。

AOP有五种通知类型，该使用哪种呢?

我们的需求是将原始方法的参数处理后在参与原始方法的调用，能做这件事的就只有环绕通知。

综上所述，我们需要考虑两件事:

①：在业务方法执行之前对所有的输入参数进行格式处理——trim()

②：使用处理后的参数调用原始方法——环绕通知中存在对原始方法的调用

环境准备

创建一个Maven项目

pom.xml添加Spring依赖

添加ResourcesService，ResourcesServiceImpl,ResourcesDao和ResourcesDaoImpl类

public interface ResourcesDao {boolean readResources(String url, String password);}@Repositorypublic class ResourcesDaoImpl implements ResourcesDao {public boolean readResources(String url, String password) {//模拟校验return password.equals("root");}}public interface ResourcesService {public boolean openURL(String url ,String password);}@Servicepublic class ResourcesServiceImpl implements ResourcesService {@Autowiredprivate ResourcesDao resourcesDao;public boolean openURL(String url, String password) {return resourcesDao.readResources(url,password);}}

创建Spring的配置类

@Configuration@ComponentScan("com.itheima")public class SpringConfig {}

编写App运行类

public class App {public static void main(String[] args) {ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);ResourcesService resourcesService = ctx.getBean(ResourcesService.class);boolean flag = resourcesService.openURL("/haha", "root");System.out.println(flag);}}

最终创建好的项目结构如下:

现在项目的效果是，当输入密码为"root"控制台打印为true,如果密码改为"root "控制台打印的是false

需求是使用AOP将参数进行统一处理，不管输入的密码root前后包含多少个空格，最终控制台打印的都是true。

具体实现

步骤1:开启SpringAOP的注解功能

@Configuration@ComponentScan("com.itheima")@EnableAspectJAutoProxypublic class SpringConfig {}

步骤2:编写通知类

@Component@Aspectpublic class DataAdvice {@Pointcut("execution(boolean com.itheima.service.*Service.*(*,*))")private void servicePt(){}}

步骤3:添加环绕通知

@Component@Aspectpublic class DataAdvice {@Pointcut("execution(boolean com.itheima.service.*Service.*(*,*))")private void servicePt(){}@Around("DataAdvice.servicePt()")// @Around("servicePt()")这两种写法都对public Object trimStr(ProceedingJoinPoint pjp) throws Throwable {Object ret = pjp.proceed();return ret;}}

步骤4:完成核心业务，处理参数中的空格

@Component@Aspectpublic class DataAdvice {@Pointcut("execution(boolean com.itheima.service.*Service.*(*,*))")private void servicePt(){}@Around("DataAdvice.servicePt()")// @Around("servicePt()")这两种写法都对public Object trimStr(ProceedingJoinPoint pjp) throws Throwable {//获取原始方法的参数Object[] args = pjp.getArgs();for (int i = 0; i < args.length; i++) {//判断参数是不是字符串if(args[i].getClass().equals(String.class)){args[i] = args[i].toString().trim();}}//将修改后的参数传入到原始方法的执行中Object ret = pjp.proceed(args);return ret;}}

步骤5:运行程序

不管密码root前后是否加空格，最终控制台打印的都是true

步骤6:优化测试

为了能更好的看出AOP已经生效，我们可以修改ResourcesImpl类，在方法中将密码的长度进行打印

@Repositorypublic class ResourcesDaoImpl implements ResourcesDao {public boolean readResources(String url, String password) {System.out.println(password.length());//模拟校验return password.equals("root");}}

再次运行成功，就可以根据最终打印的长度来看看，字符串的空格有没有被去除掉。

AOP总结

AOP的核心概念

概念：AOP(Aspect Oriented Programming)面向切面编程，一种编程范式

作用：在不惊动原始设计的基础上为方法进行功能增强

核心概念

代理（Proxy）：SpringAOP的核心本质是采用代理模式实现的连接点（JoinPoint）：在SpringAOP中，理解为任意方法的执行切入点（Pointcut）：匹配连接点的式子，也是具有共性功能的方法描述通知（Advice）：若干个方法的共性功能，在切入点处执行，最终体现为一个方法切面（Aspect）：描述通知与切入点的对应关系目标对象（Target）：被代理的原始对象成为目标对象