Spring Aop实例

最新推荐文章于 2021-09-25 20:31:37 发布
最新推荐文章于 2021-09-25 20:31:37 发布
阅读量415 收藏
点赞数
分类专栏： AOP Spring

一、XML方式

1. TestAspect：切面类

[java] view plaincopyprint?

1. packagecom.spring.aop;

2.  

3. importorg.aspectj.lang.JoinPoint;

4. importorg.aspectj.lang.ProceedingJoinPoint;

5.  

6. publicclass TestAspect {

7.  

8. publicvoid doAfter(JoinPoint jp) {

9. System.out.println("logEnding method: " + jp.getTarget().getClass().getName() + "." +jp.getSignature().getName());

10.}

11. 

12.publicObject doAround(ProceedingJoinPoint pjp) throws Throwable {

13.long time= System.currentTimeMillis();

14.ObjectretVal = pjp.proceed();

15.time =System.currentTimeMillis() - time;

16.System.out.println("processtime: " + time + " ms");

17.returnretVal;

18.}

19. 

20.publicvoid doBefore(JoinPoint jp) {

21.System.out.println("logBegining method: " + jp.getTarget().getClass().getName() + "." +jp.getSignature().getName());

22.}

23. 

24.publicvoid doThrowing(JoinPoint jp, Throwable ex) {

25.System.out.println("method" + jp.getTarget().getClass().getName() + "." + jp.getSignature().getName()+ " throw exception");

26.System.out.println(ex.getMessage());

27.}

28.}

packagecom.spring.aop;

 

importorg.aspectj.lang.JoinPoint;

importorg.aspectj.lang.ProceedingJoinPoint;

 

publicclass TestAspect {

 

public void doAfter(JoinPoint jp) {

  System.out.println("log Ending method:" + jp.getTarget().getClass().getName() + "." +jp.getSignature().getName());

}

 

public Object doAround(ProceedingJoinPoint pjp)throws Throwable {

  long time = System.currentTimeMillis();

  Object retVal = pjp.proceed();

  time = System.currentTimeMillis() - time;

  System.out.println("process time: "+ time + " ms");

  return retVal;

}

 

public void doBefore(JoinPoint jp) {

  System.out.println("log Begining method:" + jp.getTarget().getClass().getName() + "." +jp.getSignature().getName());

}

 

public void doThrowing(JoinPoint jp, Throwableex) {

  System.out.println("method " +jp.getTarget().getClass().getName() + "." +jp.getSignature().getName() + " throw exception");

  System.out.println(ex.getMessage());

}

}

2. AServiceImpl：目标对象

[java] view plaincopyprint?

1. packagecom.spring.service;

2.  

3. // 使用jdk动态代理

4. publicclass AServiceImpl implements AService {

5.  

6. publicvoid barA() {

7. System.out.println("AServiceImpl.barA()");

8. }

9.  

10.publicvoid fooA(String _msg) {

11.System.out.println("AServiceImpl.fooA(msg:"+ _msg + ")");

12.}

13.}

packagecom.spring.service;

 

// 使用jdk动态代理

publicclass AServiceImpl implements AService {

 

public void barA() {

  System.out.println("AServiceImpl.barA()");

}

 

public void fooA(String _msg) {

  System.out.println("AServiceImpl.fooA(msg:"+ _msg + ")");

}

}

3. BServiceImpl：目标对象

[java] view plaincopyprint?

1. packagecom.spring.service;

2.  

3. // 使用cglib

4. publicclass BServiceImpl {

5.  

6. publicvoid barB(String _msg, int _type) {

7. System.out.println("BServiceImpl.barB(msg:"+ _msg + " type:" + _type + ")");

8. if (_type== 1)

9. throw newIllegalArgumentException("测试异常");

10.}

11. 

12.publicvoid fooB() {

13.System.out.println("BServiceImpl.fooB()");

14.}

15. 

16.}

packagecom.spring.service;

 

// 使用cglib

publicclass BServiceImpl {

 

public void barB(String _msg, int _type) {

  System.out.println("BServiceImpl.barB(msg:"+ _msg + " type:" + _type + ")");

  if (_type == 1)

   throw new IllegalArgumentException("测试异常");

}

 

public void fooB() {

  System.out.println("BServiceImpl.fooB()");

}

 

}

4. ApplicationContext：Spring配置文件

[html] view plaincopyprint?

1. <?xml version="1.0"encoding="UTF-8"?>

2. <beans xmlns="http://www.springframework.org/schema/beans"

3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

4. xmlns:aop="http://www.springframework.org/schema/aop"

5. xmlns:context="http://www.springframework.org/schema/context"

6. xmlns:tx="http://www.springframework.org/schema/tx"

7. xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-3.1.xsd

8. http://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop-3.1.xsd

9. http://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context-3.1.xsd

10.http://www.springframework.org/schema/txhttp://www.springframework.org/schema/tx/spring-tx-3.1.xsd">

11.<aop:config>

12.<aop:aspect id="TestAspect"ref="aspectBean">

13.<!--配置com.spring.service包下所有类或接口的所有方法-->

14.<aop:pointcut id="businessService"expression="execution(*com.spring.service.*.*(..))" />

15.<aop:before pointcut-ref="businessService"method="doBefore"/>

16.<aop:after pointcut-ref="businessService"method="doAfter"/>

17.<aop:around pointcut-ref="businessService"method="doAround"/>

18.<aop:after-throwing pointcut-ref="businessService"method="doThrowing"throwing="ex"/>

19.</aop:aspect>

20.</aop:config>

21. 

22.<bean id="aspectBean"class="com.spring.aop.TestAspect"/>

23.<bean id="aService"class="com.spring.service.AServiceImpl"></bean>

24.<bean id="bService"class="com.spring.service.BServiceImpl"></bean>

25.</beans>

<?xmlversion="1.0" encoding="UTF-8"?>

<beansxmlns="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"

  xmlns:tx="http://www.springframework.org/schema/tx"

  xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-3.1.xsd

    http://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop-3.1.xsd

    http://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context-3.1.xsd

    http://www.springframework.org/schema/txhttp://www.springframework.org/schema/tx/spring-tx-3.1.xsd">

    <aop:config>

        <aop:aspectid="TestAspect" ref="aspectBean">

            <!--配置com.spring.service包下所有类或接口的所有方法-->

            <aop:pointcutid="businessService" expression="execution(*com.spring.service.*.*(..))" />

            <aop:beforepointcut-ref="businessService" method="doBefore"/>

            <aop:afterpointcut-ref="businessService" method="doAfter"/>

            <aop:aroundpointcut-ref="businessService" method="doAround"/>

            <aop:after-throwingpointcut-ref="businessService" method="doThrowing" throwing="ex"/>

        </aop:aspect>

    </aop:config>

   

    <bean id="aspectBean"class="com.spring.aop.TestAspect" />

    <bean id="aService"class="com.spring.service.AServiceImpl"></bean>

    <bean id="bService"class="com.spring.service.BServiceImpl"></bean>

</beans>

二、注解（Annotation）方式

1. TestAnnotationAspect

[java] view plaincopyprint?

1. packagecom.spring.aop;

2.  

3. importorg.aspectj.lang.ProceedingJoinPoint;

4. import org.aspectj.lang.annotation.After;

5. importorg.aspectj.lang.annotation.AfterReturning;

6. importorg.aspectj.lang.annotation.AfterThrowing;

7. importorg.aspectj.lang.annotation.Around;

8. importorg.aspectj.lang.annotation.Aspect;

9. importorg.aspectj.lang.annotation.Before;

10.importorg.aspectj.lang.annotation.Pointcut;

11. 

12.@Aspect

13.publicclass TestAnnotationAspect {

14. 

15.@Pointcut("execution(*com.spring.service.*.*(..))")

16.privatevoid pointCutMethod() {

17.}

18. 

19.//声明前置通知

20.@Before("pointCutMethod()")

21.publicvoid doBefore() {

22.System.out.println("前置通知");

23.}

24. 

25.//声明后置通知

26.@AfterReturning(pointcut ="pointCutMethod()", returning = "result")

27.publicvoid doAfterReturning(String result) {

28.System.out.println("后置通知");

29.System.out.println("---"+ result + "---");

30.}

31. 

32.//声明例外通知

33.@AfterThrowing(pointcut ="pointCutMethod()", throwing = "e")

34.publicvoid doAfterThrowing(Exception e) {

35.System.out.println("例外通知");

36.System.out.println(e.getMessage());

37.}

38. 

39.//声明最终通知

40.@After("pointCutMethod()")

41.publicvoid doAfter() {

42.System.out.println("最终通知");

43.}

44. 

45.//声明环绕通知

46.@Around("pointCutMethod()")

47.publicObject doAround(ProceedingJoinPoint pjp) throws Throwable {

48.System.out.println("进入方法---环绕通知");

49.Object o= pjp.proceed();

50.System.out.println("退出方法---环绕通知");

51.return o;

52.}

53.}

packagecom.spring.aop;

 

importorg.aspectj.lang.ProceedingJoinPoint;

importorg.aspectj.lang.annotation.After;

importorg.aspectj.lang.annotation.AfterReturning;

importorg.aspectj.lang.annotation.AfterThrowing;

importorg.aspectj.lang.annotation.Around;

importorg.aspectj.lang.annotation.Aspect;

importorg.aspectj.lang.annotation.Before;

importorg.aspectj.lang.annotation.Pointcut;

 

@Aspect

publicclass TestAnnotationAspect {

 

@Pointcut("execution(*com.spring.service.*.*(..))")

private void pointCutMethod() {

}

 

//声明前置通知

@Before("pointCutMethod()")

public void doBefore() {

  System.out.println("前置通知");

}

 

//声明后置通知

@AfterReturning(pointcut ="pointCutMethod()", returning = "result")

public void doAfterReturning(String result) {

  System.out.println("后置通知");

  System.out.println("---" + result +"---");

}

 

//声明例外通知

@AfterThrowing(pointcut ="pointCutMethod()", throwing = "e")

public void doAfterThrowing(Exception e) {

  System.out.println("例外通知");

  System.out.println(e.getMessage());

}

 

//声明最终通知

@After("pointCutMethod()")

public void doAfter() {

  System.out.println("最终通知");

}

 

//声明环绕通知

@Around("pointCutMethod()")

public Object doAround(ProceedingJoinPoint pjp)throws Throwable {

  System.out.println("进入方法---环绕通知");

  Object o = pjp.proceed();

  System.out.println("退出方法---环绕通知");

  return o;

}

}

2. ApplicationContext：Spring配置文件

[java] view plaincopyprint?

1. <?xmlversion="1.0" encoding="UTF-8"?>

2. <beansxmlns="http://www.springframework.org/schema/beans"

3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

4. xmlns:aop="http://www.springframework.org/schema/aop"

5. xmlns:context="http://www.springframework.org/schema/context"

6. xmlns:tx="http://www.springframework.org/schema/tx"

7. xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-3.1.xsd

8. http://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop-3.1.xsd

9. http://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context-3.1.xsd

10.http://www.springframework.org/schema/txhttp://www.springframework.org/schema/tx/spring-tx-3.1.xsd">

11.<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

12.<beanclass="org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator"/>

13. 

14.<beanid="aspectBean" class="com.spring.aop.TestAnnotationAspect"/>

15.<beanid="aService"class="com.spring.service.AServiceImpl"></bean>

16.<beanid="bService"class="com.spring.service.BServiceImpl"></bean>

17.</beans>

<?xmlversion="1.0" encoding="UTF-8"?>

<beansxmlns="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"

  xmlns:tx="http://www.springframework.org/schema/tx"

  xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-3.1.xsd

    http://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop-3.1.xsd

    http://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context-3.1.xsd

    http://www.springframework.org/schema/txhttp://www.springframework.org/schema/tx/spring-tx-3.1.xsd">

    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

    <beanclass="org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator"/>

 

    <bean id="aspectBean"class="com.spring.aop.TestAnnotationAspect" />

    <bean id="aService"class="com.spring.service.AServiceImpl"></bean>

    <bean id="bService"class="com.spring.service.BServiceImpl"></bean>

</beans>

关于切入点表达式，大家需要好好练习才能深入理解其中含义。即使看的懂，但是写起来却非常麻烦，并没有想象中那么简单。

最后，再告诉大家：

任何通知（Advice）方法可以将第一个参数定义为 org.aspectj.lang.JoinPoint类型。JoinPoint接口提供了一系列有用的方法， 比如 getArgs() （返回方法参数）、getThis() （返回代理对象）、getTarget() （返回目标）、getSignature() （返回正在被通知的方法相关信息）和 toString() （打印出正在被通知的方法的有用信息。

其中getSignature()返回的Signature对象可强制转换为MethodSignature，其功能非常强大，能获取包括参数名称在内的一切方法信息。

zxh66
关注
专栏目录
Spring AOP实例
12-27
Spring AOP，全称Aspect-Oriented Programming（面向切面编程），是Spring框架的一个重要组成部分。它提供了一种模块化和声明式的方式来处理系统中的交叉关注点，如日志、事务管理、性能监控等，从而使得业务代码...
JAVA开发（AOP之ProceedingJoinPoint）
JAVA领域优质创作者，基于分片网络查询方法专利发明者。
01-12 6247
我们在开发过程中经常使用到自定义注解来实现在一些类或者方法执行过程中切面，统一实现某些业务操作。例如自定义注解
写了个牛逼的日志切面，甩锅更方便了！
欢迎关注公众号：【码农突围】，回复9999，可以获取一份LeetCode刷题笔记
10-27 268
点击上方“码农突围”，马上关注这里是码农充电第一站，回复“666”，获取一份专属大礼包真爱，请设置“星标”或点个“在看”来源：r6d.cn/2Zrc最近项目进入联调阶段，服务层的接口需要...
Spring AOP-@doAround学习
做最好的自己
12-30 8071
@Around("controllerAspect()") public Object doAround(ProceedingJoinPoint joinPoint) { Object result = null; try { result = joinPoint.proceed(); } catch (Throwable e) { e.printStackTr
（2021.9.25）面向切面编程简述
qq_23665305的博客
09-25 2840
说到面向切面编程，想必大家都不会陌生。不就是AOP——Aspect Orient Programming 但是说了那么久，你所理解的面向切面编程，用一句话概括到底是什么呢？ 1.什么是AOP（面向切面编程） 在我的理解来说： 在运行时，动态的 将代码切入到 类的 指定方法。 这种编程思想就成为面向切面编程 来举个例子吧,你写了A方法之后，老板想让你看看这段代码的执行时间。ok，那你就在A方法的前后加上代码，查看时间。。。 过了几天，你又完成了B方法之后，老板又想让看你记录这段代码的日志...
第七讲：7.2 spring AOP后置-环绕
Cruise的博客
11-03 260
一，后置 1，studentServiceAspect类添加doAfter方法，public void doAfter(JoinPoint jp){        System.out.println("类名："+jp.getTarget().getClass().getName());        System.out.println("方法名："+jp.getSignature().getN...
SpringAop实例
07-28
在这个"SpringAop实例"中，可能包含了演示如何创建和使用这两种配置方式的代码示例。文件列表中的"spring32"可能是指Spring 3.2版本的相关文件，这个版本的Spring对AOP的支持已经相当成熟。 通过学习这个实例，你...
Spring AOP 实例
12-19
以下我们将探讨三个具体的Spring AOP实例，包括日志记录、方法运行时间和订单检查。 1. **简单的AOP日志实现-某方法之前的前后记录日志** 在这个实例中，我们创建一个切面来拦截目标方法的调用，以便在方法执行...
spring aop实例
08-07
**Spring AOP 实例详解** 在Java开发中，Spring AOP（Aspect Oriented Programming，面向切面...以上是对Spring AOP实例的详细解释，通过学习和实践，你可以更好地理解和运用这一强大的工具来优化你的Java应用程序。
AOP之proceedingjoinpoint和joinpoint区别（获取各对象备忘）、动态代理机制及获取原理代理对象、获取Mybatis Mapper接口原始对象...
weixin_30920597的博客
04-19 943
现在AOP的场景越来越多，所以我们有必要理解下和AOP相关的一些概念和机制。 import org.aspectj.lang.reflect.SourceLocation; public interface JoinPoint { String toString(); //连接点所在位置的相关信息 String toShortString()...
使用ProceedingJoinPoint获取当前请求的方法等参数——spring mvc拦截器
SmuEdward的博客
01-10 3万+
在项目中常常需要顾虑请求参数中的特殊字符，比如+，等 解决方案是可以使用spring mvc 的拦截器，配合aspectJ使用 package com.cpic.core.web; import java.lang.annotation.Annotation; import java.lang.reflect.Method; import java.math.BigDecimal; impo
springboot异步和切面_SpringBoot强化篇（八）-- Spring AOP
weixin_42309599的博客
01-30 819
Spring AOP简介AOP(Aspect Orient Programming)是一种设计思想，是软件设计领域中的面向切面编程，它是面向对象编程(OOP)的一种补充和完善。它以通过预编译方式和运行期动态代理方式，实现在不修改源代码的情况下给程序动态统一添加额外功能的一种技术。AOP与OOP字面意思相近，但其实两者完全是面向不同领域的设计思想。实际项目中我们通常将面向对象理解为一个静态过程(例如...
Spring AOP(五)之Around增强处理
热门推荐
owen_william的博客
03-06 3万+
@Around注解用于修饰Around增强处理，Around增强处理是功能比较强大的增强处理，它近似于Before增强处理和AfterReturing增强处理的总结，Around增强处理既可在执行目标方法之前增强动作，也可在执行目标方法之后织入增强的执行。与Before增强处理、AfterReturning增强处理不同的是，Around增强处理可以决定目标方法在什么时候执行，如何执行，甚至可以完全
使用SpringBoot通过自定义注解+AOP+全局异常处理实现参数统一非空校验
Beauxie的博客
01-06 7751
在我们写后台接口时，难免对参数进行非空校验，如果一两个还好，但如果需要写大量的接口，及必填参数太多的时候，会给我们开发带来大量的重复工作，及很多相似代码。而sping自带的@RequestParam注解并不能完全满足我们的需求，因为这个注解只会校验请求中是否存在该参数，而不会校验这个参数的值是nulll还是空字符串(“”)，如果参数不存在则会抛出org.springfr
SpringBoot 使用自定义注解（基于AOP） 实现操作日志管理
最近学习目标：MySQL，Redis
11-10 1909
操作日志的记录 因为我们不光要记录代码的运行，如（logback log4j），而且还应该记录用户的行为（Controller 请求日志），这叫做业务运行日志。 业务运行日志的作用 记录用户的行为 用于后续的分析 记录用户的所有的操作 日志实现的思路 1.我们需要记录哪些数据（谁在什么时间干了什么事情，结果如何）？ 数据要存入到哪里（存储到数据库表，推送到指定日志存储服务，打印到日志文件等）？ 2.在项目中什么位置记录（一般在Controller请求，进行around 环绕增强） 如何实现记录
Spring系列之AOP实现的两种方式
weixin_34102807的博客
10-24 662
AOP常用的实现方式有两种，一种是采用声明的方式来实现（基于XML），一种是采用注解的方式来实现（基于AspectJ）。 首先复习下AOP中一些比较重要的概念： Joinpoint（连接点）：程序执行时的某个特定的点，在Spring中就是某一个方法的执行 。Pointcut（切点）：说的通俗点，spring中AOP的切点就是指一些方法的集合，而这些方法是需要被增强、被代理的。一般都是按照一定的...
Aspect编程中＠Around注解的使用
u012614534的专栏
04-15 3万+
面向切面编程可以方便我们对系统进行监控。最近正在学习AOP，而＠Around使用的应该是最多的。我们可以在切面逻辑中得到连接点的名字和所在类名。方便我们快速定位到系统中出现问题的地方。 例子： @Component  //和sping整合的时候必须要这个注解，否则sping容器解析不到该切面导致切面不能工作 @Aspect public class AOPConfig {     @
aop java proceed,Java ProceedingJoinPoint.proceed方法代碼示例
weixin_36360543的博客
03-18 2588
本文整理匯總了Java中org.aspectj.lang.ProceedingJoinPoint.proceed方法的典型用法代碼示例。如果您正苦於以下問題：Java ProceedingJoinPoint.proceed方法的具體用法？Java ProceedingJoinPoint.proceed怎麽用？Java ProceedingJoinPoint.proceed使用的例子？那麽恭喜您, ...
spring aop实例讲解
最新发布
04-26
好的，讲解一下spring aop实例。在Spring框架中，AOP(Aspect-oriented programming)可以帮助我们更好地实现面向切面的编程，解耦业务代码和非业务代码，提高系统的可维护性和可扩展性。下面是一个基本的AOP实例： ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值