Spring AOP之基于注解的使用

1、技术说明

AOP是思想，AspectJ是AOP思想的实现。

在这里插入图片描述

动态代理（InvocationHandler）：JDK原生的实现方式，需要被代理的目标类必须实现接口。因为这个技术要求代理对象和目标对象实现同样的接口（兄弟两个拜把子模式）。
cglib：通过继承被代理的目标类（认干爹模式）实现代理，所以不需要目标类实现接口。
AspectJ：本质上是静态代理，将代理逻辑“织入”被代理的目标类编译得到的字节码文件，所以最终效果是动态的。weaver就是织入器。Spring只是借用AspectJ中的注解。

有关动态代理和静态代理的前置知识，可以参考这篇博客->静态代理和JDK动态代理以及CGLIB动态代理

2、准备工作

①添加依赖

在IOC所需依赖基础上再加入依赖即可：

<?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.atguigu</groupId>
    <artifactId>spring-aop</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <!-- 基于Maven依赖传递性，导入spring-context依赖即可导入当前所需所有jar包 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.1</version>
        </dependency>
        <!-- junit测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

        <!-- spring-aspects会帮我们传递过来aspectjweaver -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.3.1</version>
        </dependency>

    </dependencies>
</project>

②准备被代理的目标资源

接口：

package com.atguigu.aop.annotation;

public interface Calculator {
    
    
    int add(int i,int j);
    int sub(int i,int j);
    int mul(int i,int j);
    int div(int i,int j);
}

实现类：

package com.atguigu.aop.annotation;

import org.springframework.stereotype.Component;

@Component
public class CalculatorImpl implements Calculator{
    
    
    @Override
    public int add(int i, int j) {
    
    
        int result = i + j;
        System.out.println("方法内部 result = " + result);
        return result;
    }
    @Override
    public int sub(int i, int j) {
    
    
        int result = i - j;
        System.out.println("方法内部 result = " + result);
        return result;
    }
    @Override
    public int mul(int i, int j) {
    
    
        int result = i * j;
        System.out.println("方法内部 result = " + result);
        return result;
    }
    @Override
    public int div(int i, int j) {
    
    
        int result = i / j;
        System.out.println("方法内部 result = " + result);
        return result;
    }
}

3、创建切面类并配置

// @Aspect表示这个类是一个切面类
@Aspect
// @Component注解保证这个切面类能够放入IOC容器
@Component
public class LogAspect {
    
    
    @Before("execution(public int com.atguigu.aop.annotation.CalculatorImpl.*(..))")
public void beforeMethod(JoinPoint joinPoint){
    
    
	String methodName = joinPoint.getSignature().getName();
	String args = Arrays.toString(joinPoint.getArgs());
	System.out.println("Logger-->前置通知，方法名："+methodName+"，参数："+args);
	}
    @After("execution(* com.atguigu.aop.annotation.CalculatorImpl.*(..))")
	public void afterMethod(JoinPoint joinPoint){
    
    
		String methodName = joinPoint.getSignature().getName();
		System.out.println("Logger-->后置通知，方法名："+methodName);
	}
    @AfterReturning(value = "execution(*com.atguigu.aop.annotation.CalculatorImpl.*(..))", returning = "result")
	public void afterReturningMethod(JoinPoint joinPoint, Object result){
    
    
		String methodName = joinPoint.getSignature().getName();
		System.out.println("Logger-->返回通知，方法名："+methodName+"，结果："+result);
	} 
    @AfterThrowing(value = "execution(*com.atguigu.aop.annotation.CalculatorImpl.*(..))", throwing = "ex")
	public void afterThrowingMethod(JoinPoint joinPoint, Throwable ex){
    
    
		String methodName = joinPoint.getSignature().getName();
		System.out.println("Logger-->异常通知，方法名："+methodName+"，异常："+ex);
	}
    @Around("execution(* com.atguigu.aop.annotation.CalculatorImpl.*(..))")
	public Object aroundMethod(ProceedingJoinPoint joinPoint){
    
    
        String methodName = joinPoint.getSignature().getName();
		String args = Arrays.toString(joinPoint.getArgs());
		Object result = null;
        try {
    
    
            System.out.println("环绕通知-->目标对象方法执行之前");
            //目标对象（连接点）方法的执行
            result = joinPoint.proceed();
            System.out.println("环绕通知-->目标对象方法返回值之后");
		} catch (Throwable throwable) {
    
    
            throwable.printStackTrace();
            System.out.println("环绕通知-->目标对象方法出现异常时");
		} finally {
    
    
			System.out.println("环绕通知-->目标对象方法执行完毕");
		}
		return result;
	}
}

在Spring的配置文件中配置：

<?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的实现：
     1、将目标对象和切面都要交给IOC容器管理（注解+扫描）
     2、开启AspectJ的自动代理，为目标对象自动生成代理
     3、切面类必须通过注解@Aspect标识
 -->
    <context:component-scan base-package="com.atguigu.aop.annotation"></context:component-scan>

<!--    开启基于注解的AOP-->
    <aop:aspectj-autoproxy />
</beans>

Demo1：

package com.atguigu.aop.annotation;

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

@Aspect // 将当前类标记为切面类
@Component
public class LoggerAspect {
    
    

    @Before("execution(public int com.atguigu.aop.annotation.CalculatorImpl.add(int,int))")
    public void beforeMethod(){
    
    
        System.out.println("LoggerAspect,前置通知");
    }
}

package com.atguigu.test;

import com.atguigu.aop.annotation.Calculator;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AOPTest {
    
    
    @Test
    public void testAOPBefore(){
    
    
        ClassPathXmlApplicationContext ioc = new ClassPathXmlApplicationContext("aop-annotation.xml");
        // 无法在IOC容器中获取目标对象，只能在IOC容器中获取代理对象
        Calculator calculator = ioc.getBean(Calculator.class); // AOP后通过接口类型进行获取
        calculator.add(1,1);
    }
}

输出：

LoggerAspect,前置通知
方法内部 result = 2

Demo2:

package com.atguigu.aop.annotation;

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

@Aspect // 将当前类标记为切面类
@Component
public class LoggerAspect {
    
    

//    @Before("execution(public int com.atguigu.aop.annotation.CalculatorImpl.add(int,int))")
    @Before("execution(* com.atguigu.aop.annotation.CalculatorImpl.*(..))") // 通配表达式
    public void beforeMethod(){
    
    
        System.out.println("LoggerAspect,前置通知");
    }
}

4、各种通知

前置通知：使用@Before注解标识，在被代理的目标方法前执行
返回通知：使用@AfterReturning注解标识，在被代理的目标方法返回值之后执行，有异常就不会执行（寿终正寝）
异常通知：使用@AfterThrowing注解标识，在被代理的目标方法catch子句中执行（死于非命）
后置通知：使用@After注解标识，在被代理的目标方法finally子句中执行（盖棺定论）
环绕通知：使用@Around注解标识，使用try…catch…finally结构围绕整个被代理的目标方法，包括上面四种通知对应的所有位置

各种通知的执行顺序：

Spring版本5.3.x以前：

前置通知

目标操作

后置通知

返回通知或异常通知

Spring版本5.3.x以后（当前笔记的版本）：

前置通知

目标操作

返回通知或异常通知

后置通知

5、切入点表达式语法

①作用

在这里插入图片描述

②语法细节

用*号代替“权限修饰符”和“返回值”部分表示“权限修饰符”和“返回值”不限
在包名的部分，一个“”号只能代表包的层次结构中的一层，表示这一层是任意的。
- 例如：.Hello匹配com.Hello，不匹配com.atguigu.Hello
在包名的部分，使用“…”表示包名任意、包的层次深度任意
在类名的部分，类名部分整体用号代替，表示类名任意
在类名的部分，可以使用号代替类名的一部分
- *例如：*Service匹配所有名称以Service结尾的类或接口
在方法名部分，可以使用号表示方法名任意
在方法名部分，可以使用号代替方法名的一部分
- 例如：*Operation匹配所有方法名以Operation结尾的方法
在方法参数列表部分，使用(…)表示参数列表任意
在方法参数列表部分，使用(int,…)表示参数列表以一个int类型的参数开头
在方法参数列表部分，基本数据类型和对应的包装类型是不一样的
- 切入点表达式中使用 int 和实际方法中 Integer 是不匹配的
在方法返回值部分，如果想要明确指定一个返回值类型，那么必须同时写明权限修饰符
- 例如：execution(public int …Service.(…, int)) 正确
- 例如：execution( int *…Service.(…, int)) 错误

在这里插入图片描述

6、重用切入点表达式

针对某一个类中的切入点进行重用，方便后续的增强。

①声明

@Pointcut("execution(* com.atguigu.aop.annotation.*.*(..))")
public void pointCut(){
    
    }

②在同一个切面中使用

@Before("pointCut()")
public void beforeMethod(JoinPoint joinPoint){
    
    
    String methodName = joinPoint.getSignature().getName();
    String args = Arrays.toString(joinPoint.getArgs());
    System.out.println("Logger-->前置通知，方法名："+methodName+"，参数："+args);
}

③在不同切面中使用

@Before("com.atguigu.aop.CommonPointCut.pointCut()")
public void beforeMethod(JoinPoint joinPoint){
    
    
    String methodName = joinPoint.getSignature().getName();
    String args = Arrays.toString(joinPoint.getArgs());
    System.out.println("Logger-->前置通知，方法名："+methodName+"，参数："+args);
}

7、获取通知的相关信息

①获取连接点信息

获取连接点信息可以在通知方法的参数位置设置JoinPoint类型的形参

@Before("execution(public int com.atguigu.aop.annotation.CalculatorImpl.*(..))")
public void beforeMethod(JoinPoint joinPoint){
    
    
    //获取连接点的签名信息
    String methodName = joinPoint.getSignature().getName();
    //获取目标方法到的实参信息
    String args = Arrays.toString(joinPoint.getArgs());
    System.out.println("Logger-->前置通知，方法名："+methodName+"，参数："+args);
}

②获取目标方法的返回值

@AfterReturning中的属性returning，用来将通知方法的某个形参，接收目标方法的返回值

@AfterReturning(value = "execution(* com.atguigu.aop.annotation.CalculatorImpl.*(..))", returning = "result")
    public void afterReturningMethod(JoinPoint joinPoint, Object result){
    
    
    String methodName = joinPoint.getSignature().getName();
    System.out.println("Logger-->返回通知，方法名："+methodName+"，结果："+result);
}

③获取目标方法的异常

@AfterThrowing中的属性throwing，用来将通知方法的某个形参，接收目标方法的异常

@AfterThrowing(value = "execution(* com.atguigu.aop.annotation.CalculatorImpl.*(..))", throwing = "ex")
    public void afterThrowingMethod(JoinPoint joinPoint, Throwable ex){
    
    
    String methodName = joinPoint.getSignature().getName();
    System.out.println("Logger-->异常通知，方法名："+methodName+"，异常："+ex);
}

8、环绕通知

相当于前面四个普通通知的合体

更像是动态代理，目标方法的执行，目标方法的返回值一定要返回给外界调用者。

@Around("execution(* com.atguigu.aop.annotation.CalculatorImpl.*(..))")
// ProceedingJoinPoint joinPoint表示目标对象方法的执行，才能在执行的过程中加入额外的操作
public Object aroundMethod(ProceedingJoinPoint joinPoint){
    
    
    String methodName = joinPoint.getSignature().getName();
    String args = Arrays.toString(joinPoint.getArgs());
    Object result = null;
    try {
    
    
        System.out.println("环绕通知-->目标对象方法执行之前");
        //目标方法的执行，目标方法的返回值一定要返回给外界调用者
        result = joinPoint.proceed();
        System.out.println("环绕通知-->目标对象方法返回值之后");
    } catch (Throwable throwable) {
    
    
        throwable.printStackTrace();
        System.out.println("环绕通知-->目标对象方法出现异常时");
    } finally {
    
    
        System.out.println("环绕通知-->目标对象方法执行完毕");
    }
    return result; // 一定要返回给调用者
}

9、切面的优先级

相同目标方法上同时存在多个切面时，切面的优先级控制切面的内外嵌套顺序。

优先级高的切面：外面
优先级低的切面：里面

使用@Order注解可以控制切面的优先级：

@Order(较小的数)：优先级高
@Order(较大的数)：优先级低

在这里插入图片描述

package com.atguigu.aop.annotation;

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

@Component
@Aspect
@Order(1) // 设置切面优先级
public class ValidateAspect {
    
    
    @Around("com.atguigu.aop.annotation.LoggerAspect.pointCut()")
    public Object AroundAdviceMethod(ProceedingJoinPoint joinPoint){
    
    
        Object result=null;
        try {
    
    
            System.out.println("ValidateAspect环绕通知--》前置通知");
            result = joinPoint.proceed();
            System.out.println("ValidateAspect环绕通知--》返回通知");
        } catch (Throwable e) {
    
    
            e.printStackTrace();
            System.out.println("ValidateAspect环绕通知--》异常通知");
        } finally {
    
    
            System.out.println("ValidateAspect环绕通知--》后置通知");
        }
        return result;
    }
}

package com.atguigu.aop.annotation;

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

import java.util.Arrays;

@Aspect // 将当前类标记为切面类
@Component
public class LoggerAspect {
    
    


    @Pointcut("execution(* com.atguigu.aop.annotation.CalculatorImpl.*(..))")
    public void pointCut(){
    
    }

    @Around("pointCut()")
    public Object aroundAdviceMethod(ProceedingJoinPoint joinPoint){
    
    
        Object result=null;
        try {
    
    
            System.out.println("LoggerAspect环绕通知--》前置通知");
            result = joinPoint.proceed();
            System.out.println("LoggerAspect环绕通知--》返回通知");
        } catch (Throwable e) {
    
    
            e.printStackTrace();
            System.out.println("LoggerAspect环绕通知--》异常通知");
        } finally {
    
    
            System.out.println("LoggerAspect环绕通知--》后置通知");
        }
        return result;
    }
}

测试：

package com.atguigu.test;

import com.atguigu.aop.annotation.Calculator;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AOPTest {
    
    
    @Test
    public void testAOPBefore(){
    
    
        ClassPathXmlApplicationContext ioc = new ClassPathXmlApplicationContext("aop-annotation.xml");
        Calculator calculator = ioc.getBean(Calculator.class); // AOP后通过接口类型进行获取
        calculator.add(1,1);
    }
}

输出：

ValidateAspect环绕通知--》前置通知
LoggerAspect环绕通知--》前置通知
方法内部 result = 2
LoggerAspect环绕通知--》返回通知
LoggerAspect环绕通知--》后置通知
ValidateAspect环绕通知--》返回通知
ValidateAspect环绕通知--》后置通知

Spring AOP之基于注解的使用

1、技术说明

2、准备工作

①添加依赖

②准备被代理的目标资源

3、创建切面类并配置

4、各种通知

5、切入点表达式语法

①作用

②语法细节

6、重用切入点表达式

①声明

②在同一个切面中使用

③在不同切面中使用

7、获取通知的相关信息

①获取连接点信息

②获取目标方法的返回值

③获取目标方法的异常

8、环绕通知

9、切面的优先级

猜你喜欢