什么是AOP及其作用

1、AOP被称之为面向切面（方面）编程(Aspect Oriented Programming)简写
2、AOP可以对业务逻辑各个方面进行隔离，从而降低代码的耦合性，提高代码的可复用性
通俗讲就是在不通过修改源码的情况下实现主干功功能上增加新的功能

AOP中常用术语

1、连接点：类中需要被增强的方法都称之为连接点
2、切入点：实际被增强的方法被称之切入点
3、通知（增强）：实际增强的逻辑被称之为通知
4、切面：切面是一个过程，将通知应用到切入点的过程被称之为切面

通知的类型

1、前置通知：切入点之前执行的逻辑
2、后置通知：切入点之后执行的逻辑
3、环绕通知：切入点前后都执行逻辑
4、异常通知：当切入点发生异常后的逻辑
5、返回通知：当返回结果是执行的逻辑

上述通知代码

1、pom.xml

<dependencies>
    <!-- junit测试包 -->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>

    <!-- spring-context 包含Spring-->
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.2.6.RELEASE</version>
    </dependency>

    <!-- aspectj -->
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjrt</artifactId>
      <version>1.8.13</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.9.5</version>
      <scope>runtime</scope>
    </dependency>

    <!-- https://mvnrepository.com/artifact/cglib/cglib -->
    <dependency>
      <groupId>cglib</groupId>
      <artifactId>cglib</artifactId>
      <version>3.3.0</version>
    </dependency>
    <!-- aspectj -->
  </dependencies>

2、BookDao需要被增强的类

package work.chenc.spring.dao;

import org.springframework.stereotype.Component;

// 需要增强类
@Component
public class BookDao {

    // 可以被增强的方法-连接点
    public void insert() {
        int A = 10 / 0;
        System.out.println("执行了insert().........:" + A);
    }

    // 需要被增强的方法-切入点
    public void add() {
        System.out.println("执行了add().........");
    }

}

3、BookProxy增强类—在什么位置对BookDao类中的方法进行增强逻辑

package work.chenc.spring.proxy;

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

// 增强类
@Component
@Aspect
public class BookProxy {
    // 相同切入点的抽取
    @Pointcut(value = "execution(* work.chenc.spring.dao.BookDao.add(..))")
    public void pointcutDemo() { }

    // 前置通知
   //   @Before(value = "execution(* work.chenc.spring.dao.BookDao.add(..))")
    // 自定义公共切入点的使用
    @Before(value = "pointcutDemo()")
    public void before() {
        System.out.println("前置通知——执行了before()方法");
    }

    // 后置通知 - 在方法执行之后执行
    @After(value = "execution(* work.chenc.spring.dao.BookDao.add(..))")
    public void after() {
        System.out.println("后置通知——执行了after()方法");
    }

    // 返回通知-在方法返回后执行
    @AfterReturning(value = "execution(* work.chenc.spring.dao.BookDao.add(..))")
    public void afterReturning() {
        System.out.println("后置通知——执行了afterReturning()方法");
    }

    // 环绕通知
    @Around(value = "execution(* work.chenc.spring.dao.BookDao.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕通知之前-----------");
        proceedingJoinPoint.proceed();
        System.out.println("环绕通知之前-----------");
    }

    // 异常通知
    @AfterThrowing(value = "execution(* work.chenc.spring.dao.BookDao.insert(..))")
  public void afterThrowing() {
        System.out.println("异常通知........");
    }
}

4、bean.xml—开启注解扫描 开启Aspectj生成代理对象

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
  
  <!-- 
    这里新增了一个aop的名名称空间
    xmlns:aop="http://www.springframework.org/schema/aop"
   -->
  
  <!-- 开启注解扫描 -->
  <context:component-scan base-package="work.chenc.spring.*"></context:component-scan>

  <!--
    开启Aspect注解生成代理对象
    到开启注解扫描的类里面寻找有@Aspect注解的类，并声称对应的代理对象
  -->
  <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

5、测试类

@Test
public void aspectTest() {
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:bean.xml");
    BookDao bookDao = applicationContext.getBean("bookDao", BookDao.class);
    // 测试非异常通知
        // bookDao.add();
    // 测试异常通知
    bookDao.insert();
}  

AOP部分解释说明

1）什么是AspectJ
AspectJ不是Spring的组成部分，是独立的AOP框架，一般把AspectJ和Spring框架一起使用，进行AOP操作

2）切入点表达式
execution([权限修饰符][返回类型][类的全路径]方法名称)
execution(* work.chenc.spring.dao.BookDao.add(..))
[权限修饰符]：public default protected private *表示所有
[返回类型]：Java中的类如String int 等自定义类型，空格表示void

3）相同切入点的抽取前置通知中有使用

@Pointcut(value = "execution(* work.chenc.spring.dao.BookDao.add(..))")
public void pointcutDemo() {}

AOP存在多个增强类对同一个方法增强时，设置增强类的优先级

目标

存在BookProxy和BookOtherProxy两个增强类对通一个方法进行增强，BookOtherProxy中的增强方法先执行
代码如下
1）新增一个增强类BookOtherProxy

package work.chenc.spring.proxy;

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

@Component
@Aspect
@Order(1)
public class BookOtherProxy {

    @Pointcut(value = "execution(* work.chenc.spring.dao.BookDao.add(..))")
    public void pointcut() {

    }

    @Before(value = "pointcut()")
    public void before() {
        System.out.println("BookOtherProxy........");
    }

}

2）在原有的BookProxy中新增一个注解@Order(2)

package work.chenc.spring.proxy;

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

// 增强类
@Component
@Aspect
@Order(2)
public class BookProxy {

    // 相同切入点的抽取
    @Pointcut(value = "execution(* work.chenc.spring.dao.BookDao.add(..))")
    public void pointcutDemo() {}

  // 前置通知
//  @Before(value = "execution(* work.chenc.spring.dao.BookDao.add(..))")
    // 自定义公共切入点的使用
    @Before(value = "pointcutDemo()")
    public void before() {
        System.out.println("前置通知——执行了before()方法");
    }

    // 后置通知 - 在方法执行之后执行
    @After(value = "execution(* work.chenc.spring.dao.BookDao.add(..))")
    public void after() {
        System.out.println("后置通知——执行了after()方法");
    }

    // 返回通知-在方法返回后执行
    @AfterReturning(value = "execution(* work.chenc.spring.dao.BookDao.add(..))")
    public void afterReturning() {
        System.out.println("后置通知——执行了afterReturning()方法");
    }

    // 环绕通知
    @Around(value = "execution(* work.chenc.spring.dao.BookDao.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕通知之前-----------");
        proceedingJoinPoint.proceed();
        System.out.println("环绕通知之前-----------");
    }

    // 异常通知
    @AfterThrowing(value = "execution(* work.chenc.spring.dao.BookDao.insert(..))")
    public void afterThrowing() {
        System.out.println("异常通知........");
    }
}

@Order()解释
Order这里的注解是对增强方法进行优先级的区分括号中的填入数字，从0开始，数字越大，优先级越低
通过上述的代码先执行的是BookOtherProxy中的前置通知before()，然后再执行BookProxy中的前置通知