springAOP及一些简单的应用(一)

最新推荐文章于 2022-10-25 16:35:02 发布
最新推荐文章于 2022-10-25 16:35:02 发布
阅读量389 收藏
点赞数
分类专栏： spring 文章标签： spring springAOP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38846242/article/details/82934032
版权

springAOP及一些简单的应用（一）


以下内容仅为做一个记录，以备可能会用到。

什么是AOP

AOP就是面向切面编程，它是spring框架的核心之一，开应用程序开发过程中可以解决很多问题，比如：日志记录，事务，权限等。同时，利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率

AOP中的相关术语

  • Aspect(切面)：横切关注点的模块化，在spring中通常是一个类，里面可以定义切入点和通知。
  • JointPoint(连接点)：指在程序执行过程中某个特定的点，一般是方法的调用。
  • Advice(通知)：在切面的某个特定的连接点上执行的动作,在spring中有before,after,afterReturning,afterThrowing,around这五种。
  • Pointcut(切入点)：其实就是带有通知的连接点，在程序中主要体现为书写切入点表达式。
  • 引入（Introduction)：用来给一个类型声明额外的方法或属性（也被称为连接类型声明（inter-type declaration））。Spring允许引入新的接口（以及一个对应的实现）到任何被代理的对象。例如，你可以使用引入来使一个bean实现IsModified接口，以便简化缓存机制
  • AOP代理（AOP Proxy)：AOP框架创建的对象，用来实现切面契约（例如通知方法执行等等）。在Spring中，AOP代理可以是JDK动态代理或者CGLIB代理。
  • 织入（Weaving)：把切面连接到其它的应用程序类型或者对象上，并创建一个被通知的对象。这些可以在编译时（例如使用AspectJ编译器），类加载时和运行时完成。Spring和其他纯Java AOP框架一样，在运行时完成织入。

通知类型

  • 前置通知（Before advice)：在某连接点之前执行的通知，但这个通知不能阻止连接点之前的执行流程（除非它抛出一个异常）。
  • 后置通知（After returning advice)：在某连接点正常完成后执行的通知：例如，一个方法没有抛出任何异常，正常返回。
  • 异常通知（After throwing advice)：在方法抛出异常退出时执行的通知。
  • 最终通知（After (finally) advice)：当某连接点退出的时候执行的通知（不论是正常返回还是异常退出）。
  • 环绕通知（Around Advice)：包围一个连接点的通知，如方法调用。这是最强大的一种通知类型。环绕通知可以在方法调用前后完成自定义的行为。它也会选择是否继续执行连接点或直接返回它自己的返回值或抛出异常来结束执行，像事务,日志等都是环绕通知。

springboot中使用AOP例子

  • 工程目录：
    在这里插入图片描述
    我们需要加入spring-boot-starter-aop启动器
  • 业务类
package com.springboot.springbootaop.service;

import org.springframework.stereotype.Service;

@Service
public class TestService {

	public void test() {
		System.out.println("this is test");
	}

}
  • 切面类
@Component
@Aspect
public class TestAspect {

	/**
	 * 切入点，这里我们直接切入到这个方法
	 */
	@Pointcut("execution(* com.springboot.springbootaop.service.TestService.test(..))")
	public void pointCut() {
	}

	/**
	 * 前置通知
	 * 
	 * @param joinPoint
	 */
	@Before("pointCut()")
	public void doBefore(JoinPoint joinPoint) {
		System.out.println("AOP 前置通知...");
	}

	/**
	 * 最终通知，不管方法执行是否异常
	 * 
	 * @param joinPoint
	 */
	@After("pointCut()")
	public void doAfter(JoinPoint joinPoint) {
		System.out.println("AOP 最终通知...");
	}

	/**
	 * 后置通知，方法正常执行返回后
	 * 
	 * @param joinPoint
	 * @param returnVal
	 */
	@AfterReturning(pointcut = "pointCut()", returning = "returnVal")
	public void afterReturn(JoinPoint joinPoint, Object returnVal) {
		System.out.println("AOP 后置通知:" + returnVal);
	}

	/**
	 * 异常通知，方法执行异常时通知
	 * 
	 * @param joinPoint
	 * @param error
	 */
	@AfterThrowing(pointcut = "pointCut()", throwing = "error")
	public void afterThrowing(JoinPoint joinPoint, Throwable error) {
		System.out.println("AOP 异常通知..." + error);
	}

	/**
	 * 环绕通知
	 * 
	 * @param pjp
	 */
	@Around("pointCut()")
	public void around(ProceedingJoinPoint pjp) {
		System.out.println("AOP 环绕通知 before...");
		try {
			pjp.proceed();
		} catch (Throwable e) {
			e.printStackTrace();
		}
		System.out.println("AOP 环绕通知 after...");
	}
}
  • 测试类
@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringbootAopApplicationTests {
	
	@Autowired
	private TestService testService;

	@Test
	public void contextLoads() {
		this.testService.test();
	}

}
  • 结果
    没有异常时：
AOP 环绕通知 before...
AOP 前置通知...
this is test
AOP 环绕通知 after...
AOP 最终通知...
AOP 后置通知:null

有异常时：

AOP 环绕通知 before...
AOP 前置通知...
java.lang.ArithmeticException: / by zero
	at com.springboot.springbootaop.service.TestService.test(TestService.java:9)
	at com.springboot.springbootaop.service.TestService$$FastClassBySpringCGLIB$$64f0483d.invoke(<generated>)
	at org.springframework.cglib.proxy.MethodProxy.invoke(MethodProxy.java:204)
	at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.invokeJoinpoint(CglibAopProxy.java:746)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:163)
	at org.springframework.aop.framework.adapter.MethodBeforeAdviceInterceptor.invoke(MethodBeforeAdviceInterceptor.java:56)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:185)
	at org.springframework.aop.aspectj.MethodInvocationProceedingJoinPoint.proceed(MethodInvocationProceedingJoinPoint.java:88)
	at com.springboot.springbootaop.aspect.TestAspect.around(TestAspect.java:76)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)
	at java.lang.reflect.Method.invoke(Unknown Source)
	at org.springframework.aop.aspectj.AbstractAspectJAdvice.invokeAdviceMethodWithGivenArgs(AbstractAspectJAdvice.java:644)
	at org.springframework.aop.aspectj.AbstractAspectJAdvice.invokeAdviceMethod(AbstractAspectJAdvice.java:633)
	at org.springframework.aop.aspectj.AspectJAroundAdvice.invoke(AspectJAroundAdvice.java:70)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:185)
	at org.springframework.aop.aspectj.AspectJAfterAdvice.invoke(AspectJAfterAdvice.java:47)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:185)
	at org.springframework.aop.framework.adapter.AfterReturningAdviceInterceptor.invoke(AfterReturningAdviceInterceptor.java:55)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:185)
	at org.springframework.aop.aspectj.AspectJAfterThrowingAdvice.invoke(AspectJAfterThrowingAdvice.java:62)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:185)
	at org.springframework.aop.interceptor.ExposeInvocationInterceptor.invoke(ExposeInvocationInterceptor.java:92)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:185)
	at org.springframework.aop.framework.CglibAopProxy$DynamicAdvisedInterceptor.intercept(CglibAopProxy.java:688)
	at com.springboot.springbootaop.service.TestService$$EnhancerBySpringCGLIB$$c0bc1172.test(<generated>)
	at com.springboot.springbootaop.SpringbootAopApplicationTests.contextLoads(SpringbootAopApplicationTests.java:20)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)
	at java.lang.reflect.Method.invoke(Unknown Source)
	at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)
	at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
	at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:47)
	at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)
	at org.springframework.test.context.junit4.statements.RunBeforeTestExecutionCallbacks.evaluate(RunBeforeTestExecutionCallbacks.java:73)
	at org.springframework.test.context.junit4.statements.RunAfterTestExecutionCallbacks.evaluate(RunAfterTestExecutionCallbacks.java:83)
	at org.springframework.test.context.junit4.statements.RunBeforeTestMethodCallbacks.evaluate(RunBeforeTestMethodCallbacks.java:75)
	at org.springframework.test.context.junit4.statements.RunAfterTestMethodCallbacks.evaluate(RunAfterTestMethodCallbacks.java:86)
	at org.springframework.test.context.junit4.statements.SpringRepeat.evaluate(SpringRepeat.java:84)
	at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)
	at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.runChild(SpringJUnit4ClassRunner.java:251)
	at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.runChild(SpringJUnit4ClassRunner.java:97)
	at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
	at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
	at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
	at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
	at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
	at org.springframework.test.context.junit4.statements.RunBeforeTestClassCallbacks.evaluate(RunBeforeTestClassCallbacks.java:61)
	at org.springframework.test.context.junit4.statements.RunAfterTestClassCallbacks.evaluate(RunAfterTestClassCallbacks.java:70)
	at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
	at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.run(SpringJUnit4ClassRunner.java:190)
	at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:86)
	at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38)
	at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:459)
	at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:678)
	at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:382)
	at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:192)
AOP 环绕通知 after...
AOP 最终通知...
AOP 后置通知:null

例子分析

在上述的列子结果中我们可以分析出通知执行的优先级：

  • 无异常的情况
    进入目标方法时,先织入Around,再织入Before，退出目标方法时，先织入Around,再织入After,最后才织入AfterReturning。
    在没有异常的时候，切入点方法执行以后，除了上述例子的结果以外，也有可能先执行Around通知，再执行AfterReturning通知，再执行After通知。

  • 有异常的情况

  • 可以看到例子中有异常的情况下AfterThrowing通知没有执行，因为Spring AOP的环绕通知会影响到AfterThrowing通知的运行，不要同时使用，同时使用也没啥意义，这是只是演示而已。

切入点表达式

切入点表达式有：

  • execution - 匹配方法执行的连接点，这是你将会用到的Spring的最主要的切入点指示符。

  • within - 限定匹配特定类型的连接点（在使用Spring AOP的时候，在匹配的类型中定义的方法的执行）。

  • this - 限定匹配特定的连接点（使用Spring AOP的时候方法的执行），其中bean reference（Spring AOP 代理）是指定类型的实例。

  • target - 限定匹配特定的连接点（使用Spring AOP的时候方法的执行），其中目标对象（被代理的应用对象）是指定类型的实例。

  • args - 限定匹配特定的连接点（使用Spring AOP的时候方法的执行），其中参数是指定类型的实例。

  • @target - 限定匹配特定的连接点（使用Spring AOP的时候方法的执行），其中正执行对象的类持有指定类型的注解

  • @args - 限定匹配特定的连接点（使用Spring AOP的时候方法的执行），其中实际传入参数的运行时类型持有指定类型的注解。

  • @within - 限定匹配特定的连接点，其中连接点所在类型已指定注解（在使用Spring AOP的时候，所执行的方法所在类型已指定注解）

  • @annotation - 限定匹配特定的连接点（使用Spring AOP的时候方法的执行），其中连接点的主题持有指定的注解

具体springboot整合AOP实际操作中切入点表达式怎么用在另一篇文章中再详细叙述。

参考文章：
http://shouce.jb51.net/spring/aop.html

_飞飞飞飞
关注
专栏目录
Spring AOP
xt_tao的博客
04-03 148
SpringAOP SpringAOP（Aspect Oriented Programming），即：面向切面编程。通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。 代理模式 文中提到的基于接口的JDK动态代理与基于子类的CGLib动态代理两种动态代理的方式都是实现SpringAOP的基础。 简单转账功能 准备数据 # 删除spring_aop数据库 drop database if exists spring_aop; # 创建spring_aop数据库 create database
spring AOP注解的应用1
01-23
在Spring框架中，AOP（面向切面编程）是一...Spring AOP注解的应用使得切面编程更加简单直观，大大简化了对横切关注点的管理。在实际开发中，结合Spring提供的其他特性，如事务管理，可以构建出高效、健壮的后端系统。
Spring Aop简单应用
l_learning的博客
04-12 168
AOP：Aspect Oriented Programming 面向方面编程（AOP）通过提供另一种思考程序结构的方式来补充面向对象编程（OOP）。OOP中模块化的关键单元是类，而在AOP中，模块化单元是方面。方面实现了跨越多种类型和对象的关注点（例如事务管理）的模块化。（这些担忧在AOP文献中通常被称为“横切”问题。） 官方文档 Java配置启用@AspectJ支持 要使用Java启用@As...
Spring实现AOP的4种方式
08-27 2413
Spring实现AOP的4种方式
spring Aop 简单应用
菜鸟新人
06-09 237
基本配置 最近在写一些东西,但是日常开发配置接触的太少了很多都忘记了 记录一些常用的东西的最简单用用法方便自己快速的使用 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w...
spring AOP简单运用：打印日志
星坠竹空
11-01 344
场景说明：在开发调试时，总是需要打断点来看哪个方法错误了，哪些参数传错了，在很多情况下如果直接能从日志中拿到是执行了哪个类的哪个方法，并且知道方法参数情况，可能会大大减少调试时间，一种做法是在相应的方法上加上日志，这样会非常的烦人，重复工作很多，而且为了完全，可能在上线的时候还要去除，在这种场景下使用AOP是非常合适的，AOP可以达到一次配置，到处使用的效果。 1.xml配置方式： applica...
SpringAOP切面实例讲解及应用场景（通俗易懂）
12-21
在给定的例子中，我们将创建一个简单的 AOP 切面来理解其工作原理： 1. **引入依赖**： 首先，我们需要在项目中引入 AspectJ 的依赖库，这可以通过在 `pom.xml` 文件中添加相应的 `<dependency>` 标签来完成。在...
简单spring aop 例子
03-24
现在，我们来看如何创建一个简单的Spring AOP例子： 1. **定义切面（Aspect）**：切面是包含通知（Advice）和切入点（Pointcut）的类。通知定义了要执行的逻辑，切入点定义了何时执行。例如，我们可以创建一个名为`...
springAOP及一些简单的应用(二)
qq_38846242的博客
09-24 460
springAOP及一些简单的应用（二）利用 AOP 实现日志处理日志注解实现切面测试 利用 AOP 实现日志处理 这是AOP最常用的用法，基本已经普及 日志注解 为了获取操作描述和是否存数据库，同时方便定义统一的切入点，先定义一个注解 package com.aop.annotation; import java.lang.annotation.Documented; import java....
spring aop简单应用示例
03-28
在IT行业中，Spring AOP（面向切面编程）是一种强大的工具，它允许程序员在不修改原有业务代码的情况下，实现如日志记录、性能监控、事务管理等横切关注点的功能。本示例将深入探讨Spring AOP的基础知识，以及如何在...
Spring AOP介绍及简单应用
星韵月光的博客
03-26 162
Spring AOP的简单应用Spring AOP简介使用spring 的aop来完成代理1.先引入相关依赖2.创建一个切面类3.创建application.xml文件内容为4.创建一个接口定义四种算法5.创建接口对应的实现类：注不要忘写注解6.编写测试类进行测试 Spring AOP简介 spring aop就是面向切面编程，在不影响核心代码的前提下，可在任意位置添加非核心代码。 使用spring 的aop来完成代理 1.先引入相关依赖 <dependencies> &l
Spring-AOP的简述和简单使用
hzsd_ygdcs的博客
10-25 421
Spring-AOP的简述和简单使用
springAOP
weixin_37841366的博客
10-19 84
AOP的目标:让我们可以"专心做事" AOP的原理 将复杂的需求分解出不同方面，将散步在系统中的公共功能集中解决 采用代理机制组装起来运行，在不改变原程序的基础上对代码段进行增强处理，增加新的功能 AOP的相关术语 增强处理(Advice) 前置增强，后置增强，环绕增强，异常抛出增强，最终增强等类型 切入点(PointCut) 连接点(Join Point) 切面(Aspect) 目标对象(Target object) AOP代理(AOP proxy) 织入(Weaving) 实..
（转）一个简单的Spring的AOP例子
安迪的专栏
05-04 123
经过这段日子的学习和使用Spring,慢慢地体会到Spring的优妙之处，正在深入地吸收Spring的精华， 呵呵。现在写的这个只是个简单AOP例子,包括前置通知，后置通知,环绕通知,和目标对象。写这个例子的主要目标只是想让想学AOP的能更快地入门，了解 一下如何去配置AOP里面的东东。 目标对象的接口:IStudent.java  1 /**...
SpringAop
CSDN19970806的博客
07-04 492
先在说一下什么是Aop。我们之前在学filter的时候说过一点，当请求进入到servlet的时候，我们进行设置了字符编码以及跨域问题， 那么我们每个servelt都要去写，很麻烦，所以，我们可以利用aop思想，纵向重复，横行抽取。我们可以在过滤器中配置编码以及解决跨域问题，因为我们设置的过滤器是过滤我们的所有请求。所以在过滤器里面可以设置这些。那么SpringAop也是如此，我们每次在servic...
SpringAOP -- 应用
m0_46218511的博客
03-18 78
一、作用 作用：在不修改源代码的情况下，可以实现功能的增强。 aop思想：基于代理思想，对原来目标对象，创建代理对象，在不修改原对象代码情况下，通过代理对象，调用增强功能的代码，从而对原有业务方法进行增强 ！ 二、应用场景 场景一： 记录日志 场景二： 监控方法运行时间 （监控性能） 场景三： 权限控制 场景四： 缓存优化 （第一次调用查询数据库，将查询结果放入内存对象， 第二次调用， 直接从内存对象返回，不需要查询数据库 ） 场景五： 事务管理 （调用方法前开启事务， 调用方法后提交关闭事务 ） 三、Sp
SpringAop的简单理解.pdf
02-28
SpringAOP(面向切面编程)是Spring框架的一个关键组件，它允许开发者通过定义切面来统一处理横切关注点，比如日志、安全等。它与AspectJ一样，目标是为了处理横切业务，但实现方式有所区别。AspectJ是一种更全面的AOP...
SpringAOP的基础使用
TangSongYMQ的博客
10-13 238
SpringAOP 概述 AOP的全称是Aspect Oriented Programming(面向切面编程) OOP语言提供了类与类之间纵向的关系（继承、接口），而AOP补充了横向的关系（比如在不改变目标类中源代码的情况下给com.john.demo.dao包下所有类中以insert和update开头的方法添加事务管理） SpringAOP和AspectJ的区别 ​ AspectJ是一个专门...
Spring详解(二)AOP面向切面编程
sunnygao的博客
10-13 460
文章目录第三章 AOP 面向切面编程1.增加功能导致的问题。2. AOP概念2.1 什么是AOP怎么理解面向切面编程？3. AOP作用3.AOP中术语AOP中重要的三个要素：Aspect , Pointcut , Advice。4.什么时候用AOP5.AOP技术思想的实现6.使用Aspectj框架实现AOP6.1通知6.2 Pointcut 位置6.3前置通知6.4 后置通知@AfterReturning6.5@Around 环绕通知6.6 @AfterThrowing 异常通知6.7 @After 最终
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值