AspectJ

最新推荐文章于 2024-08-09 08:31:39 发布
最新推荐文章于 2024-08-09 08:31:39 发布
阅读量2.3k 收藏 4
点赞数 2
分类专栏： JAVAWEB学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cuterabbitbaby/article/details/80559989
版权

1       AspectJ

1.1  介绍

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

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

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

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

l  主要用途：自定义开发

 

1.2  切入点表达式【掌握】

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:pointcut expression="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')

 

1.3  AspectJ 通知类型

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

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

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

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

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

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

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

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

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

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

              必须手动执行目标方法

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

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

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

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

环绕

 

try{

     //前置：before

    //手动执行目标方法

    //后置：afterRetruning

} catch(){

    //抛出异常 afterThrowing

} finally{

    //最终 after

}




 

 

1.4  导入jar包

l  4个：

       aop联盟规范

       springaop 实现

       aspect规范

       springaspect 实现

1.5  基于xml

1.目标类：接口 + 实现

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

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

4.测试

 

1.5.1   切面类

/**

 * 切面类，含有多个通知

 */

public class MyAspect {

   

    public void myBefore(JoinPoint joinPoint){

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

    }

   

    public void 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;

    }

   

    public void myAfterThrowing(JoinPoint joinPoint,Throwable e){

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

    }

   

    public void myAfter(JoinPoint joinPoint){

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

    }

 

}

 

1.5.2   spring配置

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

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

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

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

    <!-- 3 aop编程

        <aop:aspect> 将切面类声明“切面”，从而获得通知（方法）

            ref 切面类引用

        <aop:pointcut> 声明一个切入点，所有的通知都可以使用。

            expression 切入点表达式

            id 名称，用于其它通知引用

    -->

    <aop:config>

        <aop:aspect ref="myAspectId">

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

           

            <!-- 3.1 前置通知

                <aop:before method="" pointcut="" pointcut-ref=""/>

                    method : 通知，及方法名

                    pointcut :切入点表达式，此表达式只能当前通知使用。

                    pointcut-ref ：切入点引用，可以与其他通知共享切入点。

                通知方法格式：public void myBefore(JoinPoint joinPoint){

                    参数1：org.aspectj.lang.JoinPoint  用于描述连接点（目标方法），获得目标方法名等

                例如：

            <aop:before method="myBefore" pointcut-ref="myPointCut"/>

            -->

           

            <!-- 3.2后置通知  ,目标方法后执行，获得返回值

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

                    returning 通知方法第二个参数的名称

                通知方法格式：public void myAfterReturning(JoinPoint joinPoint,Object ret){

                    参数1：连接点描述

                    参数2：类型Object，参数名 returning="ret" 配置的

                例如：

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

            -->

           

            <!-- 3.3 环绕通知

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

                通知方法格式：public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable{

                    返回值类型：Object

                    方法名：任意

                    参数：org.aspectj.lang.ProceedingJoinPoint

                    抛出异常

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

                例如：

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

            -->

            <!-- 3.4 抛出异常

                <aop:after-throwing method="" pointcut-ref="" throwing=""/>

                    throwing ：通知方法的第二个参数名称

                通知方法格式：public void myAfterThrowing(JoinPoint joinPoint,Throwable e){

                    参数1：连接点描述对象

                    参数2：获得异常信息，类型Throwable，参数名由throwing="e" 配置

                例如：

            <aop:after-throwing method="myAfterThrowing" pointcut-ref="myPointCut" throwing="e"/>

            -->

            <!-- 3.5 最终通知 -->       

            <aop:after method="myAfter" pointcut-ref="myPointCut"/>

           

           

           

        </aop:aspect>

    </aop:config>

 

 

1.6  基于注解

1.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>

 

1.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.*(..))")

   public void 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.*(..))")

   private void myPointCut(){

   }

 

l  替换后置

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

 

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

    public void 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());

    }

 

1.6.3   切面类

/**

 * 切面类，含有多个通知

 */

@Component

@Aspect

public class MyAspect {

   

    //切入点当前有效

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

    public void myBefore(JoinPoint joinPoint){

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

    }

   

    //声明公共切入点

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

    private void myPointCut(){

    }

   

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

    public void 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")

    public void myAfterThrowing(JoinPoint joinPoint,Throwable e){

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

    }

   

    @After("myPointCut()")

    public void myAfter(JoinPoint joinPoint){

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

    }

 

}

 

 

1.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>

 

 

1.6.5   aop注解总结

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

通知

       @Before前置

       @AfterReturning后置

       @Around环绕

       @AfterThrowing抛出异常

       @After最终

切入点

       @PointCut，修饰方法 privatevoid xxx(){}  之后通过“方法名”获得切入点引用


cuterabbitbaby
关注
专栏目录
简单使用AspectJ
WuSheng的博客
07-12 4654
这篇博客主要写给自己看的，方便以后回顾AspectJ是一个AOP框架，由于SpringAOP的配置过于繁琐，因此使用了AspectJ依赖注解开发1、Aspecj依赖坐标，此处省略了Spring相关依赖&lt;dependency&gt; &lt;groupId&gt;org.aspectj&lt;/groupId&gt; &lt;artifactId...
aspectJ
05-28
【AspectJ】是一种强大的面向切面编程（AOP）框架，它允许开发者在Java应用程序中进行声明式的横切关注点编程。AOP的核心思想是将系统中的横切关注点（如日志、事务管理、权限控制等）与业务逻辑分离，以提高代码的...
Spring 之AOP AspectJ切入点语法详解（最全面、最详细。）
热门推荐
zhengchao1991的博客
11-29 9万+
6.5 AspectJ切入点语法详解 6.5.1 Spring AOP支持的AspectJ切入点指示符 切入点指示符用来指示切入点表达式目的，，在Spring AOP中目前只有执行方法这一个连接点，Spring AOP支持的AspectJ切入点指示符如下： execution：用于匹配方法执行的连接点； within：用于匹...
推荐使用AspectJX：一款高效、灵活的Android AOP框架
最新发布
gitblog_01198的博客
08-09 263
推荐使用AspectJX：一款高效、灵活的Android AOP框架 gradle_plugin_android_aspectjxA Android gradle plugin that effects AspectJ on Android project and can hook methods in Kotlin, aar and jar file.项目地址:https://gitcode....
AspectJ在测试中的应用
weixin_34121282的博客
08-31 105
1. 介绍 1.1面向切面的编程 面向切面的编程(AOP，Aspect Oriented Programming)，主要实现的目的是针对业务处理过程中的切面进行提取，它所面对是处理过程中的某个步骤或阶段，以获得逻辑过程中各部分之间低耦合性的隔离效果。 软件设计的一个重要原则，就是要清晰分离各种关注点，然后分而治之，各个击破，最后形成同一的解决方案。然而在目前的技术框...
关于AspectJ 中的pointcut 语法
闲人别居
10-17 1609
    这两天忙着看AspectJ in Action 为了补一下AOP知识。看了Spring 2.0的规范，其中AOP部分已经基本融合了AspectJ，看来有必要看一看AspectJ了。   看了很多AOP的文章了，AOP这两年发展的很慢，没有什么新意，现在到处都是SOA，SCA了，不过研究了一下，觉得还是很有帮助的。尤其是增加系统的契约性和模块的独立性来说，很有帮助。   当然，学东西，基础很
AspectJ使用
赶路人儿
03-19 1万+
一、AOP介绍 AOP：Aspect-Oriented Programming，面向切面编程，是一种新的方法论（编程范式），是对传统 OOP(Object-Oriented Programming，面向对象编程)的补充。旨在通过允许横切关注点的分离，提高模块化。如在方法执行前、或执行后、或是在执行中出现异常后这些地方进行拦截处理或叫做增强处理。主要应用于：日志收集、事务管理、安全检查、缓存、对象池管理等。 AOP实现的关键就在于AOP框架自动创建的AOP代理，AOP代理则可分为静态代理（例如：sprin
Aspectj
03-01
AspectJ是一种广泛使用的Java语言的面向切面编程(AOP)扩展。它允许开发者将关注点模块化，使得系统中的交叉切面（如日志、事务管理、安全性等）可以独立于核心业务逻辑进行处理。本指南将深入探讨AspectJ的核心概念...
aspectj-1.9.6.jar
04-07
《AspectJ 1.9.6.jar：Java AOP编程的基石》 AspectJ是Java平台上的一种面向切面编程（AOP）框架，它允许开发者将关注点分离，提高代码的可维护性和可复用性。AspectJ 1.9.6.jar文件是AspectJ库的核心组成部分，它...
android-gradle-aspectj：gradle插件在Android项目中添加了对AspectJ的支持
02-03
AspectJ是一种广泛使用的AOP框架，它允许程序员在不修改原有代码的情况下，插入额外的功能或监控行为。然而，原生的Android Gradle插件并不直接支持AspectJ。为了解决这个问题，社区开发了`android-gradle-aspectj`...
spring源码导入所需aspectj包
09-14
在Spring框架中，AspectJ是一种强大的面向切面编程（AOP）工具，它允许开发者定义“切面”——即跨越多个对象的行为或属性。这些切面可以用来封装那些分散在整个应用中的横切关注点，例如日志、事务管理或者安全控制...
java aspectj有什么作用_AspectJ 是什么
weixin_35740814的博客
02-16 876
http://www.blogjava.net/hwpok/archive/2008/06/28/211312.html1. 序Aspect Oriented Programming (AOP)是近来一个比较热门的话题。AspectJ是AOP的Java语言的实现，获得了Java程序员的广泛关注。关于AspectJ和AOP的具体资料，请从下列链接中查找：http://www.eclipse.org/...
AspectJ的使用方法
F_V
02-27 1459
最近在复习Spring框架的内容，记录一下之前我所用到的工具方法以及一些基本原理。 AspectJ是Spring aop编程的一个静态面向切面编程框架，该框架使用起来非常简单，相当于帮助你把Spring aop编程给封装好了，直接在maven那里导入然后配置一下属性即可轻松实现面向对象编程。 先上示例代码： @Aspect @Component public class Transact...
AspectJ语法
KEEP CODING
01-18 907
AspectJ 通过连接点向Java添加一些新的程序元素来扩展Java，是Java面向切点一种实现。其主要包括连接点、切点、建议、切面及类型间声明。
AspectJ框架的使用
AbsolutelyOcean的博客
05-30 143
目录1.xml配置通知的方式2.xml配置包扫描+注解的方式3.纯注解 1.xml配置通知的方式 1.创建接口以及实现类 public interface PersonService { void addPerson(); void updatePerson(); } public class PersonServiceImpl implements PersonService { @Override public void addPerson() { Sys
aspectj框架的使用
qq_55471073的博客
01-02 311
加入依赖，spring依赖和aspectj依赖。 创建目标类，接口和实现类。给这个类中加上方法。 创建切面类。 在类之上加上@Aspect 在这个类的方法上加上注解表示在哪里值为切入表达式。 创建spring配置文件，声明对象，把对象交给容器统一管理，声明对象可以用配置文件也可以用注解。 声明目标类 声明切面类 声明aspectj框架中的自动代理生成器标签。自动代理生成器用来完成对对象的创建。 5. 生成测试类。 joinpoint这个参数...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值