Spring学习总结（九）：AspectJ 开发 AOP 的两种方式

最新推荐文章于 2024-09-10 16:52:56 发布
最新推荐文章于 2024-09-10 16:52:56 发布
阅读量627 收藏
点赞数
分类专栏： Spring学习 文章标签： spring java aop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47382783/article/details/112821681
版权

一、基于XML的声明式

       基于 XML 的声明式是指通过 Spring 配置文件的方式定义切面、切入点及声明通知，而所有的切面和通知都必须定义在 <aop:config> 元素中。

       步骤如下：

       （1）导入jar包。

   <!-- https://mvnrepository.com/artifact/org.springframework/spring-aop -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>5.2.6.RELEASE</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/aopalliance/aopalliance -->
    <dependency>
      <groupId>aopalliance</groupId>
      <artifactId>aopalliance</artifactId>
      <version>1.0</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.8.13</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjrt -->
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjrt</artifactId>
      <version>1.8.9</version>
    </dependency>

       （2）创建Book类

public class Book {
    public void addBook(){
        System.out.println("add Book……");
    }
    public void updateBook(){
        System.out.println("update Book……");
    }

}

       （3）创建BookProxy类

public class BookProxy {
    public void before(){
        System.out.println("before……");
    }
    public void after(){
        System.out.println("after……");
    }
    public void afterReturing(){
        System.out.println("afterReturing……");
    }
    public void afterThrowing(){
        System.out.println("afterThrowing……");
    }
    public void around(ProceedingJoinPoint point) throws Throwable {
        System.out.println("around  之前……");
        point.proceed();
        System.out.println("around  之后……");
    }
}

       （4）在bean.xml中进行bean配置和aop的配置。

    <!--  基于XML的AOP实现  -->
    <!--  配置bean  -->
    <bean id="book" class="com.yht.example6.Book"></bean>
    <bean id="bookProxy" class="com.yht.example6.BookProxy"></bean>
    <!-- aop配置   -->
    <aop:config>
        <!--
            expression : 配置切入点的具体位置
            id:切入点的id
         -->
        <aop:pointcut id="p1" expression="execution(* com.yht.example6.Book.*(..))"/>
        <!--    -->
        <aop:aspect ref="bookProxy">
            <aop:before method="before" pointcut-ref="p1"></aop:before>
            <aop:after method="after" pointcut-ref="p1"></aop:after>
            <aop:after-returning method="afterReturing" pointcut-ref="p1"></aop:after-returning>
            <aop:after-throwing method="afterThrowing" pointcut-ref="p1"></aop:after-throwing>
            <aop:around method="around" pointcut-ref="p1"></aop:around>
        </aop:aspect>
    </aop:config>

       （5）进行单元测试

    @Test
    public void testBook(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        Book book = context.getBean("book", Book.class);
        book.addBook();
    }

       执行结果如下：

 

二、基于注解的声明式

       在 Spring 中，尽管使用 XML 配置文件可以实现 AOP 开发，但是如果所有的相关的配置都集中在配置文件中，势必会导致 XML 配置文件过于臃肿，从而给维护和升级带来一定的困难。AspectJ 框架为 AOP 开发提供了另一种开发方式——基于 Annotation 的声明式。AspectJ 允许使用注解定义切面、切入点和增强处理，而 Spring 框架则可以识别并根据这些注解生成 AOP 代理。常用注解介绍如下：

名称说明
@Aspect用于定义一个切面
@Before用于定义前置通知，相当于BeforeAdvice
@AfterReturning用于定义后置通知，相当于AfterReturningAdvice
@Around用于定义环绕通知，相当于MethodInterceptor
@AfterThrowing用于定义异常抛出通知，相当ThrowAdvice
@After用于定义最终（final）通知，不管是否异常，该通知都会执行
@DeclareParents用于定义引介通知，相当于IntroductionInterceptor（了解）

       （1）在bean.xml中配置。

<!--  配置注解扫描的包  -->
    <context:component-scan base-package="com.yht.example6"></context:component-scan>
    <!--   
        通过aop命名空间的<aop:aspectj-autoproxy />声明自动为spring容器中那些配置@aspectJ切面的bean创建代理，织入切面。
     -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

       通过aop命名空间的<aop:aspectj-autoproxy />声明自动为spring容器中那些配置@aspectJ切面的bean创建代理，织入切面。在<aop:aspectj-autoproxy />有一个proxy-target-class属性，默认为false，如果proxy-target-class属值被设置为false或者这个属性被省略，那么标准的JDK 基于接口的代理将起作用。当配为<aop:aspectj-autoproxy  poxy-target-class="true"/>时，表示使用CGLib动态代理技术织入增强。不过即使proxy-target-class设置为false，如果目标类没有声明接口，则spring将自动使用CGLib动态代理。

       （2）创建User类

@Component
public class User {
    public void addUser(){
        System.out.println("添加用户");
    }
    public void updateUser(){
        System.out.println("修改用户");
    }
    public void deleteUser(){
        System.out.println("删除用户");
    }
    public void searchUser(){
        System.out.println("查找用户");
    }

}

       （3）创建UserProxy

@Component
@Aspect
public class UserProxy {
    @Before(value = "execution(* com.yht.example6.User.addUser(..))")
    public void before(){
        System.out.println("方法执行之前");
    }
    @After(value = "execution(* com.yht.example6.User.addUser(..))")
    public void after(){
        System.out.println("方法执行之后");
    }
    @AfterReturning(value = "execution(* com.yht.example6.User.addUser(..))")
    public void afterReturning(){
        System.out.println("返回后通知");
    }
    @AfterThrowing(value = "execution(* com.yht.example6.User.addUser(..))")
    public void afterThrowing(){
        System.out.println("抛出异常后通知");
    }
    @Around(value = "execution(* com.yht.example6.User.addUser(..))")
    public void around(ProceedingJoinPoint point) throws Throwable {
        System.out.println("环绕通知——方法执行之前");
        point.proceed();
        System.out.println("环绕通知——方法执行之后");
    }
}

       （4）进行单元测试。

    @Test
    public void testUser(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        User user = context.getBean("user", User.class);
        user.addUser();
    }

       执行结果如下：

几点说明：

       （1）afterThrowing方法是在程序出现异常时执行的，在User的addUser()让程序出现异常。检测该方法是否会执行。

    @AfterThrowing(value = "execution(* com.yht.example6.User.addUser(..))")
    public void afterThrowing(){
        System.out.println("抛出异常后通知");
    }

       制造一个NumberFormatException：

    public void addUser(){
        int val = Integer.parseInt("123ab");//异常
        System.out.println("添加用户");
    }

        结果如下：

（2）@Order的介绍

       @Order 注解用来声明组件的顺序，值越小，优先级越高，越先被执行/初始化。如果没有该注解，则优先级最低。对于上述代码，再添加一个PersonProxy类，给定@Order(1)，UserProxy给定@Order(5)，则执行结果PersonProxy的before方法会在UserProxy的before方法之前执行。

       1）定义PersonProxy类：

@Component
@Aspect
@Order(1)
public class PersonProxy {
    @Before(value = "execution(* com.yht.example6.User.addUser(..))")
    public void beforeMethod(){
        System.out.println("我是PersonProxy的before方法");
    }
}

       2） 给UserProxy添加@Order(5)：

       3）进行测试。得到结果如下：

       （3）相同切入点的提取

       在上面的例子中，UserProxy中的五种通知的配置，它们的切入点表达式是相同的，我们可以将其提取出来，然后在每个通知的注解中引用即可。所以UserProxy类就如下面：

@Component
@Aspect
@Order(5)
public class UserProxy {
    
    @Pointcut(value = "execution(* com.yht.example6.User.addUser(..))")
    public void commonMsg(){}
    
    @Before(value = "commonMsg()")
    public void before(){
        System.out.println("方法执行之前");
    }
    @After(value = "commonMsg()")
    public void after(){
        System.out.println("方法执行之后");
    }
    @AfterReturning(value = "commonMsg()")
    public void afterReturning(){
        System.out.println("返回后通知");
    }
    @AfterThrowing(value = "commonMsg()")
    public void afterThrowing(){
        System.out.println("抛出异常后通知");
    }
    @Around(value = "commonMsg()")
    public void around(ProceedingJoinPoint point) throws Throwable {
        System.out.println("环绕通知——方法执行之前");
        point.proceed();
        System.out.println("环绕通知——方法执行之后");
    }
}

       最终得到的结果和前面也将是一样的。

       （4）AOP纯注解开发 

       AOP纯注解开发 和IOC注解开发基本类似，提供一个配置类。加入注解：

@Configuration
@ComponentScan(basePackages = "com.yht.example6")
//@EnableAspectJAutoProxy标记在主配置类上，表示开启基于注解的aop模式
@EnableAspectJAutoProxy
public class AopConfig {
}

测试如下：

    @Test
    public void testUserAnno(){
        ApplicationContext context = new AnnotationConfigApplicationContext(AopConfig.class);
        User user = context.getBean("user", User.class);
        user.addUser();
    }

 

姚舜禹_12140
关注
专栏目录
Spring AOP的两种实现
gaishi_hero的博客
02-21 252
文章目录注解方式实现AOPxml方式实现AOP Spring AOP有两种实现方式，一种是基于注解的，另一种是基于xml的。 注解方式实现AOP 首先介绍基于注解的实现方式，实现需要有切面类和连接点两个主要的东西。切面类定义了在执行要拦截方法前后执行的方法。而连接点就是指要拦截的方法。 连接点printRole()，首先定义一个接口： public interface RoleService ...
【aop】AOP实现的两种方式：Spring AOP 和 AspectJ
engineer_hzl
01-07 405
AOP AOP（Aspect Oriented Programming），即面向切面编程，可以说是OOP（Object Oriented Programming，面向对象编程）的补充和完善。OOP引入封装、继承、多态等概念来建立一种对象层次结构，用于模拟公共行为的一个集合。不过OOP允许开发者定义纵向的关系，但并不适合定义横向的关系，例如日志功能。日志代码往往横向地散布在所有对象层次中，而与它对
Spring的aspectj的AOP操作
最新发布
bishe361的博客
09-10 881
（1）execution(*com.cn.aop.Book.add(..)) *代表任意修饰符 ..代表任何参数。execution(<访问修饰符>?<返回类型><方法名>（<参数>）<异常>)(4) 匹配所有save开头的方法 execution(*save*(..))1.切入点：实际增强的方法。使用表达式配置切入点。
Spring系列之AOP实现的两种方式
weixin_34102807的博客
10-24 667
AOP常用的实现方式有两种，一种是采用声明的方式来实现（基于XML），一种是采用注解的方式来实现（基于AspectJ）。 首先复习下AOP中一些比较重要的概念： Joinpoint（连接点）：程序执行时的某个特定的点，在Spring中就是某一个方法的执行 。Pointcut（切点）：说的通俗点，spring中AOP的切点就是指一些方法的集合，而这些方法是需要被增强、被代理的。一般都是按照一定的...
springboot进阶学习（九）springboot常见注解详解
牛魔王的专栏
07-07 356
springboot常见注解详解 springboot中的注解很多很多，我们不一一说明，就把常见的讲解下就行，遇到不常见的到时候再查资料就可以了。 启动类中的注解 @SpringBootApplication：该注解用在启动类上面，是springboot最核心注解，也是组合注解，他包含下面几个注解 @SpringBootConfiguration：继承自@Configuration，@SpringBootConfiguration是来声明当前类是SpringBoot应用的配置类，项目中只能有一个 @En
Spring实现AOP的4种方式
08-27 2413
Spring实现AOP的4种方式
aspectj实现aop的两种操作
lcn_Lynn的博客
10-12 681
aspectj实现aop的两种操作 1-配置方式 <!--method：增强类里面使用那个方法作为前置 ，其实就是用增强类中哪个方法来增强被增强的类 pointcut-ref:指定方法用到哪个切入点 -->
Spring 使用AspectJ 实现 AOP（基于xml文件、基于注解）
04-18
Spring支持两种方式集成AspectJ：编译时织入（使用ajc编译器）和运行时织入（使用Spring代理）。运行时织入更灵活，不需要改变原有的编译过程，但可能性能稍逊。 **五、AspectJ的切点表达式** AspectJ提供了一种...
Spring框架(6)AspectJ实现AOP共7页.pd
10-30
Spring支持三种方式来实现AOP：基于代理的AOP、基于注解的AOP和基于AspectJ的AOP。本资料“Spring框架(6)AspectJ实现AOP共7页.pdf”将重点介绍基于AspectJ的AOP实现。 首先，AspectJ的引入需要添加相应的库到项目中...
spring和aspectj的aop实验
07-30
Spring AOP主要通过代理模式实现，有接口代理和CGLIB代理两种方式。接口代理适用于实现了接口的目标对象，而CGLIB代理则用于未实现接口的对象。在Spring中，我们可以通过注解或XML配置来定义切面和通知。 3. **...
深入探析切面编程：解密 AspectJ 与 Spring AOP 的 AOP 魔法
m0_71777195的博客
08-22 688
这个表格总结了AspectJ和Spring AOP在不同方面的区别。特性/方面AspectJSpring AOP实现方式独立的切面编程框架，扩展了Java语法Spring框架的一部分，基于动态代理和字节码增强技术功能复杂性提供更高级的切面编程能力，支持复杂的切面逻辑更专注于常见的切面功能，适用于简单的切面逻辑依赖性独立使用，需要AspectJ编译器或插件与Spring框架集成，依赖于Spring框架织入方式支持编译时织入和运行时织入。
AOP及事务代码示例
03-29
AOP及事务代码示例，包含数据库，可运行。。。。，，，，，
spring aop两种配置方式
09-03
总结：Spring AOP提供了两种配置方式，分别是注解配置和XML配置。注解配置更加简洁、直观，适合简单的切面定义；而XML配置则更为灵活，适用于复杂的场景，可以精细控制通知的顺序和作用域。在实际开发中，可以根据...
使用aspectJ实现Spring AOP的两种方式
weixin_34401479的博客
10-17 160
方式一:基于aspectJ的XML配置 方式二:基于aspectJ的注解方式 基于aspectJ的XML配置 1) 引入相关jar包 2) 创建Spring核心配置文件,必须导入aop的约束 <?xml version="1.0" encoding="UTF-8"?><beans xmlns="h...
两种方式开发AspectJ
nuist_NJUPT的博客
06-14 531
两种方式开发AspectJ AspectJ一个基于Java语言的AOP框架，建议开发者使用AspectJ实现AOP 使用AspectJ实现AOP有两种方式 1-基于XML配置开发AspectJ 2-基于注解开发AspectJ 基于XML配置开发AspectJ是指通过XML配置文件定义切面，切入点及通知 所有这些定义都必须在aop:config元素内， aop:config:开发AspectJ顶层配置元素，配置文件beans下可以包含多个该元素 <aop：aspect>
Spring基础学习（九）——基于AspectJ的两种AOP实现方式
cc_梅
02-04 370
AspectJ实现AOP的区别：aop联盟定义通知类型具有特性接口，必须实现相应的接口，从而确定方法名称。  Aspectj 通知类型只定义类型名称以及方法格式，不用实现接口。 AspectJ的通知类型：        before:前置通知(应用：各种校验）   在方法执行前执行，如果通知抛出异常，阻止方法运行        afterReturning:后置通知(应用：常规数据处理) 
Aop的三种开发方式
weixin_73399088的博客
03-28 280
Aop：再不改变原代码的基础上，无入侵的增加额外功能。 介绍了三种AOP的开发方式
Spring AOP编程(两种:1,传统的AOP切面编程 2,基于aspectj框架切点传统开发)
反正我不管，就爱陈旭员
08-13 604
Spring AOP编程(两种:1,传统的AOP切面编程  2,基于aspectj框架切点传统开发) 第一种,Spring传统AOP编程开发 在传统的spring aop中有5种对类中方法的增强 1,前置通知   在目标方法之前来执行对类中方法的增强 2,后置通知   在目标方法执行之后来执行方法增强 3,环绕通知   在目标方法执行前后抛出方法的增强 4,异常抛出
aop事物控制小案例
ss123mlk的博客
05-07 152
基于xml配置 1.导包 spring-context spring-test junit mysql aspectweaver 2.bean.xml中 aop约束 dao对象 service对象 datasource对象 transactionManager对象 配置aop 基于注解的aop配置 在bean.xml中放入context约束 写上要扫描的包context-scan pa...
AspectJ：Spring AOP 实现与概念解析
此外，AspectJ提供了编译时和运行时两种织入方式，编译时织入可以在源代码级别集成切面，而运行时织入则在类加载时完成。这使得AspectJ可以在不修改原始代码的情况下实现切面功能。 总结来说，AspectJ为Java开发者...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值