Spring之理解AOP（面向切面）

最新推荐文章于 2024-04-29 17:13:56 发布
最新推荐文章于 2024-04-29 17:13:56 发布
阅读量790 收藏 3
点赞数 1
文章标签： spring java 前端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42338744/article/details/125529713
版权

文章目录

一、AOP常用的术语

  1. 切面：就是那些重复的、公共的、通用的功能称为切面，例如：日志、事务、权限
  2. 连接点：就是目标方法。因为在目标方法中要实现目标方法的功能和切面功能。
  3. 切入点：指定切入点的位置。多个连接点构成切入点。切入点可以是一个目标方法，可以是一个类中的所有方法，可以是某个包下的所有类中的方法。
  4. 目标对象：操作谁，谁就是目标对象
  5. 通知：来指定切入的时机。是在目标方法执行前还是执行后还是出错时，还是环绕目标方法 切入切面功能。

二、AspectJ框架

AspectJ是一个优秀面向切面的框架，它扩展了Java语言，提供了强大的切面实现。

2.1 AspectJ常见的通知类型

@Before：前置通知
@AfterReturning后置通知
@Around：环绕通知
@After：最终通知
@Poincut：定义切入点

2.2 AspectJ的切入点表达式

规范的公式：
execution(访问权限 方法返回值 方法声明（参数） 异常类型)
简化后的公式：
execution(方法返回值 方法声明（参数）)
用到的符号：

  1.  * 代表任意的字符

  2. ..如果出现在方法的参数中，则代表任意参数。如果出现在路径中，则代表本路径及其所有的子路径

示例：
3. execution(public * (…)) 只要是public访问权限下的、任意返回值类型的、任意路径下的、任意方法的任意参数。也就是公共访问权限下的所有方法都可切入切面功能
4. execution( set*(…)) 所有以set开头的方法
5. execution(* com.xyz.service.impl..(…) ) impl包下的任意类的任意方法的任意参数

2.3 AspectJ的前置通知@Before

在目标方法执行钱切入切面的功能。在切面方法中不可获得目标方法的返回值，只能得到目标方法的签名。
在这里插入图片描述
实现步骤：

  1. 创建业务接口
/**
 7. 业务接口
 */
public interface SomeService {
    String doSome(String name,int age);
}
  1. 创建业务实现
/**
 * 业务实现类
 */
public class SomeServiceImpl implements SomeService{
    @Override
    public String doSome(String name, int age) {
        System.out.println("doSome的业务功能实现....."+name);
        return "cccccccccc";
    }
}
  1. 创建切面类，实现切面方法
/**
 * 此类为切面类，包含各种切面方法
 */
@Aspect  //在pom.xml文件中添加依赖。交给AspectJ的框架去识别切面类
public class MyAspect {
    @Before(value = "execution(public String com.bjpowernode.SomeServiceImpl.doSome(String,int))")
    public void before(){
        System.out.println("切面方法中的前置功能实现......");
    }
}
  1. 在applicationContext.xml文件中进行配置
<!--创建业务对象-->
    <bean id="someService" class="com.bjpowernode.SomeServiceImpl"></bean>
    <!--创建切面对象-->
    <bean id="aspect" class="com.bjpowernode.MyAspect"></bean>
    <!--绑定-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
  1. 测试类
    @Test
    public void test1(){
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        SomeService service = (SomeService) ac.getBean("someService");
        String s = service.doSome("西西",22);
        System.out.println(s);
    }
  1. 运行结果
    在这里插入图片描述
    注意：AspectJ框架切换JDK动态代理和CGLib动态代理：
  •  <aop:aspectj-autoproxy></aop:aspectj-autoproxy>===》默认是JDK动态代理，取出对象时必须使用接口类型。

 <aop:aspectj-autoproxy proxy-target-class="true"></aop:aspectj-autoproxy>===》设置为CGLib动态代理，取出对象时，可以使用接口和实现类来接
    使用接口来接永远不会出错
    使用注解的方式实现AspectJ的前置功能：
  1. 创建业务接口
/**
 7. 业务接口
 */
public interface SomeService {
    String doSome(String name,int age);
}
  1. 创建业务实现
/**
 * 业务实现类
 */
@Service
public class SomeServiceImpl implements SomeService{
    @Override
    public String doSome(String name, int age) {
        System.out.println("doSome的业务功能实现....."+name);
        return "cccccccccc";
    }
}
  1. 创建切面类，实现切面方法
/**
 * 此类为切面类，包含各种切面方法
 */
@Aspect  //在pom.xml文件中添加依赖。交给AspectJ的框架去识别切面类
@Component
public class MyAspect {
    @Before(value = "execution(public String com.bjpowernode.SomeServiceImpl.doSome(String,int))")
    public void before(){
        System.out.println("切面方法中的前置功能实现......");
    }
}
  1. 在applicationContext.xml文件中进行配置(基于注解的访问要添加包扫描)
<context:component-scan base-package="com.bjpowernode"></context:component-scan>
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
  1. 测试类（注意此时测试类中getBean的参数）
    @Test
    public void test1(){
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        SomeService service = (SomeService) ac.getBean("someServiceImpl");
        String s = service.doSome("西西",22);
        System.out.println(s);
    }

2.4 AspectJ的后置通知@ArterReturning

在这里插入图片描述
使用注解方式：
实现步骤：

  1. 创建业务接口（同上）
  2. 创建业务实现（同上）
  3. 创建切面类，实现切面方法
@Aspect  //在pom.xml文件中添加依赖。交给AspectJ的框架去识别切面类
@Component
public class MyAspect {
    //returning：指定目标方法的返回值名称，名称必须与切面方法的参数名称一致
    //value：指定切入点表达式
    @AfterReturning(value = "execution(* com.bjpowernode.*.*(..))",returning = "obj")
    public void myafterReturning(Object obj){
        System.out.println("后置通知功能实现....");
    }
}
  1. 在applicationContext.xml文件中进行配置(基于注解的访问要添加包扫描)(同上)
  2. 测试类（同上）
  3. 运行结果
    在这里插入图片描述
    拓展：操作目标方法的返回值
    @AfterReturning(value = "execution(* com.bjpowernode.*.*(..))",returning = "obj")
    public void myafterReturning(Object obj){
        System.out.println("后置通知功能实现....");
        if(obj != null){
            if(obj instanceof String){
                String s  = obj.toString().toUpperCase();//改为大写
                System.out.println("在切面方法中目标方法的返回值："+s);
            }
        }
    }

运行结果：
在这里插入图片描述
结果是并没有将目标方法的返回值进行改变
再举一个例子：
1、添加一个学生实体类：

public class Student {
    private String name;

    public Student() {
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Student(String name) {
        this.name = name;
    }
}

2、在业务接口中添加一个方法：

public interface SomeService {
    String doSome(String name,int age);
    Student change();
}

3、在实现类中重写change()方法：

 @Override
    public Student change() {
        System.out.println("change方法被执行");
        return new Student("张三");
    }

4、在切面中修改目标方法的返回值：

 @AfterReturning(value = "execution(* com.bjpowernode.*.*(..))",returning = "obj")
    public void myafterReturning(Object obj){
        System.out.println("后置通知功能实现....");
        if(obj != null){
            if(obj instanceof String){
                obj  = obj.toString().toUpperCase();//改为大写
                System.out.println("在切面方法中目标方法的返回值："+obj);
            }
            if(obj instanceof Student){
                Student stu = (Student) obj;
                stu.setName("李四");
                System.out.println("在切面方法中目标方法的返回值："+stu);
            }
        }
    }

5、测试：

 @Test
    public void test2(){
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        SomeService service = (SomeService) ac.getBean("someServiceImpl");
        Student stu = service.change();
        System.out.println("目标方法的返回值："+stu);
    }

6、运行结果：
在这里插入图片描述
总结：
如果目标方法的返回值是8种基本数据类型或String类型则不可改变
如果是引用型数据类型则可以改变

2.5 AspectJ的环绕通知@Around

是通过拦截目标的方式，在目标方法前后增强功能的通知。是功能最强大的通知，一般事务使用此通知。它可以轻易的改变目标方法的返回值。
在这里插入图片描述
使用注解方式：
实现步骤（没有添加学生实体类，没有添加方法）：

  1. 创建业务接口（同上）
  2. 创建业务实现（同上）
  3. 创建切面类，实现切面方法
    @Around(value = "execution(* com.bjpowernode.*.*(..))")
    public Object myAround(ProceedingJoinPoint pjp) throws Throwable {
        //前切功能实现
        System.out.println("环绕通知中的前切功能实现");
        //目标方法实现
        Object obj = pjp.proceed(pjp.getArgs());
        //后切功能实现
        System.out.println("环绕通知中的后切功能实现");
        return obj.toString().toUpperCase();//改变了目标方法的返回值
    }
  1. 测试类（同上）
  2. 运行结果：
    在这里插入图片描述

2.6 AspectJ的最终通知@After

无论目标方法是否正常执行，最终通知的代码都会被执行（类似于try-catch中的finally）。
使用注解方式：
实现步骤（没有添加学生实体类，没有添加方法）：

  1. 创建业务接口（同上）
  2. 创建业务实现（同上）
  3. 创建切面类，实现切面方法
    @After(value = "execution(* com.bjpowernode.*.*(..))")
    public void myAfter(){
        System.out.println("最终通知的功能实现了....");
    }
  1. 测试类（同上）
  2. 运行结果：
    在这里插入图片描述
Bwy_1004
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring AOP面向切面编程实现原理方法详解
08-18
主要介绍了Spring AOP面向切面编程实现原理方法详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Spring切面简介
Mark_Li
03-25 2081
1 切点简介代码下载增强提供了连接点信息（1.执行点即什么情况或者方法中织入增强，2.方位信息即在连接点执行前，执行后...）和织入逻辑。此时的增强适用于目标类的每个方法。必须要结合切点进行过滤才能将增强用于特定连接点，也就是说切点制定了过滤规则用来筛选连接点。如下是Pointcut的接口定义以及依赖关系Pointcut由ClassFilter和MethodMather组成。从类命的定义就可以知道...
spring-aop切面
ssehs的博客
02-17 1434
前言 切面(Aspect)是类(Class)的一个补充，两者正交互补，让spring的Ioc容器功能得到大大的增强。 使用Spring进行面向方面的编程 面向方面编程(AOP)是对面向对象编程(OOP)的补充，它提供了考虑程序结构的另一种方式。在OOP中模块化的关键单元是类，而在AOP中模块化的单元是方面。方面支持对跨多种类型和对象的关注点(如事务管理)进行模块化。(在AOP文献中，这种关注通常被称为“横切”关注。) Spring的一个关键组件是AOP框架。虽然Spring IoC容器不依赖于AOP(这意味
Spring基础：切面
热门推荐
水知道答案
03-01 1万+
前言在之前的文章中总结了 AOP 在 Spring 中的作用及地位，在分析 AOP 时涉及到切面的内容，这一节详细的分析切面的知识点。正题在开始文章前，有几个问题需要思考一下：切面到底是神马切面的构成切面有哪些实现类切面有哪些类型1. 切面到底是神马在 AOP 一文中提到什么是 AOP？ AOP 可以使用 “面向切面编程”的译法。那切面就是把非业务逻辑相关的代码抽取出来定位到具体的连接点上的一种实...
Spring面向切面编程（AOP）详解
qq_52943130的博客
06-15 680
Spring面向切面编程（AOP）详解 面向切面编程（AOP）是Spring框架的另外一个重要的核心内容。 而在讲AOP之前，先来了解一下动态代理这个概念，因为AOP基于动态代理。 动态代理概念：在程序执行的过程中，创建代理对象。通过代理对象执行目标方法，在不影响原来的目标方法的前提下，增加额外的功能。就简单来说，就是在目标方法内部执行代码不变的情况下，增加额外的功能。 面向切面编程（AOP）概念：面向切面编程基于动态代理，其实就是动态代理的规范化，把动态代理的实现步骤、方法都定义好了，让开发人员使用一套统
Spring的艺术（五）：通俗易懂的AOP切面详解
Java鱼仔的博客
12-14 1640
通俗易懂的AOP切面详解
SpringAop(切面)理解
__Forward
03-23 698
1.什么是面向切面编程 切面通俗来说，可以帮助我们简化重复代码。 我们在日常开发中，我们可能会在各个增删改接口中记录日志，以便出现问题时可以及时有效地找出原因，但是系统中增删改的接口不是一个两个，而是会有很多个，我们如果在所有增删改的接口中编写记录日志的代码，就会导致记录日志的的逻辑散布于系统中的任何犄角旮旯，导致接口臃肿，接口核心功能不明确。 切面正好可以帮助我们解决这个问题，切面正如其名，好像...
Spring AOP（面向切面）介绍以及示例（@Before @Around @After @AfterReturning @AfrerThrowing）
qq_37130607的博客
03-31 3743
1、什么是面向切面（AOP） 在使用面向切面之前我们要理解一下面向对象和面向切面这两个概念。 面向对象就是提取公共特征进行抽象化，比如，不管是男人还是女人，它们都有年龄、名字等属性，那么就可以把这些属性以及相同的方法（如get、set）抽取到父类中，是一种纵向的抽取。 面向切面，就是将一些逻辑通过横向切割的方式抽取到一个独立的模块，业务只需要关注自身的逻辑，在运行业务时，由程序将这些逻辑织入，是一种横向的抽取。比如假设数据库操作之前需要编写日志，这时可以对修改每个函数添加写日志操作，为了提升代码复用可以进
【JavaEE】Spring AOP （面向切面）详解
xqs196301的博客
08-26 1534
【JavaEE】Spring AOP （面向切面）详解
16.2 Spring框架-AOP面向切面编程
04-12
16.2 Spring框架-AOP面向切面编程
Spring4AOP 面向切面编程实例之方法拦截
10-13
Spring4AOP 面向切面编程实例之方法拦截实例 一下利用Spring4的最后一个版本Spring4.3.9，实现简单的方法拦截实例。 Eclipse 建立java工程,导入必要的jar包，工程目录如下:
Spring 面向切面编程AOP实现详解
08-25
主要介绍了Spring 面向切面编程AOP实现详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Spring框架AOP面向切面JAR
10-15
aspectjrt-1.5.2.jar aspectjweaver-1.9.1.jar spring-aop-5.0.8.RELEASE.jar spring-aspects-5.0.8.RELEASE.jar
Spring AI 抢先体验，5 分钟玩转 Java AI 应用开发
最新发布
阿里巴巴云原生的博客
04-29 746
Spring Cloud Alibaba AI 以 Spring AI 为基础，并在此基础上提供阿里云通义系列大模型全面适配，让用户在 5 分钟内开发基于通义大模型的 Java AI 应用。
springboot集成-mybatis-puls
csy08845的博客
04-29 114
Spring Boot中集成MyBatis Plus是一个相对简单的过程，MyBatis Plus是一个MyBatis的增强工具，它简化了CRUD操作，并且提供了一些额外的功能，比如性能优化、自动填充等。3.配置MyBatis Plus：通常，MyBatis Plus的配置与MyBatis类似，不需要额外的配置，因为它会自动配置。6.使用Mapper：在你的Service中注入Mapper，并使用它。7.配置扫描：确保Spring Boot扫描到你的Mapper接口。
SpringBoot项目打包分离高阶操作
Record Little
04-23 732
虽然传输jar包 比较大，但是安全性、稳定性比较高，不需要关注pom.xml 添加了新的依赖、更新了版本号等等影响版本功能的操作。关注maven的特性， profiles即可满足， 根据不同的activation 状态，激活不同的build操作。每次修改一小部分代码或仅仅更新某个依赖jar包时，都需要重新进行整个项目的构建、打包、上传和部署。但是当你的项目趋于稳定，只有业务上的逻辑变更时，如果使用分离版本，可以加快迭代、更新的速度。弊端： 需要配置IDE命令，修改依赖时需要同时修改2处。
mysql-connector-java和spring-boot-starter-jdbc和mybatis-spring-boot-start
xzy的博客
04-23 1029
JDBC是使用java语言操作mysql数据库的规范，java语言必须按照这个规范写才可以操作mysql数据库。
SpringCloudAlibaba：2.nacos
m0_63040701的博客
04-26 921
Nacos是阿里巴巴开源的服务注册中心以及配置中心Nacos=注册中心Eureka + 服务配置Config + 服务总线Bus。
Spring声明式事务（@Transactional）原理之-ProxyTransactionManagementConfiguration
良月柒
04-26 679
在传统的编程模型中，我们需要在代码中显式地编写事务管理逻辑，包括事务的开始、提交、回滚等。而在声明式事务管理模型中，我们可以通过注解或者XML配置的方式，将事务管理逻辑与业务逻辑分离开来，使得我们只需要专注于业务逻辑的实现，而不需要关心事务管理的细节。@Transactional注解就是用来实现声明式事务管理的重要工具之一。
spring aop面向切面编程
08-15
对的，Spring AOP（Aspect-Oriented Programming，面向切面编程）是Spring框架提供的一个重要特性。它允许开发者通过在应用程序中定义横切关注点（cross-cutting concerns），将这些关注点与核心业务逻辑分离开来。 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值