Spring boot AOP通过 XML 配置文件声明

最新推荐文章于 2024-07-05 10:07:39 发布
最新推荐文章于 2024-07-05 10:07:39 发布
阅读量3.8k 收藏 3
点赞数
分类专栏： Spring Boot 文章标签： spring boot aop xml
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_27462223/article/details/106855684
版权

 

通过 XML 配置文件声明

在前两篇博文和示例中，我们已经展示了如何通过注解配置去声明切面，下面我们看看如何在 XML 文件中声明切面。下面先列出 XML 中声明 AOP 的常用元素：

AOP配置元素用途
aop:advisor定义AOP通知器
aop:after定义AOP后置通知（不管被通知的方法是否执行成功）
aop:after-returning定义AOP返回通知
aop:after-throwing定义AOP异常通知
aop:around定义AOP环绕通知
aop:aspect定义一个切面
aop:aspectj-autoproxy启用@AspectJ注解驱动的切面
aop:before定义一个AOP前置通知
aop:config顶层的AOP配置元素。大多数的aop:*元素必须包含在aop:config元素内
aop:declare-parents以透明的方式为被通知的对象引入额外的接口
aop:pointcut定义一个切点

 XML 配置文件中切点指示器

在XML配置文件中，切点指示器表达式与通过注解配置的写法基本一致，区别前面有提到，即XML文件中需要使用 “and”、“or”、“not”来表示 “且”、“或”、“非”的关系。

XML 文件配置 AOP 

新建OrderXmlAop.java:

package com.example.demo.aop;

public class OrderXmlAop {

    /**
     * @description  在连接点执行之前执行的通知
     */
    public void doBefore(){
        System.out.println("阿里阿塞哟！");
    }

    /**
     * @description  在连接点执行之后执行的通知（返回通知和异常通知的异常）
     */
    public void doAfter(){
        System.out.println("after！");
    }


    /**
     * @description  在连接点执行之后执行的通知（返回通知）
     */
     public void doAfterReturning(){

         System.out.println("返回通知：AfterReturning");
      }

    /**
     * @description  在连接点执行之后执行的通知（异常通知）
     */
    public void doAfterThrowing(){
     System.out.println("异常通知：AfterThrowing");
     }
}

在 Resource 目录下新建一个配置文件 aoporder.xml ：

<?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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

    <bean id="wmzService" class="com.example.demo.service.impl.WMZServiceImpl"></bean>
    <bean id="zsService" class="com.example.demo.service.impl.ZSServiceImpl"></bean>
    <!-- 切面类 -->
    <bean id="OrderXmlAop" class="com.example.demo.aop.OrderXmlAop"></bean>

    <!-- Aop配置 -->
    <aop:config proxy-target-class="true">

        <!-- 切面 -->
        <aop:aspect ref="OrderXmlAop">
            <!-- 前置通知： 在目标方法调用前执行 -->
            <aop:before pointcut="execution(public * com.example.demo.service.TakeawayService.*(..)))" method="doBefore"/>
            <!-- 后置通知： -->
            <aop:after pointcut="execution(public * com.example.demo.service.TakeawayService.*(..)))" method="doAfter"/>
            <!-- 返回后通知 -->
            <aop:after-returning pointcut="execution(public * com.example.demo.service.TakeawayService.*(..)))" method="doAfterReturning"/>
            <!-- 异常通知 -->
            <aop:after-throwing pointcut="execution(public * com.example.demo.service.TakeawayService.*(..)))" method="doAfterThrowing"/>
        </aop:aspect>
    </aop:config>
</beans>

新建 TakeXmlController.java

package com.example.demo.controller;

import com.example.demo.entity.Response;
import com.example.demo.entity.ResponseResult;
import jdk.internal.org.objectweb.asm.tree.analysis.Value;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.example.demo.service.TakeawayService;
@RestController
@RequestMapping("/api")

public class TakeXmlController {

    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("aoporder.xml");
    @RequestMapping("/orderxml")
    public ResponseResult Ordexml()
    {
        /**
        ** 注意 此处的getBean（name）中的name 必须要和aoporder.xml 配置的bean节点上的id 保持一致
         * 如： <bean id="wmzService" class="com.example.demo.service.impl.WMZServiceImpl"></bean>
         *  TakeawayService wmzService=(TakeawayService)context.getBean("wmzService");
         */
        TakeawayService wmzService=(TakeawayService)context.getBean("wmzService");
        String wmz= wmzService.Order(12);
        System.out.println(wmz);
        TakeawayService zsService=(TakeawayService)context.getBean("zsService");
        String zs=zsService.Order(4396);
        System.out.println(zs);
        return Response.makeOKRsp(wmz+";"+zs);
    }
}

运行结果：

 

声明环绕通知

修改OrderXmlAop.java:

package com.example.demo.aop;

import org.aspectj.lang.ProceedingJoinPoint;

public class OrderXmlAop {

    /**
     * @description  在连接点执行之前执行的通知
     */
    public void doBefore(){
        System.out.println("阿里阿塞哟！");
    }

    /**
     * @description  在连接点执行之后执行的通知（返回通知和异常通知的异常）
     */
    public void doAfter(){
        System.out.println("after！");
    }


    /**
     * @description  在连接点执行之后执行的通知（返回通知）
     */
     public void doAfterReturning(){

         System.out.println("返回通知：AfterReturning");
      }

    /**
     * @description  在连接点执行之后执行的通知（异常通知）
     */
    public void doAfterThrowing(){
     System.out.println("异常通知：AfterThrowing");
     }

    /**
     * @description  在连接点执行之后执行的通知（异常通知）
     */
    public void doAround(ProceedingJoinPoint pj) {
        try {
            System.out.println("Around 调用方法前 ");
            pj.proceed();
            System.out.println("Around 调用方法后");
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
    }
}

aoporder.xml:
<?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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

    <bean id="wmzService" class="com.example.demo.service.impl.WMZServiceImpl"></bean>
    <bean id="zsService" class="com.example.demo.service.impl.ZSServiceImpl"></bean>
    <!-- 切面类 -->
    <bean id="OrderXmlAop" class="com.example.demo.aop.OrderXmlAop"></bean>

    <!-- Aop配置 -->
    <aop:config proxy-target-class="true">

        <!-- 切面 -->
        <aop:aspect ref="OrderXmlAop">
            <!-- 环绕通知 -->
            <aop:around pointcut="execution(public * com.example.demo.service.TakeawayService.*(..)))" method="doAround"/>
            <!-- 前置通知： 在目标方法调用前执行 -->
            <aop:before pointcut="execution(public * com.example.demo.service.TakeawayService.*(..)))" method="doBefore"/>
            <!-- 后置通知： -->
            <aop:after pointcut="execution(public * com.example.demo.service.TakeawayService.*(..)))" method="doAfter"/>
            <!-- 返回后通知 -->
            <aop:after-returning pointcut="execution(public * com.example.demo.service.TakeawayService.*(..)))" method="doAfterReturning"/>
            <!-- 异常通知 -->
            <aop:after-throwing pointcut="execution(public * com.example.demo.service.TakeawayService.*(..)))" method="doAfterThrowing"/>
        </aop:aspect>
    </aop:config>
</beans>

运行结果：

结果和我们预期的一致，环绕通知通过xml配置成功。

XML 文件配置声明切点 

在上面的例子中，我们发现有切点表达式多次重复出现，那么可不可以和aspectj配置一样，单独声明切点，后面复用，答案是当然可以。如下修改aoporder.xml：

<?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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

    <bean id="wmzService" class="com.example.demo.service.impl.WMZServiceImpl"></bean>
    <bean id="zsService" class="com.example.demo.service.impl.ZSServiceImpl"></bean>
    <!-- 切面类 -->
    <bean id="OrderXmlAop" class="com.example.demo.aop.OrderXmlAop"></bean>

    <!-- Aop配置 -->
    <aop:config proxy-target-class="true">
        <!-- 切点 -->
        <aop:pointcut id="point" expression="execution(public * com.example.demo.service.TakeawayService.*(..)))"/>
        <!-- 切面 -->
        <aop:aspect ref="OrderXmlAop">
            <!-- 环绕通知 -->
            <aop:around pointcut-ref="point" method="doAround"/>
            <!-- 前置通知： 在目标方法调用前执行 -->
            <aop:before pointcut-ref="point" method="doBefore"/>
            <!-- 后置通知： -->
            <aop:after pointcut-ref="point" method="doAfter"/>
            <!-- 返回后通知 -->
            <aop:after-returning pointcut-ref="point" method="doAfterReturning"/>
            <!-- 异常通知 -->
            <aop:after-throwing pointcut-ref="point" method="doAfterThrowing"/>
        </aop:aspect>
    </aop:config>
</beans>

 修改后执行结果：

 

 XML文件配置为通知传递参数

修改OrderXmlAop.java

 public String doAround(ProceedingJoinPoint pj,double price) {
        try {
            System.out.println("Around 调用方法前 ");
            pj.proceed();
            if(price>=4396)
            {
                System.out.println("zs下单超过了4399，赠送一份鲜果饮汇源牌饮料");
                return "爆浆牛丸和饮料";
            }
            System.out.println("Around 调用方法后");
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        return "爆浆牛丸";
    }

修改aoporder.xml

<?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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

    <bean id="wmzService" class="com.example.demo.service.impl.WMZServiceImpl"></bean>
    <bean id="zsService" class="com.example.demo.service.impl.ZSServiceImpl"></bean>
    <!-- 切面类 -->
    <bean id="OrderXmlAop" class="com.example.demo.aop.OrderXmlAop"></bean>

    <!-- Aop配置 -->
    <aop:config proxy-target-class="true">
        <!-- 切点 -->
        <aop:pointcut id="point" expression="execution(com.example.demo.service.TakeawayService.Order(double)) and args(price) and bean(zsService)"/>
        <!-- 切面 -->
        <aop:aspect ref="OrderXmlAop">
            <!-- 环绕通知 -->
            <aop:around pointcut-ref="point" method="doAround"/>
        </aop:aspect>
    </aop:config>
</beans>

总结

本文主要通过XML配置文件使用 Spring AOP进行编程，和上一篇的注解方式两者联系起来对于刚入门的应该多多少少还是有点帮助的吧，针对于aop 通过三篇博客简单的描述，相信大家对此都有点印象了，记录了 AOP 的编程思想，然后介绍了 Spring 中 AOP 的相关概念，以及通过注解方式和XML配置文件两种方式使用 Spring AOP进行编程。所以对aop的博文就简单到这儿了，有人要问了，aop里面的代理啊还有各种各样的，如果真要吧aop重头到尾来一遍的话，这个系列可以单独提出来一个专栏了，所以后面的博文应该都是围绕连接数据库，记录日志，接入swagger文档等功能相继展开了。在此过程中，我有错误使用的地方，或者表达有问题，还请您及时告知，本人会在第一时间予以改正。最后在祝大家周末愉快，C Y L L

源码：https://github.com/LeeCurtain/demo.git

CurtainMy
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring Boot - spring-boot-starter-aop
学无止境
06-12 1056
然后，我们创建了一个切面类LoggingAspect，它使用@Before和@After注解来定义前置通知和后置通知，这些通知将在UserService类的getUser()在工作中，spring-boot-starter-aop常用于在应用程序中实现切面编程，例如日志记录、性能监控、事务管理等。最后，在Application类的main()方法中，我们获取UserService的实例并调用getUser()方法。在这个示例中，我们创建了一个UserService类，它有一个getUser()
spring boot aop其中pom.xml文件
weixin_41414522的博客
06-30 1198
首先新建一个maven项目，在项目的pom.xml中添加spring aop相关的依赖项： 如下是完整的pom.xml： 4.0.0 <groupId>cn.outofmemory</groupId> <artifactId>spring-aop-aspect</artifactId> <version>0.0.1-SNAPSHOT</version> <packaging>jar</packaging> &
【Spring进阶系列丨第九篇】基于XML的面向切面编程(AOP)详解
陈橘又青的博客
04-14 1万+
/ 保存用户// 根据id查询用户// 查询全部用户// 保存用户// 根据id查询用户// 查询全部用户// 定义记录日志的类,这个类就封装了我们所有的公共的代码// 该方法的作用是在切入点方法执行之前执行System.out.println("开始打印日志啦");
【Spring Boot AOP介绍】
最新发布
武帝为此的博客
07-05 1237
Spring AOP 是 Spring 框架的一部分，提供了简单易用的 AOP 功能。Spring AOP 使用动态代理实现运行时织入，并支持基于注解和基于 XML 的配置方式。Spring AOP 主要用于处理方法级别的横切关注点，适用于大多数企业应用场景。切点定义了切面织入的具体位置，可以通过@Pointcut注解来定义。Pointcut;@Pointcut注解定义了一个名为的切点，该切点匹配包中的所有方法执行。
Spring Boot原理分析（三）：AOP
TracyCoder的博客
07-15 828
它使用注解来定义切面和通知操作，使用动态代理来生成代理对象，并在运行时将切面的通知操作织入到代理对象的方法调用中。一旦切面被织入到目标对象中，它可以在目标对象的方法执行前、执行后或异常抛出时插入额外的逻辑，从而实现横切关注点的功能。它使用 XML配置文件来定义切面、切点和通知操作等信息，使用 AOP 命名空间来声明和配置切面和通知操作等元素，从而实现代理对象的方法调用拦截和增强。它使用注解来定义切面和通知操作，使用动态代理来生成代理对象，并在运行时将切面的通知操作织入到代理对象的方法调用中。
Spring boot中使用aop详解
热门推荐
tianyaleixiaowu的专栏
04-27 2万+
aop是spring的两大功能模块之一，功能非常强大，为解耦提供了非常优秀的解决方案。 现在就以springboot中aop的使用来了解一下aop。 一：使用aop来完成全局请求日志处理 创建一个springboot的web项目，勾选aop，pom如下： <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="htt
spring boot aop
Zllvincent的博客
10-21 3716
一、简介 AOP（Aspect Orient Programming），即面向切面编程，作为面向对象的一种补充，用于处理系统中分布于各个模块的横切关注点，比如事务管理、日志、缓存等等。AOP实现的关键在于AOP框架自动创建的AOP代理，AOP代理主要分为静态代理和动态代理。 Spring AOP中的动态代理主要有两种方式，JDK动态代理和CGLIB动态代理。 1.通知(有的地方叫增强)(Advic...
spring boot 配置文件pom.xml详解
qq_41931797的博客
07-03 1万+
spring boot 配置文件pom.xml详解 看下方资料的同时可以参考Spring3.0结构图，帮助理解。 pom.xml实例讲解 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocat...
1、Spring Boot 项目文件介绍 -pom.xml
qq_41978323的博客
01-08 2026
一、解析 pom.xml 文件 （1）让我们来看看默认生成的 pom.xml 文件中到底有些什么： <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/
Spring boot AOP通过XML配置文件声明
08-19
Spring Boot AOP 通过 XML 配置文件声明 Spring Boot AOP 通过 XML 配置文件声明是 Spring Boot 框架中的一种实现 AOP（Aspect-Oriented Programming，面向方面编程）的方式。AOP 是一种编程技术，旨在将横切关注...
spring-boot aop
01-23
1. **引入依赖**：在`pom.xml`或`build.gradle`文件中添加Spring AOP和AspectJ的依赖。对于Maven，添加以下依赖： ```xml <groupId>org.springframework.boot <artifactId>spring-boot-starter-aop ``` 2. ...
Spring Boot配置AOP打印日志的全过程
08-25
Spring Boot配置AOP打印日志的全过程 Spring Boot是一个流行的Java框架，通过使用AOP（Aspect-Oriented Programming，面向切面编程）可以实现日志的打印，并减少重复的代码。下面将详细介绍如何在Spring Boot中配置...
spring boot2 AOP
01-17
在Spring Boot 2.x中，AOP（面向切面编程）是一种强大的工具，它允许我们以声明式的方式处理横切关注点，如日志记录、事务管理、性能监控等。AOP通过切面（Aspect）将这些关注点与业务逻辑解耦。下面我们将详细探讨...
spring boot如何使用AOP统一处理web请求
08-25
首先，我们需要在pom.xml文件中添加相关的依赖项，包括spring-boot-starter-web和spring-boot-starter-aop。前者用于支持Web应用程序，后者用于支持AOP功能。 其次，我们需要在application.properties文件中添加AOP...
Spring Boot读取 properties或者application.yml 配置文件中的数据
Curtain的博客
06-15 4797
Spring Boot读取配置的 5 种方式 读取application文件 在application.yml或者properties文件中添加： user.address=china user.company=demo user.name=让我康康 1、使用@Value注解读取 直接代码如下： package im.homeapi.controller; import org.springframework.beans.factory.annotation.V...
Spring AOP 编程入门
Curtain的博客
06-17 4467
什么是OOP？ 面向对象编程，也称为OOP（即Object Oriented Programming），通过的是继承、封装和多态等概念来建立一种对象层次结构，用于模拟公共行为的一个集合，最大的优点在于能够将业务模块进行封装，从而达到功能复用的目的。 什么是AOP? 面向切面编程，也称为AOP（即Aspect Oriented Programming），指的是将一定的切面逻辑按照一定的方式编织到指定的业务模块中，从而将这些业务模块的调用包裹起来。OOP从纵向上区分出一个个的类来，而AOP则从横...
Spring Boot 整合Swagger 2文档
Curtain的博客
06-23 3677
在实际开发过程中，前后端分离后，那么势必存在如何在多人协作中共享和及时更新API开发接口文档的问题，维护接口文档就变成了必不可少的工作，在初期开发的时候接口一直处在变化中，每次接口更新，都要去单独维护接口文档，做过的老铁都知道这是一件多么令人脑瓜子疼得事。使用swagger2集成文档，有多个优势: 功能丰富：支持多种注解，自动生成接口文档界面，支持在界面测试API接口功能； 及时更新：开发过程中养成写注释的习惯，就可以及时的更新API文档； 整合简单：通过添加pom依赖和简单配置，内嵌于应用中就...
Spring AOP 编程入门（二）
Curtain的博客
06-18 3615
相信大家通过上一篇的Spring AOP 编程入门对AOP 的术语已经有了一定的认知，概念看起来总是有点懵，所以需要慢慢在应用中理解，今天主要是通过一些小例子加深一下aop在实际应用中到底能干嘛。 一、初步认识 Spring AOP 1.Spring AOP 的特点 AOP 框架有很多种, Spring 中的 AOP 是通过动态代理实现的。不同的 AOP 框架支持的连接点也有所区别，例如，AspectJ 和 JBoss,除了支持方法切点，它们还支持字段和构造器的连接点。而 S...
spring boot aop
05-13
Spring Boot AOP（面向切面编程）是 Spring Boot...Spring Boot AOP 基于 AspectJ 框架实现，支持注解和 XML 配置方式，非常灵活。如果你想使用 AOP 实现一些通用的功能或业务逻辑，Spring Boot AOP 是一个不错的选择。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值