Spring基于XML的AOP开发&&基于注解的AOP开发

已于 2022-10-16 12:10:31 修改
阅读量756 收藏 2
点赞数
分类专栏： Spring 文章标签： java
于 2021-02-11 17:50:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43408367/article/details/113791212
版权

文章目录

基于XML的AOP开发

  1. pom文件

    <?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/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>spring_aop_xml</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
    </properties>
    <dependencies>
        <!--导入spring的context坐标，context依赖aop-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.5.RELEASE</version>
        </dependency>
        <!-- aspectj的织入（切点表达式需要用到该jar包） -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.13</version>
        </dependency>
        <!--spring整合junit-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.1.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>
</project>

  2. 创建目标接口和目标实现类

    package com.code.service;

public interface AccountService {
    
    //目标方法：（切入点：要进行拦截增强的方法）
    public void transfer();
}

    package com.code.service.impl;

import com.code.service.AccountService;

public class AccountServiceImpl implements AccountService {

    /*
        目标方法：（切入点：要进行拦截增强的方法）
    */
    @Override
    public void transfer() {

        System.out.println("转账方法执行了....");
        //int i = 1/0;
    }
}

  3. 创建通知类

    public class MyAdvice {
	public void before() {
		System.out.println("前置通知...");
	}
}

  4. Spring配置文件，将目标类和通知类对象创建权交给spring

    <?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">


    <!--目标类交给IOC容器-->
    <bean id="accountServcie" class="com.code.service.impl.AccountServiceImpl"></bean>

    <!--通知类交给IOC容器-->
    <bean id="myAdvice" class="com.code.advice.MyAdvice"></bean>



    <!--
    execution([修饰符] 返回值类型 包名.类名.方法名(参数))
    execution(public void com.code.service.impl.AccountServiceImpl.transfer(java.lang.String))

    - 访问修饰符可以省略
    execution(void com.code.service.impl.AccountServiceImpl.transfer(java.lang.String))

    - 返回值类型、包名、类名、方法名可以使用星号 * 代替，代表任意
    execution(* *.*.*.*.*.*())

    - 包名与类名之间一个点 . 代表当前包下的类，两个点 .. 表示当前包及其子包下的类
    execution(* *..*.*())

    - 参数列表可以使用两个点 .. 表示任意个数，任意类型的参数列表
    execution(* *..*.*(..))
    -->

    <!--AOP配置-->
    <aop:config>
        <!--抽取的切点表达式-->
        <aop:pointcut id="accountService" expression="execution(* com.code.service.impl.AccountServiceImpl.*(..))"/>

        <!--配置切面：切入点+通知-->
        <aop:aspect ref="myAdvice">
            <aop:before method="before" pointcut-ref="accountService"/>
            <aop:after-returning method="afterReturning" pointcut-ref="accountService"/>
            <aop:after-throwing method="afterThrowing" pointcut-ref="accountService"/>
            <aop:after method="after" pointcut-ref="accountService"/>
            <aop:around method="around" pointcut-ref="accountService"/>

        </aop:aspect>

    </aop:config>
    

</beans>

  5. 切点表达式抽取：当多个增强的切点表达式相同时，可以将切点表达式进行抽取，在增强中使用 pointcut-ref 属性代替pointcut 属性来引用抽取后的切点表达式

    <aop:config>
	<!--抽取的切点表达式-->
	<aop:pointcut id="myPointcut" expression="execution(* com.code.service..*.*(..))"> </aop:pointcut>
	<aop:aspect ref="myAdvice">
		<aop:before method="before" pointcut-ref="myPointcut"></aop:before>
	</aop:aspect>
</aop:config>

  6. 通知的配置语法：<aop:通知类型 method=“通知类中方法名” pointcut=“切点表达式"></aop:通知类型>

    名称标签说明
    前置通知aop:before用于配置前置通知。指定增强的方法在切入点方法之前执行
    后置通知aop:afterReturning用于配置后置通知。指定增强的方法在切入点方法之后执行
    异常通知aop:afterThrowing用于配置异常通知。指定增强的方法出现异常后执行
    最终通知aop:after用于配置最终通知。无论切入点方法执行时是否有异常，都会执行
    环绕通知aop:around用于配置环绕通知。开发者可以手动控制增强代码在什么时候执行

基于注解的AOP开发

  1. pom文件

    <dependencies>
    <!--导入spring的context坐标，context依赖aop-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.1.5.RELEASE</version>
    </dependency>
    <!-- aspectj的织入 -->
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.8.13</version>
    </dependency>
    <!--spring整合junit-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>5.1.5.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
</dependencies>

  2. 创建目标接口和目标实现类

    public interface AccountService {
	public void transfer();
}

    public class AccountServiceImpl implements AccountService {
	@Override
	public void transfer() {
		System.out.println("转账业务...");
	}
}

  3. 创建通知类：

    public class MyAdvice {
	public void before() {
		System.out.println("前置通知...");
	}
}

  4. 将目标类和通知类对象创建权交给spring

    @Service
public class AccountServiceImpl implements AccountService {}

@Component
public class MyAdvice {}

  5. 在通知类中使用注解配置织入关系，升级为切面类

    @Component
@Aspect
public class MyAdvice {
	@Pointcut("execution(* com.code..*.*(..))")
	public void myPoint(){}
	
	@Before("MyAdvice.myPoint()")
	public void before() {
	System.out.println("前置通知...");
	}
}

  6. 在配置文件中开启组件扫描和 AOP 的自动代理

    <!--组件扫描-->
<context:component-scan base-package="com.code"/>
<!--aop的自动代理-->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

  7. 通知类型:通知的配置语法：@通知注解(“切点表达式")

    名称标签说明
    前置通知@Before用于配置前置通知。指定增强的方法在切入点方法之前执行
    后置通知@AfterReturning用于配置后置通知。指定增强的方法在切入点方法之后执行
    异常通知@AfterThrowing用于配置异常通知。指定增强的方法出现异常后执行
    最终通知@After用于配置最终通知。无论切入点方法执行时是否有异常，都会
    执行环绕通知@Around用于配置环绕通知。开发者可以手动控制增强代码在什么时候执行

  8. 当前四个通知组合在一起时，执行顺序：@Before -> @After -> @AfterReturning（如果有异常：@AfterThrowing）

  9. 纯注解配置

    package com.code.config;


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

@Configuration
@ComponentScan("com.code")
@EnableAspectJAutoProxy //开启AOP的自动代理 替代了<aop:aspectj-autoproxy>
public class SpringConfig {
}
努力转行的任同学...
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基础XML配置的AOP与基于注解实现的AOP详细对比
Rosen's
03-11 1454
aop思想通过动态代理，一定程度上实现了代码的解耦。我们可以将日志模块，权限校验，事物等模块，与核心的业务代码相隔离，让程序员在写代码的时候，能够更加专注于业务。 基于注解实现AOP步骤： ①将目标类与切面类都加入到ioc容器中。 目标类该用啥注解用啥，切面类通常用@Component即可。另外，记得在applicationContext.xml文件中配置包扫描。 ②为切面类标注@Aspect...
注解与 xml 实现aop哪种好_Spring 从入门到入土——AOP 就这么简单！| 原力计划
weixin_39970369的博客
10-21 227
作者| 冢狐责编 | 夕颜出品 | CSDN博客什么是AOP？面向切面编程(Aspect Oriented Programming)，通过预编译的方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生泛型，利用AOP可以对业务逻辑的各个部分进行隔离，从而使业务逻辑各个部分的耦合度降低，提高程序...
spring中基于xml和注解的AOP实现
智障小鲁班
11-03 1019
所谓AOP, 即指的事面向切面编程.AOP的优势主要在于在程序运行期间，可以实现在不修改源码的情况下对已有方法进行增强.AOP的本质其实使用的动态代理技术. AOP的XML配置 在resources下新建一个bean.xml的文件, 然后导入aop配置. <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://w...
使用AOP的另外两种方式-注解与xml结合和纯xml
m0_37166734的博客
08-19 336
1.注解与xml结合,后期web开发IOC用XML配置比较多，和AOP整合，自然用的比较多是注解与xml的方式。 1.用的还是AOP(一)文档里的吃饭的案例。需要改动的只是取消配置类EatConfig，在xml文件里生产Bean和开启切面代理。而切面类不用动，依然使用方便的注解方式。 2.测试 到此xml和注解结合实现aop的方式就结束了。 2.纯xml文件实现AOP(配置稍麻...
Spring--AOP，代理模式，基于注解的AOP和基于XML的AOP
weixin_43903745的博客
11-14 318
AOP，代理模式，基于注解的AOP和基于XML的AOP
spring中AOP 注解开发示例详解
08-31
在Spring框架中，AOP...总之，Spring AOP的注解开发使得切面的定义和应用更加简洁，无需编写XML配置。通过这种方式，我们可以更轻松地实现如日志记录、事务管理等跨功能的需求，从而提高代码的可维护性和模块化程度。
Spring使用AspectJ注解和XML配置实现AOP
09-01
本主题将深入探讨如何使用AspectJ注解和XML配置在Spring中实现AOP。 首先，我们要了解AOP的基本概念。AOP的核心是切面（Aspect），它将分散在多个对象中的横切关注点（如日志、性能监控）提取出来，形成独立的模块...
Spring用AspectJ开发AOP(基于Annotation)
08-25
文章指出，在Spring框架中，尽管可以使用XML配置文件来实现AOP开发，但是这种方式会导致XML配置文件过于臃肿，从而给维护和升级带来一定的困难。因此，AspectJ框架提供了基于Annotation的声明式方式来开发AOP。 在...
Spring 使用AspectJ 实现 AOP（基于xml文件、基于注解）
04-18
2. **@Before、@After等注解**: 在需要作为通知的方法上使用相应的AOP注解，如`@Before`、`@After`、`@Around`等。 3. **@Pointcut注解**: 定义切点表达式，可以在注解中直接写或引用其他方法。 4. **启用注解驱动的...
Spring AOP 基于注解详解及实例代码
10-19
在本篇内容中，我们将重点讨论Spring AOP如何通过注解实现，以及相关的实例代码。 首先，要启用Spring对@AspectJ注解的支持，我们需要在Spring配置文件中添加相应的XML配置。有两种方式： 1. 使用`<aop:aspectj-...
Spring基础学习(三)：基于XML和注解的AOP
Fortuneteller的博客
06-04 256
本文主要内容：基于XML和注解的AOP使用 AOP概念 AOP：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率 个人理解：就是把我们程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的基础上，对我们的已有方法进行增
Spring(八）基于xml的AOP实现
超级程序诞生的博客
08-08 228
基于xml与基于注解的AOP本质上是非常相似的，都是需要封装横切关注点，封装到切面中，然后把横切关注点封装为一个方法，再把该方法设置为当前的一个通知，再通过切入点表达式定位到横切点就可以了，思路是非常相似的。
生存期模型
Lucky_YanHao
04-08 5843
三、生存期模型 3.1 生存期模型选择 软件开发模型变迁： 作坊式–>过程控制–>敏捷–>DevOps等 从项目变化性和提交频率两个维度可将模型分为四个大类型： 预测型：提前进行大量的计划工作，然后一次性执行；执行是一个连续的过程。即预测模型是没有变更的。 迭代型(项目变化最高)：允许对未完成的工作进行反馈，从而改进和修改该工作。即迭代模型是通过不断反馈原型，改进产品。 增量型...
软件工程——软件生存期模型
TAO1031的博客
11-04 3603
软件是计算机系统中与硬件相互依存的另一个部分，包括程序、数据、及其相关文档的完整集合。其中，程序是按事先设计的功能和性能要求执行的指令序列；数据是使程序能够正确地处理信息的数据结构；文档是与程序开发、维护和使用有关的图文资料。也被称为软件过程模型，是从软件项目需求定义直至软件运行维护为止，跨越整个生命周期的系统开发、运行和维护所实施的全部过程、活动和任务的结构框架。1）阶段间具有顺序性和依赖性必须等前一阶段的工作完成之后，才能开启后一阶段的工作。前一阶段的输出文档就是后一阶段的输入文档。
基于XML配置以及基于注解开发AspectJ实现AOP
qq_41193133的博客
02-26 945
回顾：AOP通知类型以及基于代理类的AOP实现 AspectJ是基于java语言实现的AOP框架。使用AspectJ实现Spring AOP有两种方式：基于XML配置开发AspectJ 和 基于注解开发AspectJ。 基于XML配置开发AspectJ 基于XML配置是指 通过XML配置文件定义切面、切入点及通知，所有的定义必须在< aop:config>元素内完成。 元素名称...
软件项目管理-第三章生存期模型
千寻一见的博客
08-02 2556
生存模型 项目生存选择： 1.预测生存期模型：提前进行大量计划工作，然后一次性执行；执行是一个连续的过程。 瀑布模型：只能从上往下，不能返回。编码阶段不能修改需求和设计。 优点：管理方便，只需要严格控制项目的执行顺序。 缺点：项目的可变性无法适应瀑布模型的要求。 一般对需求很明确，且方案也很明确的项目使用，短期项目比较适应。 V模型是瀑布模型的一个变种，但强调测试与开发的利益关系，对系统性能、安全等有严格要求。 2.迭代型生存期模型：运行对未完成的工作进行反馈，从而改进和修改该工作。 原型模型：通过构
软件生存期模型介绍
09-04 507
软件生存期模型是跨越整个生存期的系统开发、运作和维护所实施的全部过程、活动和任务的结构框架 ~瀑布模型 瀑布模型规定了各项软件工程活动，包括制定开发计划、需求分析和说明、软件设计、程序编码、测试和运行、维护，并且规定了它们自上而下、相互衔接的固定次序，如同瀑布流水，逐级下落。 实践表明，上述各项活动之间并非完全是自上而下，呈线性图式。实际情况是，每项开发活动均应具有以下特征： （...
软件生存期模型
javasogo
08-02 374
软件生存期模型是跨越整个生存期的系统开发、运作和维护所实施的全部过程，活动和任务的结构框架. 一、下面介绍几种常见的软件生存期模型的优缺点，及其适用范围。 1、瀑布模型 瀑布模型将软件生命周期划分为制定计划、需求分析、软件设计、程序编写、软件测试和运行维护等六个基本活动，并且规定了它们自上而下、相互衔接的固定次序，如同瀑布流水，逐级下落。 优点： （1）为项目提供了按阶段划分...
【软件工程】生存期模型（含图）
随心更博
10-08 5978
为了反映软件生存周期内各个工作应如何组织，各阶段如何衔接，需要软件开发模型给出直观图示表达。软件开发模型是软件思想的具体化，是实施在过程模块中的软件开发方法和工具。  下面来介绍开发模型的特点以及他们的优缺点。 瀑布模型 核心思想是按工序开发软件，功能，设计与实现分开，各阶段分工协作。 结构化分析设计方法，逻辑实现和物理实现分开。 活动为：开发计划，需求分析和说明，设计，测试，运
spring aop 纯注解开发
最新发布
03-15
在Spring AOP中，纯注解开发是一种常见的方式，它通过使用注解来定义切面和切点，而不需要额外的XML配置文件。下面是纯注解开发Spring AOP的步骤： 1. 引入相关依赖：在项目的pom.xml文件中添加Spring AOP的相关...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值