day03 Spring-AOP面向切面编程
day03 Spring-AOP面向切面编程
1.AOP的概述
1.1 为什么需要AOP
1.1.1 情景设定
1.1.1.1 声明一个计算器接口
public interface Calculator {
int add(int i, int j);
int sub(int i, int j);
int mul(int i, int j);
int div(int i, int j);
}
1.1.1.2 给接口声明一个纯净版实现类
package com.atuigu;
/**
* 计算器接口的实现类
*/
public class CalculatorPureImpl implements Calculator {
@Override
public int add(int i, int j) {
return i + j;
}
@Override
public int sub(int i, int j) {
return i - j;
}
@Override
public int mul(int i, int j) {
return i * j;
}
@Override
public int div(int i, int j) {
return i / j;
}
}
1.1.1.3 需求
在计算器的每个方法执行前后加入日志打印
1.1.1.4 实现方案探讨
方案一：在每个方法的前后都加上日志打印的代码
方案二：创建一个工具类，将日志打印的代码写在工具类中，然后再每个方法的前后直接调用工具类中的方法打印日志
方案三：创建一个父类，在父类的方法中打印日志，子类重写父类的方法(对目前功能不适用)
方案四：动态代理
方案五：AOP
2.代理模式
2.1 概念
二十三种设计模式中的一种，属于结构型模式。它的作用就是通过提供一个代理类，让我们在调用目标方法的时候，不再是直接对目标方法进行调用，而是通过代理类间接调用。让不属于目标方法核心逻辑的代码从目标方法中剥离出来——解耦。调用目标方法时先调用代理对象的方法，减少对目标方法的调用和打扰，同时让附加功能能够集中在一起也有利于统一维护。
未经过代理的情况:
使用了代理模式的情况:
2.2 相关术语
- 代理: 又称之为代理者，用于将非核心逻辑剥离出来以后，封装这些非核心逻辑的类、对象、方法
- 目标: 又称之为被代理者，用于执行核心逻辑，并且将代理者的非核心逻辑代码套用在目标类、对象、方法上
2.3 静态代理
2.3.1 创建静态代理类：
先添加依赖包
<dependencies>
<dependency>
<groupId>junitgroupId>
<artifactId>junitartifactId>
<version>4.13version>
<scope>testscope>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-contextartifactId>
<version>5.3.1version>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-testartifactId>
<version>5.3.1version>
dependency>
dependencies>
创建代理类
package com.atuigu.proxy;
import com.atuigu.Calculator;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
/**
* 代理类
*/
@Component
public class CalculatorProxy implements Calculator {
// 自动装配 根据类型进行依赖注入
@Autowired
private Calculator calculator;
@Override
public int add(int i, int j) {
System.out.println("日志 add 方法开始了，参数是：" + i + "," + j);
// 调用代理对象的核心方法
int result = calculator.add(i, j);
System.out.println("日志 add 方法结束了，结果是:" + result);
return result;
}
@Override
public int sub(int i, int j) {
System.out.println("日志 sub 方法开始了，参数是：" + i + "," + j);
// 调用代理对象的核心方法
int result = calculator.sub(i, j);
System.out.println("日志 sub 方法结束了，结果是:" + result);
return result;
}
@Override
public int mul(int i, int j) {
System.out.println("日志 mul 方法开始了，参数是：" + i + "," + j);
// 调用代理对象的核心方法
int result = calculator.mul(i, j);
System.out.println("日志 mul 方法结束了，结果是:" + result);
return result;
}
@Override
public int div(int i, int j) {
System.out.println("日志 div 方法开始了，参数是：" + i + "," + j);
// 调用代理对象的核心方法
int result = calculator.div(i, j);
System.out.println("日志 div 方法结束了，结果是:" + result);
return result;
}
}
2.3.2 测试结果
package com.atguigu;
import com.atuigu.Calculator;
import com.atuigu.proxy.CalculatorProxy;
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 javax.annotation.Resource;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring.xml")
public class CalculatorTest {
// 自动装配 根据类型匹配
@Autowired
private CalculatorProxy calculatorProxy;
@Test
public void test01(){
System.out.println(calculatorProxy.add(1, 2));
}
}
实现需求
2.3.3 问题思考
静态代理确实实现了解耦，但是由于代码都写死了，完全不具备任何的灵活性。就拿日志功能来说，将来其他地方也需要附加日志，那还得再声明更多个静态代理类，那就产生了大量重复的代码，日志功能还是分散的，没有统一管理。
提出进一步的需求：将日志功能集中到一个代理类中，将来有任何日志需求，都通过这一个代理类来实现。这就需要使用动态代理技术了。
2.4 动态代理
2.4.1 创建生产代理对象的工厂类
JDK本身就支持动态代理，这是反射技术的一部分。下面我们还是创建一个代理类(生产代理对象的工厂类)
package com.atuigu.proxy;
import com.atuigu.Calculator;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
/**
* 在此类中编写代理规则
*/
public class AtguiguInvocationHandler<T> implements InvocationHandler {
// 被代理者
private T t;
public AtguiguInvocationHandler(T t) {
this.t = t;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 1.invoke()方法它会在代理对象调用任何方法的时候都执行，所以我们在invoke()方法中编写代理规则
// 参数一 proxy:指定的是代理对象
// 参数二 method：指定的是代理对象调用的方法
String methodName = method.getName();
// 参数三 args:指定的是代理对象调用的方法传入的参数
// 编写代理的规则
// 1.如果被代理者是Calculator接口的实现类，并且调用的方法不是Object类的方法(就表示调用的是加减乘除方法)
if (t instanceof Calculator && !Object.class.equals(method.getDeclaringClass())){
System.out.println("日志" + methodName + "方法开始了，参数是：" + args[0] + "," + args[1]);
// 调用被代理者的方法
Object result = method.invoke(t, args);
System.out.println("日志" + methodName + "方法结束了，参数是：" + result);
}
// 表示调用不是我们需要代理的方法，按照原本的方法执行
return method.invoke(t, args);
}
}
package com.atuigu.proxy;
import java.lang.reflect.Proxy;
public class ProxyFactory<T> {
// 被代理者
private final T t;
// 创建代理工厂的时候将代理者传进来
public ProxyFactory(T t) {
this.t = t;
}
// 创建代理对象
public T newInstance(AtguiguInvocationHandler<T> atguiguInvocationHandler){
// Proxy.newProxyInstance(类加载器对象，要代理的接口的字节码对象数组，InvocationHandler接口的实现类对象)就是JDK提供的动态代理的API
// 参数一：类加载器，我们可以使用被代理对象的类加载器
// 1.获取被代理对象的字节码对象
Class<?> clazz = t.getClass();
// 2.使用被代理对象的字节码对象获取类加载器
ClassLoader classLoader = clazz.getClassLoader();
// 参数二：要代理的接口的字节码对象数组，我们可以使用被代理者对象实现的接口的数组
// 3.使用被代理者的字节码对象获取被代理者实现的接口的数组
Class<?>[] interfaces = clazz.getInterfaces();
// 参数三：InvocationHandler接口的实现类对象,我们可以创建一个InvocationHandler接口的实现类
// 转成代理类型
return (T) Proxy.newProxyInstance(classLoader, interfaces, atguiguInvocationHandler);
}
}
2.4.2 测试
package com.atguigu;
import com.atuigu.Calculator;
import com.atuigu.CalculatorPureImpl;
import com.atuigu.proxy.AtguiguInvocationHandler;
import com.atuigu.proxy.ProxyFactory;
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;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring.xml")
public class CalculatorTest {
// 自动装配 根据类型匹配
@Autowired
private CalculatorPureImpl calculatorPure;
@Test
public void test01(){
// calculatorPure是被代理对象
// 1.创建代理工厂
ProxyFactory<Calculator> calculatorProxyFactory = new ProxyFactory<>(calculatorPure);
// 2.创建代理对象
Calculator proxyCalculatorPure = calculatorProxyFactory.newInstance(new AtguiguInvocationHandler<>(this.calculatorPure));
// 3.代理方法调用方法
// 调用Object方法并不会进行代理，没有在方法执行前后添加日志
System.out.println(proxyCalculatorPure.toString());
System.out.println(proxyCalculatorPure.add(1, 2));
}
}
3.AOP的相关概念
3.1 概念
AOP：Aspect Oriented Programming 面向切面编程
3.2 作用
- 简化代码：把目标方法中固定位置的重复的代码抽取出来，让目标方法更专注于自己的核心功能，提高内聚性。
- 代码增强：把抽取出来的特定的功能封装到切面类中，看哪里有需要，就往上套，被套用了切面逻辑的方法就被切面给增强了。
3.3 AOP的核心思路
3.4 AOP的相关术语
3.4.1 横切关注点(了解)
横切关注点是从每个方法中抽取出来的同一类非核心业务。在同一个项目中，我们可以使用多个横切关注点对相关方法进行多个不同方面的增强。
这个概念不是语法层面天然存在的，而是根据附加功能的逻辑上的需要：有十个附加功能，就有十个横切关注点。
3.4.2 通知
每一个横切关注点上要做的事情都需要写一个方法来实现，这样的方法就叫通知方法。
- 前置通知：在被代理的目标方法前执行
- 返回通知：在被代理的目标方法成功结束后执行（寿终正寝）
- 异常通知：在被代理的目标方法异常结束后执行（死于非命）
- 后置通知：在被代理的目标方法最终结束后执行（盖棺定论）
- 环绕通知：使用try…catch…finally结构围绕整个被代理的目标方法，包括上面四种通知对应的所有位置
3.4.3 切面
封装通知方法的类。
3.4.4 目标
被代理的目标对象,执行核心业务代码的那个对象
3.4.5 代理(了解)
向目标对象应用通知之后创建的代理对象
3.4.6连接点(了解)
这也是一个纯逻辑概念，不是语法定义的。
把方法排成一排，每一个横切位置看成x轴方向，把方法从上到下执行的顺序看成y轴，x轴和y轴的交叉点就是连接点。连接点其实就是各个方法中可以被增强或修改的点
3.4.7 切入点
每个类的方法中都包含多个连接点，所以连接点是类中客观存在的事物（从逻辑上来说）。而切入点指的则是方法中真正要去配置增强或者配置修改的地方
4 基于注解方式配置AOP
4.1 加入依赖
在IOC所需依赖基础上载入下面依赖即可
<dependencies>
<dependency>
<groupId>junitgroupId>
<artifactId>junitartifactId>
<version>4.13version>
<scope>testscope>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-contextartifactId>
<version>5.3.1version>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-testartifactId>
<version>5.3.1version>
<scope>testscope>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-aspectsartifactId>
<version>5.3.1version>
dependency>
dependencies>
4.2 准备被代理的目标资源
4.2.1 接口
package com.atuigu;
/**
* 计算器
*/
public interface Calculator {
int add(int i, int j);
int sub(int i, int j);
int mul(int i, int j);
int div(int i, int j);
}
4.2.2 接口的实现类
在Spring环境下工作，所有的一切都必须放在IOC容器中。现在接口的实现类是AOP要代理的目标类，所以它也必须放入IOC容器
package com.atuigu;
import org.springframework.stereotype.Component;
/**
* 计算器接口的实现类
* 被代理类
*/
@Component
public class CalculatorPureImpl implements Calculator {
@Override
public int add(int i, int j) {
return i + j;
}
@Override
public int sub(int i, int j) {
return i - j;
}
@Override
public int mul(int i, int j) {
return i * j;
}
@Override
public int div(int i, int j) {
return i / j;
}
}
4.2.3 创建切面类
package com.atuigu.aspect;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
/**
* Aspect注解：指定一个切面类
* Component注解：对这个切面类进行IOC
*
* 注解AOP的关键点：
* 1.一定要在配置文件中加上 表示允许自动代理
* 2.切面类一定要加上Aspect注解，并且切面类一定要进行IOC
* 3.其他的类改进型IOC和依赖注入的就一定要进行IOC和依赖注入
* 4.通知上一定要指定切入点(怎么使用切入点表达式描述切入点又是一个难点)
*/
@Aspect
@Component
public class LogAspect {
// 切入点 后续再介绍
@Before("execution(int com.atuigu.CalculatorPureImpl.* (int,int))")
public void printLogBefore() {
System.out.println("[前置通知]在方法执行之前打印日志...");
}
@AfterReturning("execution(int com.atuigu.CalculatorPureImpl.* (int,int))")
public void printLogAfterReturning() {
System.out.println("[返回通知]在方法执行成功之后打印日志..."); }
@AfterThrowing("execution(int com.atuigu.CalculatorPureImpl.* (int,int))")
public void printLogAfterThrowing() {
System.out.println("[AOP异常通知]在方法抛出异常之后打印日志...");
}
@After("execution(int com.atuigu.CalculatorPureImpl.* (int,int))")
public void printLogAfter() {
System.out.println("[AOP后置通知]在方法最终结束之后打印日志...");
}
}
4.2.4 创建Spring的配置文件
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
<context:component-scan base-package="com.atuigu">context:component-scan>
<aop:aspectj-autoproxy>aop:aspectj-autoproxy>
beans>
4.2.5 测试
package com.atguigu;
import com.atuigu.Calculator;
import com.atuigu.CalculatorPureImpl;
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 javax.annotation.Resource;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring.xml")
public class CalculatorTest {
// 自动装配 根据类型匹配
@Resource
private Calculator Calculator;
@Test
public void testAdd(){
System.out.println(Calculator.add(22, 33));
}
}
4.3 通知执行顺序
- Spring版本5.3.x以前：
- 前置通知
- 目标操作
- 后置通知
- 返回通知或异常通知
- Spring版本5.3.x以后：
- 前置通知
- 目标操作
- 返回通知或异常通知
- 后置通知
4.4 在通知内部获取细节信息
4.4.1 JoinPoint接口
- 要点1：JoinPoint接口通过getSignature()方法获取目标方法的签名
- 要点2：通过目标方法签名对象获取方法名
- 要点3：通过JoinPoint对象获取外界调用目标方法时传入的实参列表组成的数组
// 切入点表达式:告诉Sprint当前通知方法套用到哪个目标方法上
// 在前置通知方法形参位置声明一个JoinPoint类型的参数,spring就会将这个对象传入
// 根据JoinPoint对象就可以获取目标方法名称/实际参数列表
@Before("execution(int com.atuigu.CalculatorPureImpl.* (int,int))")
public void printLogBefore(JoinPoint joinPoint) {
// 1.通过JoinPoint对象获取目标方法签名对象
// 获取方法的签名信息
MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
// 2.从方法的签名信息中,我们可以获取到很多东西
// 2.1 获取切入点方法
Method method = methodSignature.getMethod();
// 2.2 获取方法的所属的类的全限定名
Class<?> clazz = method.getDeclaringClass();
String className = clazz.getName();
// 2.3 获取方法名
String methodName = method.getName();
// 2.4 获取方法的返回值类型
Class<?> returnType = method.getReturnType();
String returnTypeName = returnType.getName();
// 2.5 获取方法的参数信息
Object[] args = joinPoint.getArgs();
System.out.println("[前置通知]" + className + "." + methodName + "方法开始了,参数是:" + args[0] + "," + args[1]);
}
需要获取方法签名、传入的实参等信息时，可以在通知方法声明JoinPoint类型的形参。
4.4.2 获取目标方法的方法返回值
只有在AfterReturning返回通知中才能够获取目标方法的返回值
// @AfterReturning注解标记返回通知方法
// 在返回通知中获取目标方法返回值分两步:
// 第一步:在@AfterRetruning注解中通过returnning属性设置一个名称
// 第二部:使用returning属性设置的名称在通知方法中声明一个对应的形参
@AfterReturning(value = "execution(int com.atuigu.CalculatorPureImpl.* (int,int))", returning = "result")
public void printLogAfterReturning(JoinPoint joinPoint, Object result) {
// 1.获取方法的签名信息
MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
// 获取切入点方法
Method method = methodSignature.getMethod();
// 获取全限定名
String className = method.getDeclaringClass().getName();
// 获取方法名
String methodName = method.getName();
// 2.获取切入点执行的结果
System.out.println("[返回通知]" + className + "." + methodName + "方法正常结束了,执行结果是:" + result); }
打印效果：
4.4.3 获取目标方法抛出的异常
只有在AfterThrowing异常通知中才能获取到目标方法抛出的异常
通过@AfterThrowing注解的throwing属性获取目标方法抛出的异常对象
// @AfterThrowing注解标记异常通知方法
// 在异常通知中获取目标方法抛出的异常分两步：
// 第一步：在@AfterThrowing注解中声明一个throwing属性设定形参名称
// 第二步：使用throwing属性指定的名称在通知方法声明形参，Spring会将目标方法抛出的异常对象从这里传给我们
@AfterThrowing(value = "execution(int com.atuigu.CalculatorPureImpl.* (int,int))", throwing = "throwable")
public void printLogAfterThrowing(JoinPoint joinPoint, Throwable throwable) {
// 1.获取方法的签名信息
MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
// 获取切入点方法
Method method = methodSignature.getMethod();
// 获取全限定名
String className = method.getDeclaringClass().getName();
// 获取方法名
String methodName = method.getName();
System.out.println("[AOP异常通知]" + className + "." + methodName + "方法异常结束了,异常信息是" + throwable);
}
打印效果：
4.4.4 After 目标方法执行后执行
无论是正常结束还是异常结束都会执行
// @AfterThrowing注解通知方法
// 不管是正常结束还是异常结束 都会执行此方法 无法获取到返回值和报错信息 因为不确定是否正常执行结束和异常结束
@After("execution(int com.atuigu.CalculatorPureImpl.* (int,int))")
public void printLogAfter(JoinPoint joinPoint) {
// 1.h获取方法的签名信息
MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
// 2.获取方法对象
Method method = methodSignature.getMethod();
// 3.获取全限定名
String className = method.getDeclaringClass().getName();
// 4.获取方法名
String methodName = method.getName();
System.out.println("[AOP后置通知]" + className +"." + methodName + "方法执行结束了");
}
4.5 切入点
4.5.1 重用切入点
4.5.1.1 声明切入点
在一处声明切入点表达式之后，其他有需要的地方引用这个切入点表达式。易于维护，一处修改，处处生效。声明方式如下：
@Pointcut("execution(int com.atguigu.component.CalculatorPureImpl.*(int,int))")
public void calculatorPointCut(){
}
4.5.1.2 同一个类内部引用切入点
@Before("calculatorPointCut()")
public void printLogBeforeCore(JoinPoint joinPoint){
4.5.1.3 在其他类中引用切入点
@Before("com.atguigu.pointcut.AtguiguPointCut.calculatorPointCut()")
public void printLogBeforeCore(JoinPoint joinPoint){}
4.5.1.4 对项目中的所有切入点进行统一管理
而作为存放切入点表达式的类，可以把整个项目中所有切入点表达式全部集中过来，便于统一管理：
package com.atguigu.pointcut;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
@Component
public class AtguiguPointCut {
// 表示返回值可以任意类型 任意包中任意类的任意方法 任意参数类型和任意个数
@Pointcut("execution(* *..*.*(..))")
public void pt1(){}
// 精确匹配
@Pointcut("!execution(int com.atguigu.component.CalculatorPureImpl.add(int,int))")
public void pt2(){}
// 两者任意一个都可以匹配
@Pointcut("execution(int com.atguigu.component.CalculatorPureImpl.add(int,int)) || execution(int com.atguigu.component.CalculatorPureImpl.sub(int,int))")
public void pt3(){}
// 两者都满足才可以匹配
@Pointcut("!execution(int com.atguigu.component.CalculatorPureImpl.add(int,int)) && execution(int com.atguigu.component.CalculatorPureImpl.*(int,int))")
public void pt4(){}
}
4.6 切入点表达式语法
4.6.1 切入点表达式的作用
切入点表达式的作用是用于描述将代理逻辑套用在哪些目标方法上
4.6.2 语法细节
- 用*号代替“权限修饰符”和“返回值”部分表示“权限修饰符”和“返回值”不限
- 在包名的部分，一个“*”号只能代表包的层次结构中的一层，表示这一层是任意的。
- 例如：*.Hello匹配com.Hello，不匹配com.atguigu.Hello
- 在包名的部分，使用“*…”表示包名任意、包的层次深度任意
- 在类名的部分，类名部分整体用*号代替，表示类名任意
- 在类名的部分，可以使用*号代替类名的一部分
*Impl
(1). 返回值类型
① 精确
② * 表示任意返回值类型(2). 包名:
① 精确
② *. 表示一级包，包名可以任意
③ *… 表示包的层级任意，包名也任意(3). 类名:
① 精确
② * 任意类名
③ *Impl(4). 方法名:
① 精确 add
② * 任意方法名
③ select*(5). 参数:
① 精确 (int,int)
② * 表示一个参数，但是类型可以任意
③ (…) 参数的个数和类型都任意
对于execution()表达式整体可以使用三个逻辑运算符号
- execution() || execution()表示满足两个execution()中的任何一个即可
- execution() && execution()表示两个execution()表达式必须都满足
- !execution()表示不满足表达式的其他方法
4.6.3 总结
4.7 环绕通知
4.7.1 什么是环绕通知
环绕通知对应整个try…catch…finally结构，可以在目标方法的各个部位进行套用代理逻辑，它能够真正介入并改变目标方法的执行
(1). 作用位置: 切入点执行的前后
(2). 注解: @Around
4.7.2 什么情况下使用环绕通知?
在切入点执行之前，校验切入点的参数; 在切入点执行成功之后，记录切入点执行的结果; 在切入点执行出现异常之后，将异常信息记录到日志文件中。不适合用环绕通知，因为这里是多件事情
在切入点上加入事务控制: 适合使用环绕通知
(1). 开启事务
(2). 执行切入点
(3). 没有异常，则提交事务
(4). 出现异常，则回滚事务
(5). 无论出没出现异常，都需要设置connection的autoCommit为true，并且归还连接
计算切入点的执行时长: 适合使用环绕通知
(1). 获取切入点执行之前的毫秒数
(2). 执行切入点
(3). 获取切入点执行结束之后的毫秒数
(4). 两个毫秒数之间的差值就是切入点的执行时长
缓存: 适合使用环绕通知
(1). 从缓存中查询数据，如果有数据则直接返回
(2). 如果缓存中没有数据，则执行切入点从数据库查询数据
(3). 将数据库查询出来的数据存储到缓存中
(4). 返回数据库查询到的数据
4.7.3 计算方法执行总时长
@Around("com.atguigu.pointcut.AtguiguPointCut.pt1()")
public Object printExecuteTime(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
// 1.获取切入点执行前的毫秒数
long startTime = System.currentTimeMillis();
// 2.执行切入点
try {
Object result = proceedingJoinPoint.proceed();
return result;
} catch (Throwable e) {
e.printStackTrace();
throw e;
} finally {
// 休眠3秒
Thread.sleep(3000);
// 3.获取切入点执行之后的毫秒数
long endTime = System.currentTimeMillis();
// 4.计算执行时长
long executeTime = endTime - startTime;
MethodSignature methodSignature = (MethodSignature) proceedingJoinPoint.getSignature();
String className = methodSignature.getMethod().getDeclaringClass().getName();
String methodName = methodSignature.getMethod().getName();
// 5.日志输出执行时长
System.out.println("[环绕通知]" + className + "." + methodName + "方法执行的总时长是：" + executeTime);
}
}
测试结果
4.8 切面的优先级
4.8.1 优先级的规则
相同目标方法上同时存在多个切面时，切面的优先级控制切面的内外嵌套顺序。
- 优先级高的切面：外面
- 优先级低的切面：里面
使用@Order注解可以控制切面的优先级：
- @Order(较小的数)：优先级高
- @Order(较大的数)：优先级低
4.8.2 实际意义
实际开发时，如果有多个切面嵌套的情况，要慎重考虑。例如：如果事务切面优先级高，那么在缓存中命中数据的情况下，事务切面的操作都浪费了。
此时应该将缓存切面的优先级提高，在事务操作之前先检查缓存中是否存在目标数据。
4.9 CGLIB的动态代理
4.9.1 动态代理的分类
动态代理分成两种:
第一种是JDK内置的动态代理，这种动态代理需要被代理者实现接口，如果被代理者没有实现接口，那么则无法使用JDK的动态代理
第二种是CGLIB的动态代理，在被代理类没有实现任何接口的情况下，Spring会自动使用cglib技术实现代理。
4.9.2 Debug查看
4.9.2.1 没有实现接口的情况
4.9.2.2 由实现接口的情况
4.9.3 Spring中到底使用哪种动态代理
如果要创建代理对象的类实现了接口，那么就使用JDK的动态代理；如果要创建代理对象的类没有实现接口，那么就使用CGLIB的动态代理
5.基于XML方式配置AOP(了解)
5.1 准备工作
5.1.1 加入依赖
和基于注解的AOP时一样
5.1.2 准备代码
把基于注解的Module复制一份，修改Module名，并导入到工程中，然后去除所有AOP注解。
5.2 配置Spirng配置文件
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/aop/spring-aop.xsd">
<context:component-scan base-package="com.atguigu"/>
<aop:config>
<aop:aspect id="myAspect" ref="logAspect">
<aop:before method="printLogBeforeCore" pointcut-ref="calculatorPoint"/>
<aop:after-returning method="printLogAfterReturning" pointcut-ref="calculatorPoint" returning="result"/>
<aop:after-throwing method="printLogAfterThrowing" pointcut-ref="calculatorPoint" throwing="throwable"/>
<aop:after method="printLogFinallyEnd" pointcut-ref="calculatorPoint"/>
<aop:around method="printLogAround" pointcut-ref="calculatorPoint"/>
<aop:pointcut id="calculatorPoint"
expression="execution(* com.atguigu.component.CalculatorPureImpl.*(..))"/>
aop:aspect>
aop:config>
beans>
5.3 测试
package com.atguigu;
import com.atguigu.component.Calculator;
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;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring-application.xml")
public class TestAop {
@Autowired
private Calculator calculator;
@Test
public void testAdd(){
//调用CalculatorPureImpl对象的add()方法
System.out.println("调用完目标方法之后获取返回值是:"+calculator.sub(5, 3));
}
}
6. AOP总结
目标：
1. 将目标方法中的非核心业务抽取出来制作成通知
2. 在调用目标方法的核心业务的时候，底层动态自动将非核心业务套在核心业务上执行
实现目标：
-
识别出哪些地方可以抽取
-
准备一个切面类：
2.1 IOC：@Component
2.2 让他称为切面类：@Aspect
-
将抽取出来的代码封装成方法(通知)，方法放在切面类中
-
让切面类中的方法称为通知
4.1 前置通知: Before
4.2 返回通知:AfterReturning
4.3 异常通知:AfterThrowing
4.4 后置通知:After
4.5 环绕通知Around
-
指定通知的作用位置(切入点):就是引用切入点
5.1 如果切入点和通知在同一个类中：根据方法名引用
5.2 如果切入点跟通知不在同一个类中：根据类的全限定名.方法名来引用
6. 声明切入点以及切入点的语法