Spring_10 Spring中的AOP通知[掌握]

最新推荐文章于 2023-06-04 20:41:24 发布
最新推荐文章于 2023-06-04 20:41:24 发布
阅读量108 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42390340/article/details/107847325
版权

文章目录

一、AOP入门

1、业务层

/**
 * 	 账户的实现类
 */
public class AccountServiceImpl implements IAccountService{

	public void saveAccount() {
		System.out.println("AccountService.saveAccount()");
	}
	
	public void updateAccount(int i) {
		System.out.println("AccountService.updateAccount()"+i);
	}
	
	public int deleteAccount() {
		System.out.println("AccountService.deleteAccount()");
		return 0;
	}

}

2、通知类

/***
 * 记录日志的工具类，它里面提供的公共的代码
 */ 
public class Logger {
	/** 
	 * 用于打印日志：计划让其在切入点方法执行之前执行（切入点方法就是业务层方法）
	 */
	public void printLog() {
		System.out.println("Logger.printLog()开始记录日志了");
	}
}

3、配置文件

 <dependencies>
	<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
	<dependency>
	    <groupId>org.springframework</groupId>
	    <artifactId>spring-context</artifactId>
	    <version>5.0.2.RELEASE</version>
	</dependency>
	
	<dependency><!-- 为了解析切入点表达式 -->
		<groupId>org.aspectj</groupId>
		<artifactId>aspectjweaver</artifactId>
		<version>1.8.7</version>
	</dependency>
  </dependencies>

<?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">

    <!-- 配置Spring的Ioc,把service对象配置进来 -->
	<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"></bean>
	
	<!-- spring中基于XML的AOP配置步骤
		1、把通知Bean(log)也交给spring来管理
		2、使用aop:config标签表明开始AOP的配置
		3、使用aop:aspect标签表明(配置切面)
				id属性：是给切面提供一个唯一标识
				ref属性:是指定通知类（通知内容）bean的Id
		4、在aop：aspect标签的内部使用对应标签来配置通知的类型
				我们现在示例是让printLog方法在切入点方法执行之前执行：所以是前置通知。
				aop:before:标识配置前置通知
					method属性:用于指定Logger类中哪个方法是前置通知。
					pointCut属性：用于指定切入点表达式，该表达式的含义指的是对业务层中哪些方法增强
			==================================================================
				切入点表达式的写法：
					关键字：execution(表达式)
					表达式：访问修饰符    返回值   路径 类名 方法名(参数)
						public void com.itheima.service.impl.AccountServiceImpl.saveAccount()
					(1)访问修饰符可以省略
						void com.itheima.service.impl.AccountServiceImpl.saveAccount()
					(2)返回值可以使用通配符，表示任意返回值。
						* com.itheima.service.impl.AccountServiceImpl.saveAccount()
					(3)包名可以使用通配符，表示任意包。但是有几级包，就有几个*.
						* *.*.*.*.AccountServiceImpl.saveAccount()
						包名可以使用..表示当前包及其子包
							* *..AccountServiceImpl.saveAccount()
					(4)类名和方法名可以使用通配符
						* *..*.*()
					(5)参数
						a、可以使用*表示任意参数(不包括无参)	* *..*.*(*)
						a、可以使用..表示任意参数(包括无参)		* *..*.*(..)
						c、可以直接写数据类型：
							基本类型直接写名称		int
							引用类型写包.类名的方式	java.lang.String
					全统配写法：
						* *..*.*(..)
					实际开发中切入点表达式的通常写法：
						切换到业务层实现类下的所有方法
							* com.itheima.service.impl.*.*(..)
			==================================================================	
	 -->
	 
	 <!-- 配置Logger类 -->
	<bean id="logger" class="com.itheima.service.utils.Logger"></bean>
	
	<!-- 配置AOP -->
	<aop:config>
		<!-- 配置切面 -->
		<aop:aspect id="logAdvice" ref="logger">
			<!-- 配置通知的类型，并且建立通知方法和切入点方法的关联 -->
			<aop:before method="printLog" pointcut="execution(* com.itheima.service.impl.*.*(*))"/>
		</aop:aspect>
	</aop:config>
</beans>

4、测试类

/**
 * 测试AOP的配置
 */
public class AOPTest { 

	public static void main(String[] args) {
		//1、获取容器
		ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
		//2、获取对象
		IAccountService as = (IAccountService) ac.getBean("accountService");
		as.saveAccount(); 
		as.deleteAccount();
		as.updateAccount(3);
	}
}

5、执行结果

在这里插入图片描述

二、通知类型

1、业务层

/**
 * 	 账户的实现类
 * @author 
 */
public class AccountServiceImpl implements IAccountService{

	public void saveAccount() {
		//int i=1/0;
		System.out.println("AccountService.saveAccount()");
		
	}

	public void updateAccount(int i) {
		System.out.println("AccountService.updateAccount()"+i);
		
	}

	public int deleteAccount() {
		System.out.println("AccountService.deleteAccount()");
		return 0;
	}

}

2、通知类

/**
 * 记录日志的工具类，它里面提供的公共的代码
 */ 
public class Logger {
	/** 
	 * 前置通知
	 */
	public void beforePrintLog() {
		System.out.println("前置通知Logger.beforePrintLog()");
	}
	
	/** 
	 * 后置通知
	 */
	public void afterReturningPrintLog() {
		System.out.println("后置通知Logger.afterReturningPrintLog()");
	}
	
	/** 
	 * 异常通知
	 */
	public void afterThrowingPrintLog() {
		System.out.println("异常通知Logger.afterThrowingPrintLog()");
	}
	
	/** 
	 * 最终通知
	 */
	public void afterPrintLog() {
		System.out.println("最终通知Logger.afterPrintLog()");
	}
	/**
	 * 	环绕通知
	 * 	问题：
	 * 		当我们配置了环绕通知之后，切入点方法没有执行，而通知方法执行了
	 * 	分析：
	 * 		通过对比动态代理中的环绕通知代码
	 * 		发现动态代理的环绕通知有明确的切入点方法调用，而我们代码中没有。
	 * 	解决：
	 * 		spring框架为我们提供一个接口：ProceedingJoinPoint.
	 * 		该接口有一个方法processd(),此方法就相当于明确调用切入点方法。
	 * 
	 * 		该接口可以作为环绕通知的方法参数，在程序执行时，
	 * 		spring框架会为我们提供该接口的实现类供我们使用
	 * 
	 * 	spring中的环绕通知：
	 * 		它是spring框架为我们提供的一种可以在代码中手动控制增强的方法何时执行的方式。
	 */
	public Object aroundPringLog(ProceedingJoinPoint pjp ) {
		Object rtValue = null;
		System.out.println("环绕通知 Logger.aroundPringLog()。。。前置");
		try {
			//Object[] args = pjp.getArgs();//得到方法执行所需的参数
			//System.out.println("123:"+args.toString());
			
			//明确:调用业务层方法（切入点方法）
			rtValue =  pjp.proceed();
			
			System.out.println("环绕通知 Logger.aroundPringLog()。。。后置");
			return rtValue;
		} catch (Throwable e) {
			System.out.println("环绕通知 Logger.aroundPringLog()...异常");
			throw new RuntimeException();
		}finally {
			System.out.println("环绕通知 Logger.aroundPringLog()。。。最终");
		}
		
		
	}
}

3、配置文件

<dependencies>
	<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
	<dependency>
	    <groupId>org.springframework</groupId>
	    <artifactId>spring-context</artifactId>
	    <version>5.0.2.RELEASE</version>
	</dependency>
	
	<dependency><!-- 为了解析切入点表达式 -->
		<groupId>org.aspectj</groupId>
		<artifactId>aspectjweaver</artifactId>
		<version>1.8.7</version>
	</dependency>
  </dependencies>

<?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">

    <!-- 配置Spring的Ioc,把service对象配置进来 -->
	<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"></bean>
	 
	 <!-- 配置Logger类 -->
	<bean id="logger" class="com.itheima.service.utils.Logger"></bean>
	
	<!-- 配置AOP -->
	<aop:config>
	<!-- ================================================================================= -->
		<!-- 配置切入点表达式 id属性：指定表达式唯一标志，expression属性：表示内容。
				此标签写在aop:aspect标签内部只能当前切面使用。
				它还可以写在aop:aspect外边，此时就变成了所有切面可用。（此时需要定义在切面之前）
			 -->
		<aop:pointcut id="pt1" expression="execution(* com.itheima.service.impl.*.*(..))" />
		
	<!-- ================================================================================= -->	
		<!-- 配置切面 -->
		<aop:aspect id="logAdvice" ref="logger">
			<!-- 配置前置通知：(在切入点方法执行之前执行)并且建立通知方法和切入点方法的关联-->
			<aop:before method="beforePrintLog" pointcut-ref="pt1"/>
			
			<!-- 配置后置通知(在切入点方法正常执行之后执行)它和异常只能出现一个-->
			<aop:after-returning method="afterReturningPrintLog" pointcut-ref="pt1"/>
			
			<!-- 配置异常通知（在切入点方法执行产生异常之后执行）它和后置只能出现一个 -->
			<aop:after-throwing method="afterThrowingPrintLog" pointcut-ref="pt1"/>
			
			<!-- 配置最终通知（无论切入点是否正常执行它都会再其后面执行）-->
			<aop:after method="afterPrintLog" pointcut-ref="pt1"/>
			<!-- <aop:after method="afterPrintLog" pointcut="execution(* com.itheima.service.impl.*.*(..))"/> -->
			
			<!-- 配置环绕通知：详细的注释请看Logger类中
			<aop:around method="aroundPringLog" pointcut-ref="pt1"/> -->
			
		</aop:aspect>
		
	</aop:config>
</beans>

4、测试类

/**
 * 测试AOP的配置
 * @author 
 */
public class AOPTest { 

	public static void main(String[] args) {
		//1、获取容器
		ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
		//2、获取对象
		IAccountService as = (IAccountService) ac.getBean("accountService");
		
		as.saveAccount(); 

	}
}

5、执行结果

在这里插入图片描述

三、基于注解的AOP

1、业务层

/**
 * 	 账户的实现类
 */
@Service("accountService")
public class AccountServiceImpl implements IAccountService{

	public void saveAccount() {
		//int i=1/0;
		System.out.println("AccountService.saveAccount()");
		
	}

	public void updateAccount(int i) {
		System.out.println("AccountService.updateAccount()"+i);
		
	}

	public int deleteAccount() {
		System.out.println("AccountService.deleteAccount()");
		return 0;
	}

}

2、通知类

/***
 * 记录日志的工具类，它里面提供的公共的代码
 */ 
@Component("logger")
@Aspect//表示当前类是一个切面类
public class Logger {
	/**
	 * 配置切入点表达式
	 */
	@Pointcut("execution(* com.itheima.service.impl.*.*(..))")
	private void pt1() {}
	
	/** 
	 * 前置通知
	 */
	@Before("pt1()")
	public void beforePrintLog() {
		System.out.println("前置通知Logger.beforePrintLog()");
	}
	
	/** 
	 * 后置通知
	 */
	@AfterReturning("pt1()")
	public void afterReturningPrintLog() {
		System.out.println("后置通知Logger.afterReturningPrintLog()");
	}
	
	/** 
	 * 异常通知
	 */
	@AfterThrowing("pt1()")
	public void afterThrowingPrintLog() {
		System.out.println("异常通知Logger.afterThrowingPrintLog()");
	}
	
	/** 
	 * 最终通知
	 */
	@After("pt1()")
	public void afterPrintLog() {
		System.out.println("最终通知Logger.afterPrintLog()");
	}
	/**
	 * 	环绕通知
	 * 	问题：
	 * 		当我们配置了环绕通知之后，切入点方法没有执行，而通知方法执行了
	 * 	分析：
	 * 		通过对比动态代理中的环绕通知代码
	 * 		发现动态代理的环绕通知有明确的切入点方法调用，而我们代码中没有。
	 * 	解决：
	 * 		spring框架为我们提供一个接口：ProceedingJoinPoint.该接口有一个方法processd(),此方法就相当于明确调用切入点方法。
	 * 		该接口可以作为环绕通知的方法参数，在程序执行时，spring框架会为我们提供该接口的实现类供我们使用
	 * 	spring中的环绕通知：
	 * 		它是spring框架为我们提供的一种可以在代码中手动控制增强的方法何时执行的方式。
	 */
//	@Around("pt1()")
//	public Object aroundPringLog(ProceedingJoinPoint pjp ) {
//		Object rtValue = null;
//		System.out.println("环绕通知 Logger.aroundPringLog()。。。前置");
//		try {
//			Object[] args = pjp.getArgs();//得到方法执行所需的参数
//			rtValue =  pjp.proceed();//明确调用业务层方法（切入点方法）
//			System.out.println("环绕通知 Logger.aroundPringLog()。。。后置");
//			return rtValue;
//		} catch (Throwable e) {
//			System.out.println("环绕通知 Logger.aroundPringLog()...异常");
//			throw new RuntimeException();
//		}finally {
//			System.out.println("环绕通知 Logger.aroundPringLog()。。。最终");
//		}
//	}
}

3、配置文件

 <dependencies>
	<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
	<dependency>
	    <groupId>org.springframework</groupId>
	    <artifactId>spring-context</artifactId>
	    <version>5.0.2.RELEASE</version>
	</dependency>
	
	<dependency><!-- 为了解析切入点表达式 -->
		<groupId>org.aspectj</groupId>
		<artifactId>aspectjweaver</artifactId>
		<version>1.8.7</version>
	</dependency>
  </dependencies>

<?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"
    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/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.配置业务层@Service("accountService")
        	2.配置Logger类	@Component("logger")
        	
        	配置AOP
        	
        	1.配置切面类 @Aspect//表示当前类是一个切面类
        	2.在相应的方法上配置
        		 配置切入点表达式
	       			@Pointcut("execution(* com.itheima.service.impl.*.*(..))")
					private void pt1() {}
				配置相应的注解
        			@After @Before @Around @AfterThrowing @AfterReturning("pt()")
         -->
        
        <!-- 配置spring创建容器时所要扫描的包  -->
        <context:component-scan base-package="com.itheima"></context:component-scan>
       
        <!-- 配置spring开启注解AOP的支持 -->
        <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>

4、测试类

/**
 * 测试AOP的配置
 */
public class AOPTest { 

	public static void main(String[] args) {
		//1、获取容器
		ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
		//2、获取对象
		IAccountService as = (IAccountService) ac.getBean("accountService");
		
		as.saveAccount(); 
	}
}

5、执行结果

在这里插入图片描述

6、注意：使用纯注解

在这里插入图片描述

strongsix
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring AOP的5种通知类型
流楚丶格念的博客
07-24 5690
AOP通知描述了抽取的共性功能，根据共性功能抽取的位置不同，最终运行代码时要将其加入到合理的位置。编写通知类，我们使用5种通知类型分别配置update与save方法上。接下来我们将save中的除0操作取消注释。编写配置类，开启切面编程配置。再运行，发现运行异常通知。.........
spring_aop.rar_spring_aop
09-19
spring aop的实例工程，可以让学过javaweb的人快速了解什么是springaop
Spring aop 五种通知类型
小熊
12-20 9219
Spring aop 五种通知类型 spring aop 的五种通知类型 前置通知 Before advice：在连接点前面执行，前置通知不会影响连接点的执行，除非此处抛出异常 后置通知 After returning advice：在连接点正常执行完成后执行，如果连接点抛出异常，则不会执行 异常通知 After throwing advice：在连接点抛出异常后执行 最终通知 After (finally) advice：在连接点执行完成后执行，不管是正常执行完成，还是抛出异常，都会执行返回通知中的内
Spring之AOP
zxy15974062965的博客
10-26 380
本期内容： 1、aop介绍 2、前置通知 3、后置通知 4、环绕通知 5、异常通知 6、过滤通知 一、aop介绍
Spring第35篇：详解Aop中5种通知，透彻
chenzoff的专栏
05-19 1130
本文内容：详解AOP中5种通知的使用，内容很干。 Aop相关阅读 阅读本文之前，需要先掌握下面几篇文章内容，不然会比较吃力。 Spring第15篇：代理详解（java动态代理&CGLIB代理) Spring第30篇：jdk动态代理和cglib代理 Spring第31篇：Aop概念详解 Spring第32篇：AOP核心源码、原理详解 Spring第33篇：ProxyFactoryBean创建AOP代理 Spring第34篇：@Aspect中@
Spring AOP通知（Advice）详解
Purpletaro的专栏
06-04 1164
Before advice（前置通知）：连接点前面执行，不能终止后续流程，除非抛异常After returning advice（后置通知）：连接点正常返回时执行，有异常不执行Around advice（环绕通知）：围绕连接点前后执行，也能捕获异常处理After advice（最终通知）：连接点退出时执行，无论是正常退出还是异常退出After throwing advice（异常通知）：连接点方法抛出异常时执行。
spring_AOP.rar_876.aop_java aop_spring_aop
09-14
Spring AOP技术 是ssh框架的重要内容要加以掌握与练习
spring-aop.rar_aop1270_spring_spring aop
09-23
spring aop 源码用于spring 开源软件源码的获取
Spring_aop.rar_spring aop
09-22
java web开发中spring aop技术的应用。教你如何利用此技术
8_24_SpringAOP_springaop_
10-03
spring aop 的配置文件，新手可以用来学习学习
Spring AOP的五种通知方式代码实例
08-25
主要介绍了Spring AOP的五种通知方式代码实例,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Spring AOP（5种通知类型）
kimi
03-08 1387
Spring AOP（5种通知类型）
SpringAop中的五种常见的通知的注解及@annotation 切入点表达式
qq_47910339的博客
04-08 2774
@Before: 前置通知注解 @AfterReturning:后置通知 @After :最终通知 @Around: 环绕通知 @AfterThrowing:异常通知 @annotation 切入点表达式 execution切入点表达式 根据我们所指定的方法的描述信息来匹配切入点方法，这种方式也是最为常用的一种方式 如果我们要匹配的切入点方法的方法名不规则，或者有一些比较特殊的需求，通过execution切入点表达式描述比较繁琐 annotation 切入点表达式 基于注解的方式来匹配切入点方法。这种方式虽
Spring Aop的使用和通知注解的执行顺序
JemeryShen的专栏
05-14 3253
AOP通知注解执行顺序
Spring AOP五种通知
刘顺顺的博客
09-07 525
目录 通知类型通知执行顺序代码展示代码正常结束代码出现异常 通知类型 在基于Spring AOP编程的过程中，基于AspectJ框架标准，spring中定义了五种类型的通知，它们分别是： 前置通知 (@Before) 返回通知 (@AfterRe...
关于Spring Aop支持五种类型通知
qq_59649143的博客
07-04 1346
关于Spring Aop支持五种类型通知
Spring AOP三部曲之通知
孤芳不自赏
05-25 85
前言 上篇文章我们讲解了Spring AOP是如何创建代理对象的，在这篇文章我们继续讲解AOP是如何通知的。 这是从网上找的一个简单demo，大家可以对照着去理解。注意：本文是以5.1.10版本为讲解。 步骤一：获取此方法的拦截链 我们通过getInterceeptorsAndDynamicInterceptionAdvice获得相应拦截器集合，业务很简单，如果有缓存，取缓存中的数据，否则调用this.advisorChainFactory.getInterceptorsAndD...
第14章-Spring AOP通知（Advice）详解
码匠
04-27 1343
文章目录一、概述二、通知的定义1. 前置通知2. 后置通知3. 环绕通知4. 最终通知5. 异常通知三、通知的参数1. 切入点2. 通知的参数传递四、通知的顺序五、附录1. 常用注解2. 示例代码 Spring 的 AOP 功能中一个关键概念是通知（Advice），与切点（Pointcut）表达式相关联在特定节点织入一些逻辑，Spring 提供了五种类型的通知。 理解 AOP 概念参阅：《Spring的AOP和动态代理》 配置 AOP 参阅：《Spring基于注解配置AOP》《Spring基于XML配置AO
Java-GUI介绍和使用
最新发布
04-18
GUI API包含的类分为三个部分:组件类(component class) 容器类(container class),和辅助类(helper class) 1. 组件类是用来创建用户图形界面的,例如JButton,JLabel,JTextField. 2. 容器类是用来包含其他组件的,例如JFrame,JPanel 3. 辅助类是用来支持GUI组件的,例如Color,Font
springaop通知怎么加进去
09-05
对于 Spring AOP，您可以通过以下步骤将通知添加到应用程序中： 1. 创建一个通知类：创建一个普通的 Java 类，作为您的通知类。您可以使用 Spring AOP 支持的不同类型的通知，如前置通知（Before Advice）、后置...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值