java

关注公众号 jb51net

关闭
首页 > 软件编程 > java > Spring AOP

Spring AOP快速入门及开发步骤

作者：gobeyye

Spring AOP（面向切面编程）核心概念包括切面(Aspect)、连接点(JoinPoint)、切点(Pointcut)、通知(Advice)等,通过在不改变原代码的情况下,对方法进行增强,实现了代码的解耦和功能扩展,本文带来大家掌握Spring 中 AOP 的开发步骤,感兴趣的朋友一起看看吧

Spring 框架有两大核心 IoC，AOP。在前面我们已经学习过了 IoC 的相关知识，今天就让我们开始 AOP 的学习。

一、AOP 概述

Aspect Oriented Programming（面向切面编程）。

切面就是指某一类特定问题，所以 AOP 也可以理解为面向特定方法编程。

**AOP 是一种思想，是对某一类事情的集中处理。**Spring AOP 是其中的一种实现方式。

AOP 的作用：在程序运行期间，在不修改源代码的基础上，对已有方法进行增强（无侵入性：解耦）。

二、Spring AOP 快速入门

我们先通过下面的程序体验下 AOP 的开发，并掌握 Spring 中 AOP 的开发步骤。

2.1 引入 AOP 依赖：

在 pom.xml 文件中添加配置：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

2.2 编写 AOP 程序：

@Aspect
@Slf4j
@Component
public class TestAspect {
    @Around("execution(* com.example.demo.controller.*.*(..))")
    public Object demo(ProceedingJoinPoint joinPoint) throws Throwable {
        log.info("方法执行前执行");
        Object result = joinPoint.proceed();
        log.info("方法执行后执行");
        return result;
    }
}

controller 类：

@RequestMapping("/test")
@RestController
@Slf4j
public class TestController {
    @RequestMapping("/t1")
    public void test1(){
        log.info("我是 test1");
    }
}

调用 controller 中的 test1 方法。

结果如下：

对程序进行简单的讲解：

整个代码划分为三部分。

通过上面的程序，我们也可以感受到 AOP 面向切面编程的一些优势：

三、Spring AOP 详解

3.1 Spring AOP 核心概念：

3.1.1 切点（Pointcut）：

切点（Pointcut），也称之为"切入点"。

Pointcut 的作用就是提供一组规则（使用 AspectJ pointcut expression language 来描述），告诉程序对哪些方法来进行功能增强。

上面的表达式 execution(* com.example.demo.controller..(…)) 就是切点表达式。

3.1.2 连接点（Join Point）：

满足切点表达式规则的方法，就是连接点。也就是可以被 AOP 控制的方法。

切点和连接点的关系：

连接点是满足切点表达式的元素。切点可以看做是保存了众多连接点的一个集合。

3.1.3 通知（Advice）：

通知就是具体要做的工作，指哪些重复的逻辑，也就是共性功能（最终体现为一个方法）。

在 AOP 面向切面编程当中，我们把这部分重复的代码逻辑抽取出来单独定义，这部分代码就是通知的内容。

3.1.4 切面（Aspect）：

切面（Aspect）= 切点（Pointcut）+ 通知（Advice）。

通过切面就能够描述当前 AOP 程序需要针对于哪些方法，在什么时候执行什么样的操作。

切面既包含了通知逻辑的定义，也包括了连接点的定义。

切面所在的类，我们一般称为切面类（被 @Aspect 注解标识的类）。

3.2 通知类型：

上面我们讲了什么是通知，接下来学习通知的类型。@Around 就是其中一种通知类型，表示环绕通知。Spring 中 AOP 的通知类型有以下几种：

没有异常的运行顺序：

程序正常运行的情况下，@AfterThrowing 标识的通知方法不会执行。

出现异常的运行顺序：

@AfterReturning 标识的通知方法不会执行，@AfterThrowing 标识的通知方法执行了。

@Around 环绕通知中原始方法调用时有异常，通知中的环绕后的代码逻辑也不会再执行了（因为原始方法调用出异常了）。

注意：

3.3 @PointCut：

Spring 提供了 @PointCut 注解，把公共的切点表达式提取出来，需要用到时引用该切入点表达式即可，便于后续代码的维护。

@Aspect
@Slf4j
@Component
public class TestAspect {
    @Pointcut("execution(* com.example.demo.controller.*.*(..))")
    public void pt(){}
    @Around("pt()")
    public Object demo(ProceedingJoinPoint joinPoint) throws Throwable {
        log.info("方法执行前执行");
        Object result = joinPoint.proceed();
        log.info("方法执行后执行");
        return result;
    }
}

当切点定义使用 private 修饰时，仅能在当前切面类中使用，当其他切面类也要使用当前切点定义时，就需要把 private 改为 public。引用方式为：全限定类名.方法名()。

@Slf4j
@Component
@Aspect
public class TestAspect2 {
    @Before("com.example.demo.aspect.TestAspect.pt()")
    public void doBefore() {
        log.info("执⾏ TestAspect2 -> Before ⽅法");
    }
}

3.4 切面优先级 @Order：

当我们在一个项目中，定义了多个切面类时，并且这些切面类的多个切入点都匹配到了同一个目标方法。当目标方法运行的时候，这些切面类中的通知方法都会执行，那么这几个通知方法的执行顺序是什么样的呢？

我们通过程序来进行验证。

@Slf4j
@Component
@Aspect
public class TestAspect2 {
    @Pointcut("execution(* com.example.demo.controller.*.*(..))")
    private void pt(){}
    //前置通知
    @Before("pt()")
    public void doBefore() {
        log.info("执行 TestAspect2 -> Before 方法");
    }
    //后置通知
    @After("pt()")
    public void doAfter() {
        log.info("执行 TestAspect2 -> After 方法");
    }
}
@Aspect
@Component
@Slf4j
public class TestAspect3 {
    @Pointcut("execution(* com.example.demo.controller.*.*(..))")
    private void pt(){}
    //前置通知
    @Before("pt()")
    public void doBefore() {
        log.info("执行 TestAspect3 -> Before 方法");
    }
    //后置通知
    @After("pt()")
    public void doAfter() {
        log.info("执行 TestAspect3 -> After 方法");
    }
}
@Aspect
@Component
@Slf4j
public class TestAspect4 {
    @Pointcut("execution(* com.example.demo.controller.*.*(..))")
    private void pt(){}
    //前置通知
    @Before("pt()")
    public void doBefore() {
        log.info("执行 TestAspect4 -> Before 方法");
    }
    //后置通知
    @After("pt()")
    public void doAfter() {
        log.info("执行 TestAspect4 -> After 方法");
    }
}

运行上面程序：

通过上述程序的运行结果，可以看出：

存在多个切面类时，默认按照切面类的类名字母排序：

但这种方式不方便管理，我们的类名更多还是具备一定含义的。

Spring 给我们提供了一个新的注解，来控制这些切面通知的执行顺序：@Order。

@Slf4j
@Component
@Aspect
@Order(10)
public class TestAspect2 {
    //代码省略
}
@Aspect
@Component
@Slf4j
@Order(5)
public class TestAspect3 {
    //代码省略
}
@Aspect
@Component
@Slf4j
@Order(1)
public class TestAspect4 {
    //代码省略
}

运行程序：

通过上述程序的运行结果，得出结论：

@Order 注解标识的切面类，执行顺序如下：

@Order 的执行顺序可以抽象成下面这张图：

3.5 切点表达式：

上面的代码中，我们一直在使用切点表达式来描述切点。下面我们来介绍一下切点表达式的语法。

切点表达式常见有两种表达方式：

3.5.1 execution 表达式：

execution() 是最常用的切点表达式，用来匹配方法，语法为：

execution (<访问修饰符> <返回类型> <包名.类名.方法(方法参数)> <异常>)

其中：访问修饰符和异常可以省略。

切点表达式支持通配符表达：

..：匹配多个连续的任意符号，可以通配任意层级的包，或任意类型，任意个数的参数。

3.5.2 @annotation：

execution 表达式更适用有规则的，如果我们要匹配多个无规则的方法呢，比如：TestController 中的 t1() 和 UserController 中的 u1() 这两个方法。这个时候我们使用 execution 这种切点表达式来描述就不是很方便了。我们可以借助自定义注解的方式以及另一种切点表达式 @annotation 来描述这一类的切点。

实现步骤：

创建一个注解类（和创建 Class 文件一样的流程，选择 Annotation 就可以了）

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

使用 @annotation 表达式来描述切点。

@Component
@Slf4j
@Aspect
public class MyAspectDemo {
    @Before("@annotation(com.example.demo.aspect.MyAspect)")
    public void doBefore(){
        log.info("我是 MyAspectDemo");
    }
}

在方法上添加自定义注解。

@RequestMapping("/test")
@RestController
@Slf4j
public class TestController {
    @MyAspect
    @RequestMapping("/t1")
    public void test1(){
        log.info("我是 test1");
    }
}

运行程序，访问 test1 方法。

3.6 Spring AOP 的实现方式（常见面试题）：

四、代理模式

Spring AOP 是基于动态代理来实现 AOP 的。

代理模式，也叫委托模式。

定义：

为其他对象提供一种代理，以控制对这个对象的访问。它的作用就是通过提供一个代理类，让我们在调用目标方法的时候，不再是直接对目标方法进行调用，而是通过代理类间接调用。

代理模式可以在不修改被代理对象的基础上，通过扩展代理类，进行一些功能的附加与增强。

根据代理的创建时期，代理模式分为静态代理和动态代理。

到此这篇关于一文掌握Spring AOP的文章就介绍到这了,更多相关Spring AOP内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:
阅读全文