aop之AspectJ学习

最新推荐文章于 2024-09-10 18:11:18 发布
最新推荐文章于 2024-09-10 18:11:18 发布
阅读量319 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36697880/article/details/80977851
版权

一、  介绍

l  AspectJ是一个基于Java语言的AOP框架

l  Spring2.0以后新增了对AspectJ切点表达式支持

l  @AspectJ 是AspectJ1.5新增功能，通过JDK5注解技术，允许直接在Bean类中定义切面

新版本Spring框架，建议使用AspectJ方式来开发AOP

l  主要用途：自定义开发


二、  切入点表达式【掌握】

1.execution()  用于描述方法【掌握】

       语法：execution(修饰符 返回值  包.类.方法名(参数) throws异常)

              修饰符，一般省略

                     public            公共方法

                     *                   任意

              返回值，不能省略

                     void               返回没有值

                     String            返回值字符串

                     *                  任意

              包，[省略]

                     com.itheima.crm                  固定包

                     com.itheima.crm.*.service     crm包下面子包任意（例如：com.itheima.crm.staff.service）

                     com.itheima.crm..                crm包下面的所有子包（含自己）

                     com.itheima.crm.*.service..   crm包下面任意子包，固定目录service，service目录任意包

              类，[省略]

                     UserServiceImpl                  指定类

                     *Impl                                  以Impl结尾

                     User*                                  以User开头

                     *                                        任意

              方法名，不能省略

                     addUser                               固定方法

                     add*                                          以add开头

                     *Do                                    以Do结尾

                     *                                        任意

              (参数)

                     ()                                        无参

                     (int)                                    一个整型

                     (int,int)                              两个

                     (..)                                      参数任意

              throws,可省略，一般不写。

 

综合1

       execution(* com.itheima.crm.*.service..*.*(..))

综合2

       <aop:pointcutexpression="execution(* com.itheima.*WithCommit.*(..)) ||

                          execution(* com.itheima.*Service.*(..))"id="myPointCut"/>

2.within:匹配包或子包中的方法(了解)

       within(com.itheima.aop..*)

3.this:匹配实现接口的代理对象中的方法(了解)

       this(com.itheima.aop.user.UserDAO)

4.target:匹配实现接口的目标对象中的方法(了解)

       target(com.itheima.aop.user.UserDAO)

5.args:匹配参数格式符合标准的方法(了解)

       args(int,int)

6.bean(id) 对指定的bean所有的方法(了解)

       bean('userServiceId')

三、  AspectJ 通知类型

l  aop联盟定义通知类型，具有特性接口，必须实现，从而确定方法名称。

l  aspectj 通知类型，只定义类型名称。已经方法格式。

l  个数：6种，知道5种，掌握1中。

       before:前置通知(应用：各种校验)

              在方法执行前执行，如果通知抛出异常，阻止方法运行

       afterReturning:后置通知(应用：常规数据处理)

              方法正常返回后执行，如果方法中抛出异常，通知无法执行

              必须在方法执行后才执行，所以可以获得方法的返回值。

       around:环绕通知(应用：十分强大，可以做任何事情)

              方法执行前后分别执行，可以阻止方法的执行

              必须手动执行目标方法

       afterThrowing:抛出异常通知(应用：包装异常信息)

              方法抛出异常后执行，如果方法没有抛出异常，无法执行

       after:最终通知(应用：清理现场)

              方法执行完毕后执行，无论方法中是否出现异常

环绕

 

try{

     //前置：before

    //手动执行目标方法

    //后置：afterRetruning

} catch(){

    //抛出异常 afterThrowing

} finally{

    //最终 after

}

 

四、  导入jar包

l  4个：

       aop联盟规范

       springaop 实现

       aspect规范

       springaspect 实现

 

五、  基于xml的实现

1.目标类：接口 + 实现

2.切面类：编写多个通知，采用aspectj 通知名称任意（方法名任意）

3.aop编程，将通知应用到目标类

4.测试

 

5.1   切面类

/**

 * 切面类，含有多个通知

 */

publicclass MyAspect {

   

    publicvoid myBefore(JoinPoint joinPoint){

        System.out.println("前置通知： " + joinPoint.getSignature().getName());

    }

   

    publicvoid myAfterReturning(JoinPoint joinPoint,Object ret){

        System.out.println("后置通知： " + joinPoint.getSignature().getName() + " , -->" + ret);

    }

   

    public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable{

        System.out.println("前");

        //手动执行目标方法

        Object obj = joinPoint.proceed();

       

        System.out.println("后");

        return obj;

    }

   

    publicvoid myAfterThrowing(JoinPoint joinPoint,Throwable e){

        System.out.println("抛出异常通知： " + e.getMessage());

    }

   

    publicvoid myAfter(JoinPoint joinPoint){

        System.out.println("最终通知");

    }

 

}

 

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


      <!-- 创建目标类 -->      
      <bean id="userService" class="com.nari.service.impl.UseServiceImpl"></bean>
        <!-- 创建切面类 --> 
      <bean id="myAspectBean" class="com.nari.c_springAop.MyAspectXml"></bean>
      
      <aop:config>
        <aop:aspect ref="myAspectBean">
          <aop:pointcut expression="execution(* com.nari.service.*impl.*.*(..))" id="myPointCut"/>
          <!-- 前置通知
              <aop:before method="myBefore" pointcut-ref="" pointcut=""/>
                  method:通知，及方法名
                  pointcut:切入点表达式 此表达式只能当前通知使用，这个不是必填项
                  pointcut-ref: 切入点引用，可以与其他通知共享切入点。
                                         通知方法里面的参数org.aspectj.lang.JoinPoint; 用来描述连接点（目标方法）
           -->
          <aop:before method="myBefore" pointcut-ref="myPointCut" />
          
          <!-- 后置通知，after-returning 目标方法正常执行后执行的 
             <aop:after-returning method="myAfterReturning" pointcut-ref="myPointCut" returning="obj"/>
             returning 通知方法的第二个参数名称
             public void myAfterReturning(JoinPoint joinPoint,Object obj)
                                          参数一:描述连接点
                                       参数二：类型必须是Object,参数名returning配置 为目标方法的放回值
             
             
          -->
          <aop:after-returning method="myAfterReturning" pointcut-ref="myPointCut" returning="obj"/>
          
          <!-- 环绕通知
          <aop:around method="myAround"  pointcut-ref="myPointCut"/>
          public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable
                            通知方法的放回类型必须是Object 
                           入参必须是 ProceedingJoinPoint类型的
                           必须抛出异常throws Throwable
          
           -->
           <aop:around method="myAround"  pointcut-ref="myPointCut"/>
           
           <!-- 抛出异常通知 
              <aop:after-throwing method="myAfterThrowing" pointcut-ref="myPointCut" throwing="e"/>
              throwing="e" 为通知方法的第二个参数的参数名称
              public void myAfterThrowing(JoinPoint joinPoint,Throwable e)
                                   参数二：为连接点的异常信息
           -->
           <aop:after-throwing method="myAfterThrowing" pointcut-ref="myPointCut" throwing="e"/>
           
           <!-- 后置通知, 不管连接点是否出现异常都会执行的方法-->
           <aop:after method="myAfter" pointcut-ref="myPointCut"/>
        </aop:aspect>
      </aop:config>
     
</beans>

 六 基于注解的实现

6.1   替换bean

<!-- 1 创建目标类 -->

    <bean id="userServiceId" class="com.itheima.d_aspect.b_anno.UserServiceImpl"></bean>

    <!-- 2 创建切面类（通知） -->

    <bean id="myAspectId" class="com.itheima.d_aspect.b_anno.MyAspect"></bean>


l  注意：扫描

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xmlns:context="http://www.springframework.org/schema/context"

       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

                            http://www.springframework.org/schema/context

                            http://www.springframework.org/schema/context/spring-context.xsd">

<!-- 1.扫描注解类 -->

    <context:component-scan base-package="com.itheima.d_aspect.b_anno"></context:component-scan>

 <!-- 是AOP注解生效 -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

6.2  替换aop

l  必须进行aspectj 自动代理

<!-- 2.确定 aop注解生效 -->

   <aop:aspectj-autoproxy></aop:aspectj-autoproxy>


l  声明切面

 <aop:aspect ref="myAspectId">


l  替换前置通知

<aop:before method="myBefore" pointcut="execution(* com.itheima.d_aspect.b_anno.UserServiceImpl.*(..))"/>

 

   //切入点当前有效

   @Before("execution(* com.itheima.d_aspect.b_anno.UserServiceImpl.*(..))")

   publicvoid myBefore(JoinPoint joinPoint){

      System.out.println("前置通知： " + joinPoint.getSignature().getName());

   }

 

l  替换 公共切入点

<aop:pointcut expression="execution(* com.itheima.d_aspect.b_anno.UserServiceImpl.*(..))" id="myPointCut"/>

 

//声明公共切入点

   @Pointcut("execution(* com.itheima.d_aspect.b_anno.UserServiceImpl.*(..))")

   privatevoid myPointCut(){

   }

 

l  替换后置

<aop:after-returning method="myAfterReturning" pointcut-ref="myPointCut" returning="ret" />

 

    @AfterReturning(value="myPointCut()" ,returning="ret")

    publicvoid myAfterReturning(JoinPoint joinPoint,Object ret){

        System.out.println("后置通知： " + joinPoint.getSignature().getName() + " , -->" + ret);

    }

 

 

l  替换环绕

<aop:around method="myAround" pointcut-ref="myPointCut"/>

 

@Around(value = "myPointCut()")

    public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable{

        System.out.println("前");

        //手动执行目标方法

        Object obj = joinPoint.proceed();

       

        System.out.println("后");

        return obj;

    }

 

l  替换抛出异常

<aop:after-throwing method="myAfterThrowing" pointcut="execution(* com.itheima.d_aspect.b_anno.UserServiceImpl.*(..))" throwing="e"/>

 

@AfterThrowing(value="execution(* com.itheima.d_aspect.b_anno.UserServiceImpl.*(..))" ,throwing="e")

    publicvoid myAfterThrowing(JoinPoint joinPoint,Throwable e){

        System.out.println("抛出异常通知： " + e.getMessage());

    }

 

6.3   切面类

/**

 * 切面类，含有多个通知

 */

@Component

@Aspect

publicclass MyAspect {

   

    //切入点当前有效

//  @Before("execution(* com.itheima.d_aspect.b_anno.UserServiceImpl.*(..))")

    publicvoid myBefore(JoinPoint joinPoint){

        System.out.println("前置通知： " + joinPoint.getSignature().getName());

    }

   

    //声明公共切入点

    @Pointcut("execution(* com.itheima.d_aspect.b_anno.UserServiceImpl.*(..))")

    privatevoid myPointCut(){

    }

   

//  @AfterReturning(value="myPointCut()" ,returning="ret")

    publicvoid myAfterReturning(JoinPoint joinPoint,Object ret){

        System.out.println("后置通知： " + joinPoint.getSignature().getName() + " , -->" + ret);

    }

   

//  @Around(value = "myPointCut()")

    public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable{

        System.out.println("前");

        //手动执行目标方法

        Object obj = joinPoint.proceed();

       

        System.out.println("后");

        return obj;

    }

   

//  @AfterThrowing(value="execution(* com.itheima.d_aspect.b_anno.UserServiceImpl.*(..))" ,throwing="e")

    publicvoid myAfterThrowing(JoinPoint joinPoint,Throwable e){

        System.out.println("抛出异常通知： " + e.getMessage());

    }

   

    @After("myPointCut()")

    publicvoid myAfter(JoinPoint joinPoint){

        System.out.println("最终通知");

    }

 

}

 

 

6.4   spring配置

<!-- 1.扫描注解类 -->

    <context:component-scan base-package="com.itheima.d_aspect.b_anno"></context:component-scan>

   

    <!-- 2.确定 aop注解生效 -->

    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

 

 

七  aop注解总结

@Aspect 声明切面，修饰切面类，从而获得 通知。

通知

       @Before前置

       @AfterReturning后置

       @Around环绕

       @AfterThrowing抛出异常

       @After最终

切入点

       @PointCut，修饰方法 privatevoid xxx(){} 一般为私有的没有返回值 之后通过“方法名”获得切入点引用




 





大龄码农生活
关注
Spring Aop之AspectJ注解配置实现日志管理的方法
08-28
Spring Aop之AspectJ注解配置实现日志管理的方法 Spring Aop是基于AspectJ实现的面向切面编程（AOP），它提供了一个灵活的方式来实现日志管理。通过使用AspectJ注解，可以轻松地实现日志记录、性能监控、安全检查...
AspectJ 使用介绍
weixin_43785662的博客
12-27 2271
文章目录AspectJ 使用介绍Compile-Time WeavingPost-Compile WeavingLoad-Time Weaving小结 上一篇文章，我们介绍了 Spring AOP 的各种用法，包括随着 Spring 的演进而发展出来的几种配置方式。 但是我们始终没有使用到 AspectJ，即使是在基于注解的 @AspectJ 的配置方式中，Spring 也仅仅是使用了 AspectJ 包中的一些注解而已，并没有依赖于 AspectJ 实现具体的功能。 本文将介绍使用 AspectJ，介绍
深入探析切面编程：解密 AspectJ 与 Spring AOP 的 AOP 魔法
m0_71777195的博客
08-22 694
这个表格总结了AspectJ和Spring AOP在不同方面的区别。特性/方面AspectJSpring AOP实现方式独立的切面编程框架，扩展了Java语法Spring框架的一部分，基于动态代理和字节码增强技术功能复杂性提供更高级的切面编程能力，支持复杂的切面逻辑更专注于常见的切面功能，适用于简单的切面逻辑依赖性独立使用，需要AspectJ编译器或插件与Spring框架集成，依赖于Spring框架织入方式支持编译时织入和运行时织入。
org.aspectj.apache.bcel.classfile.ClassFormatException 深度解析
最新发布
qq_34419312的博客
09-10 4282
org.aspectj.apache.bcel.classfile.ClassFormatException 深度解析
AOP之ASpectj最详细使用
qq_36237165的博客
10-03 5824
AOP面向切面编程，通过预编译方式和运行期动态代理实现程序的统一维护的一种技术。 Aspectj框架就是通过预编译方式实现程序的统一维护，今天介绍如何使用： //配置版本信息分两步，使用分三步 最新版本的aspectj是1.9.4但是需要SDK最低版本24，这里我就是使用1.8.9版本 //配置信息 1：在工程的build.gradle添加下面依赖 buildscript { ...
aspectJ框架的使用
qq_49044908的博客
05-24 3273
切面三个关键的要素 1. 切面的功能代码:切面是干什么的 2. 切面的执行时间:使用通知(Advice)表示, 是在目标方法之前还是之后 3. 切面的执行位置:使用切入点(Pointcut)表示切面执行位置 从三要素使用aspectJ框架 1. 切面的功能代码, 这个由开发人员自己定义 2. 切面的执行时间, 在规范中叫Advice(通知, 增强) 注解表示 1. @Before 前置通知 ...
解决报错之org.aspectj.lang不存在
m0_64803878的博客
09-03 4083
可以右击项目的根目录中的pom.xml文件，选择Unlink并再次加载Maven项目。例如，可检查是否存在org.aspectj.lang.annotation.Around这个类的相关jar包。引用:java错误-java.lang.ClassNotFoundException: org.aspectj.lang.annotation.Around。总结起来，解决org.aspectj.lang不存在的问题，可以先检查依赖配置，然后确保引入了正确的jar包，最后可以尝试重新加载Maven项目。
Aop之AspectJ详解解读demo
05-22
**Aop之AspectJ详解解读** 在软件开发中，面向切面编程（AOP）是一种设计模式，它允许程序员将关注点分离到不同的模块，从而提高代码的可维护性和复用性。AspectJ是Java平台上的一个开源AOP框架，它提供了一种强大...
Spring AOP的AspectJ支持jar包
01-05
Spring AOP的AspectJ支持jar包； 包括： com.springsource.net.sf.cglib-2.2.0.jar com.srpingsource.org.aopalliance-1.0.0.jar com.srpingsource.org.aspectj.weaver-1.68.RELEASE.jar
Android AOP框架AspectJ使用详解
08-28
Android AOP框架AspectJ使用详解 Android AOP框架AspectJ是Android平台上的一种Aspect-Oriented Programming（面向方面编程）框架，通过在编译期将AspectJ代码插入目标程序达到AOP的目的。在Android开发中，AOP框架...
SpringAOP+AspectJ
02-10
**Spring AOP与AspectJ详解** 在现代软件开发中，面向切面编程（Aspect-Oriented Programming，简称AOP）是一种强大的设计模式，它允许我们分离关注点，将横切关注点（如日志、事务管理、权限控制等）与核心业务...
Spring AspectJ的学习一
05-26
NULL 博文链接：https://fei-xiang.iteye.com/blog/521637
Spring AOP与AspectJ
qq798280904的博客
04-11 616
当你不用Spring AOP提供的注解时，Spring AOP和AspectJ没半毛钱的关系，前者是JDK动态代理（接口级别），用到了CGLIB(Code Generation Library)，CGLIB是一个代码生成类库，可以在运行时候动态是生成某个类的子类。代理模式为要访问的目标对象提供了一种途径，当访问对象时，它引入了一个间接的层。后者是静态代理，在编译阶段就已经编译到字节码文件中。这种情况下不使用注解，使用xml配置。
记录使用idea开发Spring项目正常引入AOP后编译提示org.aspectj.lang.annotation.Aspect报错
weixin_54319871的博客
05-15 1096
原本我的版本不是1.9.7,原来的是比这个更低的版本。这个项目是我过了好几天才重新打开运行的，应该是我中途增加了什么依赖，但是我确定我是没有增加的。因为版本低，导致org.aspectj依赖加载不上。1、在pom.xml里面查看报错的依赖（版本原来是1.6.8，这个版本我的会报错，1.9.7是我换了之后没有再报错的）2、在pom.xml里面导入1.9.7版本的依赖，重新加载。以上是我运到该类问题的解决方法，希望能帮到各位哦！，找到对应的依赖，把版本低的依赖删除。3、再次运行，就可以重新登录了。
Spring 之AOP AspectJ切入点语法详解（最全面、最详细。）
热门推荐
zhengchao1991的博客
11-29 9万+
6.5 AspectJ切入点语法详解 6.5.1 Spring AOP支持的AspectJ切入点指示符 切入点指示符用来指示切入点表达式目的，，在Spring AOP中目前只有执行方法这一个连接点，Spring AOP支持的AspectJ切入点指示符如下： execution：用于匹配方法执行的连接点； within：用于匹...
Spring5框架—— AspectJ
qq_50233116的博客
11-08 543
AOP基本的操作术语，AspectJ的准备（基于AspectJ实现AOP操作、切入点表达式）、AOP操作（AspectJ注解方式、AspectJ配置文件方式）包括完全注解方式
面向切面编程之AspectJ框架的学习
qq_38164867的博客
07-04 370
1. AOP编程: AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。说白了就是用反射、注解等相关技术来hook原有的方法，来执行自己的逻辑。 2.AspectJ框架: 简介： AspectJ框架就位我们的AOP编程提供了非常便捷的方式，它是一个面向切面编程的框架。AspectJ是对java的扩...
记一次“java: 程序包org.aspectj.lang不存在”问题解决
brighthuacon的专栏
01-14 7315
“java: 程序包org.aspectj.lang不存在”问题解决
AspectJ使用
赶路人儿
03-19 1万+
一、AOP介绍 AOP：Aspect-Oriented Programming，面向切面编程，是一种新的方法论（编程范式），是对传统 OOP(Object-Oriented Programming，面向对象编程)的补充。旨在通过允许横切关注点的分离，提高模块化。如在方法执行前、或执行后、或是在执行中出现异常后这些地方进行拦截处理或叫做增强处理。主要应用于：日志收集、事务管理、安全检查、缓存、对象池管理等。 AOP实现的关键就在于AOP框架自动创建的AOP代理，AOP代理则可分为静态代理（例如：sprin
Spring AOP与AspectJ学习资源：必备jar包下载指南
资源摘要信息:"本压缩包为学习Spring框架中的面向切面编程（AOP）以及AspectJ的增强版所需的Java库文件包。Spring AOP是Spring框架的重要组成部分，允许开发者以声明的方式将横切关注点（如日志、安全等）应用到程序...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值