AOP - 面向切面编程

最后更新时间：2022年08月15日

DAY3 - AOP

一、AOP简介

  • AOP(Aspect Oriented Programming)面向切面编程，一种编程范式，指导开发者如何组织程序结构。
  • 作用：在不惊动原始设计的基础上为其进行功能增强。
  • Spring理念：无入侵式/无侵入式

1.1 AOP核心概念

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

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

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

    • 在SpringAOP中，一个切入点可以只描述一个具体方法，也可以匹配多个方法。

      • 一个具体方法：com.li.dao包下的BookDao接口中的无形参无返回值的save方法
      • 匹配多个方法：所有的save方法，所有的get开头的方法，所有以Dao结尾的接口中的任意方法，所有带有一个参数的方法。

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

    • 在SpringAOP中，功能最终以方法的形式呈现。
  • 通知类：定义通知的类。
  • 切面（Aspect)：描述通知与切入点的对应关系。

1.1.1 示意图

1.1.2 实例

BookDaoImpl

@Repository
public class BookDaoImpl implements BookDao {
public void save() {
    //记录程序当前执行执行（开始时间）
    Long startTime = System.currentTimeMillis();
    //业务执行万次
    for (int i = 0;i<10000;i++) {
        System.out.println("book dao save ...");
    }
    //记录程序当前执行时间（结束时间）
    Long endTime = System.currentTimeMillis();
    //计算时间差
    Long totalTime = endTime-startTime;
    //输出信息
    System.out.println("执行万次消耗时间：" + totalTime + "ms");
}

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

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

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

MyAdvice

@Component
@Aspect
public class MyAdvice {
@Pointcut("execution(* com.itheima.dao.BookDao.*d*(..))")
private void pt(){}

@Around("pt()")
public Object around(ProceedingJoinPoint pjp) throws Throwable {
    System.out.println("------------------------------");
    Long startTime = System.currentTimeMillis();
    for (int i = 0 ; i<10000 ; i++) {
        //调用原始操作
        pjp.proceed();
    }
    Long endTime = System.currentTimeMillis();
    Long totalTime = endTime-startTime;
    System.out.println("执行万次消耗时间：" + totalTime + "ms");
    return null;
}
}

1.2 AOP作用

  • 作用：在不惊动原始设计的基础上为其进行功能增强。
  • 前面咱们有技术就可以实现这样的功能即代理模式。

二、AOP入门案例

2.1 AOP入门案例思路分析

2.2 实例

pom.xml

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.itheima</groupId>
  <artifactId>spring_18_aop_quickstart</artifactId>
  <version>1.0-SNAPSHOT</version>

  <dependencies>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.2.10.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.9.4</version>
    </dependency>
  </dependencies>
</project>

BookDao、BookDaoImpl（定义dao接口与实现类）

public interface BookDao {
    public void save();
    public 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 ...");
    }
}

MyAdvice

  • （定义通知类，制作通知）
  • （定义切入点）
  • （绑定切入点与通知关系，并指定通知添加到原始连接点的具体执行位置）
  • （定义通知类受Spring容器管理，并定义当前类为切面类）
//通知类必须配置成Spring管理的bean
@Component
//设置当前类为切面类类
@Aspect
public class MyAdvice {
    //设置切入点，要求配置在方法上方
    @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    private void pt(){}

    //设置在切入点pt()的前面运行当前操作（前置通知）
    // @Before("pt()")
    public void method(){
        System.out.println(System.currentTimeMillis());
    }
}
  • 说明：切入点定义依托一个不具有实际意义的方法进行，即无参数，无返回值，方法体无实际逻辑。

SpringConfig（开启Spring对AOP注解驱动支持）

@Configuration
@ComponentScan("com.itheima")
//开启注解开发AOP功能
@EnableAspectJAutoProxy
public class SpringConfig {
}

2.3 知识点

三、AOP工作流程

3.1 AOP工作流程

3.2 AOP核心概念（新概念）

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

四、AOP配置管理 - AOP切入点表达式

（注：四~八皆为AOP配置管理）

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

4.1 实例

MyAdvice

@Component
@Aspect
public class MyAdvice {
    //切入点表达式：
    @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    @Pointcut("execution(void com.itheima.dao.impl.BookDaoImpl.update())")
    @Pointcut("execution(* com.itheima.dao.impl.BookDaoImpl.update(*))")    //no
    @Pointcut("execution(void com.*.*.*.update())")
    @Pointcut("execution(* *..*(..))")
    @Pointcut("execution(* *..*e(..))")
    @Pointcut("execution(void com..*())")
    @Pointcut("execution(* com.itheima.*.*Service.find*(..))")
    //执行com.itheima包下的任意包下的名称以Service结尾的类或接口中的save方法，参数任意，返回值任意
    @Pointcut("execution(* com.itheima.*.*Service.save(..))")
    private void pt(){}

    @Before("pt()")
    public void method(){
        System.out.println(System.currentTimeMillis());
    }
}

BookDaoImpl

@Repository
public class BookDaoImpl implements BookDao {

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

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

BookDao

public interface BookDao {
    public void save();
    public void update();
}

APP

public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        BookDao bookDao = ctx.getBean(BookDao.class);
        bookDao.update();
    }
}

4.2 书写技巧

五、AOP通知类型

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

  • AOP通知共分为5种类型：

    • 前置通知
    • 后置通知
    • 环绕通知（重点）
    • 返回后通知（了解）
    • 抛出异常后通知（了解）

5.1 实例

@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(){}

    //@Before：前置通知，在原始方法运行之前执行
   @Before("pt()")
    public void before() {
        System.out.println("before advice ...");
    }

    //@After：后置通知，在原始方法运行之后执行
    @After("pt2()")
    public void after() {
        System.out.println("after advice ...");
    }

    //@Around：环绕通知，在原始方法运行的前后执行
    @Around("pt()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("around before advice ...");
        //表示对原始操作的调用
        Object ret = pjp.proceed();
        System.out.println("around after advice ...");
        return ret;
    }

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

    //@AfterReturning：返回后通知，在原始方法执行完毕后运行，且原始方法执行过程中未出现异常现象
    @AfterReturning("pt2()")
    public void afterReturning() {
        System.out.println("afterReturning advice ...");
    }

    //@AfterThrowing：抛出异常后通知，在原始方法执行过程中出现异常后运行
    @AfterThrowing("pt2()")
    public void afterThrowing() {
        System.out.println("afterThrowing advice ...");
    }
}

5.2 通知类型总结

@Before

@After

@Around

@Around注意事项

@AfterReturning

@AfterThrowing

六、案例︰测量业务层接口万次执行效率

6.1 案例需求分析

  • 补充说明：当前测试的接口执行效率仅仅是一个理论值，并不是一次完整的执行过程。

6.2 实例

@Component
@Aspect
public class ProjectAdvice {
    //匹配业务层的所有方法
    @Pointcut("execution(* com.itheima.service.*Service.*(..))")
    private void servicePt(){}

    //设置环绕通知，在原始操作的运行前后记录执行时间
    @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通知获取数据

7.1 获取参数

  • JoinPoint ：适用于前置、后置、返回后、抛出异常后通知。
  • ProceedJointPoint ：适用于环绕通知。
  • JoinPoint对象描述了连接点方法的运行状态，可以获取到原始方法的调用参数。
  • ProceedJointPoint是JoinPoint的子类。

7.2 获取返回值

  • 返回后通知
  • 环绕通知
  • 抛出异常后通知可以获取切入点方法中出现的异常信息，使用形参可以接收对应的异常对象。
  • 环绕通知中可以手工书写对原始方法的调用，得到的结果即为原始方法的返回值。

7.3 获取异常（了解）

  • 抛出异常后通知
  • 环绕通知
  • 抛出异常后通知可以获取切入点方法中出现的异常信息，使用形参可以接收对应的异常对象。
  • 抛出异常后通知可以获取切入点方法运行的异常信息，使用形参可以接收运行时抛出的异常对象。

7.4 实例

@Component
@Aspect
public class MyAdvice {
    @Pointcut("execution(* com.itheima.dao.BookDao.findName(..))")
    private void pt(){}

    //JoinPoint：用于描述切入点的对象，必须配置成通知方法中的第一个参数，可用于获取原始方法调用的参数
//    @Before("pt()")
    public void before(JoinPoint jp) {
        Object[] args = jp.getArgs();
        System.out.println(Arrays.toString(args));
        System.out.println("before advice ..." );
    }

//    @After("pt()")
    public void after(JoinPoint jp) {
        Object[] args = jp.getArgs();
        System.out.println(Arrays.toString(args));
        System.out.println("after advice ...");
    }

    //ProceedingJoinPoint：专用于环绕通知，是JoinPoint子类，可以实现对原始方法的调用
//    @Around("pt()")
    public Object around(ProceedingJoinPoint pjp) {
        Object[] args = pjp.getArgs();
        System.out.println(Arrays.toString(args));
        args[0] = 666;
        Object ret = null;
        try {
            ret = pjp.proceed(args);
        } catch (Throwable t) {
            t.printStackTrace();
        }
        return ret;
    }

    //设置返回后通知获取原始方法的返回值，要求returning属性值必须与方法形参名相同
    @AfterReturning(value = "pt()",returning = "ret")
    public void afterReturning(JoinPoint jp,String ret) {
        System.out.println("afterReturning advice ..."+ret);
    }

    //设置抛出异常后通知获取原始方法运行时抛出的异常对象，要求throwing属性值必须与方法形参名相同
    @AfterThrowing(value = "pt()",throwing = "t")
    public void afterThrowing(Throwable t) {
        System.out.println("afterThrowing advice ..."+t);
    }
}

八、案例:百度网盘密码数据兼容处理

8.1 案例需求分析

8.2 实例

开启SpringAOP的注解功能

@Configuration
@ComponentScan("com.itheima")
@EnableAspectJAutoProxy
public class SpringConfig {
}

编写通知类 - 添加环绕通知 - 完成核心业务，处理参数中的空格

@Component
@Aspect
public class DataAdvice {
    @Pointcut("execution(boolean com.itheima.service.*Service.*(*,*))")
    private void servicePt(){}

    @Around("DataAdvice.servicePt()")
    public Object trimStr(ProceedingJoinPoint pjp) throws Throwable {
        Object[] args = pjp.getArgs();
        for (int i = 0; i < args.length; i++) {
            //判断参数是不是字符串
            if(args[i].getClass().equals(String.class)){
                args[i] = args[i].toString().trim();
            }
        }
        Object ret = pjp.proceed(args);
        return ret;
    }

}

模拟校验

public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        ResourcesService resourcesService = ctx.getBean(ResourcesService.class);
        boolean flag = resourcesService.openURL("http://pan.baidu.com/haha", "root ");
        System.out.println(flag);
    }
}

九、AOP总结

9.1 概念

  • AOP —— 面向切面编程，一种编程范式。

9.2 作用

  • 在不惊动原始设计的基础上为方法进行功能增强。

9.3 核心概念

9.4 切入点

9.5 通知类别

9.6 通知获取数据 （参数、返回值、异常）

声明：三二一的一的二|版权所有，违者必究|如未注明，均为原创|本网站采用BY-NC-SA协议进行授权

转载：转载请注明原文链接 - AOP - 面向切面编程

三二一的一的二