spring——Aspectj

最新推荐文章于 2025-04-01 11:11:41 发布
最新推荐文章于 2025-04-01 11:11:41 发布
阅读量1.1k 收藏 1
点赞数
分类专栏： spring初学笔记 文章标签： 仅当笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43650773/article/details/85019629
版权
本文介绍了Spring AOP中AspectJ的使用，包括切入点表达式、通知类型和基于XML与注解的配置。重点讲解了execution()表达式的用法，以及如何通过@AspectJ注解创建切面和定义不同类型的通知。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

spring——Aspectj

1.1 介绍

  • AspectJ是一个基于Java语言的AOP框架
  • Spring2.0以后新增了对AspectJ切点表达式支持
  • @AspectJ 是AspectJ1.5新增功能，通过JDK5注解技术，允许直接在Bean类中定义切面
    新版本Spring框架，建议使用AspectJ方式来开发AOP
  • 主要用途：自定义开发

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 通知类型

  • aop联盟定义通知类型，具有特定接口，必须实现，从而确定方法名称。
  • aspectj 通知类型，只定义类型名称。以及方法格式。
  • 个数：6种，知道5种，掌握1种。
    • before:前置通知(应用：各种校验)
      在方法执行前执行，如果通知抛出异常，阻止方法运行
    • afterReturning:后置通知(应用：常规数据处理)
      方法正常返回后执行，如果方法中抛出异常，通知无法执行
      必须在方法执行后才执行，所以可以获得方法的返回值。
    • around:环绕通知(应用：十分强大，可以做任何事情)
      方法执行前后分别执行，可以阻止方法的执行
      必须手动执行目标方法
    • afterThrowing:抛出异常通知(应用：包装异常信息)
      方法抛出异常后执行，如果方法没有抛出异常，无法执行
    • after:最终通知(应用：清理现场)
      方法执行完毕后执行，无论方法中是否出现异常
环绕

try{
     //前置：before
    //手动执行目标方法
    //后置：afterReturning
} catch(){
    //抛出异常 afterThrowing
} finally{
    //最终 after
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

1.4 导入jar包

  • 4个：
    aop联盟规范
    spring aop 实现
    aspect 规范
    spring aspect 实现
    在这里插入图片描述

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>

在这里插入图片描述
在这里插入图片描述

  • 注意：扫描
<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
  • 必须进行aspectj 自动代理
    <!-- 2.确定 aop注解生效 --> <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
  • 声明切面
 <aop:aspect ref="myAspectId">

在这里插入图片描述

  • 替换前置通知
<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()); }

  • 替换 公共切入点
<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(){
	}
  • 替换后置通知
<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);
	}

在这里插入图片描述

  • 替换环绕通知
<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;
	}
  • 替换抛出异常
<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")
	public void 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 ，修饰方法 private void xxx(){} 之后通过“方法名”获得切入点引用

Spring——AOP操作 AspectJ动态代理方式
chenxingxingxing的博客
03-30 2937
Spring——AOP操作 AspectJ动态代理方式
AOP-面向切面编程——AspectJ
弗里曼的小伙伴
03-28 1675
AOP-面向切面编程 ——AspectJ sf2gis@163.com 2016年3月23日   1 目标：在不改变原有程序的前题下，增加新的功能。 能够为类、方法、jar包等增加新功能。 能够为自己的程序增加新功能。 2 原理：使用aspectj代替java重新编译和组织已有的基本功能类。 参考：Aspectj Cookbook中文版。 aspectj将代码中的aspectj
Spring AspectJ的学习一
05-26
NULL 博文链接：https://fei-xiang.iteye.com/blog/521637
Spring AspectJ
黄文孝同学的博客
12-28 2814
Hello，这里来简单的说一下AspectJ的使用 概述： AspectJ是一个基于Java语言的AOP框架，在Spring2.0以后添加了对AspectJ切入点表达式的支持 @AspectJ允许在Bean类定义切面 Spring配置文件 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.sprin...
在Spring框架中使用AspectJ实现AOP（面向切面编程）
最新发布
DolphinHome的博客
04-01 950
封装横切关注点（如日志、事务）的模块，通过@Aspect注解标记类，包含和的定义。定义需要拦截的目标方法，使用表达式（如execution）描述匹配规则。指定切面逻辑在何时执行，分为五种类型：•：方法执行前•：方法执行后（无论是否异常）•：方法正常返回后•：方法抛出异常时•：包裹目标方法，可控制其执行流程。</</</</</</</在Spring Boot主类添加•Spring默认使用JDK动态代理（需接口），若目标类无接口则切换为CGLIB。
AspectJ在Spring中的使用
weixin_33912638的博客
11-18 347
在上一篇AspectJ的入门中，简单的介绍了下AspectJ的使用，主要是以AspectJ的example作为例子。介绍完后也留下了几个问题：1）我们在spring中并没有看到需要aspectj之类的关键词，而是使用java代码就可以了，这是如何做到的2）Spring中如何做到不使用特殊的编译器实现aop的（AspectJ如何在运行期使用）3）Sprin...
spring-AspectJ
azjnf1847的博客
05-22 116
动态代理 ProxyFactoryBean织入切面数量太多不利于围护 BeanNameAutoProxyCreater-------------根据Bean名称创建代理 DefaultAdvisorAutoProxyCreator-------------根据Advisor本身包含信息创建代理 AnnotationAwareAspectJAutoPr...
征服Spring AOP—— @AspectJ
04-03
@AspectJ是AspectJ项目的一部分，但已被Spring框架集成，使得在Spring应用中使用AspectJ变得更加方便。使用@AspectJ，我们可以创建一个包含切面逻辑的类，并通过注解来声明切点（pointcuts）和通知（advisors）。...
Spring 使用AspectJ 实现 AOP之前置通知小例子
04-17
标题提到的"Spring 使用AspectJ 实现 AOP之前置通知小例子"，指的是利用AspectJ在Spring中实现AOP的一种特定类型的通知——前置通知（Before advice）。前置通知在目标方法执行之前运行，但不会阻止方法的执行。这种...
spring基于AspectJ实现事务控制
07-30
AspectJ是一种面向切面编程（AOP）的Java语言扩展，它允许开发者定义“切面”——关注点的模块化，这些关注点包括日志、事务管理、安全性等。AspectJ提供了一种强大的类型系统和编译时及运行时织入机制，使得切面...
Spring-------AspectJ
qq_32659773的博客
04-22 258
AspectJ简介 AspectJ是一个基于Java语言的AOP框架 Spring2.0以后新增了对AspectJ切点表达式支持 @AspectJ 是AspectJ1.5新增功能，通过JDK5注解技术，允许直接在Bean类中定义切面 新版本Spring框架，建议使用AspectJ方式来开发AOP 主要用途：自定义开发 2.2 切入点表达式【掌握】 execution() 用...
AspectJ 学习
hwpokay的专栏
06-28 184
参照：王海龙 (buaawhl@sina.com)的 What is AspectJ（IBM developerWorks 中国 ） 1. 序 Aspect Oriented Programming (AOP)是近来一个比较热门的话题。 AspectJ是AOP的Java语言的实现，获得了Java程序员的广泛关注。 关于AspectJ和AOP的具体资料，请从下列链接中查找： http://ww...
Spring - AspectJ基础
sususz的博客
11-16 174
AOP的基本组成主要有以下几个对于程序员来说，需要配置的只有。
spring中的aspectJ表达式
linchunhua的专栏
01-15 3504
Spring AOP supports the following AspectJ pointcut designators (PCD) for use in pointcut expressions:   表　达　式 说明 execution 匹配方法执行连接点。我们可以指定包、类或者方法名，以及方法的可见性、返回值和参数类型。这是应
Spring学习之AspectJ开发
明昕ztoy的博客
03-28 7554
        AspectJ是一个基于Java语言的AOP框架，它提供了强大的AOP功能。Spring 2.0以后，Spring AOP引入了对AspectJ的支持，并允许直接使用AspectJ进行编程，而Spring自身的AOP API也尽量与AspectJ保持一致。所以新版本的Spring框架，建议使用Aspec...
【归纳总结】Spring之AspectJ
Octavius_的博客
03-31 318
AspectJ实际上是对AOP编程思想的一个实践 有三种实践方式： 切入点表达式 advisor aspect 需要导包： <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>1.9.6</version&gt
Spring之AspectJ
weixin_34268843的博客
02-07 104
时间：2017-2-4 21:12 ——AspectJ简介1、AspectJ是一个基于Java语言的AOP框架。2、Spring2.0以后新增了对AspectJ切点表达式的支持。3、@AspectJ是AspectJ1.5新增功能，通过JDK5注解技术，允许直接在Bean类中定义切面。 4、新版本Spring框架，建议使用AspectJ方式来开发AOP。 5、使用AspectJ需要...
Spring AspectJ 框架
m0_51343808的博客
09-08 166
1.什么是AspectJ AspectJ 是一个基于 Java 语言的 AOP 框架。在 Spring 2.0 以后，新增了对 AspectJ 框 架的支持。在 Spring 框架中建议使用 AspectJ 框架开发 AOP。 2.AspectJ 框架中的通知类型 3.AspectJ 框架配置 AOP 方式 3.1通过 XML 文件配置 AOP 通过 AspectJ 配置方式 通过 Spring 的 Schema_based 方式 ...
spring-aspectj
03-08
### Spring框架与...通过这种方式，不仅可以享受到Spring所提供的便捷性和灵活性所带来的好处，同时也获得了来自AspectJ所赋予的强大特性的支持——比如对非托管bean的支持、更精细级别的切入点匹配能力等等[^4]。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值