Spring AOP

---

1. 什么是 AOP ？

AOP 即面向切面编程。如下图，我们可以抽离出业务逻辑中的通用部分，将其做成一个单独的模块，这样以后在拓展主干功能的时候，就可以不用修改源代码，而且直接插入相应的模块，这样可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

2. AOP 底层原理

AOP 底层使用动态代理。

2.1 JDK 动态代理 —— 有接口的情况

2.1.1 原理示意图

• 创建==接口实现类==代理对象，增强类的方法

  

2.1.2 代码实现

2.1.2.1 重要类及方法 —— Proxy.newProxyInstance()

三个参数：

• loader：类加载器
• interfaces：增强方法所在的类，这个类实现的接口，支持多个接口
• h：实现接口 InvocationHandler，创建代理对象，写增强的方法

2.1.2.2 创建接口，定义方法

public interface UserDao {
    public int add(int a,int b);
    public String update(String id);
}

2.1.2.3 创建接口实现类

public class UserDaoImpl implements UserDao {

    @Override
    public int add(int a, int b) {
        System.out.println("add 方法执行了....");
        return a+b;
    }

    @Override
    public String update(String id) {
        System.out.println("update 方法执行了....");
        return id;
    }
}

2.1.2.4 使用 Proxy 类创建代理对象

public class JDKProxy {

    public static void main(String[] args) {

        //创建接口实现类代理对象

        //第②个参数
        Class[] interfaces = {UserDao.class};

        //被代理对象
        UserDaoImpl userDao = new UserDaoImpl();

        //增强后的对象
        UserDao dao = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));

        //调用增强后的方法
        int add = dao.add(1, 2);

        //输出结果
        System.out.println(add);

    }
}

//第③个参数
class UserDaoProxy implements InvocationHandler{

    //需要把对象传到这里面来，才能执行原先方法的功能，再在此基础上添加新的功能 =》 把被代理对象传到代理类中
    //可以通过有参构造进行传递
    private Object object;
    public UserDaoProxy(Object object){
        this.object = object;
    }

    //方法增强的逻辑
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        //方法之前
        System.out.println("方法之前执行...."+method.getName()+"，传递的参数："+ Arrays.toString(args));

        //被增强的方法执行
        Object res = method.invoke(object, args);

        //方法之后
        System.out.println("方法之后执行...."+object);

        return res;
    }
}

输出结果：

方法之前执行....add，传递的参数：[1, 2]
add 方法执行了....
方法之后执行....com.hedon.UserDaoImpl@5a07e868
3

Process finished with exit code 0

补充：可以用 method.getName() 来获取方法名，来决定具体增强哪些方法。

2.2 CGLIB 动态代理 —— 无接口的情况

2.2.1 原理示意图

• 创建==子类==的代理对象，增强类的方法

  

3. AOP 术语

3.1 连接点

所有可以被增强的方法。

3.2 切入点

已经被增强的方法。

3.3 通知（增强）

增强的逻辑。

• 前置通知
• 后置通知
• 环绕通知
• 异常通知
• 最终通知

3.4 切面

把通知应用到切入点的==过程==就叫做切面。

4. AspectJ

Spring 框架一般是基于 AspectJ 实现 AOP 操作。

4.1 准备工作

4.1.1 导入相关 Jar 包

4.1.2 切入点表达式

4.1.2.1 作用

知道对哪个类里面的哪个方法进行增强

4.1.2.2 语法结构

exection( [权限修饰符] [返回类型] [类路径] [方法名称] ([参数列表]) )

• 举例1：对 com.hedon.BookDao 类中的 add() 方法进行增强

  • 权限修饰符可以省略
  • *号标识任意
  • .. 表示任意参数

  execution(* com.hedon.BookDao.add(..))
  

• 举例2：对 com.hedon.BookDao 类中的所有方法进行增强

  execution(* com.hedon.BookDao.*(..))
  

• 举例3：对 com.hedon 包中的所有类及其所有方法都进行增强

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

• 举例4：任意

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

4.2 基于 XML 配置文件

4.2.1 创建被增强类

public class Book {
    public void buy(){
        System.out.println(" buy 方法执行了 ....");
    }
}

4.2.2 创建增强类

public class BookProxy {
    //前置通知
    public void before(){
        System.out.println("BookProxy前置通知方法执行了.....");
    }
}

4.2.3 注入对象

<bean id="book" class="com.hedon.aopxml.Book"></bean>
<bean id="bookProxy" class="com.hedon.aopxml.BookProxy"></bean>

4.2.4 配置 AOP 增强

<!--配置 AOP 增强-->
<aop:config>
    <!--切入点-->
    <aop:pointcut id="p" expression="execution(* com.hedon.aopxml.Book.buy(..))"/>

    <!--
        配置切面
        ref：指向增强类对象
        order：配置增强类优先级
    -->
    <aop:aspect ref="bookProxy" order="1">
        <!--
            配置增强作用在具体的方法上
            method: 用来增强的方法
            pointcut-ref：指向切入点
         -->
        <aop:before method="before" pointcut-ref="p"/>
    </aop:aspect>
</aop:config>

4.3 基于注解（重点）

4.3.1 创建被增强类

public class User {
    public void add(){
        System.out.println("add 方法执行了 ....");
    }
}

4.3.2 创建增强类(编写增强逻辑)

在该类中写不同的方法，代表不同的通知类型：

public class UserProxy {

    //前置通知
    public void before(){
        System.out.println("前置通知方法执行了....");
    }

    //后置通知
    public void after(){
        System.out.println("后置通知方法执行了....");
    }
}

4.3.3 进行通知的配置

4.3.3.1 开启注解扫描

<context:component-scan base-package="com.hedon.aopanno"></context:component-scan>

4.3.3.2 使用注解创建 User 和 UserProxy 对象

@Component
public class User {

@Component
public class UserProxy {

4.3.3.3 在增强类上添加注解 @Aspect

@Component
@Aspect //生成代理对象
public class UserProxy {

4.3.3.4 在 Spring 配置文件中开启 AspectJ 生成代理对象

开启这个会去扫描所有标注 @Aspect 的类，生成代理对象

<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

4.3.3.5 配置不同类型的通知

在增强类中作为通知方法上面使用切入点表达式添加通知类型注解。

@Component
@Aspect //生成代理对象
public class UserProxy {

    //前置通知 =》 每一个方法开始之前执行一段代码
    @Before(value = "execution(* com.hedon.aopanno.User.add(..))")
    public void before(){
        System.out.println("前置通知方法执行了....");
    }

    //后置通知（返回通知）=》方法正常结束后执行的代码，返回通知是可以访问到方法的返回值的
    @AfterReturning(value = "execution(* com.hedon.aopanno.User.add(..))",returning = "result")
    public void afterReturning(JoinPoint joinPoint, Object result){
        String methodName = joinPoint.getSignature().getName();
        System.out.println("后置通知执行了...."+"方法名："+methodName+", 结果："+result);
    }

    //最终通知 =》 每一个实现类的每一个方法执行之后执行一段代码无论该方法是否出现异常
    @After(value = "execution(* com.hedon.aopanno.User.add(..))")
    public void after(){
        System.out.println("最终通知方法执行了....");
    }

    //异常通知
    @AfterThrowing(value = "execution(* com.hedon.aopanno.User.add(..))",throwing = "e")
    public void afterThrowing(JoinPoint joinPoint, Exception e){
        String methodName = joinPoint.getSignature().getName();
        System.out.println("异常通知执行了....方法名：" + methodName + "，异常: " + e);
    }

    //环绕通知
    @Around(value = "execution(* com.hedon.aopanno.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
        System.out.println("环绕之前...");

        //执行原先方法
        proceedingJoinPoint.proceed();

        System.out.println("环绕之后..");
    }
}

4.3.3.6 抽取相同切入点 —— @Pointcut

//抽取相同切入点
@Pointcut(value = "execution(* com.hedon.aopanno.User.add(..))")
public void pointDemo(){

}

//前置通知 =》 每一个方法开始之前执行一段代码
@Before(value = "pointDemo()")
public void before(){
    System.out.println("前置通知方法执行了....");
}

4.3.3.7 配置增强类的优先级 —— @Order

如果有多个增强类对同一个方法进行增强，可以设置增强的优先级

• 再添加一个增强类

  @Component
  @Aspect
  public class PersonProxy {
      
      @Before(value = "execution(* com.hedon.aopanno.User.add(..))")
      public void before(){
          System.out.println("PersonProxy 的 before 方法执行了...");
      }
  }
  

• 配置优先级，==数字越小越优先==

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

  @Component
  @Aspect //生成代理对象
  @Order(3)
  public class UserProxy {
  

4.3.4 测试

@Test
public void test1(){
    ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
    //得到增强后的对象
    User user = context.getBean("user",User.class);
    //检查效果
    user.add();
}

4.3.5 正常结果

如下，只有异常通知不会执行。

PersonProxy 的 前置通知方法执行了...
环绕之前...
前置通知方法执行了....
add 方法执行了 ....
环绕之后..
最终通知方法执行了....
后置通知执行了....方法名：add, 结果：null

4.3.6 异常结果

如下，不会执行后置通知和环绕之后的通知。

PersonProxy 的 前置通知方法执行了...
环绕之前...
前置通知方法执行了....
最终通知方法执行了....
异常通知执行了....方法名：add，异常: java.lang.ArithmeticException: / by zero

4.3.7 完全注解版本 ——@EnbaleAspectJAutoProxy

添加一个配置类：

@Configuration
@ComponentScan(basePackages = {"com.hedon"})
@EnableAspectJAutoProxy(proxyTargetClass = true)  //替代配置文件中的 <aop:aspectj-autoproxy> 开启 AspectJ 生成代理对象
public class ConfigAop {
    
}