SpringAOP中各种增强方法

最新推荐文章于 2023-08-22 21:09:53 发布
最新推荐文章于 2023-08-22 21:09:53 发布
阅读量574 收藏
点赞数 1
分类专栏： 框架
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Zzze0101/article/details/96171433
版权

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: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-4.3.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">

	<context:component-scan base-package="com.zzu"></context:component-scan>
	<aop:aspectj-autoproxy proxy-target-class="false"></aop:aspectj-autoproxy>
</beans>

//待增强的目标类
import org.springframework.stereotype.Service;

@Service
public class CalculatorService implements ICalculatorService {

	@Override
	public int mul(int a, int b) {
		int result = a*b;
		return result;
	}
}

//Test类
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.zzu.calculator.ICalculatorService;

public class Test {

	public static void main(String[] args) {
		ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
		ICalculatorService calculator = applicationContext.getBean(ICalculatorService.class);
		int result = calculator.mul(1, 2);
		System.out.println(result);
		applicationContext.close();
	}
}

1、Before
前置增强（又称前置通知）：在目标方法执行之前执行

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class CalculatorAspect {

	@Before("execution(public int com.zzu.calculator.CalculatorService.mul(int, int))")
	public void before(JoinPoint jp) {
		Object obj = jp.getTarget();
		Object[] args = jp.getArgs();
		System.out.println(obj.getClass().getName()+"：The "+methodName+" method begins.");
		System.out.println(obj.getClass().getName()+"：Parameters of the "+methodName+" method： ["+args[0]+","+args[1]+"]");
	}
}

执行Test类结果：

com.zzu.calculator.CalculatorService：The mul method begins.
com.zzu.calculator.CalculatorService：Parameters of the mul method： [1,2]
2

2、After
保留Before，查看整体效果。

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class CalculatorAspect {

	//前置增强
	@Before("execution(public int com.zzu.calculator.CalculatorService.mul(int, int))")
	public void before(JoinPoint jp) {
		Object obj = jp.getTarget();
		Object[] args = jp.getArgs();
		String methodName = jp.getSignature().getName();
		System.out.println(obj.getClass().getName()+"：The "+methodName+" method begins.");
		System.out.println(obj.getClass().getName()+"：Parameters of the "+methodName+" method： ["+args[0]+","+args[1]+"]");
	}
	//后置增强
	@After("execution(public int com.zzu.calculator.CalculatorService.mul(int,int))")
	public void after(JoinPoint jp) {
		Object obj = jp.getTarget();
		String methodName = jp.getSignature().getName();
		System.out.println(obj.getClass().getName()+"：The "+methodName+" method ends.");
	}
}

执行Test类结果：

com.zzu.calculator.CalculatorService：The mul method begins.
com.zzu.calculator.CalculatorService：Parameters of the mul method： [1,2]
com.zzu.calculator.CalculatorService：The mul method ends.
2

后置增强（又称后置通知）：在目标方法执行后执行，无论目标方法运行期间是否出现异常。
例如我们在目标类的方法中添加异常：

if(true) {
	throw new ArithmeticException("两数之积不能为0");
}

在这里插入图片描述
出现异常，但是并没有影响后置增强的输出。
注意：后置增强无法获取目标方法执行结果，可以在返回增强中获取。
3、AfterReturning
返回增强（又称返回通知）：在目标方法正常结束后执行，可以获取目标方法的执行结果。
保留前置增强和后置增强，查看整体效果

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class CalculatorAspect {

	//前置增强
	@Before("execution(public int com.zzu.calculator.CalculatorService.mul(int, int))")
	public void before(JoinPoint jp) {
		Object obj = jp.getTarget();
		Object[] args = jp.getArgs();
		String methodName = jp.getSignature().getName();
		System.out.println(obj.getClass().getName()+"：The "+methodName+" method begins.");
		System.out.println(obj.getClass().getName()+"：Parameters of the "+methodName+" method： ["+args[0]+","+args[1]+"]");
	}
	//返回增强
	@AfterReturning(value="execution(public int com.zzu.calculator.CalculatorService.mul(int,int))",returning="result")
	public void afterReturning(JoinPoint jp,Object result) {
		Object obj = jp.getTarget();
		String methodName = jp.getSignature().getName();
		System.out.println(obj.getClass().getName()+"：Result of the "+methodName+" method："+result);
	}
	//后置增强
	@After("execution(public int com.zzu.calculator.CalculatorService.mul(int,int))")
	public void after(JoinPoint jp) {
		Object obj = jp.getTarget();
		String methodName = jp.getSignature().getName();
		
		System.out.println(obj.getClass().getName()+"：The "+methodName+" method ends.");
	}
}

执行Test类结果：

com.zzu.calculator.CalculatorService：The mul method begins.
com.zzu.calculator.CalculatorService：Parameters of the mul method： [1,2]
com.zzu.calculator.CalculatorService：The mul method ends.
com.zzu.calculator.CalculatorService：Result of the mul method：2
2

发现上面的最后两条信息与我们期望顺序相反，这与After和AfterReturning的执行顺序有关，一般来说更改不了。
4、AfterThrowing
异常增强（又称异常通知）：目标方法抛出异常之后执行，可以访问到异常对象，且可以指定在出现哪种异常时才执行增强代码

package com.zzu.calculator;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class CalculatorAspect {

	//前置增强
	@Before("execution(public int com.zzu.calculator.CalculatorService.mul(int, int))")
	public void before(JoinPoint jp) {
		Object obj = jp.getTarget();
		Object[] args = jp.getArgs();
		String methodName = jp.getSignature().getName();
		System.out.println(obj.getClass().getName()+"：The "+methodName+" method begins.");
		System.out.println(obj.getClass().getName()+"：Parameters of the "+methodName+" method： ["+args[0]+","+args[1]+"]");
	}
	//返回增强
	@AfterReturning(value="execution(public int com.zzu.calculator.CalculatorService.mul(int,int))",returning="result")
	public void afterReturning(JoinPoint jp,Object result) {
		Object obj = jp.getTarget();
		String methodName = jp.getSignature().getName();
		System.out.println(obj.getClass().getName()+"：Result of the "+methodName+" method："+result);
	}
	//异常增强
	@AfterThrowing(value="execution(public int com.zzu.calculator.CalculatorService.mul(int,int))",throwing="exception")
	public void afterThrowing(JoinPoint jp,NullPointerException exception) {
		Object obj = jp.getTarget();
		String methodName = jp.getSignature().getName();
		System.out.println(obj.getClass().getName()+"：Exception of the method "+methodName+": "+exception.getMessage());
	}
	//后置增强
	@After("execution(public int com.zzu.calculator.CalculatorService.mul(int,int))")
	public void after(JoinPoint jp) {
		Object obj = jp.getTarget();
		String methodName = jp.getSignature().getName();
		
		System.out.println(obj.getClass().getName()+"：The "+methodName+" method ends.");
	}
}

在目标方法中添加代码：

if(true) {
	throw new ArithmeticException("两数之积不能为0");
}

执行Test类结果：

com.zzu.calculator.CalculatorService：The mul method begins.
com.zzu.calculator.CalculatorService：Parameters of the mul method： [1,2]
com.zzu.calculator.CalculatorService：The mul method ends.
Exception in thread "main" java.lang.ArithmeticException: 两数之积不能为0

发现没有结果输出，也就是说异常出现时目标方法中的result没有返回，同时返回增强没有执行。
到此我们得出执行顺序：前置增强–>后置增强–>返回增强或异常增强
5、Around
Around是环绕增强，此注解可以完成以上所有注解的整合：

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class CalculatorAspect {

	@Around("execution(public int com.zzu.calculator.CalculatorService.mul(int,int))")
	public Object result(ProceedingJoinPoint jp) {//环绕增强实现以上所有增强，
		Object result = null;
		Object obj = jp.getTarget();
		Object[] args = jp.getArgs();
		String methodName = jp.getSignature().getName();
		try {
			try {
				//前置增强
				System.out.println(obj.getClass().getName()+"：The mul method begins.");
				System.out.println(obj.getClass().getName()+"：Parameters of the mul method： ["+args[0]+","+args[1]+"]");
				result = jp.proceed();//调用目标对象方法
			} finally {
				//后置增强
				System.out.println(obj.getClass().getName()+"：The mul method ends.");
			}
			//返回增强
			System.out.println(obj.getClass().getName()+"：Result of the "+methodName+" method："+result);
		} catch (Throwable e) {
			//异常增强
			System.out.println(obj.getClass().getName()+"：Exception of the method "+methodName+": "+e.getMessage());
		}
		return result;
	}
}

执行Test类结果：

com.zzu.calculator.CalculatorService：The mul method begins.
com.zzu.calculator.CalculatorService：Parameters of the mul method： [1,2]
Exception in thread "main" org.springframework.aop.AopInvocationException: Null return value from advice does not match primitive return type for: public abstract int com.zzu.calculator.ICalculatorService.mul(int,int)
	at org.springframework.aop.framework.JdkDynamicAopProxy.invoke(JdkDynamicAopProxy.java:227)
	at com.sun.proxy.$Proxy8.mul(Unknown Source)
	at com.zzu.test.Test.main(Test.java:12)
com.zzu.calculator.CalculatorService：The mul method ends.
com.zzu.calculator.CalculatorService：Exception of the method mul: 两数之积不能为0
Zzze0101
关注
专栏目录
Spring AOP之5种增强方法应用范例
05-19
Spring AOP之5种增强方法应用范例 ，具体效果和过程看博文 http://blog.csdn.net/evankaka/article/details/45241863
Spring Aop中五种增强方法
S_Tian的博客
02-04 836
@Aspect @Component public class CalculatorAspect { @Pointcut("execution(public int live.sunhao.calculator.service.CalculatorService.*(..))") public void pointcut() { } //前置增强（又称前置通知）：在目标方法执...
Spring常见的两种增强方式
02-25 246
一、编程式增强 　　不借助spring的配置，通过自己实例化对象来实现的增强方式 创建增强类，需要实现你需要的增强接口，（只有实现了该接口，这个类就是一个通知）） 1 /** 2 * 增强类 3 */ 4 public class Advice implements MethodBeforeAdvice, AfterReturningAdvice { 5 ...
Spring的增强方式
weixin_66107760的博客
12-04 200
Spring的增强方式
Spring-aop的四种增强方式
weixin_66187554的博客
02-22 180
java
Spring Aop Advise方法(增强方法) 中获取目标方法的参数
04-21
在Spring AOP（面向切面编程）中，Advise（增强方法）是核心概念之一，它允许我们在不修改原有业务代码的情况下，通过拦截器模式来插入额外的功能或行为。这篇博客文章“Spring Aop Advise方法(增强方法) 中获取目标...
线程池中使用spring aop事务增强
08-25
本篇文章将深入探讨如何在使用线程池的情况下，利用Spring AOP来增强事务处理。 首先，让我们理解问题的核心。在给定的示例中，一个服务类`AAAService`有一个`doJob`方法，它会将`job`方法提交给线程池执行。由于`...
spring AOP的Around增强实现方法分析
08-25
在 Spring AOP 中，Around 增强是最强大的增强类型之一，能够在目标方法的前后执行一些操作。下面我们就来详细分析 Spring AOP 的 Around 增强实现方法。 首先，我们需要在配置文件中启用 @AspectJ 支持。我们可以...
spring AOP的After增强实现方法实例分析
08-25
Spring AOP的After增强实现方法实例分析 Spring AOP（Aspect-Oriented Programming，面向切面编程）是一种编程技术，旨在将横切关注点从业务逻辑中分离出来，提供了一个更加灵活、可维护的架构。在Spring框架中，...
Spring AOP 16道面试题及答案.docx
06-29
连接点（Joint Point）是程序执行过程中的特定点，通常在Spring AOP中，它代表一个方法的执行。而切入点（Point Cut）是匹配连接点的规则，它定义了一组连接点的集合，可以是一个断言或表达式。Advice与切入点关联，...
Spring AOP三种方式定义增强
deel_feel的博客
01-20 2165
一、通过实现（implements）的方式增强 BeforeLog： package cn.log; import java.lang.reflect.Method; import org.springframework.aop.MethodBeforeAdvice; public class BeforeLog implements MethodBeforeAdvice { /*
Spring AOP五种增强
qq_43234235的博客
07-01 1121
概念： AOP，面向切面编程，就是当你已经完成，或者更加注意一些核心功能的时候。需要使用的编程过程，这个使用，你会发现，一个核心的业务，是由一个核心功能，和若干个额外服务类型的功能，统一组成的，比如数据验证，再比如日志的记录。 其实在场景中，我们的核心功能是针对数据库的操作，可能是增删过程。而服务类功能，比如记录日志，或者输入内容的验证过程。其实不是非有不可。没有这个功能，核心功能也能正常执行。 这个时候，我们就要考虑一个问题，这些必要或者非必要的额外功能，是不是要写在你的核心代码过程当中啊? 我们现在，将
Spring 框架学习——AOP之5种增强方法应用范例
热心网友
08-10 981
Spring AOP 提供了 5 种类型的通知，它们分别是 Before Advice（前置通知）、After Returning Advice（后置通知）、Interception Around Advice（周围通知)、Throws Advice（异常通知）和 Introduction Advice（引介通知）。下面分别进行介绍。 一、前置通知（前置增强） 前置通知顾名思意，该通知织入...
Spring AOP之3种增强方式简单示例
wl_Honest的博客
07-03 716
AOP （Aspect Orient Programming）,直译过来就是 面向切面编程。AOP 是一种编程思想，是面向对象编程（OOP）的一种补充。面向对象编程将程序抽象成各个层次的对象，而面向切面编程是将程序抽象成各个切面。从《Spring实战（第4版）》图书中扒了一张图：从该图可以很形象地看出，所谓切面，相当于应用对象间的横切点，我们可以将其单独抽象为单独的模块。想象下面的场景，开发中在多个模块间有某段重复的代码，我们通常是怎么处理的？显然，没有人会靠“复制粘贴”吧。在传统的面向过程编程中，我们也会
SpringAOP的5种增强类型应用讲解
weixin_41251135的博客
09-27 1907
SpringAOP的5种增强类型应用讲解 一.前言 spring框架中为我们提供的增强包括针对切面的增强和针对切入点的增强，对一个方法的增强底层使用的是动态代理，所以在学习springAop增强之前大家有必要先了解一下动态代理相关内容； 本文分别采用继承接口和使用配置文件来实现增强。 二.springAOP自带的增强类型 按照增强在目标类方法中的连接点位置，可以分为5种： 1.前置增强：org.springframework.aop.BeforeAdvice是前置增强顶层接口，因为Spring只持方法的增强
Spring学习日记：Aop五种增强+注解开发Ioc/Aop
最新发布
m0_74777020的博客
08-22 2599
自述：此篇文章主要记录了本人学习Spring的日常，在CSDN上发表，一是为了方便今后回顾，二也是想分享给有需要的人。
AOP操作AspectJ注解实现增强功能
qq_42388853的博客
08-30 253
先在xml文件里配置上aop和context，用context来开启注解扫描，aop生成增强对象 <?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:context="http://www.spring
AOP常用的几种增强方式和各自特点
m0_73878473的博客
12-11 806
AOP常用的几种增强方式和各自特点
SSM框架之Spring-AOP常见增强处理的使用
瞌睡虫的博客
08-26 1658
SSM 框架学习 (Spring篇) 一、常见增强类型与特点 增强类型 注解 特点 前置增强 @Before 目标方法前织入增强方法。 后置增强 @AfterReturning 目标方法正常执行后织入增强方法（不出现异常）。 异常增强 @AfterThrowing 目标方法发生异常后织入的增强方法，可拔插的异常处理方案。 ...
spring aop 怎么对普通方法增强
03-12
可以使用 Spring AOP 的 @Before、@After、@Around 等注解来实现对普通方法的增强。其中，@Before 注解可以在目标方法执行前执行一段逻辑，@After 注解可以在目标方法执行后执行一段逻辑，@Around 注解可以在目标方法执行前后都执行一段逻辑，并且可以控制目标方法的执行。具体实现可以参考 Spring AOP 的官方文档。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值