Spring AOP 动态代理

文章目录

  • 一、认识 Spring AOP
    • 1-1 什么是 Spring AOP?
    • 1-2 AOP 的功能?
    • 1-3 如何学习?
  • 二、AOP 组成
    • 2-1 切面 @Aspect
    • 2-2 连接点(Join Point)
    • 2-3 切点 @Pointcut
    • 2-4 通知(Advice)
  • 三、Spring AOP 的使用
    • 3-1 execution 连接法
      • 3-1-1 添加 AOP 框架支持
      • 3-1-2 定义切面、切点、通知
      • 3-1-3 调用 AOP
    • 3-2 @annotation 自定义切点注解
  • 四、Spring AOP 实现原理
    • 4-1 动态代理
    • 4-2 JDK 和 CGLIB 的区别
  • 五、总结


提示:以下是本篇文章正文内容,Java系列学习将会持续更新

一、认识 Spring AOP

1-1 什么是 Spring AOP?

AOP(Aspect Oriented Programming):面向切面编程,它是一种思想,它是对某一类事情的集中处理。比如用户登录权限的效验,没学 AOP 之前,我们所有需要判断用户登录的方法,都要各自实现或调用用户验证。然而有了 AOP 之后,我们只需要在某一处配置一下,就可以一下实现所有的用户登录验证了,不再需要每个方法中都写相同代码。对于这种功能统一,且使用的地方较多的功能,就可以考虑 AOP来统一处理了。

而 AOP 是一种思想,而 Spring AOP 是一个框架,提供了一种对 AOP 思想的实现,它们的关系和 IoC与 DI 类似。

1-2 AOP 的功能?

除了统一的用户登录验证之外,AOP 还可以实现:

  • 统一日志记录
  • 统一方法执行时间统计
  • 统一的返回格式设置
  • 统一的异常处理
  • 事务的开启和提交等

也就是说使用 AOP 可以扩充多个对象的某个能力,所以 AOP 可以说是 OOP(Object Oriented
Programming,面向对象编程)的补充和完善。

1-3 如何学习?

Spring AOP 学习主要分为以下 3 个部分:

  1. 学习 AOP 是如何组成的?
  2. 学习 Spring AOP 使用。
  3. 学习 Spring AOP 实现原理。

回到目录…

二、AOP 组成

AOP 整个组成部分的概念如下图所示,以多个页面都要访问用户登录权限为例:
Spring AOP 动态代理_第1张图片

2-1 切面 @Aspect

切面Aspect)由切点(Pointcut)和通知(Advice)组成,它既包含了横切逻辑的定义,也包括了连接点的定义。

切面类@Aspect 注解修饰。

切面是包含了:通知、切点和切面的,相当于 AOP 实现的某个功能的集合。

回到目录…

2-2 连接点(Join Point)

应用执行过程中能够插入切面的一个点,这个点可以是方法调用时抛出异常时、甚至修改字段时。切面代码可以利用这些点插入到应用的正常流程之中,并添加新的行为。

连接点相当于需要被增强的某个 AOP 功能的所有方法。

回到目录…

2-3 切点 @Pointcut

Pointcut 是匹配 连接点 (Join Point) 的谓词。
Pointcut 的作用就是提供一组规则(使用 AspectJ pointcut expression language 来描述)来匹配 Join Point,给满足规则的 Join Point 添加 Advice。

切点相当于保存了众多连接点的一个集合(如果把切点看成一个表,而连接点就是表中一条一条的数据)。

切点表达式说明,AspectJ 支持三种通配符:

  • *:匹配任意字符,只匹配一个元素(包,类,或方法,方法参数)。
  • *.. :匹配任意字符,可以匹配多个元素 ,在表示类时,必须和 * 联合使用。
  • +:表示按照类型匹配指定类的所有类,必须跟在类名后面,如 com.cad.Car+ ,表示继承该类的所有子类包括本身。

切点表达式由切点函数组成,其中 execution() 是最常用的切点函数,用来匹配方法,语法为:

// 语法格式:
execution(<修饰符><返回类型><..方法(参数)><异常>)  // 修饰符和异常可以省略

// 表达式示例:
execution(* com.cad.demo.User.*(..))  // 匹配User类里的所有方法。
execution(* com.cad.demo.User+.*(..)) // 匹配该类的子类包括该类的所有方法。
execution(* com.cad.*.*(..))          // 匹配com.cad包下的所有类的所有方法。
execution(* com.cad..*.*(..))         // 匹配com.cad包下、子孙包下所有类的所有方法。
execution(* addUser(String, int))     // 匹配addUser方法,且参数类型是String, int。

回到目录…

2-4 通知(Advice)

切面也是有目标的 ——它必须完成的工作。在 AOP 术语中,切面的工作被称之为通知

通知:定义了切面是什么,何时使用,其描述了切面要完成的工作,还解决何时执行这个工作的问题。

Spring 切面类中,可以在方法上使用以下注解,会设置方法为通知方法,在满足条件后会通知本方法进行调用:

  • 前置通知使用 @Before:通知方法会在目标方法调用之前执行。
  • 后置通知使用 @After:通知方法会在目标方法返回或者抛出异常后调用。
  • 返回之后通知使用 @AfterReturning:通知方法会在目标方法返回后调用。
  • 抛异常后通知使用 @AfterThrowing:通知方法会在目标方法抛出异常后调用。
  • 环绕通知使用 @Around:通知包裹了被通知的方法,在被通知的方法通知之前和调用之后执行自定义的行为。

切点相当于要增强的方法。

回到目录…

三、Spring AOP 的使用

我们使用 Spring AOP 来实现一下 AOP 的功能,完成的目标是拦截所有 UserController 里面的方法,每次调用 UserController 中任意一个方法时,都执行相应的通知事件

Spring AOP 的实现步骤如下:

  1. 添加 Spring AOP 框架支持。
  2. 定义切面和切点。
  3. 定义通知。

3-1 execution 连接法

3-1-1 添加 AOP 框架支持

Spring Boot Starter AOP 官方文档

在 pom.xml 中修改原本的依赖配置:


<dependency>
	<groupId>org.springframework.bootgroupId>
	<artifactId>spring-boot-starter-aopartifactId>
dependency>

回到目录…

3-1-2 定义切面、切点、通知

用户注册服务的类:

@Service
public class UserService {
    public void register(String username, String password) {
        System.out.printf("UserService.register(username = %s, password = %s)\n", username, password);
    }
}

为用户注册服务定义AOP:

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

@Component // 1. 首先,把类注册到 Spring 中
@Aspect    // 2. 需要声明这个类是一个 切面类
public class UserAspect {
	/**
	 * 定义切点方法: 
	 * 通过 AspectJ(市场做 AOP 做的比较早的,而且做的比较强的)
     * 所以 Spring 这里使用 AspectJ 规范语法,但并没有使用 AspectJ 的实现
     * 当执行 com.example.aop.UserService 下的任意方法(*)
     * 方法的参数不限(..)
     * 返回值类型不限 *
	 */
	@Pointcut("execution(* com.example.aop.UserService.*(..))")
	public void pointcut(){ }

	// 前置通知: 表示在切点方法之前执行
	@Before("pointcut()") // 切点方法名
	public void doBefore(){
		System.out.println("执行 Before 方法");
	}
	
	// 后置通知
	@After("pointcut()")
	public void doAfter(){
		System.out.println("执行 After 方法");
	}
	
	// return 之前通知
	@AfterReturning("pointcut()")
	public void doAfterReturning(){
		System.out.println("执行 AfterReturning 方法");
	}
	
	// 抛出异常之前通知
	@AfterThrowing("pointcut()")
	public void doAfterThrowing(){
		System.out.println("执行 doAfterThrowing 方法");
	}
	
	// 添加环绕通知
	@Around("pointcut()")
	public Object doAround(ProceedingJoinPoint joinPoint){
		Object obj = null;
		System.out.println("Around 方法开始执行");
		try {
			// 执行拦截方法
			obj = joinPoint.proceed();
		} catch (Throwable throwable) {
			throwable.printStackTrace();
		}
		System.out.println("Around 方法结束执行");
		return obj;
	}
}

回到目录…

3-1-3 调用 AOP

@SpringBootApplication
public class AopApplication {

    public static void main(String[] args) {
        SpringApplication.run(AopApplication.class, args);
//        可以在主方法中直接调用
//        UserServiceImpl userService = new UserServiceImpl();
//        userService.register("wangshaoyu", "123456");
    }

    @Bean
    // 也可以在加载数据时调用: 服务启动执行,执行加载数据等操作
    public CommandLineRunner runner(UserServiceImpl userService) {
        return new CommandLineRunner() {
            @Override
            public void run(String... args) throws Exception {
                userService.register("wangshaoyu", "123456");
            }
        };
    }
}

回到目录…

3-2 @annotation 自定义切点注解

①自定义切点注解:

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface SomePointcut {
}

②定义切面类:

@Component
@Aspect
public class MyAspect {
    // 将一个注解定义成 切点,哪个方法需要 AOP,就可以把这个注解修饰在方法上
    @Pointcut("@annotation(com.example.aop.SomePointcut)") // 指向自定义注解
    public void somePointcut() { }

    @Before("somePointcut()")
    public void beforeMethodInvoked() {
        System.out.println("MyAspect.beforeMethodInvoked()");
    }

    @After("somePointcut()")
    public void afterMethodInvoked() {
        System.out.println("MyAspect.afterMethodInvoked()");
    }
}

③使用自定义注解 修饰要连接切面的方法:

@Component
public class CourseService {
    @SomePointcut // 执行 add() 方法,会被代理
    public void add(String name) {
        System.out.println("CourseService.add(), name = " + name);
    }

    public void delete(String name) {
        System.out.println("CourseService.delete(), name = " + name);
        this.add(name); // 这里会不会去执行 AOP 的两个通知?
                        // 不会,因为这里的 this 指向的就是 CourseService 对象本身,所以没有代理
    }
}

回到目录…

四、Spring AOP 实现原理

Spring AOP 是构建在动态代理基础上,因此 Spring 对 AOP 的支持局限于方法级别的拦截。

Spring AOP 支持 JDK ProxyCGLIB 方式实现动态代理。默认情况下实现了接口的类,使用 AOP 会基于 JDK 生成代理类;没有实现接口的类,会基于 CGLIB 生成代理类。
Spring AOP 动态代理_第2张图片

4-1 动态代理

此种实现在设计模式上称为动态代理模式,在实现的技术手段上,都是在 class 代码运行期,动态的织入字节码。

我们学习 Spring 框架中的AOP,主要基于两种方式:JDK 及 CGLIB 的方式。这两种方式的代理目标都是被代理类中的方法,在运行期,动态的织入字节码生成代理类。

  • CGLIB 是 Java中的动态代理框架,主要作用就是根据目标类和方法,动态生成代理类。
  • Java 中的动态代理框架,几乎都是依赖字节码框架(如 ASM,Javassist 等)实现的。
  • 字节码框架是直接操作 class 字节码的框架。可以加载已有的class字节码文件信息,修改部分信息,或动态生成一个 class。

4-2 JDK 和 CGLIB 的区别

  1. JDK 实现,要求被代理类必须实现接口,之后是通过 InvocationHandlerProxy,在运行时动态的在内存中生成了代理类对象,该代理对象是通过实现同样的接口实现(类似静态代理接口实现的方式),只是该代理类是在运行期时,动态的织入统一的业务逻辑字节码来完成。
  2. CGLIB 实现,被代理类可以不实现接口,是通过继承被代理类,在运行时动态的生成代理类对象。

回到目录…

五、总结

AOP 是对某方面能力的统一实现,它是一种实现思想,Spring AOP 是对 AOP 的具体实现,Spring AOP 可通过 @AspectJ(注解)的方式来实现 AOP 的功能。Spring AOP 的实现步骤是:

  1. 添加 AOP 框架支持。
  2. 定义切面和切点。
  3. 定义通知。

Spring AOP 是通过动态代理的方式,在运行期将 AOP 代码植入到程序中的,它的实现方式有两种:
JDK ProxyCGLIB

spring:
  aop:
    # true 是 CGLib, 默认为 true
    # false 是 JDK Proxy(代理对象必须是一个接口)
    proxy-target-class: false

回到目录…


总结:
提示:这里对文章进行总结:
以上就是今天的学习内容,本文是Spring AOP的学习,学习AOP的思想,AOP的使用(定义切面、切点和通知),以及两种常用的AOP使用方法。之后的学习内容将持续更新!!!

你可能感兴趣的:(Spring,spring,java,后端)