【Spring】AOP入门（一）
一.什么是AOP
Spring有两个核心的概念，一个是IOC/DI，一个是AOP。
我们都知道OOP是一种编程思想，而AOP也是一种编程思想，编程思想主要的内容就是指导程序员该如何编写程序，所以它们两个是不同的编程范式。
- AOP(Aspect Oriented Programming)面向切面编程（面向特定方法编程），一种编程范式，指导开发者如何组织程序结构。
那么它对我们编程有什么作用呢？
- 它能帮助我们在
不改动原有代码的前提下对其进行功能增强。
二.作用
为了能更好的理解AOP的相关概念以及作用，我们通过一些使用场景来学习它~
(1) 引入案例
假如我们有一个项目，上线后发现项目执行效率比较低，我们准备优化一些执行比较耗时的业务功能，此时就需要统计每一个业务方法的执行耗时。但是我们的项目中方法的数量令人头疼…
想必没人愿重复做若干遍相同的操作，就算你做了，假如我们优化完了，这些测试就比较多余了，再让你一个个去掉…不知有何感想~
而我们使用AOP面向切面编程便可以很轻松的完成这个工作，做到在不改变原始方法的情况下，对原始方法进行编程（增强或改变）。
我们可以定义一个模板方法，将通用的逻辑定义在模板方法中，再在模板方法中调用原始方法。当我们调用原始方法时，将不会直接执行原始方法，而是转而执行模板方法并在其中开始原始方法的执行。
(2) 案例实现
实现过程我们暂时可以不用关注，只需看我们在不修改原始方法的情况下，给下面四个方法进行万次执行耗时测试的效果。
// 原始方法类
@Repository
public class BookDaoImpl implements BookDao {
public void save(){
System.out.println("book dao save ...");
}
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 ...");
}
}
我们来定义模板方法测试他们，语法暂时不用关心~
@Component
@Aspect
public class MyAdvice {
@Pointcut("execution(* com.guanzhi.dao.BookDao.*(..))")
private void pt(){}
// 测试方法万次执行耗时
@Around("pt()")
public Object around(ProceedingJoinPoint pjp) throws Throwable {
System.out.println("------------------------------");
Long startTime = System.currentTimeMillis();
for (int i = 0 ; i<10000 ; i++) {
//调用原始操作
pjp.proceed();
}
Long endTime = System.currentTimeMillis();
Long totalTime = endTime-startTime;
System.out.println("执行万次消耗时间：" + totalTime + "ms");
return null;
}
}
我们分别执行上述save,delete,update和select方法后会有如下的打印结果:
可以看到我们未对上述原始方法进行任何的修改，却成功的给他们都加上了耗时测试，一劳永逸是不是很爽呀？
(3) 小结
除此之外，AOP还可以帮助我们很快很方便的实现众多功能，例如：
- 统一记录操作日志
- 统一进行权限控制
- 事务管理
- …
它有着许多的优势使我们开发体验更好：
- 代码无侵入，增加功能不影响原始代码
- 减少众多重复代码的编写
- 维护方便，需要发生更改时我们只要修改模板方法即可
- …
三.核心概念
(1) 引入
说了这么多，Spring到底是如何实现的呢？接下来我们一起了解一下AOP的相关概念。
前面一直在强调，Spring的AOP是对一个类的方法在不进行任何修改的前提下实现增强。对于上面的案例中BookServiceImpl中有
save,update,delete和select方法,这些方法我们给起了一个名字叫连接点这四个方法中都只有打印而没有计算万次执行消耗时间的功能，但是在运行的时候已经有该功能，那也就是说这几个方法都已经被增强，所以对于需要增强的方法我们给起了一个名字叫
切入点在执行这四个方法的时候都被添加了一个计算万次执行消耗时间的功能，将这个功能抽取到一个方法中，换句话说就是存放共性功能的方法，我们给起了个名字叫
通知通知是要增强的内容，会有多个，切入点是需要被增强的方法，也会有多个，那哪个切入点需要添加哪个通知，就需要提前将它们之间的关系描述清楚，那么对于通知和切入点之间的关系描述，我们给起了个名字叫
切面通知是一个方法，方法不能独立存在需要被写在一个类中，这个类我们也给起了个名字叫
通知类
概括来说就是：首先我们先找到程序中的共性功能抽取出来，写一个通知类，在通知类中定义一个方法，这个方法就叫做通知，我们再把需要执行通知的方法找出来，也就是切入点，最后我们再把他们之间进行绑定也就是切面。
(2) 总结
连接点(JoinPoint)：程序执行过程中的任意位置，粒度为执行方法、抛出异常、设置变量等- 在SpringAOP中，理解为方法的执行
切入点(Pointcut):匹配连接点的式子- 在SpringAOP中，一个切入点可以描述一个具体方法，也可也匹配多个方法
- 一个具体的方法:如com.guanzhi.dao包下的BookDao接口中的无形参无返回值的save方法
- 匹配多个方法:所有的save方法，所有的get开头的方法，所有以Dao结尾的接口中的任意方法，所有带有一个参数的方法
- 连接点范围要比切入点范围大，是切入点的方法也一定是连接点，但是是连接点的方法就不一定要被增强，所以可能不是切入点。
- 在SpringAOP中，一个切入点可以描述一个具体方法，也可也匹配多个方法
通知(Advice):在切入点处执行的操作，也就是共性功能- 在SpringAOP中，功能最终以方法的形式呈现
通知类：定义通知的类切面(Aspect):描述通知与切入点的对应关系。
四.入门案例
了解了AOP的作用与概念之后，接下来让我们一步一步的来使用一下AOP面向切面编程~
(1) 引入
上述测试接口执行效率案例稍微有点繁琐，为了方便我们初学AOP的使用，我们对其进行简化，只在方法执行前输出当前系统时间。
此外对于SpringAOP的开发也有两种方式，XML 和 注解，由于现在注解使用的比较多，所以我们就采用注解完成案例。
需求明确后，具体该如何实现，都有哪些步骤，我们先来分析下:
导入相关坐标(pom.xml)
制作连接点(原始操作，Dao接口与实现类)
制作共性功能(通知类与通知)
定义切入点
绑定切入点与通知关系(切面)
(2) 环境准备
创建一个Maven项目,在pom.xml添加spring-aop相关依赖
<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>
因为spring-context中已经导入了spring-aop,所以不需要再单独导入spring-aop
AspectJ是AOP思想的一个具体实现，Spring有自己的AOP实现，但是相比于AspectJ来说比较麻烦，所以我们直接采用Spring整合ApsectJ的方式进行AOP开发。
制作BookDao和BookDaoImpl类
public interface BookDao { public void save(); public void update(); } @Repository public class BookDaoImpl implements BookDao { public void save() { System.out.println("book dao save ..."); } public void update(){ System.out.println("book dao update ..."); } }创建Spring的配置类
@Configuration @ComponentScan("com.guanzhi") 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(); } }
最终创建好的项目结构如下:
再说明一下我们的目的：使用SpringAOP的方式在不改变方法的前提下让其具有打印系统时间的功能。
(3) AOP实现步骤
(3.1) 定义通知类和通知
- 通知就是将共性功能抽取出来后形成的方法，共性功能指的就是当前系统时间的打印。
// 通知类
public class MyAdvice {
// 通知
// 打印当前系统时间的
public void method(){
System.out.println(System.currentTimeMillis());
}
}
类名和方法名没有要求，可以任意。
(3.2) 定义切入点
- BookDaoImpl中有两个方法，分别是save和update，我们现在只增强的是update方法，该如何定义呢?
// 通知类
public class MyAdvice {
// 定义切入点
@Pointcut("execution(void com.guanzhi.dao.BookDao.update())")
private void pt(){}
// 通知
public void method(){
System.out.println(System.currentTimeMillis());
}
}
说明:
- 切入点定义依托一个不具有实际意义的方法进行，即无参数、无返回值、方法体无实际逻辑，还有另一种写法后面会讲。
- execution及后面编写的内容，先不必关心，后面我们也会讲到。
(3.3) 制作切面
切面是用来描述通知和切入点之间的关系，如何进行关系的绑定?
// 通知类
public class MyAdvice {
// 定义切入点
@Pointcut("execution(void com.guanzhi.dao.BookDao.update())")
private void pt(){}
// 通知
// 绑定切入点与通知关系，并指定通知添加到原始连接点的具体执行位置(Before)
@Before("pt()")
public void method(){
System.out.println(System.currentTimeMillis());
}
}
说明:@Before翻译过来是之前，也就是说通知会在切入点方法执行之前执行，除此之前还有其他四种类型，后面会讲。
(3.4) 标识切面类
目前我们的Spring容器并不知道它的存在，更不知道它是通知类，因此我们还需要给他加上相应注解。
// 交给Spring管理
@Component
// 定义为切面类
@Aspect
public class MyAdvice {
@Pointcut("execution(void com.guanzhi.dao.BookDao.update())")
private void pt(){}
@Before("pt()")
public void method(){
System.out.println(System.currentTimeMillis());
}
}
(3.5) 开启注解格式AOP功能
我们开始说到了使用注解开发，由此需要开启相应功能告知Spring加载相关功能
@Configuration
@ComponentScan("com.guanzhi")
@EnableAspectJAutoProxy
public class SpringConfig {
}
(3.6) 运行程序
好了，我们终于可以测试我们的程序了~
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编程成功。
(4) 相关注解说明
@EnableAspectJAutoProxy
| 名称 | @EnableAspectJAutoProxy |
|---|---|
| 类型 | 配置类注解 |
| 位置 | 配置类定义上方 |
| 作用 | 开启注解格式AOP功能 |
@Aspect
| 名称 | @Aspect |
|---|---|
| 类型 | 类注解 |
| 位置 | 切面类定义上方 |
| 作用 | 设置当前类为AOP切面类 |
@Pointcut
| 名称 | @Pointcut |
|---|---|
| 类型 | 方法注解 |
| 位置 | 切入点方法定义上方 |
| 作用 | 设置切入点方法 |
| 属性 | value（默认）：切入点表达式 |
@Before
| 名称 | @Before |
|---|---|
| 类型 | 方法注解 |
| 位置 | 通知方法定义上方 |
| 作用 | 设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法前运行 |
通知类型还有几种我们后期会一一学习到~
五.工作流程
我们已经完成了AOP的入门案例，接下来我们一起对于刚才案例的执行过程进行分析。
由于AOP是基于Spring容器管理的bean做的增强，所以整个工作过程需要从Spring加载bean说起
(1) Spring容器启动
- 容器启动就需要去加载bean,上述案例中哪些类需要被加载呢?
- 需要被增强的类，如:BookServiceImpl
- 通知类，如:MyAdvice
- 注意此时bean对象还没有创建成功
(2) 读取所有切面配置中的切入点
- 上面这个例子中有两个切入点的配置，但是第一个
ptx()并没有被使用，所以不会被读取。
(3) 初始化bean
判定bean对应的类中的方法是否匹配到任意切入点
注意第1步在容器启动的时候，bean对象还没有被创建成功。
让要被实例化bean对象的类中的方法和切入点进行匹配
- 匹配失败，创建原始对象,如
UserDao- 匹配失败说明不需要增强，直接调用原始对象的方法即可。
- 匹配成功，创建原始对象（目标对象）的代理对象,如:
BookDao- 匹配成功说明需要对其进行增强
- 对哪个类做增强，这个类对应的对象就叫做目标对象
- 因为要对目标对象进行功能增强，而采用的技术是动态代理，所以会为其创建一个代理对象
- 最终运行的是代理对象的方法，在该方法中会对原始方法进行功能增强
- 匹配失败，创建原始对象,如
(4) 获取bean执行方法
- 获取的bean是
原始对象时，调用相应方法并执行，完成操作 - 获取的bean是
代理对象时，根据代理对象的运行模式运行原始方法与增强的内容，完成操作
(5) 验证容器中是否为代理对象
为了验证IOC容器中创建的对象和我们刚才所说的结论是否一致，首先把结论理出来:
- 如果目标对象中的方法会被增强，那么容器中将存入的是目标对象的代理对象
- 如果目标对象中的方法不被增强，那么容器中将存入的是目标对象本身。
(5.1) 验证思路
先让要执行的方法，不被定义的切入点包含，即不增强，打印当前类的getClass()方法
再让要执行的方法，被定义的切入点包含，即增强，打印出当前类的getClass()方法
观察两次打印的结果
(5.2) 修改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());
}
}
(5.3) 修改MyAdvice类，不增强
因为定义的切入点中，被修改成update1,所以BookDao中的update方法在执行的时候，就不会被增强，
所以容器中的对象应该是目标对象本身。
@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());
}
}
(5.4) 运行程序
(5.5) 修改MyAdvice类，增强
因为定义的切入点中，被修改成update,所以BookDao中的update方法在执行的时候，就会被增强，
所以容器中的对象应该是目标对象的代理对象
@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());
}
}
(5.6) 运行程序
至此对于刚才的结论，我们就得到了验证，这块大家需要注意的是:
不能直接打印对象，从上面两次结果中可以看出，直接打印对象走的是对象的toString方法，不管是不是代理对象打印的结果都是一样的，原因是内部对toString方法进行了重写。
(6) 核心概念补充
在上面介绍AOP的工作流程中，我们提到了两个核心概念，分别是:
- 目标对象(Target)：原始功能去掉共性功能对应的类产生的对象，这种对象是无法直接完成最终工作的
- 代理对象(Proxy)：目标对象无法直接完成工作，需要对其进行功能回填，通过原始对象的代理对象实现
上面这两个概念比较抽象，简单来说，
目标对象就是要增强的类[如:BookServiceImpl类]对应的对象，也叫原始对象，不能说它不能运行，只是它的运行效果不能够令我们满意。
SpringAOP是在不改变原有设计(代码)的前提下对其进行增强的，它的底层采用的是代理模式实现的，所以要对原始对象进行增强，就需要对原始对象创建代理对象，在代理对象中的方法把通知 [如:MyAdvice中的method方法] 内容加进去，就实现了增强,这就是我们所说的代理(Proxy)。
- 点赞
- 收藏
- 关注作者
评论（0）