Spring学习-Spring07-AOP之通知(aspectJ)

最新推荐文章于 2022-07-27 19:19:00 发布
最新推荐文章于 2022-07-27 19:19:00 发布
阅读量154 收藏
点赞数
分类专栏： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Fu_si/article/details/104537857
版权

Spring07-AOP之通知

AspectJ的切入点表达式

  1. execution(public * *(..))
    指定切入点为：任意公共方法。
  2. execution(* set *(..))
    指定切入点为：任何一个以“set”开始的方法。
  3. execution(* com.xyz.service.*.*(..))
    指定切入点为：定义在service包里的任意类的任意方法。
  4. execution(* com.xyz.service..*.*(..))
    指定切入点为：定义在service包或者子包里的任意类的任意方法。“…”出现在类名中时，后面必须跟“*”，表示包、子包下的所有类。
  5. execution(* *.service.*.*(..))
    指定只有一级包下的serivce子包下所有类(接口)中的所有方法为切入点。

搭建AspectJ的开发环境

  1. 导入两个Jar包
    com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar
    spring-aspects-4.1.6.RELEASE.jar
  2. 引入AOP约束

AspectJ对于AOP的实现有两种方式：

  1. 注解方式
  2. XML方式
1. 通知的用法(注解方式)
  • 定义通知类
package com.caorui.aspects;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;


//切面类
@Aspect  //表明当前类是一个切面
public class MyAspect {
	
	
	//该注解表明当前方法是前置通知方法
	@Before("execution(* *..service.*.doSome(..))")
	public void before() {
		System.out.println("前置方法执行！");
	}
	
	//该注解表明当前方法是后置通知方法
	@AfterReturning(value = "execution(* *..service.*.doOther(..))", returning = "result")
	public void afterReturning(Object result) {
		System.out.println("后置方法执行！目标参数的返回值是：" + result);
	}
	
	//该注解表明当前方法是环绕通知方法
	@Around("execution(* *..service.*.doOther(..))")
	public Object around(ProceedingJoinPoint pjp) throws Throwable {
		System.out.println("环绕通知：目标执行之前！");
		String result = (String)pjp.proceed();
		if (result != null) {
			result = result.toUpperCase();
		}
		System.out.println("环绕通知：目标执行之后！");
		return result;
	}
	
	//该注解表明当前方法是异常通知方法
	@AfterThrowing(value = "execution(* *..service.*.doSome(..))", throwing = "ex")
	public void throwing(Exception ex) {
		System.out.println("异常通知方法执行！" + ex);
	}
	
	//该注解表明当前方法是最终通知方法：无论程序执行是否正常，该通知都会执行。类似于
try..catch中finally代码块。
	@After("execution(* *..service.*.doSome(..))")
	public void after() {
		System.out.println("最终通知方法执行！");
	}
}
  • 定义目标类
package com.caorui.service;

public interface SomeService {
	
	void doSome();
	String doOther();
}


package com.caorui.service.impl;

import com.caorui.service.SomeService;

public class SomeServiceImpl implements SomeService {

	public SomeServiceImpl() {
		System.out.println("SomeServiceImpl.SomeServiceImpl()");
	}
	@Override
	public void doSome() {
		System.out.println("SomeServiceImpl.doSome()");
		System.out.println("SomeServiceImpl.doSome()" + 1/0);
	}
	@Override
	public String doOther() {
		System.out.println("SomeServiceImpl.doOther()");
		return "love";
	}

}
  • 注册目标类、注册切面类、注册自动代理
<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">
    <!-- 注册目标类 -->
	<!-- bean的定义:以下配置相当于SomeService service = new SomeServiceImpl(); id相当于service这个引用 -->
	<bean id="someServiceImpl" class="com.caorui.service.impl.SomeServiceImpl"></bean>
	<!-- 注册切面，前置通知 -->
	<bean id="MyAspect" class="com.caorui.aspects.MyAspect"></bean>
	<!-- 注册自动代理 -->
	<aop:aspectj-autoproxy/>
</beans>
  • 测试类
package com.caorui.test;

import org.junit.Test;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.core.io.ClassPathResource;

import com.caorui.service.SomeService;
import com.caorui.service.impl.SomeServiceImpl;

public class SomeTest {

	
	//方式二:实现了测试类和service实现类的耦合
	@Test
	public void testSome01() {
		//创建容器对象,ApplicationContext初始化时，所有容器中beans创建完毕
		ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
		SomeService service = ac.getBean("someServiceImpl", SomeService.class);
		service.doSome();
		String result = service.doOther();
		System.out.println(result);
		
		
	}	

}
2. 通知的用法(XML方式)
  • 通知类
package com.caorui.aspects;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;


//切面类
@Aspect  //表明当前类是一个切面
public class MyAspect {
	
	
//	//该注解表明当前方法是前置通知方法
//	public void before() {
//		System.out.println("前置方法执行！");
//	}
//	
//	public void before(JoinPoint jp) {
//		System.out.println("前置方法执行！" + jp);
//	}
	
	
//	//该注解表明当前方法是后置通知方法
//	public void afterReturning(Object result) {
//		System.out.println("后置方法执行！目标参数的返回值是：" + result);
//	}
//	
//	//该注解表明当前方法是环绕通知方法
//	public Object around(ProceedingJoinPoint pjp) throws Throwable {
//		System.out.println("环绕通知：目标执行之前！");
//		String result = (String)pjp.proceed();
//		if (result != null) {
//			result = result.toUpperCase();
//		}
//		System.out.println("环绕通知：目标执行之后！");
//		return result;
//	}
//	
//	//该注解表明当前方法是异常通知方法
//	public void throwing(Exception ex) {
//		System.out.println("异常通知方法执行！" + ex);
//	}
//	
	//该注解表明当前方法是最终通知方法
	public void after() {
		System.out.println("最终通知方法执行！");
	}
	
}
  • 注册目标类、注册切面类、AOP配置
<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">
    <!-- 注册目标类 -->
	<!-- bean的定义:以下配置相当于SomeService service = new SomeServiceImpl(); id相当于service这个引用 -->
	<bean id="someServiceImpl" class="com.caorui.service.impl.SomeServiceImpl"></bean>
	<!-- 注册切面，前置通知 -->
	<bean id="MyAspect" class="com.caorui.aspects.MyAspect"></bean>
	<!-- AOP配置 -->
	<aop:config>
		<!-- 定义切入点 -->
		<aop:pointcut expression="execution(* *..service.*.doSome(..))" id="doSomePC"/>
		<aop:pointcut expression="execution(* *..service.*.doOther(..))" id="doOtherPC"/>
		<aop:aspect ref="MyAspect">
			<!-- <aop:before method="before" pointcut-ref="doSomePC"/> -->
			<!-- <aop:before method="before(org.aspectj.lang.JoinPoint)" pointcut-ref="doSomePC"/> -->
			<!-- <aop:after-returning method="afterReturning(java.lang.Object)" pointcut-ref="doOtherPC" returning="result"/>  result和方法的形参一致-->
			<!-- <aop:around method="around" pointcut-ref="doOtherPC" /> -->
			<!-- <aop:after-throwing method="throwing(java.lang.Exception)" pointcut-ref="doSomePC" throwing="ex"/> -->
			<aop:after method="after" pointcut-ref="doSomePC"/>
		</aop:aspect>
	</aop:config>
</beans>
Fu_si
关注
专栏目录
Spring Boot - spring-boot-starter-aop
学无止境
06-12 1105
然后，我们创建了一个切面类LoggingAspect，它使用@Before和@After注解来定义前置通知和后置通知，这些通知将在UserService类的getUser()在工作中，spring-boot-starter-aop常用于在应用程序中实现切面编程，例如日志记录、性能监控、事务管理等。最后，在Application类的main()方法中，我们获取UserService的实例并调用getUser()方法。在这个示例中，我们创建了一个UserService类，它有一个getUser()
Spring AOP详解& AspectJ表达式
wonking666的博客
07-22 611
近期项目中用到了Spring AOP，开一篇文章记录我爬过的坑。不知道其他初次接触Spring AOP框架的同学有没有感同身受，Spring AOP中最大的障碍莫过于写AspectJ表达式，稍有不慎便可能出现如下错误。 1.Pointcut is not well-formed: expecting ‘)’ at character position 71 execution(* com.won
@AspectJ中的几种通知方式详解
wh柒八九的博客
10-13 543
本文来详细说下@AspectJ中的几种通知方式 文章目录概述 概述
spring中的aspectJ表达式
linchunhua的专栏
01-15 3473
Spring AOP supports the following AspectJ pointcut designators (PCD) for use in pointcut expressions:   表　达　式 说明 execution 匹配方法执行连接点。我们可以指定包、类或者方法名，以及方法的可见性、返回值和参数类型。这是应
Spring源码学习(十八)---基于注解配置Aop的aspectj-autoproxy解析
https://juejin.cn/user/4248168663101239/posts
02-16 1396
这里主要是使用org.springframework:spring-beans:5.2.0.RELEASE进行分析 文章目录①. aspectj-autoproxy标签1. proxy-target-class属性2. expose-proxy属性②. aspectj-autoproxy标签解析③. DefaultBeanDefinitionDocumentReader类的parseBeanDefinitions方法④. 通过parseCustomElement解析自定义标⑤. Namespacehand.
SpringAOP学习--SpringAOP简介及原理
热门推荐
u012098021的博客
05-15 6万+
前文对AOP做了介绍，实际项目中，一般不会直接上手手动实现aop，而是使用一些高级封装的aop实现，如SpringAOP。 Spring是一个广泛应用的框架，SpringAOP则是Spring提供的一个标准易用的aop框架，依托Spring的IOC容器，提供了极强的AOP扩展增强能力，对项目开发提供了极大地便利。 前文提到AOP的实现有AspectJ、JDK动态代理、CGLIB动态代理，SpringAOP不是一种新的AOP实现，其底层采用的是JDK/CGLIB动态代理。 JDK动态代理回顾 上一篇简单介绍了
SpringAOP源码解析之aop:aspectj-autoproxy标签解析
0xZzzz的博客
01-11 9746
阅读须知文章中使用//单行注释做代码的简单注释，而/**/多行注释的代码会做深入分析，为了避免篇幅过长，删掉了Spring原来的注释和空行，建议配合Spring源代码进行阅读，本文对应的Spring源码的版本为4.3.8。本文的主要内容是分析Spring AOP配置解析的源码。正文Spring AOP是我们日常开发中经常使用的工具，常被用来做统一的日志、异常处理、监控等功能，使用方法在此不多赘述，有
spring-boot-starter-aop及其使用场景说明
吴声子夜歌的博客
11-21 1万+
如今，AOP（Aspect Oriented Programming）已经不是什么崭新的概念了，在经历了代码生成、动态代理、字节码增强甚至静态编译等不同时代的洗礼之后，Java 平台上的 AOP 方案基本上已经以 SpringAOP 结合 AspectJ 的方式稳固下来（虽然大家依然可以自己通过各种字节码工具偶尔“打造一些轮子”）。 现在 Spring 框架提供的 AOP 方案倡导了一种各取所长的...
Spring系列八：Spring AOP 和 AspectJ AOP 区别
退役复学在校大学生，目光所至，皆为华夏
07-27 4647
编译期织入（Compile-timeweaving）如类A使用AspectJ添加了一个属性，类B引用了它，这个场景就需要编译期的时候就进行织入，否则没法编译类B。来实现的，在容器启动时需要生成代理实例，在方法调用上也会增加栈的深度，使得SpringAOP的性能不如AspectJ的那么好。类加载后织入（Load-timeweaving）指的是在加载类的时候进行织入，要实现这个时期的织入，有几种常见的方法。AspectJ是一个易用的功能强大的AOP框架，属于。.........
Spring (六) ---------- AspectJ 对 AOP 的实现
在森林里麋了鹿
02-08 2726
目录前言一、AspectJ 简介二、AspectJ 的通知类型三、AspectJ 的 切入点表达式四、AspectJ 开发环境五、AspectJ 基于注解的 AOP 实现实现步骤@Before 前置通知，方法有 JoinPoint 参数@AfterReturning 后置通知 - 注解有 returning 属性@Around 环绕通知-增强方法有 ProceedingJoinPoint参数@AfterThrowing 异常通知-注解中有 throwing 属性@After 最终通知@Pointcut 定义
spring-aop-aspectj-ctw:用AspectJ编译Spring AOP
05-17
Spring AOP的一个常见问题是获取Pointcut到达类的内部方法调用。 在这个示例中，您可以在一个简单的Spring Boot示例中看到如何使用AspectJ处理节拍时间编织。 示例场景 在此示例中，将发生以下情况： 我们在上调用...
spring-boot aop
01-23
默认情况下，Spring使用基于Java的代理，但对于需要在静态方法或非Spring管理对象上应用AOP的情况，可能需要使用CGLIB或AspectJ字节码代理。 5. **理解代理行为**：理解Spring AOP代理的工作方式很重要，因为这可能...
jar包---Spring Aop AspectJ新增包.rar
07-16
Spring AOP的实现主要有两种方式：一种是基于代理的AOP（Proxy-based AOP），另一种是基于AspectJ的AOP（AspectJ-based AOP）。基于代理的AOP是Spring默认的方式，它主要通过JDK动态代理或者CGLIB字节码生成技术来...
spring-aop-jar
12-14
"spring-aop-jar"这个主题涉及到Spring框架中的核心组件之一——Spring AOP。这里我们将深入探讨Spring AOP、相关jar文件以及它们在实际开发中的作用。 首先，我们来看一下提供的文件： 1. aopalliance.jar：这是一...
rhino grasshoper 框内物体排列（附视频）.gh
最新发布
10-18
【闭合线内物体按方向移动/排列】https://www.bilibili.com/video/BV1z1WfeSEWu?vd_source=b420114c993138474d2e93d83ead77a5
kwant-1.4.3-cp38-cp38-win_amd64.whl
10-18
kwant-1.4.3-cp38-cp38-win_amd64.whl
rhino grasshoper 景观椅（附视频）.gh
10-18
【rhino@grasshoper 曲线金属座椅景观案例（文件获取/见简介）】https://www.bilibili.com/video/BV1Dx4y147Lr?vd_source=b420114c993138474d2e93d83ead77a5
PCIe通义万问系列文档的第一部已整理完毕，含999个PCIe相关问答
10-18
《PCIe通义万问》系列文档旨在记录PCIe相关行业工程师们在PCIe协议学习、IP设计验证、产品测试及使用过程中遇到的问题、迸发的思考、进行的探讨及可能的解决方案，以期给遇到相同相似问题的同行们些许启发。文档涉及的技术方向主要为PCIe，也包含PCIe相关的CXL、UCIe及计算机体系结构相关内容。 本文档是《PCIe通义万问》系列文档之（一），含999个问题。问题内容有以下三个来源：MangoPapa（下称博主）的“PCIe每日一问一答”系列专栏；博主的博文留言及私信讨论；博主作为群主的“PCIe技术交流群”群聊内容。MangoPapa小助理、折叠、先杰、CR小队长、kangling共同完成了问答内容提取与归纳整理，噫嘘唏及慕荷负责文辞优化及编辑排版，上述人员及MangoPapa、JasonW、皮塞阿姨、席可儿参与了文档内容的审校。感谢以上人员的无私奉献。 本文档仅对讨论内容进行总结记录，不保证问题答案的正确性，部分问题只提供解决思路或讨论过程。术业有专攻，文内定有偏颇。如您发现谬误，一敬希原宥，二望乞点拨；如您持异见，欢迎来信讨论。如有需要，欢迎联系MangoPapa加入相关
毕业设计论文SpringBoot招投标管理系统.docx
10-18
毕业设计论文
Spring AOP AspectJ配置与使用详解
"Spring AOP 和 AspectJ 使用及配置解析" Spring AOP（面向切面编程）是Spring框架的一部分，它允许我们在程序中插入横切关注点，如日志、事务管理等，而无需侵入核心业务逻辑。AspectJ是Java语言的一个独立的AOP...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值