1、切面的定义
首先要理解‘切’字，需要把对象想象成一个立方体，传统的面向对象变成思维，类定义完成之后（封装）。每次实例化一个对象，对类定义中的成员变量赋值，就相当于对这个立方体进行了一个定义，定义完成之后，那个对象就在那里，不卑不亢，不悲不喜，等着被使用，等着被回收。
面向切面编程 则是指，对于一个我们已经封装好的类，我们可以在编译期间或在运行期间，对其进行切割，把立方体切开，在原有的方法里面添加（织入）一些新的代码，对原有的方法代码进行一次增强处理。而那些增强部分的代码，就被称之为切面，如下面代码实例中的通用日志处理代码，常见的还有事务处理、权限认证等等。
1.1、切面中的几个定义
切入点 (PointCut)
要对哪些类中的哪些方法进行增强，进行切割，指的是被增强的方法。即要切哪些东西。
连接点 (JoinPoint)
我们知道了要切哪些方法后，剩下的就是什么时候切，在原方法的哪一个执行阶段加入增加代码，这个就是连接点。如方法调用前，方法调用后，发生异常时等等。
通知 (Advice)
通知被织入方法，该如何被增强。定义切面的具体实现。那么这里面就涉及到一个问题，空间（切哪里）和时间（什么时候切，在何时加入增加代码），空间我们已经知道了就是切入点中定义的方法，而什么时候切，则是连接点的概念，如下面实例中，通用日志处理（切面），@Pointcut规则中指明的方法即为切入点，@Before、@After是连接点，而下面的代码就是对应通知
2、切面的使用
1、引入依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>
2、编写切面类
@Aspect // 注解标明这是一个切面 @Component // 注入spring容器中
@Order(10) // 若有多个切面类，可以用Order注解决定不同类中的切面的执行顺序 public class AopAdvice { private final Logger log = LoggerFactory.getLogger(AopAdvice.class);
// 切点定义
/**
* 方法执行时触发
* execution (* com.aop.controller.*.*(..))
* 方法类型包含Public，Protected等，可省略
* 方法返回值类型，*可以包含所有的返回值类型
* 包路径，如“com.demo…*”,表示"com.demo"包以及该包之下子包的所有类型
* 方法名称，如“add*”,表示所有以add开头的方法，参数：(*)表示任意一个参数，(…)表示所有参数
* 异常类型，如execution(* *(…) throws Exception)”匹配所有抛出Exception的方法。
*/
@Pointcut("execution (* com.zhangqi.aop.controller.*.*(..))")
public void pointCut1() {
}
/**
* 带有指定注解的方法触发
*/
@Pointcut("@annotation(com.aop.annotion.ListReturnCheck)")
public void pointCut2() {
}
/**
* 通过参数
* args() 匹配不带参数的方法
* args(java.lang.String) 匹配方法参数是String类型的
* args(…) 带任意参数的方法
* args(java.lang.String,…) 匹配第一个参数是String类型的，其他参数任意。最后一个参数是String的同理。
*/
@Pointcut("args(java.lang.String)")
public void pointCut3() {
}
/**
* 目标对象使用aop之后生成的代理对象必须是指定的类型才会被拦截，注意是目标对象被代理之后生成的代理对象和指定的类型匹配才会被拦截
* <p>
* 若spring创建的对象如果实现了接口，默认使用jdk动态代理，如果没有实现接口，使用cglib创建代理对象
* <p>
* 所以 service 是使用jdk动态代理生成的对象，service instanceof ServiceImpl 为 false
* <p>
* - @Pointcut("this(com.aop.service.impl.ServiceImpl)")
* 表示被spring代理之后生成的对象必须为com.aop.service.impl.ServiceImpl才会被拦截，
* 但是service不是ServiceImpl类型的对象了，所以不会被拦截
* <p>
*/
@Pointcut("this(com.aop.controller.MyController)")
public void pointCut4() {
}
/**
* this作用于代理对象，target作用于目标对象
* this表示目标对象被代理之后生成的代理对象和指定的类型匹配会被拦截，匹配的是代理对象
* target表示目标对象和指定的类型匹配会被拦截，匹配的是目标对象
*/
@Pointcut("target(com.aop.controller.MyController)")
public void pointCut5() {
}
/**
* within是用来指定类型的，指定类型中的所有方法将被拦截
* <p>
* within(com.demo.service.impl.UserServiceImpl) 匹配UserServiceImpl类对应对象的所有方法调用
* 并且只能是UserServiceImpl对象，不能是它的子对象
* 拦截包中任意方法，不包含子包中的方法
* within(com.xyz.service.*)
* 拦截service包及子包中任意类的任意方法
* within(com.xyz.service..*)
*/
@Pointcut("within(com.zhangqi.aop.controller.MyController)")
public void pointCut6() {
}
/**
* 匹配的目标对象的类有一个指定的注解
* 目标对象中包含com.aop.annotion.ListReturnCheck注解，调用该目标对象的任意方法都会被拦截
*/
@Pointcut("@target(com.aop.annotion.ListReturnCheck)")
public void pointCut7() {
}
/**
* 指定匹配必须包含某个注解的类里的所有连接点
* 目标对象中包含com.aop.annotion.ListReturnCheck注解的类中的所有方法都会被拦截
* <p>
* - @target 和 @within 的不同点
* - @target(注解A)：判断被调用的目标对象中是否声明了注解A，如果有，会被拦截
* - @within(注解A)： 判断被调用的方法所属的类中是否声明了注解A，如果有，会被拦截
* - @target关注的是被调用的对象，@within关注的是调用的方法所在的类
*/
@Pointcut("@within(com.zhangqi.aop.annotion.ListReturnCheck)")
public void pointCut8() {
}
/**
* 方法参数所属的类型上有指定的注解，被匹配
* 注意：是方法参数所属的类型上有指定的注解，不是方法参数中有注解
* <p>
*
* 匹配1个参数，且第1个参数所属的类中有Anno1注解
* - @args(com.aop.annotion.ListReturnCheck)
* 匹配多个参数，且多个参数所属的类型上都有指定的注解
* - @args(com.aop.annotion.ListReturnCheck,com.aop.annotion.ListReturnCheck)
* 匹配多个参数，且第一个参数所属的类中有Anno1注解
* - @args(com.zhangqi.aop.annotion.ListReturnCheck,..)
*/
@Pointcut("@args(com.zhangqi.aop.annotion.ListReturnCheck)")
public void pointCut9() {
}
/**
* PointCut中可以使用&&、||、!运算
*/
@Pointcut("pointCut7() && pointCut8()")
public void pointCut10() {
}
// -----------以上是切点的定义-----------
// -----------以下是通知定义-----------
/**
* 前置通知（@Before）：在目标方法调用之前调用通知
* argNames 切点的方法的参数名
*/
@Before(value = "pointCut1()", argNames = "id,username")
public void beforeAdvice(JoinPoint joinPoint, String id, String username) {
// 这个RequestContextHolder是Springmvc提供来获得请求的东西
RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
HttpServletRequest request = ((ServletRequestAttributes) Objects.requireNonNull(requestAttributes)).getRequest();
// 记录下请求内容
log.info("请求地址 : " + request.getRequestURL().toString());
log.info("请求方式 : " + request.getMethod());
log.info("请求IP : " + request.getRemoteAddr());
log.info("请求的参数 : " + Arrays.toString(joinPoint.getArgs()));
MethodSignature signature = (MethodSignature) joinPoint.getSignature();
// 获取这个被代理的方法
Method method = signature.getMethod();
// 是获取包+类名的
String declaringTypeName = signature.getDeclaringTypeName();
// 获取了方法名
String name = signature.getName();
// 返回的是需要加强的目标类的对象
Object target = joinPoint.getTarget();
// 返回的是经过加强后的代理类的对象
Object aThis = joinPoint.getThis();
}
/**
* 后置通知（@After）：在目标方法完成之后调用通知
*/
@After("pointCut1()")
public void afterAdvice(JoinPoint joinPoint) {
System.out.println("afterAdvice...");
}
/**
* 环绕通知（@Around）：在目标方法完成之后调用通知
*/
@Around("pointCut1()")
public Object aroundAdvice(ProceedingJoinPoint proceedingJoinPoint) {
System.out.println("Around -- before");
try {
return proceedingJoinPoint.proceed();
} catch (Throwable t) {
return "";
}
System.out.println("Around -- after");
}
注：proceedingJoinPoint.proceed();的作用是让目标方法执行，@Around = @Before + 方法执行 + @After
/**
* 返回通知（@AfterReturning）：在目标方法成功执行之后调用通知
*
* @param result 代理方法执行的结果
*/
@AfterReturning(returning = "result", pointcut = "pointCut1())")
public void doAfterReturning(JoinPoint joinPoint, Object result) throws Exception {
}
/**
* 异常通知（@AfterThrowing）：在目标方法出现异常调用通知
*
* @param e 异常信息
*/
@AfterThrowing(throwing = "e", pointcut = "pointCut1())")
public void doAfterThrowing(JoinPoint joinPoint, Exception e) throws Exception {
}
}
3、各种通知（advice）的执行顺序注意一下各个不同的advice的拦截顺序的问题。
情况一，只有一个Aspect类：
无异常：@Around（proceed()之前的部分） → @Before → 方法执行 → @Around（proceed()之后的部分） → @After → @AfterReturning
有异常：@Around（proceed(之前的部分)） → @Before → 扔异常ing → @After → @AfterThrowing
大概是因为方法没有跑完抛了异常，没有正确返回所有@Around的proceed()之后的部分和@AfterReturning两个注解的加强没有能够织入
情况二，同一个方法有多个@Aspect类拦截：
单个Aspect肯定是和只有一个Aspect的时候的情况是一样的，但不同的Aspect里面的advice的顺序呢？
答案是不一定，像是线程一样，没有谁先谁后，除非你给他们分配优先级，同样地，在这里你也可以为@Aspect分配优先级，这样就可以决定谁先谁后了。
调整优先级有两种方式：
① 实现org.springframework.core.Ordered接口，实现它的getOrder()方法
② 给aspect添加@Order注解，该注解全称为：org.springframework.core.annotation.Order
不管是哪种，都是order的值越小越先执行
4、注意事项
如果在同一个 aspect 类中，针对同一个 pointcut，定义了两个相同的 advice(比如，定义了两个 @Before)，
那么这两个 advice的执行顺序是无法确定的，哪怕你给这两个 advice 添加了 @Order 这个注解，也不行。这点切记。
对于@Around这个advice，不管它有没有返回值，但是必须要方法内部调用一下 proceedingJoinPoint.proceed()方法，
否则Controller中的接口将没有机会被执行，从而也导致了 @Before这个advice不会被触发