Spring的基于AspectJ的AOP开发

最新推荐文章于 2022-03-04 15:28:05 发布
最新推荐文章于 2022-03-04 15:28:05 发布
阅读量155 收藏
点赞数
分类专栏： Java 文章标签： spring aop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/accadda2/article/details/108876081
版权

Spring的基于AspectJ的AOP开发

1、AspectJ简介

  • AspectJ是一个基于Java语言的AOP框架
  • 使用AspectJ需要导入Spring AOP和AspectJ相关jar包
    • spring-aop-4.2.4.RELEASE.jar
    • com.springsource.org.aopalliance-1.0.0.jar
    • spring-aspects-4.2.4.RELEASE.jar
    • com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar

2、基于AspectJ的注解方式的AOP开发

1、准备工作：

  1. 创建项目

  2. 配置jar包

    <!--引入Spring的基本开发包-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>4.2.4.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>4.2.4.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>4.2.4.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-expression</artifactId>
      <version>4.2.4.RELEASE</version>
    </dependency>

    <!--aop-->
    <dependency>
      <groupId>aopalliance</groupId>
      <artifactId>aopalliance</artifactId>
      <version>1.0</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>4.2.4.RELEASE</version>
    </dependency>

    <!--aspectj开发的jar包-->
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.8.9</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aspects</artifactId>
      <version>4.2.4.RELEASE</version>
    </dependency>

    <!--spring整合单元测试的jar包-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>4.2.4.RELEASE</version>
    </dependency>

  3. 在 applicationContext.xml中开启AspectJ的注解开发

applicationContext.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">

    <!--==========开启AspectJ的注解开发，自动代理==========-->
    <aop:aspectj-autoproxy/>
</beans>

2、通知的类型介绍

@AspectJ提供不同的通知类型：

  • @Before 前置通知（增强），相当于BeforeAdvice 例：登陆前验证
  • @AfterReturning 后置通知，相当于AfterReturningAdvice 例：删除后显示日至记录
  • @Around 环绕通知，相当于 MethodInterceptor 例：进行事务管理时 （可以阻止目标方法执行）
  • @AfterThrowing 异常抛出通知，相当于ThrowAdvice
  • @After 最终final通知，不管是否异常，该通知都会执行

3、切入点表达式的定义

在通知中通过value属性定义切点

  • 通过execution函数，可以定义切点的方法切入

  • 语法： 访问修饰符 可以不写

    • execution（<访问修饰符>？<返回类型><方法名>（<参数>）<异常>）

  • 例如：

    • 匹配所有类 public 方法 execution(public * *(…))

    • 匹配指定包下所有类方法 execution(* com.tao.dao.*(…)) 不包含子包

    • execution(* com.tao.dao…*(…)) 表示包、子孙包下所有类

    • 匹配指定类所有方法 execution(* com.tao.service.UserService.*(…))

    • 匹配实现特定接口所有类的方法

      execution(* com.tao.dao.GenericDao+.*(…))

    • 匹配所有 save 开头的方法 execution(* save*(…))

定义切面类
/**
 * 切面类
 */
@Aspect
public class MyAspectAnno {
    @Before(value = "execution(* com.tao.aspectJ.demo1.ProductDao.save(..))")
    public void before(){
        System.out.println("前置通知=====");
    }
}

4、@Before前置通知

  • 可以在方法中传入JoinPoint对象，用来获得切点信息
@Before(value = "execution(* com.tao.aspectJ.demo1.ProductDao.save(..))")
    public void before(JoinPoint joinPoint){
        System.out.println("前置通知=====" + joinPoint);
    }

5、@AfterReturing 后置通知

  • 通过returning属性可以定义方法返回值，作为参数
@AfterReturning(value = "execution(* com.tao.aspectJ.demo1.ProductDao.update(..))",returning = "result")
    public void afterReturing(Object result){
        //Object中的result需要与returning = "result"中的一致
        System.out.println("后置通知=====" + result);
    }

6、@Around 环绕通知

  • around 方法的返回值就是目标代理方法执行返回值

  • 参数为 ProceedingJoinPoint 可以调用拦截目标方法执行，可以阻止目标方法执行

  • 重点∶如果不调用 ProceedingJoinPoint 的proceed方法，那么目标方法就被拦截了

    @Around(value = "execution(* com.tao.aspectJ.demo1.ProductDao.delete(..))")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("环绕前通知=======");
        Object obj = joinPoint.proceed();//执行目标方法
        System.out.println("环绕后通知=======");
        return obj;
    }

7、@After Throwing 异常抛出通知

  • 通过设置 throwing 属性，可以设置发生异常对象参数
//出现异常时才会产生通知
@AfterThrowing(value = "execution(* com.tao.aspectJ.demo1.ProductDao.findOne(..))",throwing = "e")
    public void afterThrowing(Throwable e){
        //Throwable 中的 e 要与 throwing = "e"中的 e 一致
        System.out.println("异常抛出通知=========" + e.getMessage());
    }

8、@After 最终通知

  • 无论是否出现异常,最终通知总是会被执行的 ==》 相当于finally
@After(value = "execution(* com.tao.aspectJ.demo1.ProductDao.findAll(..))")
    public void after(){
        System.out.println("最终通知=========");
    }

9、通过@Pointcut为切点命名

  • 在每个通知内定义切点，会造成工作量大，不易维护，对于重复的切点，可以使用 @Pointcut 进行定义
  • 切点方法：private void 无参数方法，方法名为切点名
  • 当通知多个切点时，可以使用 || 进行连接
/**
 * 切面类
 */
@Aspect
public class MyAspectAnno {

    @Before(value = "myPointcut1()")
    public void before(JoinPoint joinPoint){
        System.out.println("前置通知=====" + joinPoint);
    }

    @AfterReturning(value = "myPointcut2()",returning = "result")
    public void afterReturing(Object result){
        //Object中的result需要与returning = "result"中的一致
        System.out.println("后置通知=====" + result);
    }

    @Around(value = "myPointcut3()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("环绕前通知=======");

        Object obj = joinPoint.proceed();//执行目标方法

        System.out.println("环绕后通知=======");

        return obj;
    }

    @AfterThrowing(value = "myPointcut4()",throwing = "e")
    public void afterThrowing(Throwable e){
        System.out.println("异常抛出通知=========" + e.getMessage());
    }

    @After(value = "myPointcut5()")
    public void after(){
        System.out.println("最终通知=========");
    }

    @Pointcut(value = "execution(* com.tao.aspectJ.demo1.ProductDao.save(..))")
    private void myPointcut1(){ }

    @Pointcut(value = "execution(* com.tao.aspectJ.demo1.ProductDao.update(..))")
    private void myPointcut2(){ }

    @Pointcut(value = "execution(* com.tao.aspectJ.demo1.ProductDao.delete(..))")
    private void myPointcut3(){ }

    @Pointcut(value = "execution(* com.tao.aspectJ.demo1.ProductDao.findOne(..))")
    private void myPointcut4(){ }

    @Pointcut(value = "execution(* com.tao.aspectJ.demo1.ProductDao.findAll(..))")
    private void myPointcut5(){ }
}

2、基于AspectJ的XML方式的AOP开发

1、环境搭建

  1. 创建项目
  2. 引入jar包
  3. 创建配置文件 applicationContext.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">
    <!--XML的配置方式完成AOP的开发==========-->
    <!--配置目标类-->
    <bean id="cunsomerDao" class="com.tao.aspectJ.demo2.CustomerDaoImpl"/>   
</beans>

2、使用XML配置切面类

  • 编写切面类

    /**
 * 切面类
 */
public class MyAspectXml {

    //前置通知
    public void before(JoinPoint joinPoint) {
        System.out.println("XML方式的前置通知===========" + joinPoint);
    }

    //后置通知
    public void afterReturing(Object result) {
        System.out.println("XML方式的后置通知===========" + result);
    }

    //环绕通知
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("环绕前通知===========");
        Object obj = joinPoint.proceed();
        System.out.println("环绕后通知===========");
        return obj;
    }

    //异常抛出通知
    public void afterThrowing(Throwable e){
        System.out.println("XML方式的异常抛出通知===========" + e.getMessage());
    }

    //最终通知
    public void after(){
        System.out.println("XML方式的最终通知===========");
    }
}

  • 完成切面类的配置

    <!--配置切面类-->
    <bean id="myAspectXml" class="com.tao.aspectJ.demo2.MyAspectXml"/>

  • 配置AOP完成增强

    <!--aop的配置-->
    <aop:config>
        <!--配置切入点:哪些类的哪些方法需要增强-->
        <aop:pointcut id="pointcut1" expression="execution(* com.tao.aspectJ.demo2.CustomerDao.save(..))"/>
        <aop:pointcut id="pointcut2" expression="execution(* com.tao.aspectJ.demo2.CustomerDao.update(..))"/>
        <aop:pointcut id="pointcut3" expression="execution(* com.tao.aspectJ.demo2.CustomerDao.delete(..))"/>
        <aop:pointcut id="pointcut4" expression="execution(* com.tao.aspectJ.demo2.CustomerDao.findOne(..))"/>
        <aop:pointcut id="pointcut5" expression="execution(* com.tao.aspectJ.demo2.CustomerDao.findAll(..))"/>

        <!--配置AOP的切面-->
        <aop:aspect ref="myAspectXml">
            <!--配置前置通知-->
            <aop:before method="before" pointcut-ref="pointcut1"/>
            <!--配置后置通知-->
            <aop:after-returning method="afterReturing" pointcut-ref="pointcut2" returning="result"/>
            <!--配置环绕通知-->
            <aop:around method="around" pointcut-ref="pointcut3"/>
            <!--配置异常抛出通知-->
            <aop:after-throwing method="afterThrowing" pointcut-ref="pointcut4" throwing="e"/>
            <!--配置最终通知-->
            <aop:after method="after" pointcut-ref="pointcut5"/>
        </aop:aspect>
    </aop:config>
原来是涛涛啊
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring-AOP 面向切面(AspectJ)
Crayon的博客
05-18 270
SpringAOP 架构 与AspectJ 混用---------------常用 使用AspectJ 实现AOP 所依赖的jar包 除spring基本包之外 还应添加 <dependency> <groupId>org.springframework</groupId> <artifactId>spring-aop</art...
com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar
02-07
spring 前置通知的相关jar包, 包括 com.springsource.org.aopalliance-1.0.0.jar 和 com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar
spring @AfterReturning 返回值
weixin_38312502的博客
03-04 7877
@AfterReturning是用于做aop的，其中返回值的问题，坑了我比较久，特地写出来。 1. 正确的使用 @AfterReturning(value = "pointCut()", returning = "obj") public Object doAfterReturning(JoinPoint joinPoint, Object obj) { // 正常情况下，我们想要修改obj，只需要强转为对应的对象，再重新设置值即可，如下 User user = (User)obj;
aspectJ切面包
04-21
aspectJ切面包 aspectj-1.6.10.jar包用于安装aspectj插件。 安装： 1、进入aspectj文件所在的路径，输入命令： java –jar aspectj-1.6.10.jar 出现安装界面后，选择JDK的安装路径。 2、安装完成后将bin路径添加到PATH环境变量中， 将lib\aspectjrt.jar添加到CLASSPATH环境变量中 3、将安装目标下lib文件夹中 aspectjrt.jar ; aspectjweaver.jar 添加入项目lib目录
Spring AOP基于@AspectJ注解的切面
浅然的专栏
05-07 2万+
该篇博客讲述基于AspectJ的注解方式实现AOP切面，关于AOP的一些概念性问题可以转战https://blog.csdn.net/w_linux/article/details/80194768 该篇博客主要阐述 1、编写切点(@Pointcut) 2、基于AspectJ的注解方式实现日志打印 3、环绕通知用法 4、JoinPoint用法 一、编...
Spring用AspectJ开发AOP(基于Annotation)
08-25
Spring用AspectJ开发AOP(基于Annotation) 作为一名IT行业大师，我将详细介绍Spring用AspectJ开发AOP(基于Annotation)，并对标题、描述、标签和部分内容进行详细解释。 标题: Spring用AspectJ开发AOP(基于...
Spring AspectJ AOP框架注解原理解析
09-07
Spring AspectJ AOP框架注解是Spring框架中实现面向切面编程(AOP)的一种方式，它结合了AspectJ的强大功能和Spring的易用性。AspectJ是一个独立的AOP框架，它为Java提供了专门的语法和编译器来处理切面。Spring 2.0...
spring和aspectj的aop实验
07-30
Spring框架是Java开发中广泛使用的轻量级容器，它不仅支持依赖注入，还提供了AOP功能。AspectJ则是一个独立的AOP框架，它提供了更强大和灵活的切面实现方式，可以直接编译源代码或字节码来织入切面。 标题"spring和...
基于AspectJ的AOP开发案例源码.rar
06-27
aspectj的Aop开发的入门学习案例 demo1是aspectj的Aop开发，用于用户是否登录的验证，使用注解来实现，在切面类中配置好切入点。优点：方便快捷 demo2是aspectj的Aop开发，用于用户是否登录的验证，在xml中配置好切...
Spring 使用AspectJ 实现 AOP
04-18
Spring 框架是Java开发中的一个核心组件，它提供了许多功能，其中之一就是面向切面编程（AOP）。AOP是一种编程范式，允许开发者将关注点从业务逻辑中分离出来，比如日志记录、事务管理等。在Spring中，我们可以使用...
注入AspectJ切面
stay hungry ! stay foolish!
05-09 231
如果在执行通知时，切面依赖一个或多个类，我们可以在切面内部实例化这些协作的对象。但更好的方式是，借助Spring的依赖注入把bean装配到AspectJ期末中。 通常情况下，Spring bean由Spring容器初始化，但是Aspect切面是由AspectJ在运行期创建的。等到Spring有机会为Aspect注入bean时，Aspect已经被实例化了。 因为Spring不能负责创建Aspect，那就不能在Spring中简单地把创建的Aspect声明为一个bean。相反，我们需要一种方式为Spring获得已
AspectJ切面简介
Mark_Li
04-08 1346
1 采用AspectJ模拟事务提交定义AspectJ的步骤如下1.采用注解标@AspectJ标注对应的类2.采用注解声明切点3.实现增强声明接口public interface IOrders { public List&lt;Orders&gt; queryAllOrders() throws Exception; public Orders queryOrder(int i...
Spring Aspect切面类的使用
YyyyyyT的博客
01-12 8091
最近的做的一个功能是在用户插入数据的时候插入拿到所有每个字段，遍历这些字段，插入痕迹表中。还有更新了哪个字段，就要从数据库中拿出数据将以前的字段数据和现在的字段数据做对比，并插入痕迹表。 要处理这个很简单，直接复制一个新的别表，作为历史表，插入数据的时候在插入这个表，这不是很简单吗？ 不不不，我要处理20多个模块，这个不太现实，主要有3个原因：      1、代码冗余，重复量多。     ...
Spring Mvc面向切面(AOP)
JerryBal的博客
04-11 1652
AOP? 基本概念 切面(aspect)：横切关注点被模块化的特殊对象。 通知(advice)：切面必须要完成的工作。切面中的每个方向称之为通知。通知是在切面对象中的。 目标(target)：被通知的对象。 代理(proxy)：向目标对象应用通知后创建的对象。 连接点（joinpoint）：目标对象的程序执行的某个特定位置。如某个方法调用前，调用后的位置。包括两个信息：1.目标程序的哪个方法？2...
Spring 之AOP AspectJ切入点语法详解（最全面、最详细。）
热门推荐
zhengchao1991的博客
11-29 9万+
6.5 AspectJ切入点语法详解 6.5.1 Spring AOP支持的AspectJ切入点指示符 切入点指示符用来指示切入点表达式目的，，在Spring AOP中目前只有执行方法这一个连接点，Spring AOP支持的AspectJ切入点指示符如下： execution：用于匹配方法执行的连接点； within：用于匹...
spring aop的@Before,@Around,@After,@AfterReturn,@AfterThrowing的理解
万米高空的博客
09-29 3万+
aop的这几个注解的使用非常常见，但是他们的执行顺序，以及作为我们进入核心代码前的校验，是如何在校验失败不然他进入核心方法的？博客上确实有不少讲解的很详细，我在结尾也会推荐几篇。这里就几个重要的点和不明的点做下说明，前事不忘后事之师！ 1.AOP的基本概念切面（Aspect） ：通知(advice)和切入点(pointcut)共同组成了切面(aspect)，时间、地点和要发生的“故事”。可以从注解方
深入理解面向切面的编程AOP、AspectJ、Spring
我的专栏
12-07 3630
Spring：是一个开源框架，Spring是于2003 年兴起的一个轻量级的Java 开发框架。Spring提供的AOP功能，方便进行面向切面的编程，许多不容易用传统OOP实现的功能可以通过AOP轻松应付。 AspectJ：是一个面向切面的框架，它扩展了Java语言。AspectJ定义了AOP语法，所以它有一个专门的编译器用来生成遵守Java字节编码规范的Class文件. 一、AOP介
Spring切面编程-使用AspectJ日志处理
持之以恒
10-21 573
1、背景：AspectJ作为AOP一大应用已经广为人知了，具体的应用场景也很多，如：日志处理、执行目标方法前做逻辑判断、事物控制等等；其实质大都是抽取出各类、方法中重复的、与业务逻辑无关的代码，形成一个切面（Aspect， 也就是一个类），在切面中定义切点（可以理解为将代码织入到那些 我从方法中提取出重复代码的位置处，一个切点可能包含多个连接点）、连接点（也就是切点的一个具体）、通知等，这个一来就...
AOP切面编程之Aspect框架
qq_45979629的博客
07-01 962
什么叫Aspect？ AspectJ是一个基于Java语言的AOP框架 Spring2.0以后新增了对AspectJ切点表达式支持 @AspectJ 是AspectJ1.5新增功能，通过JDK5注解技术，允许直接在Bean类中定义切面 新版本Spring框架，建议使用AspectJ方式来开发AOP 主要用途：自定义开发 Aspect通知类型 aop联盟定义通知类型，具有特性接口，必须实现，从而确定方法名称。 aspectj 通知类型，只定义类型名称。已经方法格式。 before:前置通知(应用：各种校验)
spring aop 和 AspectJ aop 有什么不同
最新发布
02-27
Spring AOP和AspectJ AOP是两种不同的AOP面向切面编程）实现方式。 1. Spring AOP是Spring框架提供的一种轻量级AOP实现，它基于代理模式来实现AOP。Spring AOP只支持方法级别的连接点（Join Point），并且只能在Spring管理的Bean上应用切面。它使用动态代理技术，在运行时生成代理对象，并将切面逻辑织入到目标对象的方法中。 2. AspectJ AOP是一个独立的AOP框架，它提供了更强大和灵活的AOP功能。AspectJ AOP支持更多的连接点类型，包括方法、构造函数、字段等，可以在任何Java类上应用切面。它使用静态织入技术，在编译时或者类加载时将切面逻辑织入到目标类中。 因此，主要的不同点如下： - 连接点支持：Spring AOP只支持方法级别的连接点，而AspectJ AOP支持更多类型的连接点。 - 织入方式：Spring AOP使用动态代理，在运行时生成代理对象并织入切面逻辑；AspectJ AOP使用静态织入，在编译时或者类加载时将切面逻辑织入目标类。 - 依赖关系：Spring AOP依赖于Spring框架，只能在Spring管理的Bean上应用切面；AspectJ AOP是一个独立的框架，可以在任何Java类上应用切面。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值