【AOP】什么是AOP？AOP有哪些应用？

已于 2024-12-22 16:33:24 修改
阅读量1.4k 收藏 16
点赞数 18
文章标签： java 后端 spring spring boot
于 2024-12-22 12:26:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/slj18633752884/article/details/144643198
版权

1. 什么是AOP？

  AOP（面向切面编程，Aspect-Oriented Programming）是一个编程范式，用于将横切关注点（cross-cutting concerns）与业务逻辑分离。在 Java 中，AOP 的主要目标是通过预先定义的切面（aspect）来增强（或修改）目标对象的功能，而不修改目标对象的源代码。
  AOP 主要关注的是如何通过“切面”来将功能逻辑从业务逻辑中分离出来，使代码更加模块化和清晰。这种方式能够使得程序中的某些行为（例如日志记录、事务管理、安全控制等）与业务逻辑相独立。

2. 入门案例

需求： 统计下面业务层实现类中每个方法的运行时间,并输出到日志中

package com.itheima.service.impl;

import com.itheima.mapper.DeptMapper;
import com.itheima.pojo.Dept;
import com.itheima.service.DeptService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDateTime;
import java.util.List;

@Slf4j
@Service
public class DeptServiceImpl implements DeptService {
    @Autowired
    private DeptMapper deptMapper;

    /**
     * 列表查询部门
     * @return
     */
    @Override
    public List<Dept> list() {
        List<Dept> deptList = deptMapper.list();
        return deptList;
    }

    /**
     * 删除部门
     * @param id
     */
    @Override
    public void delete(Integer id) {
        deptMapper.delete(id);
    }

    /**
     * 新增部门
     * @param dept
     */
    @Override
    public void save(Dept dept) {
        dept.setCreateTime(LocalDateTime.now());
        dept.setUpdateTime(LocalDateTime.now());
        deptMapper.save(dept);
    }

    /**
     * 通过id查询部门
     * @param id
     * @return
     */
    @Override
    public Dept getById(Integer id) {
        return deptMapper.getById(id);
    }

    /**
     * 修改部门信息
     * @param dept
     */
    @Override
    public void update(Dept dept) {
        dept.setUpdateTime(LocalDateTime.now());
        deptMapper.update(dept);
    }
}

普通方法

  初步思考： 在每个业务方法上增加获取方法运行开始和结束时间的代码，再相减，将结果作为运行时间输出到日志中，就像下面这样

    /**
     * 列表查询部门
     * @return
     */
    @Override
    public List<Dept> list() {
        //获取方法开始运行时的时间
        long begin = System.currentTimeMillis();
        List<Dept> deptList = deptMapper.list();
        //获取方法运行结束时的时间
        long end = System.currentTimeMillis();
        //将end-begin作为结果，输出到日志中
        log.info("运行时间：{} ms", end - begin);
        return deptList;
    }

  运行并发送请求，运行结果如下：
在这里插入图片描述
  可以看到，这样是可以实现我们想要的效果的。
  但是业务层实现类的方法有很多，如果每个方法都像这样修改的话，一是十分繁琐，二是会使我们的项目维护起来十分的麻烦。
  那有什么办法可以解决这个问题吗？AOP（面向切面编程技术） 就可以完美的解决这个问题，AOP底层由 动态代理 实现，可以在不改变原有代码的基础上，给方法添加其他额外的功能。

AOP

  导入AOP相关依赖

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

  我们新建一个aop软件包，在软件包下新建TimeAspect类，在该类中编写如下代码：

package com.itheima.aop;

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

@Component //交给IOC容器管理
@Aspect //表示该类为切面类
@Slf4j //lombok工具包
public class TimeAspect {
    @Around("execution(* com.itheima.service.*.*(..))")//匹配方法
    public Object recordTime(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        //开始时间
        long begin = System.currentTimeMillis();
        //执行原始方法
        Object result = proceedingJoinPoint.proceed();
        //结束时间
        long end = System.currentTimeMillis();
        //输出原始方法执行时间
        log.info("Time taken: {} ms", end - begin);
        //返回原始方法返回值
        return result;
    }
}

  我们重新运行程序，并发送请求，结果如下：
在这里插入图片描述
  我们可以看到，仅仅通过这一段代码，就实现了获取业务层所有方法的运行时间，AOP思想的优越之处不用多说了吧。
  下面我们就来具体学习一下AOP相关的概念与应用。

3. 核心概念

  下面这些是AOP相关的概念，无需死记硬背，见得多了就记住了。

序号名称说明
1连接点（JoinPoint）可以被AOP控制的方法
2通知（Advice）指那些重复的逻辑，也就是共性功能（最终体现为一个方法）
3切入点（PointCut）匹配连接点的条件，通知仅会在切入点方法执行时被应用
4切面（Aspect）描述通知与切入点的对应关系（通知+切入点）
5目标对象（Target）通知所应用的对象

4. Java实现AOP

4.1 AOP依赖maven坐标

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

4.2 通知类型

序号注解对应通知类型说明
1@Around环绕通知此注解标注的通知方法在目标方法前、后都被执行
2@Before前置通知此注解标注的通知方法在目标方法前被执行
3@After后置通知此注解标注的通知方法在目标方法后被执行，无论是否有异常都会执行
4@AfterReturning返回后通知此注解标注的通知方法在目标方法后被执行，有异常不会执行
5@AfterThrowing异常后通知此注解标注的通知方法发生异常后执行

下面我们通过代码演示，来加深对于不同通知类型的理解：

package com.itheima.aop;

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Component
//@Aspect
@Slf4j
public class Notification {
    //前置通知，此注解标注的通知方法在目标方法前被执行
    @Before("execution(* com.itheima.service.impl.DeptServiceImpl.*(..))")//匹配DeptServiceImpl里的所有方法
    public void noticeBefore(){
        log.info("通知类型：before...");
    }

    //后置通知，此注解标注的通知方法在目标方法后被执行，无论是否有异常都会执行
    @After("execution(* com.itheima.service.impl.DeptServiceImpl.*(..))")
    public void noticeAfter(){
        log.info("通知类型：after...");
    }

    //环绕通知，此注解标注的通知方法在目标方法前、后都被执行
    @Around("execution(* com.itheima.service.impl.DeptServiceImpl.*(..))")
    public Object noticeAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{

        log.info("环绕通知：around before ...");
        Object result = proceedingJoinPoint.proceed();
        log.info("环绕通知：around after ...");

        return result;
    }

    //返回后通知，此注解标注的通知方法在目标方法后被执行，有异常不会执行
    @AfterReturning("execution(* com.itheima.service.impl.DeptServiceImpl.*(..))")
    public void noticeReturn(){
        log.info("后置通知：afterReturning ...");
    }

    //异常通知（程序在出现异常的情况下，执行的后置通知）
    @AfterThrowing("execution(* com.itheima.service.impl.DeptServiceImpl.*(..))")
    public void noticeThrow(){
        log.info("异常通知：afterThrowing ...");
    }
}

注意

  • @Around环绕通知需要自己调用ProceedingJoinPoin.porceed（）来让原始方法执行，其他通知不需要考虑目标方法执行
  • @ Around环绕通知方法的返回值，必须指定为Object，来接受原始方法的返回值

  运行程序，查看日志输出
在这里插入图片描述

  程序运行结束，我们回过头来看一下我们书写通知类型，

//前置通知
@Before("execution(* com.itheima.service.*.*(..))")

//环绕通知
@Around("execution(* com.itheima.service.*.*(..))")
  
//后置通知
@After("execution(* com.itheima.service.*.*(..))")

//返回后通知（程序在正常执行的情况下，会执行的后置通知）
@AfterReturning("execution(* com.itheima.service.*.*(..))")

//异常通知（程序在出现异常的情况下，执行的后置通知）
@AfterThrowing("execution(* com.itheima.service.*.*(..))")

@PointCut注解抽取公共切入点表达式

  execution里的是切入点表达式 ，每一个注解里面都指定了切入点表达式，而且这些切入点表达式都一模一样。此时我们的代码当中就存在了大量的重复性的切入点表达式，假如此时切入点表达式需要变动，就需要将所有的切入点表达式一个一个的来改动，就变得非常繁琐了。
  怎么来解决这个切入点表达式重复的问题？ 答案就是：抽取
  Spring提供了 @PointCut注解 ，该注解的作用是将公共的切入点表达式抽取出来，需要用到时引用该切入点表达式即可。

    //抽取公共的切入点表达式
    @Pointcut("execution(* com.itheima.service.impl.DeptServiceImpl.*(..))")
    public void pointcut() {}//空参无返回值，函数名任意

  修改后的代码如下：

package com.itheima.aop;

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Component
@Aspect
@Slf4j
public class Notification {
    //抽取公共的切入点表达式
    @Pointcut("execution(* com.itheima.service.impl.DeptServiceImpl.*(..))")
    public void pointcut() {}

    //前置通知，此注解标注的通知方法在目标方法前被执行
    @Before("pointcut()")//匹配DeptServiceImpl里的所有方法
    public void noticeBefore(){
        log.info("通知类型：before...");
    }

    //后置通知，此注解标注的通知方法在目标方法后被执行，无论是否有异常都会执行
    @After("pointcut()")
    public void noticeAfter(){
        log.info("通知类型：after...");
    }

    //环绕通知，此注解标注的通知方法在目标方法前、后都被执行
    @Around("pointcut()")
    public Object noticeAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{

        log.info("环绕通知：around before ...");
        Object result = proceedingJoinPoint.proceed();
        log.info("环绕通知：around after ...");

        return result;
    }

    //返回后通知，此注解标注的通知方法在目标方法后被执行，有异常不会执行
    @AfterReturning("pointcut()")
    public void noticeReturn(){
        log.info("后置通知：afterReturning ...");
    }

    //异常通知（程序在出现异常的情况下，执行的后置通知）
    @AfterThrowing("pointcut()")
    public void noticeThrow(){
        log.info("异常通知：afterThrowing ...");
    }
}

  需要注意的是： 当切入点方法使用private修饰时，仅能在当前切面类中引用该表达式， 当外部其他切面类中也要引用当前类中的切入点表达式，就需要把private改为public，而在引用的时候，具体的语法为：

@Slf4j
@Component
@Aspect
public class MyAspect2 {
    //引用MyAspect1切面类中的切入点表达式
    @Before("com.itheima.aop.Notification.pt()")
    public void before(){
        log.info("MyAspect2 -> before ...");
    }
}

4.3 通知顺序

  在不同切面类中，默认按照切面类的类名字母排序：

  • 目标方法前的通知方法：字母排名靠前的先执行
  • 目标方法后的通知方法：字母排名靠前的后执行

@Order注解控制通知的执行顺序

  使用Spring提供的@Order注解，可以控制通知的执行顺序：

@Slf4j
@Component
@Aspect
@Order(2)  //切面类的执行顺序（前置通知：数字越小先执行; 后置通知：数字越小越后执行）
public class MyAspect2 {
    //前置通知
    @Before("execution(* com.itheima.service.*.*(..))")
    public void before(){
        log.info("MyAspect2 -> before ...");
    }

    //后置通知 
    @After("execution(* com.itheima.service.*.*(..))")
    public void after(){
        log.info("MyAspect2 -> after ...");
    }
}

@Slf4j
@Component
@Aspect
@Order(3)  //切面类的执行顺序（前置通知：数字越小先执行; 后置通知：数字越小越后执行）
public class MyAspect3 {
    //前置通知
    @Before("execution(* com.itheima.service.*.*(..))")
    public void before(){
        log.info("MyAspect3 -> before ...");
    }

    //后置通知
    @After("execution(* com.itheima.service.*.*(..))")
    public void after(){
        log.info("MyAspect3 ->  after ...");
    }
}

@Slf4j
@Component
@Aspect
@Order(1) //切面类的执行顺序（前置通知：数字越小先执行; 后置通知：数字越小越后执行）
public class MyAspect4 {
    //前置通知
    @Before("execution(* com.itheima.service.*.*(..))")
    public void before(){
        log.info("MyAspect4 -> before ...");
    }

    //后置通知
    @After("execution(* com.itheima.service.*.*(..))")
    public void after(){
        log.info("MyAspect4 -> after ...");
    }
}

  重新启动SpringBoot服务，测试通知执行顺序：
在这里插入图片描述

4.4 切入点表达式

4.4.1 execution

  execution主要根据方法的返回值、包名、类名、方法名、方法参数等信息来匹配，语法为：

execution(访问修饰符?  返回值  包名.类名.?方法名(方法参数) throws 异常?)

其中带?的表示可以省略的部分

  • 访问修饰符：可省略（比如: public、protected）

  • 包名.类名： 可省略

  • throws 异常：可省略（注意是方法上声明抛出的异常，不是实际抛出的异常）

示例：

@Before("execution(void com.itheima.service.impl.DeptServiceImpl.delete(java.lang.Integer))")

可以使用通配符描述切入点

  • * ：单个独立的任意符号，可以通配任意返回值、包名、类名、方法名、任意类型的一个参数，也可以通配包、类、方法名的一部分

  • .. ：多个连续的任意符号，可以通配任意层级的包，或任意类型、任意个数的参数

切入点表达式的语法规则：

  1. 方法的访问修饰符可以省略
  2. 返回值可以使用*号代替（任意返回值类型）
  3. 包名可以使用*号代替，代表任意包（一层包使用一个*）
  4. 使用..配置包名，标识此包以及此包下的所有子包
  5. 类名可以使用*号代替，标识任意类
  6. 方法名可以使用*号代替，表示任意方法
  7. 可以使用 * 配置参数，一个任意类型的参数
  8. 可以使用.. 配置参数，任意个任意类型的参数

切入点表达式示例

  • 省略方法的修饰符号

    execution(void com.itheima.service.impl.DeptServiceImpl.delete(java.lang.Integer))

  • 使用*代替返回值类型

    execution(* com.itheima.service.impl.DeptServiceImpl.delete(java.lang.Integer))

  • 使用*代替包名（一层包使用一个*）

    execution(* com.itheima.*.*.DeptServiceImpl.delete(java.lang.Integer))

  • 使用..省略包名

    execution(* com..DeptServiceImpl.delete(java.lang.Integer))

  • 使用*代替类名

    execution(* com..*.delete(java.lang.Integer))

  • 使用*代替方法名

    execution(* com..*.*(java.lang.Integer))

  • 使用 * 代替参数

    execution(* com.itheima.service.impl.DeptServiceImpl.delete(*))

  • 使用..省略参数

    execution(* com..*.*(..))

​

注意事项：

  • 根据业务需要，可以使用 且（&&）、或（||）、非（!） 来组合比较复杂的切入点表达式。

    execution(* com.itheima.service.DeptService.list(..)) || execution(* com.itheima.service.DeptService.delete(..))

切入点表达式的书写建议：

  • 所有业务方法名在命名时尽量规范，方便切入点表达式快速匹配。如：查询类方法都是 find 开头，更新类方法都是update开头

    //业务类
@Service
public class DeptServiceImpl implements DeptService {
    
    public List<Dept> findAllDept() {
       //省略代码...
    }
    
    public Dept findDeptById(Integer id) {
       //省略代码...
    }
    
    public void updateDeptById(Integer id) {
       //省略代码...
    }
    
    public void updateDeptByMoreCondition(Dept dept) {
       //省略代码...
    }
    //其他代码...
}

    //匹配DeptServiceImpl类中以find开头的方法
execution(* com.itheima.service.impl.DeptServiceImpl.find*(..))

  • 描述切入点方法通常基于接口描述，而不是直接描述实现类，增强拓展性

    execution(* com.itheima.service.DeptService.*(..))

  • 在满足业务需要的前提下，尽量缩小切入点的匹配范围。如：包名匹配尽量不使用 …，使用 * 匹配单个包

    execution(* com.itheima.*.*.DeptServiceImpl.find*(..))

4.4.2 @annotation

  我们来看下面这段代码

    //匹配DeptServiceImpl中的 list() 和 delete(Integer id)方法
    @Pointcut("execution(* com.itheima.service.DeptService.list()) || execution(* com.itheima.service.DeptService.delete(java.lang.Integer))")
    private void pt(){}

  这段代码描述的是切入点表达式要匹配DeptServiceImpl中的 list() 和 delete(Integer id)方法，可以见得上面这种写法是有些繁琐的，倘若要匹配更多的方法，那就更加反锁了，有没有什么方法可以简化一下呢？
  有的，通过@annotation描述切入点表达式

步骤：

  1. 编写自定义注解

  2. 在业务类要做为连接点的方法上添加自定义注解

1. 编写自定义注解
/**
 * 自定义注解
 */
@Retention(RetentionPolicy.RUNTIME)//元注解：指定自定义注解的生命周期：运行时间
@Target(ElementType.METHOD)//元注解：指定自定义注解的作用目标：方法
public @interface MyLog {
}
2. 添加@annotation切入点表达式
@Slf4j
@Component
@Aspect
public class MyAspect6 {
    //针对list方法、delete方法进行前置通知和后置通知

    //前置通知
    @Before("@annotation(com.itheima.anno.MyLog)")
    public void before(){
        log.info("MyAspect6 -> before ...");
    }

    //后置通知
    @After("@annotation(com.itheima.anno.MyLog)")
    public void after(){
        log.info("MyAspect6 -> after ...");
    }
}
3. 在业务类要做为连接点的方法上添加自定义注解
@Slf4j
@Service
public class DeptServiceImpl implements DeptService {
    @Autowired
    private DeptMapper deptMapper;

    @Override
    @MyLog //自定义注解（表示：当前方法属于目标方法）
    public List<Dept> list() {
        List<Dept> deptList = deptMapper.list();
        //模拟异常
        //int num = 10/0;
        return deptList;
    }

    @Override
    @MyLog  //自定义注解（表示：当前方法属于目标方法）
    public void delete(Integer id) {
        //1. 删除部门
        deptMapper.delete(id);
    }


    @Override
    public void save(Dept dept) {
        dept.setCreateTime(LocalDateTime.now());
        dept.setUpdateTime(LocalDateTime.now());
        deptMapper.save(dept);
    }

    @Override
    public Dept getById(Integer id) {
        return deptMapper.getById(id);
    }

    @Override
    public void update(Dept dept) {
        dept.setUpdateTime(LocalDateTime.now());
        deptMapper.update(dept);
    }
}

  重启SpringBoot服务，测试查询所有部门数据，查看控制台日志：在这里插入图片描述

4.4.3 总结

  • execution切入点表达式
    • 根据我们所指定的方法的描述信息来匹配切入点方法，这种方式也是最为常用的一种方式
    • 如果我们要匹配的切入点方法的方法名不规则，或者有一些比较特殊的需求，通过execution切入点表达式描述比较繁琐
  • annotation 切入点表达式
    • 基于注解的方式来匹配切入点方法。这种方式虽然多一步操作，我们需要自定义一个注解，但是相对来比较灵活。我们需要匹配哪个方法，就在方法上加上对应的注解就可以了

4.5 连接点

  在Spring中用JoinPoint抽象了连接点，用它可以获得方法执行时的相关信息，如目标类名、方法名、方法参数等。

常用方法：

方法名返回类型描述
proceed()Object执行目标方法。此方法允许你继续目标方法的执行。如果没有参数，则执行目标方法；如果有参数，可以传递自定义的参数。
proceed(Object[] args)Object执行目标方法，并传递参数。args 是一个包含方法参数的数组。
getSignature()Signature返回方法签名。类似于普通 JoinPoint 中的 getSignature()，可以用来获取目标方法的名称、参数类型等信息。
getArgs()Object[]返回目标方法的参数值数组。与普通 JoinPoint 中的 getArgs() 类似。
getTarget()Object返回目标对象（即被代理的对象）。

  • 对于 @Around 通知，获取连接点信息只能使用ProceedingJoinPoint类型

  • 对于其他四种通知，获取连接点信息只能使用JoinPoint，它是ProceedingJoinPoint的父类型

示例代码：

@Component
@Aspect
@Slf4j
public class MyJoinPoint {
    @Pointcut("execution(* com.itheima.service.impl.DeptServiceImpl.*(..))")
    public void myPointcut() {}

    @Around("myPointcut()")
    public Object myAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        //1.获取目标对象的类名
        String name = proceedingJoinPoint.getTarget().getClass().getName();
        log.info("获取目标对象的类名:{}", name);

        //2.获取目标方法的方法名
        String methodName = proceedingJoinPoint.getSignature().getName();
        log.info("获取目标方法的方法名:{}", methodName);

        //3.获取目标方法运行时传入的参数
        Object[] args = proceedingJoinPoint.getArgs();
        log.info("获取目标方法运行时传入的参数:{}", Arrays.toString(args));

        //4.执行目标方法
        Object proceed = proceedingJoinPoint.proceed();

        //5.获取目标方法的返回值
        log.info("目标方法的返回值：{}", proceed);

        return proceed;
    }
}

  重新启动SpringBoot服务，执行查询部门数据的功能：
在这里插入图片描述

5. 总结

在这里插入图片描述

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值