Spring AOP配置过程详解

最新推荐文章于 2024-06-17 14:00:16 发布
最新推荐文章于 2024-06-17 14:00:16 发布
阅读量1.6k 收藏 4
点赞数 2
分类专栏： java spring 文章标签： spring java aop spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44547562/article/details/107082182
版权
java 同时被 2 个专栏收录
21 篇文章 5 订阅
订阅专栏
spring
4 篇文章 1 订阅
订阅专栏

文章目录

AOP中的专业术语

Joinpoint（连接点）：连接点是指哪些被拦截到的点，在spring中，这些点指的是方法，因为spring只支持方法类型的连接点

Pointcut（切入点）：指我们要对哪些连接点进行拦截的定义

Advice（通知/增强）：拦截到连接点之后要做的事情
通知的类型：前置通知（在调用invoke方法前），后置通知（在调用invoke方法后），异常通知（在try语句中），最终通知（在finally语句中），环绕通知（整个增强方法）。

Target（目标对象）：代理的目标对象。

Weaving（织入）：指把增强应用到目标对象来创建新的代理对象的过程。spring采用动态代理织入，而AspectJ采用编译期织入和类装载期织入。

Proxy（代理）：一个类被AOP织入增强后，就产生一个结果代理类。

Aspect（切面）：是切入点和通知（引介）的结合。

AOP整体配置过程

  1. 在bean.xml中将切面类注入到Spring容器中

    <!-- 配置Logger类 -->
<bean id="logger" class="yonmin.utils.Logger"></bean>

  2. 使用<aop:config>标签配置AOP

    <!-- 配置Logger类 -->
<bean id="logger" class="yonmin.utils.Logger"></bean>

<!-- 配置AOP -->
<aop:config>
    ...
</aop:config>

  3. 在<aop:config>标签内部配置切入点（可省略），即被增强的方法。
    id属性是通知引用切入点时的标识，expression是切面表达式，需导入aspectjweaver，具体写法见下文。
    注意：切入点可以写在配置切面的内部，也可以写在外部。但是写在外部时要将配置切入点写在配置切面的前面。

    <!-- 配置Logger类 -->
<bean id="logger" class="yonmin.utils.Logger"></bean>

<!-- 配置AOP -->
<aop:config>
    <!-- 配置切入点 -->
    <aop:pointcut id="pt1" expression="execution(* yonmin.service.impl.*.*(..))"/>
</aop:config>

  4. 在<aop:config>标签内部配置切面，即切入点和通知（引介）的结合。切面的ref属性是导入Ioc容器中的切面类的id

    <!-- 配置AOP -->
<aop:config>

    <!-- 配置切入点 -->
    <aop:pointcut id="pt1" expression="execution(* yonmin.service.impl.*.*(..))"/>
    
    <!-- 配置切面 -->
    <aop:aspect id="logAdive" ref="logger">
        ...
    </aop:aspect>
</aop:config>

  5. 在<aop:aspect>标签内部配置通知（增强）。
    例如配置前置通知：<aop:before method="" pointcut-ref=""></aop:before>
    其中method属性是切面类中的方法名，pointcut-ref属性是配置的切入点的id。也可以不使用配置好的切入点，见下文。
    注意配置环绕通知后可能会发生切入点方法没有被执行，但是环绕通知被执行了。此时则需要修改切面类中的环绕通知方法，具体方法在下文。

    <!-- 配置Logger类 -->
<bean id="logger" class="yonmin.utils.Logger"></bean>

<!-- 配置AOP -->
<aop:config>

    <!-- 配置切入点 -->
    <aop:pointcut id="pt1" expression="execution(* yonmin.service.impl.*.*(..))"/>
    
    <!-- 配置切面 -->
    <aop:aspect id="logAdive" ref="logger">
        <!-- 前置通知：在切入点方法执行之前执行 -->
        <aop:before method="beforePrintLog" pointcut-ref="pt1"></aop:before>
        <!-- 后置通知：在切入点方法正常执行之后通知 -->
        <aop:after-returning method="afterPrintLog" pointcut-ref="pt1"></aop:after-returning>
        <!-- 异常通知：在切入点方法执行产生异常后通知 -->
        <aop:after-throwing method="exceptPrintLog" pointcut-ref="pt1"></aop:after-throwing>
        <!-- 最终通知：无论切入点方法是否正常运行都通知 -->
        <aop:after method="finalPrintLog" pointcut-ref="pt1" ></aop:after>
        <!-- 配置环绕通知 -->
        <aop:around method="aroundPrintLog" pointcut-ref="pt1"></aop:around>
    </aop:aspect>
</aop:config>

项目中的角色分工

  • 开发阶段（我们做的）
    编写核心业务代码（开发主线）：大部分程序员都能做，要求熟悉业务需求。
    把公用代码抽取出来，制作成通知。（开发阶段最后再做）：A0P编程人员来做。
    在配置文件中，声明切入点与通知间的关系，即切面。：AOP编程人员来做。

  • 运行阶段（ Spring框架完成的）
    Spring框架监控切入点方法的执行。一旦监控到切入点方法被运行，使用代理机制，动态创建目标对象的代理对象，根据通知类别，在代理对象的对应位置，将通知对应的功能织入，完成完整的代码逻辑运行。

基于XML的AOP配置

Spring中基于XML的AOP配置步骤

  1. 把通知Bean交给spring管理

  2. 使用<aop:config>标签表明开始AOP配置

  3. 使用<aop:aspect>标签表明配置切面

    • id：给切面提供一个唯一标识
    • ref：指定通知类bean的id

  4. 在<aop:aspect>标签内部使用对应标签来配置通知的类型

    • aop:before：表示配置前置通知

      1. method：用于指定Logger类中哪个方法是前置通知
      2. pointcut：用于指定切入点表达式，该表达式的含义指的是对业务层中哪些方法增强

    • 切入点表达式写法（需导入aspectjweaver）：

      • 关键字：execution（表达式）
      • 表达式：
        访问修饰符 返回值 包名.包名…类名.方法名(参数列表)
      • 标准的表达式写法
        public void yonmin.service.impl.AccountServiceImpl.saveAccount()
      • 访问修饰符可以省略
        void yonmin.service.impl.AccountServiceImpl.saveAccount()
      • 返回值可以使用返回值通配符
        * yonmin.service.impl.AccountServiceImpl.saveAccount()
      • 包名可以使用通配符表示任意包。但是有几级包，就需要写几个*.
        * *.*.*.*.AccountServiceImpl.saveAccount()
      • 包名可以使用…表示当前包及其子包
        * *..AccountServiceImpl.saveAccount()
      • 类名和方法名都可以使用*实现通配
        * *..*.*()
      • 参数列表
        • 可以直接写数据类型：
          • 基本类型直接写名称，如：int
          • 引用类型写包名.类名的方式，如：java.lang.String
        • 类型可以使用通配符 * 来表示任意类型，但必须有参数
        • 可以使用 … 表示有无参数均可，有参数可以是任意类型
      • 全通配写法（最好不要这样写）：
        * *..*.*(..)
      • 实际开发中切入点表达式的通常写法
        例如切到业务层实现类下的所有写法
        * yonmin.service.impl.*.*(..)
<!-- 配置Logger类 -->
<bean id="logger" class="yonmin.utils.Logger"></bean>

<!-- 配置AOP -->
<aop:config>
    <!-- 配置切面 -->
    <aop:aspect id="logAdive" ref="logger">
        <aop:before method="beforePrintLog" pointcut="execution(* yonmin.service.impl.*.*(..))"></aop:before>
    </aop:aspect>
</aop:config>
  • 配置切入点表达式
    • id属性用于指定表达式的唯一标识。
    • expression属性用于指定表达式内容
      此标签写在aop:aspect标签内部只能当前切面可用。
      它还可以写在aop:aspect外面，此时就变成了所有切面可用，但必须要写在aop:aspect之前
<!-- 配置Logger类 -->
<bean id="logger" class="yonmin.utils.Logger"></bean>

<!-- 配置AOP -->
<aop:config>

    <!-- 配置切入点 -->
    <aop:pointcut id="pt1" expression="execution(* yonmin.service.impl.*.*(..))"/>
    
    <!-- 配置切面 -->
    <aop:aspect id="logAdive" ref="logger">
        <!-- 前置通知：在切入点方法执行之前执行 -->
        <aop:before method="beforePrintLog" pointcut-ref="pt1"></aop:before>
        <!-- 后置通知：在切入点方法正常执行之后通知 -->
        <aop:after-returning method="afterPrintLog" pointcut-ref="pt1"></aop:after-returning>
        <!-- 异常通知：在切入点方法执行产生异常后通知 -->
        <aop:after-throwing method="exceptPrintLog" pointcut-ref="pt1"></aop:after-throwing>
        <!-- 最终通知：无论切入点方法是否正常运行都通知 -->
        <aop:after method="finalPrintLog" pointcut-ref="pt1" ></aop:after>
        <!-- 配置环绕通知 -->
        <aop:around method="aroundPrintLog" pointcut-ref="pt1"></aop:around>
    </aop:aspect>
</aop:config>

环绕通知：
在日志代码中添加环绕通知并且在bean.xml中配置好，运行程序发现环绕通知执行了，但是切入点的方法没有执行
在Logger代码中如此配置环绕通知后切入点方法即被执行。
重点是使用 ProceedingJoinPoint，明确调用业务层方法（切入点方法）

public Object aroundPrintLog(ProceedingJoinPoint pjp){
    Object rtValue = null;
    try {
        Object[] args = pjp.getArgs();

        System.out.println("前置通知");

        rtValue = pjp.proceed(args); // 明确调用业务层方法（切入点方法）

        System.out.println("后置通知");

    } catch (Throwable throwable) {
        System.out.println("异常通知");

        throwable.printStackTrace();
    }finally {
        System.out.println("最终通知");

    }
    return rtValue;
}

基于注解的AOP配置

保留bean.xml情况

bean.xml文件中如此配置使代码支持AOP注解。

<?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:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       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
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 配置spring创建容器时扫描的包 -->
    <context:component-scan base-package="yonmin"></context:component-scan>

    <!-- 使AOP支持注解 -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>

使用@Aspect表示修饰类是一个切面类。

在切面类中的方法上使用：
@Before：表示前置通知
@AfterReturning：表示后置通知
@AfterThrowing：表示异常通知
@After：表示最终通知

在切面类中使用如下代码创建名为pt1的切面对象，注意在诸如@Before("pt1()")引用时，一定要在名字后面加上括号。

//创建切面对象
@Pointcut("execution(* yonmin.service.impl.*.*(..))")
private void pt1(){}

此时运行程序发现输出如下

Log类中的beforePrintLog方法开始记录日志了。。。
执行了保存
Log类中的finalPrintLog方法开始记录日志了。。。
Log类中的afterReturningPrintLog方法开始记录日志了。。。

发现顺序出现错误，这是Spring中AOP自带的问题，解决方法是使用环绕通知。
在环绕通知的方法上添加注解@Around

@Around("pt1()")
public Object aroundPrintLog(ProceedingJoinPoint pjp){
    Object rtValue = null;
    try {
        Object[] args = pjp.getArgs();

        System.out.println("前置通知");

        rtValue = pjp.proceed(args); // 明确调用业务层方法（切入点方法）

        System.out.println("后置通知");

    } catch (Throwable throwable) {
        System.out.println("异常通知");

        throwable.printStackTrace();
    }finally {
        System.out.println("最终通知");

    }

    return rtValue;
}

去除其它通知注解后运行，输出

前置通知
执行了保存
后置通知
最终通知

显然没有出现顺序错误的问题。

删除bean.xml情况

新建一个配置类，内容如下

package yonmin.configration;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@ComponentScan("yonmin")
@EnableAspectJAutoProxy
public class SpringConfigration {

}

@Configuration说明此类是Spring的配置类
@ComponentScan(“yonmin”) 相当于XML文件中扫描包的代码
@EnableAspectJAutoProxy表明能够使用AOP注解

在test代码中使用Junit进行测试

package test;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import yonmin.configration.SpringConfigration;
import yonmin.service.IAccountService;

import javax.annotation.Resource;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfigration.class)
public class AOPTest {

    @Resource(name = "accountService")
    private IAccountService as;

    @Test
    public void test(){
        as.saveAccount();
    }
}

使用@Resource(name = "accountService")获取Ioc容器中的accountService对象。
此时删除bean.xml文件运行即可

YonminMa
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
AOP配置
apr_su
05-03 797
一、基本配置和切入点表达式写法 spring中基于xml的aop配置 把通知Bean交给spring管理 使用aop：config标签表明开始aop配置 使用aop：aspcet标签表明配置切面 id属性：是给切面提供一个唯一标识 ref属性：指定通知类bean的id 在aop：aspect标签的内部使用对应标签来配置通知的类型 <!--配置springIOC，把se...
Spring（二）Spring AOP配置详解
代码与酒
01-25 1515
一、Spring AOP         面向切面编程（AOP），是软件编程思想发展到一定阶段的产物，是对面向对象编程（OOP）的有益补充。AOP一般适用于具有横切逻辑的场合，如访问控制、事务管理、性能监测等。         面向切面编程，简单的说，就是在不改变源程序的基础上为代码段增加新的功能，对代码进行增强处理，它的设计思想来源于代理设计模式。         了解之后需要知道以下概念
Spring-AOP配置(XML)
汤键的博客
09-17 3211
Spring-AOP配置(XML)
Spring AOP详解
最新发布
这河里吗l的博客
06-17 958
AOP(Aspect-Oriented Programming)面向切面编程，作为面向对象的一种补充，将公共逻辑（事务管理、日志、缓存等）封装成切面，跟业务代码进行分离，可以减少系统的重复代码和降低模块之间的耦合度，并有利于未来的可拓展性和可维护性。
AOP简单相关配置
qq_40432598的博客
11-14 951
AOP简单相关配置
spring aop的几种配置方式
m0_67403240的博客
08-24 746
编写通知:(实现MethodBeforeAdvice等通知接口)spring中配置代理工厂。在spring中配置。编写业务处理的实现类。
SpringAop三种配置方式
qq_42283142的博客
03-13 3407
SpringAop三种配置方式 AOP 什么是AOP Aop(Asoect Oriented Programming)意味：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术，AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型，利用AOP可以对业务逻辑各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 AOP在Spring中的作用 提供声明式事务：允许用户自定义切面 横切
Spring中AOP的注解方式的配置
pipizhen_的博客
09-12 791
上篇内容简单回顾 1、Spring的IOC的注解开发 （1）引入aop的包 引入context约束 配置文件中需要组件扫描：<context:component-scan /> （2）使用注解开发： @Component ：定义Bean @Controller ：WEB层 @Service ：Service层 @Repository ：DAO层 （3）属性注入： 普通属性 ：@Value 对象属性 ：@Resource @Autowired按类型注入属性，@Qulifier按名称注入属性。
SpringAOP中的注解配置详解
08-25
SpringAOP中的注解配置详解 SpringAOP中的注解配置详解是Spring框架中的一种非常重要的技术，它允许开发者在不修改源代码的情况下实现对业务逻辑的拦截和扩展。本文将详细介绍SpringAOP中的注解配置详解，包括使用...
SpringAOP事务配置语法及实现过程详解
08-19
本篇文章将详细讲解Spring AOP如何进行事务配置以及其实现过程。 首先，我们需要配置事务管理器。Spring支持多种类型的事务管理器，如`DataSourceTransactionManager`适用于JDBC事务，而`...
Spring AOP的使用详解
08-25
Spring AOP的使用详解 Spring AOP是一种面向切面编程（Aspect-Oriented Programming）的技术，用于实现程序功能的统一维护。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容。 AOP的主要...
Spring AOP执行先后顺序实例详解
08-25
Spring AOP执行先后顺序实例详解 Spring AOP（Aspect-Oriented Programming）是一种面向方面的编程思想，它可以将散乱、分散的关注点（Concerns）模块化，通过方面（Aspect）来封装这些关注点，从而实现松耦合、...
Spring注解配置实现过程详解
08-18
Spring 注解配置实现过程详解 Spring 框架中，注解配置是一种非常重要的配置方式，它允许开发者使用注解来定义 Bean 的依赖关系和生命周期。下面我们将详细介绍 Spring 注解配置的实现过程。 首先，需要在 pom.xml...
AOP配置（注解）
weixin_51343683的博客
09-19 1260
注解开发AOP制作步骤 在XML格式基础上 导入坐标（伴随spring-context坐标导入已经依赖导入完成） 开启AOP注解支持 配置切面@Aspect 定义专用的切入点方法，并配置切入点@Pointcut 为通知方法配置通知类型及对应切入点@Before 在applicationContext.xml里添加标签，开启aop注解支持 在AOPAdvice里添加注解 运行程序可见正常运行 修改AOPAdvice内容 运行可见结果 如果在AOPAdvice里添加@Component
初识AOP
小树不倒我不倒
07-27 467
什么是Aspect Oriented Programming（AOP）面向切面编程,是可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。AOP实际是GoF设计模式的延续，设计模式孜孜不倦追求的是调用者和被调用者之间的解耦,提高代码的灵活性和可扩展性，AOP可以说也是这种目标的一种实现。理解在运行时，动态地将代码切入到类的指定方法、指定位置上的编程思想就是面
（一）Spring 核心之面向切面编程（AOP）—— 配置及使用
流华追梦的专栏
02-05 1124
AOP（Aspect Oriented Programming）是一种面向切面的编程思想。面向切面编程是将程序抽象成各个切面，即解剖对象的内部，将那些影响了多个类的公共行为抽取到一个可重用模块里，减少系统的重复代码，降低模块间的耦合度，增强代码的可操作性和可维护性。
Spring AOP的应用配置
d_drj123的博客
02-14 257
Spring AOP的高级应用配置
Spring aop的基本概念和环境搭建
m0_51523819的博客
09-15 305
spring aop的配置与使用
Spring-AOP配置管理
qq_53098203的博客
03-14 455
Spring-AOP配置管理
Spring AOP配置详解：从经典到注解驱动
"spring入门学习-6、AOP几种配置方式详解.pdf" Spring 框架中的面向切面编程（AOP）是一种强大的工具，用于在应用程序中实现关注点分离，如日志记录、事务管理等。Spring 提供了四种不同的 AOP 配置方式，让我们...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值