Spring AOP学习笔记（一）

已于 2022-11-20 00:48:54 修改
阅读量489 收藏 2
点赞数 3
分类专栏： Spring 开发 文章标签： spring java 面向切面编程
于 2022-10-09 22:52:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MarkusZhang/article/details/127235729
版权

一、本文概览

在这里插入图片描述

二、AOP简介

1、概念

AOP(Aspect Oriented Program)，即面向切面编程，它提供另一种考虑程序结构的方法，补充了面向对象编程(OOP)。面向对象编程中模块化的关键单元是类，而在AOP中模块化的单元是切面。切面支持跨多个类型和对象的关注点(如事务管理)的模块化。

2、引入原因

OOP的特点

  • 封装
  • 继承
  • 多态

OOP的局限性

  • Java是一种静态语言：类结构一旦定义，不容易被修改
    • 因为JVM定义字节码读取的标准只是字节流，不关心来源是哪里，可以在运行时动态生成字节码给到虚拟机加载起到运行时更改类结构的形式
    • 但是上述内容对于普通开发者来说，这种会比较难，提供出来一个API给到开发者会更方便一些
  • 侵入性扩展：为了在某一刻前后执行特定的行为，比如关键业务执行前后的耗时记录等，可以通过继承和组合组织新的类结构，但这种就导致了项目代码被侵入了。

所以AOP便被引入了。

三、AOP使用场景

1、日志场景

  • 诊断上下文，如：log4j或logback中的 _x0008_MDC
  • 辅助信息，如：方法的执行时间

2、统计场景

  • 方法的调用次数
  • 执行异常次数
  • 数据抽样
  • 数值累加

3、安防场景

  • 熔断，如：Netflix Hystrix
  • 限流和降级，如：Alibaba Sentinel
  • 认证和授权，如：Spring Security
  • 监控，如JMX

4、性能场景

  • 缓存，如Spring Cache
  • 超时控制

四、Demo演示

1、maven依赖

<dependencies>
  	<!-- 支持aop相关注解等 -->
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjrt</artifactId>
        <version>1.9.6</version>
    </dependency>
    <dependency>
  	<!-- 支持切入点表达式等 -->  
 		<groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.6</version>
    </dependency>
  	<!-- aop核心功能，例如代理工厂等 -->
	  <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aop</artifactId>
        <version>5.2.2.RELEASE</version>
    </dependency>
</dependencies>

2、xml配置

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">

    <aop:aspectj-autoproxy/>

    <bean id="testBeanAOP" class="com.markus.aop.TestBeanAOP"/>
    <bean class="com.markus.aop.TestBeanAOPAspect"/>
</beans>

3、代码示例

package com.markus.aop;

/**
 * @author: markus
 * @date: 2022/10/9 4:09 PM
 * @Description: AOP示例
 * @Blog: http://markuszhang.com
 * It's my honor to share what I've learned with you!
 */
public class TestBeanAOP {
    public void test(){
        System.out.println("AOP Hello World!");
    }
}

package com.markus.aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;

/**
 * @author: markus
 * @date: 2022/10/9 4:14 PM
 * @Description: 切面
 * @Blog: http://markuszhang.com
 * It's my honor to share what I've learned with you!
 */
@Aspect
public class TestBeanAOPAspect {

    @Pointcut("execution(* *.test(..))")
    public void test() {

    }

    /**
     * 切入点执行之前执行
     */
    @Before("test()")
    public void before() {
        System.out.println("before invoke test method!");
    }

    /**
     * 切入点执行之后执行
     */
    @After("test()")
    public void after() {
        System.out.println("after invoke test method!");
    }

    /**
     * 切入点环绕执行
     *  1. 切入点执行前
     *  2. 切入点执行后
     *  3. 切入点异常后
     *
     * @param point
     * @return
     */
    @Around("test()")
    public Object around(ProceedingJoinPoint point) {
        System.out.println("before");
        Object o = null;
        try {
            o = point.proceed();
        } catch (Throwable e) {
            System.out.println("exception");
//            e.printStackTrace();
        }
        System.out.println("after");
        return o;
    }
}

package com.markus.aop;

import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author: markus
 * @date: 2022/10/9 4:30 PM
 * @Description: 容器执行
 * @Blog: http://markuszhang.com
 * It's my honor to share what I've learned with you!
 */
public class TestClient {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:/META-INF/aop-application-context.xml");

        TestBeanAOP bean = context.getBean("testBeanAOP", TestBeanAOP.class);
        bean.test();

        context.close();
    }
}
  • 执行结果

在这里插入图片描述

五、AOP常见词以及常见注解

1、常见词

  • Aspect
    • 它是用于横切关注点的模块化单位，表现出来的形式类似于Java类，不过内容会包括切入点、通知和类型间声明
  • Join point
    • 程序执行期间的一个点，如方法的执行或异常的处理。在Spring AOP中，连接点总是代表一个方法的执行
  • Pointcut
    • 匹配连接点的条件
  • Advice
    • 切面在特定连接点上采取的动作。不同类型的通知包括"around"、"before"和"after"等。许多AOP框架(包括Spring)将通知建模为拦截器，并维护连接点周围的拦截器链
  • Introduction
    • 代表类型声明额外的方法或字段。Spring AOP允许你向任何被通知的对象引入新的接口(和相应的实现)。

2、常用注解

2、常用注解

1、@Aspect

  • 使用：标注在一个类上
  • 作用：表明该类是一个切面

2、@Before-前置通知

  • 使用：标注在一个方法上
  • 属性：
    • value：用于指定切入点表达式，还可以指定切入点表达式的引用
  • 作用：前置通知，在关注点执行前执行

3、@AfterReturning-后置通知

  • 使用：标注在一个方法上
  • 属性：
    • value：用于指定切入点表达式，还可以指定切入点表达式的引用
  • 作用：后置通知，在关注点正常执行后执行

4、@AfterThrowing-异常通知

  • 使用：标注在一个方法上
  • 属性：
    • value：用于指定切入点表达式，还可以指定切入点表达式的引用
  • 作用：异常通知，在关注点执行时出现异常后执行

5、@After-最终通知

  • 使用：标注在一个方法上
  • 属性：
    • value：用于指定切入点表达式，还可以指定切入点表达式的引用
  • 作用：最终通知，在关注点执行之后执行

6、@Around-环绕通知

  • 使用：标注在一个方法上
  • 属性：
    • value：用于指定切入点表达式，还可以指定切入点表达式的引用
  • 作用：环绕通知，包括前置、后置等通知

7、@Pointcut

  • 使用：标注在一个方法上
  • 属性：
    • value：用于指定切入点表达式的内容
  • 作用：指定切入点表达式

3、切入点表达式

@Pointcut(value = “execution(* *.test(…))”)

上面叙述的常见注解都需要用到了一个内容，即切入点表达式，那表达式的写法是如何的呢，下面就来简单记录下：

  • 表达式：
    • 访问修饰符 返回值 包名.包名…类名.方法名(参数列表)
    • 其中访问修饰符可省略
    • 其中返回值可使用通配符*
    • 其中包名可使用通配符*,表示任意包
      • 有几级包就写几个*
      • *…表示当前包及其子包
    • 其中类名和方法名都可以使用通配符*
    • 其中参数比较特殊
      • 当使用通配符*表示时，则代表一定有参数
      • 使用 … 表示时，则有无参数均可
  • 标准写法
    • public void com.markus.aop.TestBeanAOP.test()
  • 全通配写法：
    • *…*.*(…)

4、注解使用

示例

  • 关注点
package com.markus.aop;

/**
 * @author: markus
 * @date: 2022/10/9 4:09 PM
 * @Description: AOP示例
 * @Blog: http://markuszhang.com
 * It's my honor to share what I've learned with you!
 */
public class TestBeanAOP {
    public void test() {
        System.out.println("【target method】AOP Hello World!");
        int i = 1 / 0;
    }
}
  • 切面
package com.markus.aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;

/**
 * @author: markus
 * @date: 2022/10/9 4:14 PM
 * @Description: 切面
 * @Blog: http://markuszhang.com
 * It's my honor to share what I've learned with you!
 */
@Aspect
public class TestBeanAOPAspect {

    @Pointcut(value = "execution(* *.test(..))")
    public void test() {

    }

    /**
     * 切入点执行之前执行
     */
    @Before(value = "test()")
    public void before() {
        System.out.println("@Before");
    }

    /**
     * 切入点执行之后执行
     */
    @After(value = "test()")
    public void after() {
        System.out.println("@After");
    }

    @AfterReturning(value = "test()")
    public void afterReturning() {
        System.out.println("@AfterReturning");
    }

    @AfterThrowing(value = "test()")
    public void afterThrowing(){
        System.out.println("@AfterThrowing");
    }

    /**
     * 切入点环绕执行
     * 1. 切入点执行前
     * 2. 切入点执行后
     * 3. 切入点异常后
     *
     * @param point
     * @return
     */
    @Around(value = "test()")
    public Object around(ProceedingJoinPoint point) {
        System.out.println("【Around】before");
        Object o = null;
        try {
            o = point.proceed();
            System.out.println("【Around】after");
        } catch (Throwable e) {
            // 因为这里有异常捕捉，所以@AfterThrowing注解不生效
            System.out.println("【Around】exception");
//            e.printStackTrace();
        } finally {
            System.out.println("【Around】finally");
        }
        return o;
    }
}
  • 客户端
package com.markus.aop;

import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author: markus
 * @date: 2022/10/9 4:30 PM
 * @Description: 容器执行
 * @Blog: http://markuszhang.com
 * It's my honor to share what I've learned with you!
 */
public class TestClient {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:/META-INF/aop-application-context.xml");

        TestBeanAOP bean = context.getBean("testBeanAOP", TestBeanAOP.class);
        bean.test();

        context.close();
    }
}
  • 程序结果

在这里插入图片描述

MarkusZhang
关注
专栏目录
Spring @Pointcut
FREEDOM
01-27 5042
AOP的基本概念 Advice(通知、切面)： 某个连接点所采用的处理逻辑，也就是向连接点注入的代码， AOP在特定的切入点上执行的增强处理。 @Before：标识一个前置增强方法，相当于BeforeAdvice的功能. @After：final增强，不管是抛出异常或者正常退出都会执行. @AfterReturning： 后置增强，似于AfterReturningAdvice, ...
AOP的切入点Pointcut中的execution表达式详解
一名Java语言狂热分子。
09-15 1148
在面向切面编程（AOP）中，切入点（Pointcut）用于定义在哪些方法或代码段上应该应用切面的逻辑。切入点使用表达式来匹配目标方法的签名和执行位置。在实际使用时，你可以根据需要灵活构造切入点表达式来匹配符合条件的目标方法。在 Spring AOP 中，常用的切入点表达式是基于方法的。
Pointcut 表达式
CoderLi
12-24 5445
AOP 概念篇 今天介绍 Pointcut 的表达式 通配符 常见的通配符如下 … 含义一：方法表达式中、代表任意数量的参数 @Service public class HelloService { public void sayHi(String name) { System.out.println("hi," + name); } public void sayHi(String firstName, String lastName) { S..
Spring execution 表达式 @Pointcut
global_coding的博客
03-31 149
Spring execution 表达式 @Pointcut
AOP AspectJ
杜海的博客
09-14 404
@Pointcut的12种用法 作用 用来标注在方法上来定义切入点。 定义 格式：@ 注解(value=“表达标签 (表达式格式)”) 如： @Pointcut("execution(*com.javacode2018.aop.demo9.test1.Service1.*(..))") 表达式标签（10种） execution：用于匹配方法执行的连接点 within：用于匹配指定类型内的方法执行 this：用于匹配当前AOP代理对象类型的执行方法；注意是AOP代.
spring aop 学习笔记
05-27
本学习笔记将深入探讨Spring AOP的核心概念、工作原理以及实际应用。 1. **核心概念** - **切面（Aspect）**：切面是关注点的模块化，包含业务逻辑之外的横切关注点，如日志、事务管理。 - **连接点（Join Point...
SpringAOP学习笔记
01-27
AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性...
Spring Aop 学习笔记
03-25
Spring Aop 学习笔记
Spring AOP学习笔记
03-01
NULL 博文链接：https://linres.iteye.com/blog/281221
SpringAop学习笔记以及实现Demo
06-17
**Spring AOP 学习笔记及实现Demo** Spring AOP（Aspect Oriented Programming，面向切面编程）是Spring框架中的一个重要组成部分，它提供了一种在不修改源代码的情况下，对程序进行功能增强的技术。AOP的主要目的...
SpringBoot AOP @Pointcut切入点execution表达式排除类中的具体方法
翎野君的博客
08-08 5771
背景 工作中遇到了，要针对在原有的切面范围基础之上，排除掉某些类中的方法。所以本篇文章主要介绍了SpringBootAOP@Pointcut切入点表达式排除某些类中的方法的方式。 修饰符匹配(modifier-pattern?) 返回值匹配(ret-type-pattern)可以为*表示任何返回值,全路径的类名等 类路径匹配(declaring-type-pattern?) 方法名匹...
【注解】@Pointcut
最新发布
qq_35350487的博客
10-31 5039
在 Spring AOP 中，切入点定义了哪些方法应该被拦截（即哪些方法会被增强）。一般来说，切入点可以使用表达式来指定，表达式会匹配到需要被拦截的方法。用于定义切入点，而切入点表达式指定了哪些方法会被拦截。一旦定义了切入点，你可以在通知中引用它，从而在匹配到的方法执行前后执行额外的逻辑。是 Spring AOP（面向切面编程）中的一个注解，用于定义一个切入点（Pointcut）。方法就会在匹配到的方法执行之前被调用。然后，你可以在通知（例如。
切入点（pointcut）的申明规则
小道士写程序
02-01 1199
切入点（pointcut）的申明规则
Spring AOP切点表达式（Pointcut）详解
Purpletaro的专栏
06-04 2391
Spring AOP 只支持 Spring Bean 的方法切入，所以切点表达式只会匹配 Bean 类中的方法。
使用SpringAop切面编程通过Spel表达式实现Controller权限控制
Blueeyedboy521的博客
08-14 946
我们仅需要定义一个value属性用于接收表达式即可。@Target({/*** permissionAll()-----只要配置了角色就可以访问* hasPermission("MENU.QUERY")-----有MENU.QUERY操作权限的角色可以访问* hasAnyPermission("MENU.QUERY","MENU.ADD")-----有MENU.QUERY操作权限的角色可以访问* permitAll()-----放行所有请求。
@Pointcut 使用
一只不知疲倦的学习猿
09-16 3009
切面
Spring AOP详解之面向切面编程
老男孩的架构路
08-17 779
Target：用于描述注解的范围，即注解在哪用。@Retention：用于描述注解的生命周期，表示需要在什么级别保存该注解，即保留的时间长短。@Documented：用于将注释信息包含在javadoc中。@Inherited：它指明被注解的类会自动继承，子类可以继承父类中的该注解。更具体地说,如果定义注解时使用了 @Inherited 标记，然后用定义的注解来标注另一个父类， 父类又有一个子类(subclass),则父类的所有属性将被继承到它的子类中。...
JavaSpring-AOP详解（Maven导入 深入浅出）
Garson的博客
10-07 3025
在CSDN上看了很多关于配置AOP的文章，不是很复杂就是省略了很多步骤。本文用最简单并且最清晰的方法从导入依赖到AOP底层原理。逐步讲解SpringAOP的相关操作帮你快速了解AOP。
Spring笔记总结（Maven）
m0_69497655的博客
05-13 159
目录 一.spring介绍 二. IOC（依赖注入和控制反转） 使用注解进行配置 三.AOP（面向切面编程） 四.使用注解实现声明式事物 一.spring介绍 （1）Spring 2003年出生 ， IOC 和 AOP两大基础 IOC 控制反转 （DI 依赖注入） AOP 面向切面编程； （2）现在发展为： 二. IOC（依赖注入和控制反转） 1.在pom.xml添加依赖 <dependencies> <dependency> ..
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值