spring 两大核心: ioc 和 aop ; (ioc : 控制反转 , aop : 面相切面编程)
AOP
AOP: 面向切面编程 , 可以看作是面向对象编程的补充 ;
aop是一种思想,是对某一类事情的集中处理 (例如: 统一功能处理(拦截器,统一结果,统一异常) , 统一功能处理事AOP 的实现 )
切面: 某一类公共的事情 ;
使用AOP
场景: 某一个接口慢,需要时间多(例如: 500ms以内,但他却需要800ms)
方法: 打印时间戳, 判断哪里慢了 ,通过log.info打印时间戳 ;
每个接口里都有许多方法在调用, 都需要 记录 方法调用前的时间戳 和 方法 调用后的时间戳 , 然后计算方法 所消耗的时间
这样的事情,都是相同的事情, 符合 AOP , 对某一类的事情集中处理 ;
实现AOP
-
引入依赖 ( AOP的实现方式很多,例如: AspectJ , 这里用 Spring AOP)
-
实现切面逻辑 (切面: 就是某一类公共的事情)
AOP依赖
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency>
实现切面逻辑
切面逻辑:
-
记录开始时间
-
执行目标方法
-
记录结束时间
-
记录消耗时间
设置controller包里的所有类,所有方法 生效 , 当这些方法运行时就会将消耗的时间打印出来 ;
获取到是 哪个方法打印的日志
使用 getSignature() 获取目标方法的签名,就可以知道是哪个方法打印的消耗时间
代码解释
1.
**2. 返回结果 :**接口的返回结果必须将其返回, 如果不返回 ,那么接口也不会返回结果 (这里设置成void ,不返回结果, 导致 所有生效范围内的接口都不会返回结果 ;)
总步骤
切面: 切点+通知 (一个切面类里可以有多个切面)
切点: 切面执行的范围 ;
连接点,切面作用到的地方,亦可以说是目标方法;
通知: 切面具体要做的事情 ;
通知类型 : 什么时间执行 通知内容 ;
通知类型 :
@Around: 环绕通知 : 通知在 目标方法执行前, 目标方法执行后 执行 ; (常用)
@Before : 前置通知 , 通知 在目标方法执行前执行 ;
@After : 后置通知 , 通知在目标方法执行后执行 ;
@AfterReturnning : 返回通知 , 在目标方法返回后通知 ;
@AfterThrowing : 异常后通知 , 在目标方法发生异常后 通知 ;
AOP优势
代码无入侵,不修改原来代码,就可以对原来的业务进行功能的增强
通知详解
@Around是环绕通知,所以需要有连接点 ,需要将目标方法返回 , 而其他 通知则不能使用 ProceedingJoinPoint 连接点 ;
通知执行顺序
当一个切面里同时存在 多个通知类型(有@Around , @Before...) , 执行的顺序
- 正常响应时
从最外层进入,执行目标方法,然后出来; @Around是在最外层 ;
2. 发生异常时
原来执行目标方法后的Around通知不执行了, 目标方法正常返回后的AfterReturning通知也不执行了 ;
处理异常
切点定义 @Pointcut
将切点 提取出来,定义好, 就可以直接用定义好的切点, 而不是每个切面都用 切点表达式 ;
其他类里使用切点
在不同类里使用切点,需要用到定义切点的全限定类名.切点名() ;
不同的切面类里有相同的切点
多个切面类里有相同的切点,那么执行通知的顺序:
切面里抛异常应该try catch (Throwable 异常)
多个切面类有相同的切点时执行顺序按类名来排序
设置切面类的执行顺序 @Order
@Order不止可以在AOP里使用 , 也适用于其他方面 , 可以用来排序不同类的Bean (例如:拦截器,有多个拦截器也可以通过Order排序)
@Order(排序值): order里的值越小 ,执行的优先级越大, order值越大, 执行优先级越小;
切点表达式
execution (根据方法的签名匹配)
execution(<访问限定修饰符> <返回类型> <包名.类名.方法(方法参数) <异常> ) ; 访问限定修饰符 , 和异常可以省略 ;
通配符
- "*" 匹配一个元素
一个 * 表示包名: 任意一个包名
类: 表示任意类
返回值: 表示任意返回值 ;
方法名: 表示任意方法 ;
参数: 一个任意类型的参数 ;
- ".." 匹配多个连续的任意字符
包名 xx/.. : 表示 xx包下的任意包和所有子包 ;
参数 : 可以表示 任意个 任意类型的 参数
@annotation (根据注解匹配)
根据方法所使用的注解来匹配 : @annotaion(注解全限定类名)
但是这样会导致原本的注解(@RequestMapping)多出不必要的功能 ; 像@RequestMapping本来就是设置路径的,加了@annotation又多出了其他功能 ;
例如: 原本我只需要 t1 切点有切面逻辑处理 , 但是因为@annotation ,导致其他的使用@RequestMapping注解的地方也被处理了,例如t2 ;
使用自定义注解实现AOP
上面通过@annotation来匹配切点, 类似与@Controller,@ResponseBody这些注解,已经有他们固定的作用,如果加上AOP,加上一段切面逻辑,会影响使用这些注解的接口 ;
通过自定义注解 , 来实现AOP ;
-
定义注解
-
实现注解要完成的功能
-
使用注解
定义注解
自定义注解可以参考 其他注解的定义 ; (@注解的定义,注解的属性)
创建一个自定义注解
实现注解功能
使用注解
使用 t1和 t2 接口(t1和t2有自定义注解@TimeRecord,其他没有注解的就不会有这个计算耗时的逻辑)
AOP面试题
SpringAOP的实现方式
-
基于注解@Aspect实现
-
自定义注解实现(@annotation实现)
-
基于Spring api实现(通过配置xml的方式)
-
基于代理实现(最低层的,即上面的都是通过代理实现的)
SpringAOP原理(重点)
SpringAOP是基于 动态代理 实现的AOP ;
代理模式(重点)
代理模式(也叫委托模式),也是经典设计模式;
有些时候,一个调用方对象 不适合 或 不能 直接 调用 一个目标对象 , 而代理对象可以 在 调用方 和 目标方 起到中介作用 ;
海外代理 ; 买一个国外的产品 我 不能直接去 国外买产品 ; 但 可以通过 代理商 买到 ; 代理商 有 国外厂商授权允许; 代理商 并不会生产产品 , 真正生产产品的 还是 国外厂商;
代理模式里的关键对象 : 代理类 , 目标类(被代理对象) , 我们是和 代理类打交道 , 但是代理类 的 底层是有 目标类 实现的 ;
例如: A 类 是 B类的代理类 , 我们通过 调用 A 类 间接 去调用 B类 ;
proxy实现 (代理实现)
代理类不仅有 目标类的功能 , 并且还有对目标类进行功能的增强(加了一些功能) ; (例如: AOP就是在 目标的基础上 加上了自己的功能)
这里代理模式的实现方式和 适配器的实现方式一样
(设计模式主要是思想,它的实现方式有多种多样)
当 如果房东有任何的变动 , 例如: 加了售卖房子,装修等服务, 相对的 中介类也要有对应的改变 , 加上各种服务 ;
但其实 中介的工作流程都是 : 中介代理服务... => 房东服务 => 中介结束代理.. ;
总不能房东每变动一个方法, 中介就跟着变动一个方法 ;
中介就可以指定一套规范的标准 , 把这些重复的一类流程提出了
这就是 AOP
SpringAOP的底层就是 通过代理模式实现的 ;
根据代理的创建时期 , 分为静态代理 和 动态代理 ;
静态代理
静态代理就是 每有一个目标类 , 都有一个对应的 代理对象 ; (像上面的房东和中介一样 , 有一个房东就有一个中介类 )
有一个目标类 , 就有一个 代理类 , 在程序运行前 ,代理类就有.class文件
动态代理
在程序运行时, 运用反射机制动态创建 代理 ; (在运行时动态的生成代理 , 而不是提前全部写好)
动态代理实现
动态代理实现方式有:
-
JDK动态代理
-
CGlib
JDK 动态代理
jdk代理的缺点
只能代理接口 , 不能代理普通类
( 即使是 实现接口的类,可以代理 , 但是没有实现接口的不能; 例如: A接口 , B类实现了A 接口 , 所以可以代理 B类, c类谁都没有实现 , 无法代理c类 ;)
CGlib代理
- 引入依赖
<dependency> <groupId>cglib</groupId> <artifactId>cglib</artifactId> <version>3.3.0</version> </dependency>
CGlib动态代理的实现和jdk动态代理类似 ;
CGlib 代理 和 jdk代理 的主要区别
CGlib动态代理 可以 代理 没有实现接口的 普通类 ;
总结
AOP是什么?
AOP是一种思想 , 是对一类事情进行统一处理 ;
SpringAOP 是怎么实现的
SpringAOP是通过 动态代理实现的 ;
什么时候使用jdk , 什么时候使用 CGlib ,
jdk代理是什么 ? CG代理是什么 ;
SpringAOP主要 基于 JDK动态代理 和 CGlib动态代理实现 ,
什么时候使用 JDK代理 什么时候使用 CGlib代理 , 也看程序员的配置 ;
SpringAOP 的 代理工厂 里有一个属性: proxyTargetClass , 默认值是 false; (实现接口的 ,统一使用 JDK动态代理 , 普通类 ,使用CGlib动态代理) , 通过 配置 把proxyTargetClass 设置为 true , 则 无论是实现了接口的类 还是 普通类 , 都使用CGlib 动态代理的方式实现 ;
代理工厂创建 代理时, 有一条if( isProxyTargetClass) {} else {创建JDK代理} , 所以 当proxyTargetClass为false使 , 默认创建的都是JDK代理
Springboot 2.x 以后, 默认都使用 CGlib动态代理 , 也可以通过配置 , 设置为 默认 JDK动态代理, 普通类使用 CGlib
application配置项 , 配置默认为JDK代理 ;
Spring AOP 使用什么代理?
(大体分两个情况, 两个稍微有些地方不同)
-
Spring framework :
-
SpringBoot
共同点: 两者底层实现都用的 JDK 代理 和 CGlib代理
不同点:
Spring framework
代理的是接口, 使用 JDK代理 , 代理 没有实现接口 的类 , 使用 CGlib 代理;
Spring Boot
2.x 之后的版本:
默认配置都使用 CGlib 代理, 无论有没有实现接口 , 都用CGlib代理 ,需要用 JDK代理 , 可以在 application配置 ;
2.x之前的 版本:
默认使用 JDK代理 , 和 Springframework 保持一致 ;
为什么两这会不同:
proxyTargetClass的默认值配置不同 , SpringBoot在2.x之后的版本里, proxyTargetClass的值默认配置为 true ;
Spring怎么判断 接口和 没有实现接口的普通类
接口里最少要有一个 自定义的方法:
没有实现接口的类 , 或是 实现了接口的类 , 但是接口里没有一个方法 , 这些 都划分为 没有实现接口的普通类 , 都使用 CGlib ;
实现了接口的类 , 同时接口了 至少有一个自定义方法 , 这些才算是 : 实现接口的类
代码细节
使用Test1和Test2来测试 SpringAOP 到底使用的是哪个代理 ;
- 在没有任何配置的默认情况下 ;
- 通过application配置修改 为 JDK代理;
需要调整代码,改成使用 接口类型来接收bean , 就可以正常使用 JDK代理 ;
public class SpringAopApplication { public static void main(String[] args) { ApplicationContext context = SpringApplication.run(SpringAopApplication.class, args); // 1.在没有任何配置修改的情况下: 两种情况都能够正常代理 // Test1 t1 = context.getBean(Test1.class); // t1.say(); // System.out.println(t1.getClass().toString()); // System.out.println("--------------------------------"); // Test2 t2 = context.getBean(Test2.class); // t2.say(); // System.out.println(t2.getClass().toString()); // 2. 修改配置为 JDK代理 // 这个实现了接口的已经不能打印了 ,因为JDK要用的是接口这里应该改成接口来用 // Test1 t1 = context.getBean(Test1.class); // t1.say(); // System.out.println(t1.getClass().toString()); // 改成接口 来接收bean , 同时bean也改成用 bean名字作为参数 , // 能够正常使用 JDK代理 TestIntFace testIntFace = (TestIntFace) context.getBean("test1"); testIntFace.say(); System.out.println(testIntFace.getClass().toString()); // 普通类能够正常被 CGlib代理 // System.out.println("--------------------------------"); // Test2 t2 = context.getBean(Test2.class); // t2.say(); // System.out.println(t2.getClass().toString()); } }
判断是否为接口
1. 当接口中有自定义的方法时 , 使用的是JDK代理
2. 当接口里没有自定义方法 ;
