SpringAOP（控制反转）【看这一片文章就够了】

时间：2024-03-20 07:58:42

目录

一、SpringAOP

1.概述

1 什么是AOP

2 AOP的作用

3 AOP的底层

4 AOP相关概念

5 AOP开发前要明确的事情

2. AOP入门

小结：

3. AOP详解-通知类型

1 通知类型

2 通知方法里获取目标方法信息(备用)

3 小结

4. AOP详解-切入点表达式

1 execution

2 @annotation

3 抽取公用切入点表达式

4 小结

5. AOP详解-通知执行顺序

6. AOP练习

7. 小结

一、SpringAOP

1.概述

AOP是用于简化动态代理的使用

1 什么是AOP

  • AOP：Aspect Oriented Programming，面向切面编程。是通过预编译方式（aspectj）或者运行期动态代理（Spring）实现程序功能的统一维护的技术。

  • AOP是OOP(Object Oriented Programming)的技术延续，是软件开发中的一个热点，也是Spring中的一个重要内容。利用AOP可以实现对业务逻辑各个部分之间的隔离，从而使得业务逻辑各部分之间的耦合性降低，提高程序的可重用性，同时提高了开发效率。

面试问题：
Spring的两大核心是什么：IoC和AOP
分别有什么作用
	IoC：控制反转，目的用于解耦，底层使用的技术是反射+工厂模式
	AOP：面向切面编程，目的是在不修改目标对象源码的情况下，进行功能增强，底层使用的是动态代理技术

2 AOP的作用

  • 作用：不修改源码的情况下，进行功能增强，通过动态代理实现的

  • 优势：减少重复代码，提高开发效率，降低耦合度方便维护

  • 比如：给功能增加日志输出， 事务管理的功能

3 AOP的底层

实际上，Spring的AOP，底层是通过动态代理实现的。在运行期间，通过代理技术动态生成代理对象，代理对象方法执行时进行功能的增强介入，再去调用目标方法，从而完成功能增强。

  • 常用的动态代理技术有：

    • JDK的动态代理：基于接口实现的

    • cglib的动态代理：基于子类实现的

  • Spring的AOP采用了哪种代理方式？

    • 如果目标对象有接口，就采用JDK的动态代理技术

    • 如果目标对象没有接口，就采用cglib技术

4 AOP相关概念

  • 目标对象(Target)：要代理的/要增强的目标对象。

  • 代理对象(Proxy)：目标对象被AOP织入增强后，就得到一个代理对象

  • 连接点(JoinPoint)：能够被拦截到的点，在Spring里指的是方法。能增强的方法

  • 切入点(PointCut)：要对哪些连接点进行拦截的定义。要增强的方法

  • 通知/增强(Advice)：拦截到连接点之后要做的事情。如何增强，额外添加上去的功能和能力

  • 切面(Aspect)：是切入点和通知的结合。 告诉Spring的AOP：要对哪个方法，做什么样的增强

  • 织入(Weaving)：把增强/通知 应用到 目标对象来创建代理对象的过程

5 AOP开发前要明确的事情

有哪些事情需要我们完成的：

  • 目标类及里边的方法：完成功能的目标类。

  • 编写切面类，里边配置：

    • 切入点：要对谁进行增强

    • 通知：要做什么样的增强

有哪些事情是由SpringAOP完成的：

  • 代理对象：由SpringAOP根据我们的配置，帮我们生成的

  • 织入：根据切面配置生成代理对象的过程

2. AOP入门

需求

统计Service层每个方法的执行耗时

分析

目标类：Service层的所有类

编写切面类：

  • 切入点：Service层里所有的方法

  • 通知：计算方法执行耗时，打印出来

实现

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

Demo01AopAspect

  • 类上加@Component

  • 类上加@Aspect 声明一下这个类是切面类

package com.itheima.aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;


@Aspect
@Component
public class Demo01AopAspect {

    @Around("execution(public * com.itheima.service.impl.*.*(..))")
    public Object executeTime(ProceedingJoinPoint pjp) throws Throwable {

        long start = System.currentTimeMillis();
        
        //调用目标方法
        Object res = pjp.proceed();
        
        long end = System.currentTimeMillis();

        System.out.println(pjp.getSignature() + "方法耗时：" + (end - start) + "毫秒");

        return res;
    }

}

测试

打开浏览器访问 http://localhost:8080/depts

可看到控制台输出了执行时间

小结：

AOP的使用步骤：

  1. 添加依赖：spring-boot-starter-aop

  2. 编写切面类：类上要加 @Component, @Aspect

    类里编写通知方法：要额外增加上去的功能

    方法上加注解 @Around("切入点表达式")

3. AOP详解-通知类型

1 通知类型

Spring的AOP支持以下5种通知类型：

package com.itheima.aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

/**
 * 当前类是一个切面配置类：
 *      类上加@Component：当前类对象必须交给Spring进行管理。不给Spring管理，Spring就不能增强
 *      类上加@Aspect：告诉Spring，这个类是切面配置类
 * 需求：
 *      对Service层的每个方法统计执行时间
 */
@Aspect
@Component
public class Demo01Aspect {

    /**
     * 方法上加的注解：@Around("切入点表达式")，用于选择对哪些方法进行增强
     * @param pjp 目标方法的信息，被增强的那个方法
     * @return
     */
    @Around("execution(public * com.itheima.service.*.*(..))")
    public Object executeTime(ProceedingJoinPoint pjp) throws Throwable {

        long start = System.currentTimeMillis();
        //调用目标方法，得到返回值
        Object res = pjp.proceed();

        long end = System.currentTimeMillis();
        System.out.println("目标方法执行耗时：" + (end - start) + "毫秒");
        return res;
    }

    /**
     * 需求：要在Service的每个方法执行之前，先输出一句话：前置通知执行了
     * 分析：
     *      切入点：要对谁增强，Service的所有方法
     *      通知：要额外增加的功能，输出“前置通知执行了”
     *      通知类型：要什么时候进行增强，在目标方法执行之前
     */
    @Before("execution(public * com.itheima.service.*.*(..))")
    public void before(){
        System.out.println("前置通知执行了");
    }

    /**
     * 需求：要在Service的每个方法执行抛出异常时，输出一句话：异常通知执行了
     * 分析：
     *      切入点：要对谁增强，Service的所有方法
     *      通知：要额外增加的功能，输出“异常通知执行了”
     *      通知类型：要什么时候进行增强，在目标方法执行抛出异常之后
     */
    @AfterThrowing("execution(public * com.itheima.service.*.*(..))")
    public void afterThrowing(){
        System.out.println("异常通知执行了");
    }

    /**
     * 需求：要在Service的每个方法正常执行完成之后，输出一句话：后置通知执行了
     * 分析：
     *      切入点：要对谁增强，Service的所有方法
     *      通知：要额外增加的功能，输出“后置通知执行了”
     *      通知类型：要什么时候进行增强，在目标方法正常执行完成之后
     */
    @AfterReturning("execution(public * com.itheima.service.*.*(..))")
    public void afterReturning(){
        System.out.println("后置通知执行了");
    }

    /**
     * 需求：要在Service每个方法执行之后，必须执行，输出一句话：最终通知执行了
     * 分析：
     *      切入点：要对谁增强，Service的所有方法
     *      通知：要额外增加的功能，输出“最终通知执行了”
     *      通知类型：要什么时候进行增强，在目标方法执行之后，必须执行
     */
    @After("execution(public * com.itheima.service.*.*(..))")
    public void after(){
        System.out.println("最终通知执行了");
    }
}

2 通知方法里获取目标方法信息(备用)

不同通知方法里，获取被调用的目标方法：

  • 可以直接给通知方法，直接加形参 JoinPoint

  • 如果是环绕通知方法，则要加形参 ProceedingJoinPoint，继承了JoinPoint

JoinPoint常用方法：

  • getArgs()：获取调用方法时的实参值

  • getTarget()：获取被调用的目标对象（原始目标对象）

  • getThis()：获取当前代理对象

  • getSignature()：获取被调用的方法信息。Signature对象的方法：

    • getName()：获取被调用的方法名。比如：queryAllDepts

    • getDeclaringType()：获取被调用方法所属的类Class

    • getDeclaringTypeName()：获取被调用方法所属的类的全限定类名

    • toLongString()：获取方法的完整名称。

      比如：public java.util.List com.itheima.service.impl.DeptServiceImpl.queryAllDepts()

    • toShortString：获取方法的简短名称。

      比如：DeptServiceImpl.queryAllDepts()

    • toString：获取方法信息。

      比如：List com.itheima.service.impl.DeptServiceImpl.queryAllDepts()

package com.itheima.aop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

import java.util.Arrays;

/**
 * 当前类是一个切面配置类：
 *      类上加@Component：当前类对象必须交给Spring进行管理。不给Spring管理，Spring就不能增强
 *      类上加@Aspect：告诉Spring，这个类是切面配置类
 * 需求：
 *      对Service层的每个方法统计执行时间
 * @author liuyp
 * @since 2023/08/25
 */
@Aspect
@Component
public class Demo01Aspect {

    /**
     * 方法上加的注解：@Around("切入点表达式")，用于选择对哪些方法进行增强
     * @param pjp 目标方法的信息，被增强的那个方法
     * @return
     */
    @Around("execution(public * com.itheima.service.*.*(..))")
    public Object executeTime(ProceedingJoinPoint pjp) throws Throwable {

        long start = System.currentTimeMillis();
        //调用目标方法，得到返回值
        Object res = pjp.proceed();

        long end = System.currentTimeMillis();
        System.out.println("目标方法执行耗时：" + (end - start) + "毫秒");
        return res;
    }

    /**
     * 需求：要在Service的每个方法执行之前，先输出一句话：前置通知执行了
     * 分析：
     *      切入点：要对谁增强，Service的所有方法
     *      通知：要额外增加的功能，输出“前置通知执行了”
     *      通知类型：要什么时候进行增强，在目标方法执行之前
     */
    @Before("execution(public * com.itheima.service.*.*(..))")
    public void before(JoinPoint joinPoint){
        //调用目标方法时的实参值
        Object[] args = joinPoint.getArgs();
        //调用的目标类对象
        Object target = joinPoint.getTarget();
        //当前代理类对象
        Object aThis = joinPoint.getThis();
        //调用的目标方法
        Signature signature = joinPoint.getSignature();
        System.out.println("前置通知执行了， 目标类是：" + target.getClass().getName() + ", 目标方法：" + signature + "， 方法实参是：" + Arrays.toString(args));
    }

    /**
     * 需求：要在Service的每个方法执行抛出异常时，输出一句话：异常通知执行了
     * 分析：
     *      切入点：要对谁增强，Service的所有方法
     *      通知：要额外增加的功能，输出“异常通知执行了”
     *      通知类型：要什么时候进行增强，在目标方法执行抛出异常之后
     */
    @AfterThrowing("execution(public * com.itheima.service.*.*(..))")
    public void afterThrowing(JoinPoint joinPoint){
        System.out.println("异常通知执行了， joinPoint = " + joinPoint);
    }

    /**
     * 需求：要在Service的每个方法正常执行完成之后，输出一句话：后置通知执行了
     * 分析：
     *      切入点：要对谁增强，Service的所有方法
     *      通知：要额外增加的功能，输出“后置通知执行了”
     *      通知类型：要什么时候进行增强，在目标方法正常执行完成之后
     */
    @AfterReturning("execution(public * com.itheima.service.*.*(..))")
    public void afterReturning(JoinPoint joinPoint){
        System.out.println("后置通知执行了, joinPoint = " + joinPoint);
    }

    /**
     * 需求：要在Service每个方法执行之后，必须执行，输出一句话：最终通知执行了
     * 分析：
     *      切入点：要对谁增强，Service的所有方法
     *      通知：要额外增加的功能，输出“最终通知执行了”
     *      通知类型：要什么时候进行增强，在目标方法执行之后，必须执行
     */
    @After("execution(public * com.itheima.service.*.*(..))")
    public void after(JoinPoint joinPoint){
        System.out.println("最终通知执行了, joinPoint = " + joinPoint);
    }
}

3 小结

通知类型：

  • @Around：环绕通知。最灵活的通知方式，必须掌握的方式

  • @Before：前置通知。通知方法在 目标方法执行之前 先执行

  • @AfterReturning：返回通知。通知方法在 目标方法正常执行之后 再执行

  • @AfterThrowing：异常通知。通知方法在 目标方法抛出异常之后 再执行

  • @After：最终通知/后置通知。通知方法在 目标方法执行之后 一定会执行，无论是否有异常

4. AOP详解-切入点表达式

1 execution

用于根据方法的名称进行模糊匹配的

语法：execution(权限修饰符 返回值类型 全限定类名.方法名(形参列表))

  • *：可使用通配符来表示模糊匹配

  • ..：用于形参列表里，表示任意个任意形参； 用于其它地方，表示任意层级的package包

  • 权限修饰符写public，通常省略不写

示例：

  • public void com.itheima.service.XxService.delete(Integer)

  • void com.itheima.service.XxService.delete(Integer)

  • * com.itheima.service.XxService.delete(Integer)

  • * com.itheima.service.*.delete(Integer)

  • * com.itheima..*.delete(Integer)

  • * com.itheima..*.*(Integer)

  • * com.itheima..*.*(Integer, String)

  • * com.itheima..*.*(Integer, *)

  • * com.itheima..*.*(..)

package com.itheima.aop;

import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

/**
 * 切入点表达式：
 *      语法：`execution(权限修饰符 返回值类型 全限定类名.方法名(形参列表))`
 *      详解：
 *          权限修饰符：通常是`public`，可省略不写
 *          返回值类型：可以精确写，也可以用通配符*
 *             execution(String com.itheima.service.*.*(..))
 					表示要选中com.itheima.service下任意类的、返回值是String类型的方法
 *             execution(void com.itheima.service.*.*(..))
 					表示要选中com.itheima.service下任意类的、返回值是void类型的方法
 *             execution(* com.itheima.service.*.*(..))，
 					表示要选中com.itheima.service下任意类的、返回值是任意类型的方法
 *          全限定类名：
 *              可以精确写，execution(* com.itheima.service.DeptService.queryAllDepts(..))
 *                        表示选中com.itheima.service.DeptService类下名称为queryAllDepts方法
 *              可以用通配符，execution(* com.itheima.service.*.queryAllDepts(..))
 *                        表示选中com.itheima.service.包下任意类下名称为queryAllDepts方法
 *              可以使用..表示后代，execution(* com.itheima..*.*(..))
 *                        表示选中com.itheima包下所有的类(包括这个包里的类，以下所有下级包里的类)的所有方法
 *         方法名：可以精确写，也可以用通配符*
 *              如果写：execution(* com.itheima..*.queryAllDepts(..))
 *                     表示选中com.itheima包下所有类里queryAllDepts方法
 *              如果写：execution(* com.itheima..*.*(..))
 *                     表示选中com.itheima包下所有类里任意方法
 *         形参列表：
 *              可以精确写，
 *                  execution(* com.itheima..*.*(String)) 
 						表示选中com.itheima包下所有类的任意方法，但是要求方法有1个形参必须是String
 *                  execution(* com.itheima..*.*(String, Integer)) 
 						表示选中com.itheima包下所有类的任意方法，但是要求方法有2个形参按顺序必须是String、Integer
 *              也可以用通配符*
 *                  execution(* com.itheima..*.*(String, *)) 
 						表示选中com.itheima包下所有类的任意方法，但是要求方法有2个形参按顺序必须是String、任意类型
 *              任意个任意类型：..
 *                  execution(* com.itheima..*.*(..)) 
 					表示选中com.itheima包下任意类里任意方法，方法的形参个数和类型都不限制
 *     示例：execution(* *..*.*(..)) 表示选择任意包下、任意类的任意方法，形参不限，返回值不限。不要用
 * @author liuyp
 * @since 2023/08/25
 */
@Aspect
@Component
public class Demo02Aspect {

    @Before("execution(* com.itheima.service.*.*(..))")
    public void before(){
        System.out.println("=====Demo02Aspect.before执行了======");
    }


    @After("execution(* com.itheima.service.*.*(..))")
    public void after(){
        System.out.println("=====Demo02Aspect.after执行了======");
    }
}

2 @annotation

根据注解选择要增强的方法

语法：@annotation(注解的全限定类名)，会选择所有加了指定注解的方法，进行增强

示例：

  1. 自定义注解


import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyLog {
}

2.创建切面配置类

package com.itheima.aop;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;


@Aspect
@Component
public class Demo03Aspect {

    @Before("@annotation(com.itheima.aop.MyLog)")
    public void saveLogs(){
        System.out.println("========保存日志信息======");
    }
}

3.给DeptServiceImpl的queryAllDepts方法上加注解@MyLog

3 抽取公用切入点表达式

语法：

  • 定义公用的切入点表达式：在切面类里创建一个方法，方法上加注解@Pointcut("公用的切入点表达式")

  • 引用公用的切入点表达式：

    • 完整用法：Before("com.itheima.aop.Demo02Aspect.pc()")

    • 简写形式：Before("pc()")，仅适合于 切入点方法 和 通知方法在同一个类里

package com.itheima.aop;

import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

/**
 * 如果要抽取公用的切入点表达式：
 *      使用注解@Pointcut("公用的切入点表达式")
 *      把注解加在方法上
 * 当需要使用切入点表达式时：
 *      完整的用法：@Before("com.itheima.aop.Demo02Aspect.pc()")
 *      如果调用的同一个类里的切入点表达式方法，可以简写@Before("方法名()")。
 * @author liuyp
 * @since 2023/08/25
 */
@Aspect
@Component
public class Demo02Aspect {

    /**这个方法仅仅作为切入点表达式的载体*/
    @Pointcut("execution(* com.itheima.service.*.*(..))")
    public void pc(){}

    // @Before("execution(* com.itheima.service.*.*(..))")
    // @Before("com.itheima.aop.Demo02Aspect.pc()")
    @Before("pc()")
    public void before(){
        System.out.println("=====Demo02Aspect.before执行了======");
    }


    // @After("execution(* com.itheima.service.*.*(..))")
    @After("pc()")
    public void after(){
        System.out.println("=====Demo02Aspect.after执行了======");
    }
}

4 小结

切入点表达式：用于 选中要增强的方法

语法：

  • 根据方法名选择：execution(权限修饰符 返回值类型 全限定类名.方法名(形参列表))

  • 根据注解选择：@annotation(注解的全限定类名)

如何抽取公用切入点表达式

  • 在切面类里定义一个方法，方法上加@Pointcut("切入点表达式")

  • 需要使用切入点表达式时

    • 简写：这个方法和当前通知方法在 同一类里，可以简写 @Before("方法名()")

    • 完整：这个方法和当前通知方法不在同一类，完整写@Before("com.itheima.aspect.Demo01Aspect.pc()")

5. AOP详解-通知执行顺序

package com.itheima.aop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;


@Aspect
//@Order(150)
@Component
public class Demo04Aspect {
    @Pointcut("execution(* com.itheima.service.*.*(..))")
    public void pc(){}

    @Before("pc()")
    public void before(){
        System.out.println("===Demo04Aspect.before===");
    }

    @AfterReturning("pc()")
    public void afterReturning(){
        System.out.println("===Demo04Aspect.afterReturning===");
    }

    @AfterThrowing("pc()")
    public void afterThrowing(){
        System.out.println("===Demo04Aspect.afterThrowing===");
    }

    @After("pc()")
    public void after(){
        System.out.println("===Demo04Aspect.after===");
    }

    @Around("pc()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {

        System.out.println("===Demo04Aspect.around前===");

        //调用目标方法
        Object res = pjp.proceed();

        System.out.println("===Demo04Aspect.around后===");

        return res;
    }
}
package com.itheima.aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;


@Aspect
//@Order(100)
@Component
public class Demo05Aspect {
    @Pointcut("execution(* com.itheima.service.*.*(..))")
    public void pc(){}

    @Before("pc()")
    public void before(){
        System.out.println("===Demo05Aspect.before===");
    }

    @AfterReturning("pc()")
    public void afterReturning(){
        System.out.println("===Demo05Aspect.afterReturning===");
    }

    @AfterThrowing("pc()")
    public void afterThrowing(){
        System.out.println("===Demo05Aspect.afterThrowing===");
    }

    @After("pc()")
    public void after(){
        System.out.println("===Demo05Aspect.after===");
    }

    @Around("pc()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {

        System.out.println("===Demo05Aspect.around前===");

        //调用目标方法
        Object res = pjp.proceed();

        System.out.println("===Demo05Aspect.around后===");

        return res;
    }
}

6. AOP练习

需求

将tlias案例中增、删、改相关接口的操作日志记录到数据库表中。

  • 就是当访问部门管理和员工管理当中的增、删、改相关功能接口时，需要详细的操作日志，并保存在数据表中，便于后期数据追踪。

操作日志信息包含：操作人、操作时间、执行方法的全类名、执行方法名、方法运行时参数、返回值、方法执行时长

准备

把《资料\AOP-日志案例\tlias-web-management2》拷贝到一个不含中文、空格、特殊字符的目录里，使用idea打开项目，启动引导类

再启动tlias的nginx

打开浏览器访问 http://localhost:90

SQL脚本

use tlias;
-- 操作日志表
create table operate_log(
    id int unsigned primary key auto_increment comment 'ID',
    operate_user int unsigned comment '操作人ID',
    operate_time datetime comment '操作时间',
    class_name varchar(100) comment '操作的类名',
    method_name varchar(100) comment '操作的方法名',
    method_params varchar(1000) comment '方法参数',
    return_value varchar(2000) comment '返回值',
    cost_time bigint comment '方法执行耗时, 单位:ms'
) comment '操作日志表';

实体类

package com.itheima.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.time.LocalDateTime;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class OperateLog {
    private Integer id; //ID
    private Integer operateUser; //操作人ID
    private LocalDateTime operateTime; //操作时间
    private String className; //操作类名
    private String methodName; //操作方法名
    private String methodParams; //操作方法参数
    private String returnValue; //操作方法返回值
    private Long costTime; //操作耗时
}

Mapper接口

package com.itheima.mapper;

import com.itheima.pojo.OperateLog;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface OperateLogMapper {

    //插入日志数据
    @Insert("insert into operate_log (operate_user, operate_time, class_name, method_name, method_params, return_value, cost_time) " +
            "values (#{operateUser}, #{operateTime}, #{className}, #{methodName}, #{methodParams}, #{returnValue}, #{costTime});")
    void insert(OperateLog log);

}

分析：

选择AOP技术实现：

  • 如果不使用AOP，就需要修改源码，给大量的方法增加保存日志的代码。代码重复，日志和业务功能耦合到了一起

  • 希望：不修改源码的情况下，给Service层的方法进行增强，就使用AOP

要使用AOP技术：

  • 切入点：对哪些方法增强

    哪个方法需要保存日志，就在哪个方法上加一个自定义注解

    使用注解切入点表达式@annotation(自定义注解)

  • 通知：

    通知类型：使用@Around环绕通知

    通知方法：获取当前用户、当前时间、当前方法的类名和方法名、方法的实参、返回值，运行耗时，把这些信息保存到日志表

package com.itheima.aspect;

import com.itheima.mapper.OperateLogMapper;
import com.itheima.pojo.OperateLog;
import com.itheima.util.JwtUtils;
import io.jsonwebtoken.Claims;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import java.time.LocalDateTime;
import java.util.Arrays;


@Aspect
@Component
public class OperateLogAspect {

    @Autowired
    private OperateLogMapper logMapper;

    @Autowired
    private HttpServletRequest request;

    @Around("execution(* com.itheima.service.*.*(..))")
    public Object logSave(ProceedingJoinPoint pjp) throws Throwable {
        long start = System.currentTimeMillis();
        //调用目标方法，得到返回值
        Object res = pjp.proceed();
        long end = System.currentTimeMillis();

        //保存日志信息
        OperateLog ol = new OperateLog();
        //填充日志数据-操作人id，当前登录的用户。客户端每次请求都会携带token到服务端，只要从请求里获取token就能得到当前用户
        String token = request.getHeader("token");
        if (token != null && !"".equals(token)) {
            Claims claims = JwtUtils.parseJWT(token);
            Integer userId = claims.get("id", Integer.class);
            ol.setOperateUser(userId);
        }
        //填充日志数据-操作时间
        ol.setOperateTime(LocalDateTime.now());
        //填充日志数据-目标类名
        Signature signature = pjp.getSignature();
        String className = signature.getDeclaringTypeName();
        ol.setClassName(className);
        //填充日志数据-目标方法名
        ol.setMethodName(signature.getName());
        //填充日志数据-方法的实参
        Object[] args = pjp.getArgs();
        ol.setMethodParams(Arrays.toString(args));
        //填充日志数据-方法的返回值
        ol.setReturnValue(res.toString());
        //填充日志数据-操作耗时
        ol.setCostTime(end-start);
        //保存到数据库里
        logMapper.insert(ol);

        String remoteAddr = request.getRemoteAddr();
        System.out.println("客户端ip：" + remoteAddr);
        return res;
    }
}

7. 小结

AOP是什么：面向切面编程，底层是动态代理

AOP的作用：用于在不修改目标对象源码的情况下，进行功能增强

AOP的底层：

  • JDK的动态代理：如果有接口，就使用JDK的

  • cglib动态代理：如果没有接口，就使用cglib

AOP的几个概念：

  • 切入点PointCut：要增强的方法

  • 通知Advice：要如何增强

  • 切面Aspect：切入点 + 通知。表示 要对哪些方法 做什么样的增强

AOP的使用：

  1. 添加依赖坐标 spring-boot-starter-aop

  2. 创建切面类：类上加@Component @Aspect；类里写通知方法，通知方法加注解配置切入点表达式

@Aspect
@Order(整数) //整数是排序号，值越小，执行的越早
@Component
public class DemoAspect{
    
    @PointCut("切入点表达式")
    public void pc(){}
    
    //环绕通知方法：固定写法
    @Around("pc()")
    public Object method(ProceedingJoinPoint pjp){
        //前边写的前置增强
        
        //调用目标方法
        Object res = pjp.proceed();
        
        //后边写的后置增强
        
        return res;
    }
    
    //其它通知方法：返回值void，可以无参，方法名随便。 如果需要用到目标方法，就加形参JoinPoint
    @Before("切入点表达式")
    public void before(){
    }
    @AfterThrowing("切入点表达式")
    public void before(){
    }
    @AfterReturning("切入点表达式")
    public void before(){
    }
    @After("切入点表达式")
    public void before(){
    }
}

通知类型：

  • @Before：通知方法在 目标方法执行之前 先执行

  • @AfterReturning：通知方法在 目标方法正常执行之后 再执行

  • @AfterThrowing：通知方法在 目标方法抛出异常之后 再执行

  • @After：通知方法在 目标方法执行之后，必定会执行，无论有没有异常

切入点表达式：这种表达式是用于选择 要增强的方法

  • 根据方法名选择：execution(权限修饰符 返回值类型 全限定类名.方法名(形参类型列表))

  • 根据注解选择：@annotation(注解的全限定类名)

多个切面的执行顺序：

  • 默认按 切面类的全限定类名 顺序执行

  • 如果要设置执行顺序，就在切面类上加 @Order(整数)，整数越小，执行的越早