2022-10-12 AOP

目录

AOP

AOP核心概念

AOP(Aspect Oriented Programming)面向切面编程，一种编程范式，指导开发者如何组织程序结构

  • OOP(Object Oriented Programming)面向对象编程

作用：在不惊动原始设计的基础上为其进行功能增强

Spring理念：无侵入式、无入侵式

连接点(JoinPoint)：程序执行过程中的任意位置，粒度为执行方法、抛出异常、设置变量等

  • 在SpringAOP中，理解为方法的执行

切入点（PointCut）：匹配连接点的式子

  • 在SpringAOP中，一个切入点可以只描述一个具体的方法，也可以匹配多个方法
    • 一个具体的方法：com.itheima.dao包下的BookDao接口中的无形参无返回值的save方法
    • 匹配多个方法：所有的save方法，所有的get开头的方法，所有以Dao结尾的接口中的任意方法，所有带有一个参数的方法

通知（Advice）：在切入点处执行的操作，也就是共性功能

  • 在SpringAOP中，功能最终以方法的形式呈现

通知类

定义通知的类

切面（Aspect）

描述通知与切入点的对应关系

AOP入门案例（注解版）

  1. 导入aop相关坐标
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.4</version>
</dependency>

说明：spring-context坐标依赖spring-aop坐标

  1. 定义dao接口与实现类
public interface BookDao {
    void save();
    void update();
}

@Repository
public class BookDaoImpl implements BookDao {

    public void save() {
        System.out.println(System.currentTimeMillis());
        System.out.println("book dao save...");
    }

    public void update() {
        System.out.println("book dao update...");
    }
}
  1. 定义通知类，制作通知
public class MyAdvice {

    public void method(){
        System.out.println(System.currentTimeMillis());
    }
}
  1. 定义切入点
public class MyAdvice {

    @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    public void pt(){}
}

说明：切入点定义依托一个不具有实际意义的方法进行，即无参数，无返回值，方法体无实际逻辑

  1. 绑定切入点与通知关系，并指定通知添加到原始连接点的具体执行位置
public class MyAdvice {

    @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    public void pt(){}

    @Before("pt()")
    public void method(){
        System.out.println(System.currentTimeMillis());
    }
}
  1. 定义通知类受Spring容器管理，并定义当前类为切面类
@Component
@Aspect
public class MyAdvice {

    @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    public void pt(){}

    @Before("pt()")
    public void method(){
        System.out.println(System.currentTimeMillis());
    }
}
  1. 开启Spring对AOP注解驱动支持
@Configuration
@ComponentScan("com.itheima")
@EnableAspectJAutoProxy
public class SpringConfig {
}

AOP工作流程

  1. Spring容器启动
  2. 读取所有切面配置中的切入点
  3. 初始化bean，判定bean对应的类中的方法是否匹配到任意切入点
    • 匹配失败，创建对象
    • 匹配成功，创建原始对象（目标对象）的代理对象
  4. 获取bean执行方法
    • 获取bean，调用方法并执行，完成操作
    • 获取的bean是代理对象时，根据代理对象的运行模式运行原始方法与增强的内容，完成操作

AOP核心概念

  • 目标对象（Target）：原始功能去掉共性功能对应的类产生的对象，这种对象是无法直接完成最终工作的
  • 代理（Proxy）：目标对象无法直接完成工作，需要对其进行功能回填，通过原始对象的代理对象实现

切入点表达式

  • 切入点：要进行增强的方法
  • 切入点表达式：要进行增强的方法的描述方式

描述方式一：执行com.itheima.dao包下的BookDao接口中的无参数update方法

execution(void com.itheima.dao.BookDao.update())

描述方式二：执行com.itheima.dao.impl包下的BookDaoImpl类中的无参数update方法

execution(void com.itheima.dao.impl.BookDaoImpl.update())
  • 切入点表达式标准格式：动作关键字（访问修饰符 返回值 包名.类/接口名.方法名（参数）异常名）
execution(public User com.itheima.service.UserService.findById(int))
  1. 动作关键字：描述切入点的行为动作，例如execution表示执行到指定切入点
  2. 访问修饰符：public，private等，可以省略
  3. 返回值
  4. 包名
  5. 类/接口名
  6. 方法名
  7. 参数
  8. 异常名：方法定义中抛出指定异常，可以省略

使用通配符描述切入点

  • '*':单个独立的任意符号，可以独立出现，也可以作为前缀或者后缀的匹配符出现
execution(public * com.itheima.*.UserService.find*(*))

匹配com.itheima包下的任意包中的UserService类或接口中所有find开头的带有一个参数的方法

  • .. :多个连续的任意符号，可以独立出现，常用于简化包名与参数的书写
execution(public User com..UserService.findById(..))

匹配com包下的任意包中的UserService类或接口中所有名称为findById的方法

  • '+' :专用于匹配子类类型
execution(* *..*Service+.*(..))

execution(void com.itheima.dao.BookDao.update())
匹配接口，能匹配到
execution(void com.itheima.dao.impl.BookDaoImpl.update())
匹配实现类，能匹配到
execution(* com.itheima.dao.impl.BookDaoImpl.update())
返回值任意，能匹配到
execution(* com.itheima.dao.impl.BookDaoImpl.update(*))
返回值任意，但是update方法必须要有一个参数，无法匹配，要想匹配需要在update接口和实现类添加
参数
execution(void com.*.*.*.*.update())
返回值为void,com包下的任意包三层包下的任意类的update方法，匹配到的是实现类，能匹配
execution(void com.*.*.*.update())
返回值为void,com包下的任意两层包下的任意类的update方法，匹配到的是接口，能匹配
execution(void *..update())
返回值为void，方法名是update的任意包下的任意类，能匹配
execution(* *..*(..))
匹配项目中任意类的任意方法，能匹配，但是不建议使用这种方式，影响范围广
execution(* *..u*(..))
匹配项目中任意包任意类下只要以u开头的方法，update方法能满足，能匹配
execution(* *..*e(..))
匹配项目中任意包任意类下只要以e结尾的方法，update和save方法能满足，能匹配
execution(void com..*())
返回值为void，com包下的任意包任意类任意方法，能匹配，*代表的是方法
execution(* com.itheima.*.*Service.find*(..))
将项目中所有业务层方法的以find开头的方法匹配
execution(* com.itheima.*.*Service.save*(..))
将项目中所有业务层方法的以save开头的方法匹配

后面两种更符合我们平常切入点表达式的编写规则

书写技巧

  • 所有代码按照标准规范开发，否则以下技巧全部失效
  • 描述切入点通常描述接口，而不描述实现类,如果描述到实现类，就出现紧耦合了
  • 访问控制修饰符针对接口开发均采用public描述（可省略访问控制修饰符描述）
  • 返回值类型对于增删改类使用精准类型加速匹配，对于查询类使用*通配快速描述
  • 包名书写尽量不使用..匹配，效率过低，常用*做单个包描述匹配，或精准匹配
  • 接口名/类名书写名称与模块相关的采用 ' * ' 匹配，例如UserService书写成 ' *Service ' ,绑定业务层接口名
  • 方法名书写以动词进行精准匹配，名词采用 ' * ' 匹配，例如getById书写成 ' getBy * ',selectAll书写成selectAll
  • 参数规则较为复杂，根据业务方法灵活调整
  • 通常不使用异常作为匹配规则

AOP通知类型

AOP通知描述了抽取的共性功能，根据共性功能抽取的位置不同，最终运行代码时要将其加入到合理的位置

AOP通知的5种类型

  • 前置通知
  • 后置通知
  • 环绕通知（重点）
@Component
@Aspect
public class MyAdvice {
    @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    private void pt(){}
    @Pointcut("execution(int com.itheima.dao.BookDao.select())")
    private void pt2(){}

//    @Around("pt()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("before advice...");
        // 表示对原始操作的调用
        Object ret = pjp.proceed();
        System.out.println("after advice...");
        return ret;
    }

//    @Around("pt2()")
    public Object aroundSelect(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("before advice...");
        // 表示对原始操作的调用
        Object i = pjp.proceed();
        System.out.println("after advice...");
        return i;
    }
}
  • 返回后通知（了解）
  • 抛出异常后通知（了解）

@After

名称 @After
类型 方法注解
位置 通知方法定义上方
作用 设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法后运行

@AfterReturning

名称 @AfterReturning
类型 方法注解
位置 通知方法定义上方
作用 设置当前通知方法与切入点之间绑定关系，当前通知方法在原始切入点方法正常执行完毕后执行

@AfterThrowing

名称 @AfterThrowing
类型 方法注解
位置 通知方法定义上方
作用 设置当前通知方法与切入点之间绑定关系，当前通知方法在原始切入点方法运行抛出异常后执行

@Around

名称 @Around
类型 方法注解
位置 通知方法定义上方
作用 设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法前后运行

环绕通知注意事项

  1. 环绕通知必须依赖形参ProceedingJoinPoint才能实现对原始方法的调用，进而实现原始方法调用前后同时添加通知
  2. 通知中如果未使用ProceedingJoinPoint对原始方法进行调用将跳过原始方法的执行
  3. 对原始方法的调用可以不接收返回值，通知方法设置成void即可，如果接收返回值，最好设定为Object类型
  4. 原始方法的返回值如果是void类型，通知方法的返回值类型可以设置成void,也可以设置成Object
  5. 由于无法预知原始方法运行后是否会抛出异常，因此环绕通知方法必须要处理Throwable异常

案例：测量业务层接口万次执行效率

    @Around("ProjectAdvice.servicePt()")
    public void runSpeed(ProceedingJoinPoint pjp) throws Throwable {

        long start = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            pjp.proceed();
        }
        long end = System.currentTimeMillis();
        System.out.println("业务层接口万次执行时间： " + (end-start) + "ms");

    }
  • 区分是哪个方法执行
    @Around("ProjectAdvice.servicePt()")
    public void runSpeed(ProceedingJoinPoint pjp) throws Throwable {
        // 获取执行签名信息
        Signature signature = pjp.getSignature();
        // 通过签名获取执行类型（接口名）
        String className = signature.getDeclaringTypeName();
        // 通过签名获取执行操作名称（方法名）
        String methodName = signature.getName();

        long start = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            pjp.proceed();
        }
        long end = System.currentTimeMillis();
        System.out.println("万次执行" + className + "." + methodName + "==>" + (end-start) + "ms");

    }

AOP通知获取数据

  • 获取切入点方法的参数
    • JoinPoint：适用于前置、后置、返回后、抛出异常后通知
    • ProceedJoinPoint：适用于环绕通知
  • 获取切入点方法返回值
    • 返回后通知
    • 环绕通知
  • 获取切入点方法运行异常信息
    • 抛出异常后通知
    • 环绕通知
  1. JoinPoint对象描述了连接点方法的运行状态，可以获取到原始方法的调用参数
    @Before("pt()")
    public void before(JoinPoint jp) {
        Object[] args = jp.getArgs();
        System.out.println(Arrays.toString(args));
    }
  1. ProceedJoinPoint是JoinPoint的子类
    @Around("pt()")
    public Object around(ProceedingJoinPoint pjp) {
        Object[] args = pjp.getArgs();
        System.out.println(Arrays.toString(args));
        Object ret = pjp.proceed();
        return ret;
    }
  1. 抛出异常后通知可以获取切入点方法中出现的异常信息，使用形参可以接收对应的异常对象
    @AfterReturning(value = "pt()",returning = "ret")
    public void afterReturning(String ret){
        System.out.println("afterReturning advice..." + ret);
    }
  1. 环绕通知中可以手工书写对原始方法的调用，得到的结果即为原始方法的返回值
    @Around("pt()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        Object ret = pjp.proceed();
        return ret;
    }
  1. AOP通知获取异常数据（了解）
  • 抛出异常后通知可以获取切入点方法中出现的异常信息，使用形参可以接收对应的异常信息
    @AfterThrowing(value = "pt()",throwing = "t")
    public void afterThrowing(Throwable t){
        System.out.println("afterThrowing advice..." + t);
    }
  • 抛出异常后通知可以获取切入点方法运行的异常信息，使用形参可以接收运行时抛出的异常信息
    @Around("pt()")
    public Object around(ProceedingJoinPoint pjp) {
        Object ret = null;
        try {
            ret = pjp.proceed(args);
        } catch (Throwable t) {
            t.printStackTrace();
        }
        return ret;
    }
posted @   LegendR  阅读(31)  评论(0)  编辑  收藏  举报
相关博文：
· 2022-07-26 第八组 卢睿 学习心得
· 2022-09-27 spring
· 跟着黑马学SSM——Day4之AOP
· java框架——Spring（二）
· Spring AOP
阅读排行：
· Manus爆火，是硬核还是营销？
· 终于写完轮子一部分：tcp代理 了，记录一下
· 别再用vector＜bool＞了！Google高级工程师：这可能是STL最大的设计失误
· 单元测试从入门到精通
· 震惊！C++程序真的从main开始吗？99%的程序员都答错了
点击右上角即可分享
微信分享提示