Spring面向切面编程的三种方式以及常用相关案例总结

最新推荐文章于 2023-05-08 19:18:07 发布
最新推荐文章于 2023-05-08 19:18:07 发布
阅读量5k 收藏 4
点赞数 4
分类专栏： spring 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lixiao1048/article/details/51754930
版权

Spring面向切面编程

==================================================

spring面向切面编程的方法之一：实现接口方式

1.执行前增强：MethodBeforeAdvice接口

标示方法：public void before(Method arg0, Object[] arg1, Object arg2){}

Method arg0----目标方法, Object[] arg1----方法中的参数, Object arg2----目标对象

2.执行后增强：AfterReturningAdvice接口

标示方法：public void afterReturning(Object arg0, Method arg1, Object[] arg2,Object arg3) throws Throwable {}

Object arg0-----返回值, Method arg1----目标方法, Object[] arg2----方法中的参数,Object arg3----目标对象

3.异常抛出时增强：ThrowAdvice接口

标示方法：public void afterThrowing(Method method, Object[] args, Object target,SQLException ex) {}

Method method----目标方法, Object[] args----方法中的参数, Object target----目标对象,SQLException ex------特定的异常对象，即该异常时才会使用增强方法

4.环绕增强：MethodInterceptor

标示方法：public Object invoke(MethodInvocation arg0) throws Throwable {}

Object target = arg0.getThis(); // 获取被代理对象

Method method = arg0.getMethod(); // 获取被代理方法

Object[] args = arg0.getArguments(); // 获取方法参数

Object result = arg0.proceed(); // 调用目标方法，获取目标方法返回值--------注意抛出异常，用来定义异常是的输出。

5.使用的是aop标签：定义bean用来指代特定的需调用的切面的类，后织入增强（定义切点以及增强）

<bean id="beforeAdvice" class="com.yunhe.aspect.BeforeAdvice"></bean>

<aop:config>

<aop:pointcut expression="execution(* com.yunhe.biz.*.*(..))" id="pc1"/>

<aop:advisor advice-ref="beforeAdvice" pointcut-ref="pc1"/>

</aop:config>

 

 

==================================================

spring面向切面编程的方法之二：注解方式

1.使用@Aspect标示类，表明该类是使用注解是实现增强

2.执行前增强：@Before("execution(* biz.IUserBiz.*(..))")   

标示方法：public void before() {}

3.执行后增强：@AfterReturning("execution(* biz.IUserBiz.*(..))")  

标示方法：public void afterReturning() {}

4.异常抛出时增强：@AfterThrowing(pointcut = "execution(* biz.IUserBiz.*(..))", throwing = "e")

标示方法：public void afterThrowing(JoinPoint jp, RuntimeException e) {}

5.环绕增强：@Around("execution(* biz.IUserBiz.*(..))")

标示方法：public Object aroundLogger(ProceedingJoinPoint jp) throws Throwable {}

6.最终增强：@After("execution(* biz.IUserBiz.*(..))")

标示方法：public void afterLogger(JoinPoint jp) {}

7.spring容器标示类的存在，使用aop标签在容器中表明使用注解方式进行增强

<bean class="aop.UserBizLogger"></bean>

<aop:aspectj-autoproxy />

8.JoinPoint jp的方法：

Object target = jp.getTarget(); // 获取被代理对象

Method method = jp.getSignature(); // 获取被代理方法

Object[] args = jp.getArgs(); // 获取方法参数，通常Arrays.toString(jp.getArgs())转化后用来输出参数表列

Object result = jp.proceed(); // 调用目标方法，获取目标方法返回值--------注意抛出异常，用来定义异常是的输出。

 

 

==================================================

spring面向切面编程的方法之三：Schema方式：普通JavaBean使用aop标签在容器中定义

1.前置增强：<aop:after>

标示方法：public void before(JoinPoint  jp) {}

2.后置增强：<aop:after-returning>

标示方法：public void afterReturning(JoinPoint  jp, Object  result) {}

3.异常抛出时增强：<aop:after-throwing>

标示方法：public void afterThrowing(JoinPoint  jp,  RuntimeException  e) {}

4.环绕增强：<aop:around>

标示方法： public Object aroundLogger(ProceedingJoinPoint jp) throws Throwable {}

5.最终增强：<aop:aspect>

标示方法：public void afterLogger(JoinPoint  jp) {}

6.定义增强类，织入（定义切点，织入）

<bean id="theLogger" class="aop. AfterLogger"></bean>

<aop:config>

    <aop:pointcut id="pointcut" expression="execution(* biz.IUserBiz.*(..))" />

    <aop:aspect ref="theLogger">

        <aop:after  method="afterLogger"  pointcut-ref="pointcut" />

    </aop:aspect>

</aop:config>


Aop切面编程的几个例子

==================================================

例一：log4j实现记录日志---接口

1.实现方式：利用实现接口的Aop方法给特定方法执行后置增强

 

2.步骤：添加log4j.properties在src下，以及log4j-1.2.17.jar添加lib下

 

3.实现类实现接口用来定义

public class AfterAdvice implements AfterReturningAdvice {  

    Logger logger = Logger.getLogger(AfterAdvice.class);  

    public void afterReturning(Object arg0, Method arg1, Object[] arg2,  

            Object arg3) throws Throwable {  

        // TODO Auto-generated method stub  

        logger.debug("后置：执行对象：" + arg3 + "的方法为：" + arg1.getName() );  

          

    }  

}

4.Spring容器中定义切入方式（一个点多个面，一个面多个点均可）

  <bean id="beforeAdvice" class="com.yunhe.aspect.BeforeAdvice"></bean>  

    <bean id="afterAdvice" class="com.yunhe.aspect.AfterAdvice"></bean>  

    <aop:config>  

        <aop:pointcut expression="execution(* com.yunhe.biz.*.*(..))" id="pc1"/>  

        <aop:advisor advice-ref="beforeAdvice" pointcut-ref="pc1"/>  

        <aop:advisor advice-ref="afterAdvice" pointcut-ref="pc1"/>  

    </aop:config>  

5.log4j.properties的配置文件信息

1. ### ÉèÖÃLoggerÊä³ö¼¶±ðºÍÊä³öÄ¿µÄµØ ###  

2. log4j.rootLogger=debug, stdout,logfile  

3.   

4. ### °ÑÈÕÖ¾ÐÅÏ¢Êä³öµ½¿ØÖÆ̨ ###  

5. log4j.appender.stdout=org.apache.log4j.ConsoleAppender  

6. log4j.appender.stdout.Target=System.err  

7. log4j.appender.stdout.layout=org.apache.log4j.SimpleLayout  

8.   

9. ### °ÑÈÕÖ¾ÐÅÏ¢Êä³öµ½Îļþ£ºjbit.log ###  

10. log4j.appender.logfile=org.apache.log4j.FileAppender  

11. log4j.appender.logfile.File=jbit.log  

12. log4j.appender.logfile.layout=org.apache.log4j.PatternLayout  

13. log4j.appender.logfile.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %l %F %p %m%n  

 

6.

 

==================================================

例二：环绕增强---接口

1.实现方式：利用实现接口的Aop方法给特定方法执行环绕增强，并在产生异常的情况下进行提示

 

2.步骤：添加log4j.properties在src下，以及log4j-1.2.17.jar添加lib下

 

3.实现类实现接口用来定义

1. public class AroundLogger implements MethodInterceptor {  

2.     private static final Logger log = Logger.getLogger(AroundLogger.class);  

3.   

4.     public Object invoke(MethodInvocation arg0) throws Throwable {  

5.         Object target = arg0.getThis(); // 获取被代理对象  

6.         Method method = arg0.getMethod(); // 获取被代理方法  

7.         Object[] args = arg0.getArguments(); // 获取方法参数  

8.         log.info("调用 " + target + " 的 " + method.getName() + " 方法。方法入参："  

9.                 + Arrays.toString(args));  

10.         try {  

11.             Object result = arg0.proceed(); // 调用目标方法，获取目标方法返回值  

12.             log.info("调用 " + target + " 的 " + method.getName() + " 方法。方法返回值："  

13.                     + result);  

14.             return result;  

15.         } catch (Throwable e) {  

16.             log.error(method.getName() + " 方法发生异常：" + e);  

17.             throw e;  

18.         }  

19.     }  

20. }  

 

4.Spring容器配置

1. <bean id="aroundLogger" class="aop.AroundLogger"></bean>  

2. <aop:config>  

3.     <aop:pointcut id="pointcut" expression="execution(* biz.IUserBiz.*(..))" />  

4.     <aop:advisor pointcut-ref="pointcut" advice-ref="aroundLogger" />  

5. </aop:config>  

 

 

==================================================

例三：特定异常增强---注解

1.使用注解的Aop方式实现异常增强

 

2.方法中

1. @Aspect  

2. public class ErrorLogger {  

3.     private static final Logger log = Logger.getLogger(ErrorLogger.class);  

4.     @AfterThrowing(pointcut = "execution(* biz.IUserBiz.*(..))", throwing = "e")  

5.     public void afterThrowing(JoinPoint jp, RuntimeException e) {  

6.         log.error(jp.getSignature().getName() + " 方法发生异常：" + e);  

7.     }  

8. }  

 

3.Spring容器配置

<bean class="aop.ErrorLogger"></bean>

<aop:aspectj-autoproxy />

 

==================================================

例四：环绕增强---注解

1.使用注解方式实现环绕增强

 

2.

1. @Aspect  

2. public class AroundLogger {  

3.     private static final Logger log = Logger.getLogger(AroundLogger.class);  

4.     @Around("execution(* biz.IUserBiz.*(..))")  

5.     public Object aroundLogger(ProceedingJoinPoint jp) throws Throwable {  

6.         log.info("调用 " + jp.getTarget() + " 的 " + jp.getSignature().getName()   

7.                 + " 方法。方法入参：" + Arrays.toString(jp.getArgs()));  

8.         try {   Object result = jp.proceed();  

9.             log.info("调用 " + jp.getTarget() + " 的 "   

10.             + jp.getSignature().getName() + " 方法。方法返回值：" + result);  

11.             return result;  

12.         } catch (Throwable e) {  

13.     log.error(jp.getSignature().getName() + " 方法发生异常：" + e);  

14.     throw e; }  

15.     }   }  

 

3.注解方式的前置后置以及最终增强类型

1. @Aspect  

2. public class AfterLogger {  

3.     private static final Logger log = Logger.getLogger(AfterLogger.class);  

4.     @After("execution(* biz.IUserBiz.*(..))")  

5.     public void afterLogger(JoinPoint jp) {  

6.         log.info(jp.getSignature().getName() + " 方法结束执行。");  

7.     }  

8. }  

 

1. @Aspect  

2. public class UserBizLogger {  

3.     private static final Logger log = Logger.getLogger(UserBizLogger.class);  

4.       

5.     @Before("execution(* biz.IUserBiz.*(..))")  

6.     public void before() {  

7.         log.info("即将调用业务方法");  

8.     }  

9.       

10.     @AfterReturning("execution(* biz.IUserBiz.*(..))")  

11.     public void afterReturning() {  

12.         log.info("业务方法调用完毕");  

13.     }  

14.   

15. }  

 

==================================================

例五：环绕增强-----schema方式

1.使用注解方式实现环绕增强

1. public class AroundLogger {  

2.     public Object aroundLogger(ProceedingJoinPoint jp) throws Throwable { … }   

3. }  

 

1. <bean id="theLogger" class="aop. AroundLogger"></bean>  

2. <aop:config>  

3.     <aop:pointcut id="pointcut" expression="execution(* biz.IUserBiz.*(..))" />  

4.     <aop:aspect ref="theLogger">  

5.         <aop:around  method="aroundLogger"  pointcut-ref="pointcut" />  

6.     </aop:aspect>  

7. </aop:config>  

==================================================

例六：最终增强-----schema方式

1. public class AfterLogger {  

2.     public void afterLogger(JoinPoint  jp) { … }  

3. }  

 

1. <bean id="theLogger" class="aop. AfterLogger"></bean>  

2. <aop:config>  

3.     <aop:pointcut id="pointcut" expression="execution(* biz.IUserBiz.*(..))" />  

4.     <aop:aspect ref="theLogger">  

5.         <aop:after  method="afterLogger"  pointcut-ref="pointcut" />  

6.     </aop:aspect>  

7. </aop:config>  

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

lixiao1048
关注
  • 4
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
面向切面编程 动态代理的经典例子
06-13
这是一个面向切面编程的经典例子，用于解释拦截器，动态代理，以及hibernateTemplate模板的实现原理！
SpringAOP纯POJO切面方式实现(接口+XML)
qq_44718303的博客
08-22 439
xml自动代理和手动代理的使用 org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator org.springframework.aop.framework.ProxyFactoryBean 小实例 AOP就是在程序横向执行的过程中给程序纵向插入附加的功能，但不不会影响业务的执行，也就是在业务的两边加入需要的通知，可以是日志模块，权限模块，事务模块。 两个通知类：用于对数据访问层方法执行的通知 package com.xin.a
Spring 创建切面
实践是最好的方法
08-24 9845
目录   1、概述 2、切点类型 3、切面类型 4、静态普通方法名匹配切面 5、静态正则表达式方法匹配切面 6、动态切面 7、流程切面 8、复合切点切面 9、总结 1、概述 在前面介绍各类增强时，大家可能没有注意到一个问题：增强被织入到目标类的所有方法中。假设我们希望有选择地织入到目标类某些特定的方法中，就需要使用切点进行目标连接点的定位了。描述连接点是进行AOP编程最主要...
spring-aop 三种实现切面的方式
butcher的博客
07-09 8102
1、概念 AOP (Aspect Oriented Programming)意为∶面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。 AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。 利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 2、实现方式 使用之前需要导入aspectj织入包 <dependency> &
Spring 之 @Aspect 切面的几种简单方式
龚小帅的博客
12-30 2537
如果不用 @Aspect 注解的话，也可以通过自定义Advisor} }/*** @desc:System . out . println("我是 MyMethodAdvice 增强逻辑....");} }} /*** 控制更细粒度的开关} /*** 可以对参数进行判断做到了更新粒度的切面控制} }在执行时，Spring 就会收集到你自定义的 Advisor 来做切面逻辑。/**
Spring_Aop_切入点
一条咸鱼
05-27 1060
Aop_通知_切入点 1，概述： 若目标类中有多个目标方法，则会将通知织入到每一个方法中。如何将通知织入到指定方法中。使用切入点：指定切面织入到目标对象的具体的位置，即织入到哪些目标类的哪些目标方法中。 2，若要定义切入点，就要定义一个Pointcut接口的实现类。Pointcut接口的完整定义如下： public interface Pointcut { public ClassFil
Spring-aop实现切面的四种方式 上篇
热门推荐
Seven__________7的博客
11-08 1万+
Spring实现AOP的4种方式     先了解AOP的相关术语: 1.通知(Advice): 通知定义了切面是什么以及何时使用。描述了切面要完成的工作和何时需要执行这个工作。 2.连接点(Joinpoint): 程序能够应用通知的一 个“时机”，这些“时机”就是连接点，例如方法被调用时、异常被抛出时等等。 3.切入点(Pointcut) 通知定义了切面要发生的“故事”和时间，那么
三层架构设计模式MVC和AOP面向切面编程-SSM框架的学习与应用-Java EE企业级应用开发学习记录（第九天）
最新发布
09-05
本资源将深入探讨软件开发中两个关键的设计和编程概念：三层架构设计模式（MVC）和面向切面编程（AOP）。这两个概念是现代软件开发中不可或缺的组成部分，它们有助于提高代码的可维护性、可扩展性和可重用性。通过...
Spring AOP 的实现例子（基于XML配置实现）
01-06
Spring AOP 的实现例子（基于XML配置实现）； 具体介绍看这里：https://blog.csdn.net/qq_22078107/article/details/85865543
Spring笔记（面试题）md
08-15
10.面向切面编程AOP 11.手写AOP框架 12.Spring支持的AOP的实现 13.AOP常用的术语 14.什么是AspectJ框架 15.AspectJ常见通知类型 16.AspectJ 的切入点表达式(掌握) 17.AspectJ的前置通知@Before .... .... ....
框架系列之Spring5从放弃到入门
06-20
Spring注入、依赖、AOP面向切面开发技术 课程简介： 课程由浅入深，从项目开发环境搭建到Spring5的使用，重点讲解在企业项目开发中Spring常用功能，结合实际案例进行阶梯式讲解，整合实际开发中使用的工具代码。 ...
spring中AOP中配置切面和切入点(15)
kang82651204的博客
01-18 6857
2016/1/18 10:46:211.配置Spring所有的切面和通知器都必须放在一个内(可以配置包含多个元素),每一个可以包含pointcut,advisor和aspect元素 (它们必须按照这个顺序进行相应的声明)2.aspect配置<bean id="zjxAspect" class="com.zjx.aspect.ZjxAspect"></bean><bean id="zjxAspectB
Spring面向切面编程AOP的三种方式!史上最详细
qq_40631968的博客
10-09 781
123
Spring学习4-面向切面（AOP）之Spring接口方式
tony的专栏
04-23 2475
一、初识AOP   关于AOP的学习可以参看帮助文档：spring-3.2.0.M2\docs\reference\html目录下index.html的相关章节      1、AOP：Aspect-OrientedProgramming。AOP是OOP的补充，是GOF的延续。说到AOP，我们就不得不来提一下软件的纵向和横向问题。从纵向结构来看就是我们软件系统的各个模块，它主要负责处理我们的
Spring中的AOP切面编程的三种实现方式
xzy的博客
03-09 1535
文章目录Spring中的AOP切面编程的三种实现方式1.最基本AOP的实现a.引入jar包b.编写通知类，这里以后置通知和环绕通知类为例子进行说明c.在SpringIOC容器中配置d.测试2.使用注解对AOP进行实现a.引入jar包b.编写基于注解的AOP通知类c.在SpringIOC容器中配置d.测试3.基于自定义形式的AOP的实现a.引入jar包b.编写基于自定义形式的AOP切面编程类c.在SpringIOC容器中配置切入点execution的使用方法 Spring中的AOP切面编程的三种实现方式 1.
Spring Boot使用方法切面某个有注解的方法
weixin_42502300的博客
04-23 1248
package org.example.annotation; import java.lang.annotation.*; @Target({ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface DemoAnnotation { String value() default "test"; } package org.example.config; import.
Spring（二）Spring AOP配置详解
代码与酒
01-25 1511
一、Spring AOP         面向切面编程（AOP），是软件编程思想发展到一定阶段的产物，是对面向对象编程（OOP）的有益补充。AOP一般适用于具有横切逻辑的场合，如访问控制、事务管理、性能监测等。         面向切面编程，简单的说，就是在不改变源程序的基础上为代码段增加新的功能，对代码进行增强处理，它的设计思想来源于代理设计模式。         了解之后需要知道以下概念
SpringAOP中的环绕通知（spring5）
collogestc的博客
02-23 405
配置ascpte切面： package com.ssm.chapter11.aop.aspect; import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.After; import org.aspectj.lang.annotation.AfterReturning; import org.a...
Spring切面编程
BadBoyxiaolin的博客
05-08 1311
*** @Description: 操作日志注解*/ @Documented @Target(ElementType . METHOD) // 作用在方法上 @Retention(RetentionPolicy . RUNTIME) // 运行时有效 public @interface Operation {/*** 操作模块/*** 操作类型/*** 操作说明。
论面向方面的编程技术及其应用（AOP） 要求2000字
06-10
面向方面的编程技术（AOP）是一种编程范式，它通过将应用程序的主要业务逻辑与横切关注点（如日志记录、安全性、性能等）分离来提高代码的模块化性、可重用性和可维护性。本文将介绍AOP的概念、原理、应用和实现，以及AOP在实际项目中的应用案例。 一、AOP的概念和原理 AOP是一种基于切面（Aspect）的编程技术，它将应用程序的主要业务逻辑与横切关注点分离。切面是横跨多个对象的功能，例如日志记录、性能统计、事务管理等。利用AOP，可以将这些关注点模块化，并通过声明式编程的方式插入到应用程序的主要业务逻辑中，从而实现代码的重用和可维护性的提高。 AOP的核心原理是动态代理。在运行时，AOP框架会动态生成代理对象，并将切面织入到代理对象中。当客户端调用代理对象的方法时，代理对象会拦截该方法的调用，并执行与该方法相关的切面代码，最后再将控制权交给原始对象。通过这种方式，AOP实现了业务逻辑的分离和切面的模块化。 二、AOP的应用 AOP的应用领域非常广泛，特别是在企业级应用程序开发中。下面是AOP的几个常见应用场景： 1. 日志记录：将日志记录作为一个切面，可以在应用程序的任何地方记录日志，从而方便开发人员进行调试和故障排除。 2. 安全性：将安全性作为一个切面，可以在应用程序的任何地方实施安全性控制，从而保护应用程序的机密信息和敏感操作。 3. 性能：将性能作为一个切面，可以在应用程序的任何地方监控和优化性能，从而提高应用程序的响应速度和吞吐量。 4. 事务管理：将事务管理作为一个切面，可以在应用程序的任何地方实现事务控制，从而保证数据的一致性和可靠性。 三、AOP的实现 AOP的实现方式有两种：静态AOP和动态AOP。 静态AOP是通过编译器或预处理器实现的，它将切面织入到应用程序的字节码中。这种方式的优点是执行效率高，缺点是不够灵活，无法支持动态织入。 动态AOP是通过运行时代理实现的，它将切面织入到代理对象中。这种方式的优点是灵活性高，能够支持动态织入，缺点是执行效率相对较低。 目前比较流行的AOP框架有Spring AOP和AspectJ。Spring AOP是基于代理的动态AOP框架，它支持方法拦截和环绕通知等多种切面类型。AspectJ是基于字节码的静态AOP框架，它支持更多的切面类型，例如前置通知、后置通知、异常通知和最终通知等。 四、AOP的实际应用案例 下面是AOP在实际项目中的应用案例： 1. 日志记录：在一个电商网站中，通过AOP实现了对用户登录、购物车操作、订单提交等关键操作的日志记录。通过这种方式，可以方便地跟踪和分析用户的操作行为。 2. 安全性：在一个财务系统中，通过AOP实现了对敏感操作的安全性控制，例如只有经过授权的用户才能访问财务数据，不能将数据外传等。 3. 性能：在一个电商网站中，通过AOP实现了对数据库访问的性能监控和优化，例如使用缓存、优化SQL语句等。 4. 事务管理：在一个订单管理系统中，通过AOP实现了对订单状态的事务控制，例如在订单提交成功后，将订单状态从“待付款”改为“已付款”，并更新库存等。 总之，AOP是一种非常有用的编程技术，它可以提高代码的模块化性、可重用性和可维护性，同时也能够简化开发人员的工作和提高应用程序的质量。在实际项目中，我们可以根据具体的需求选择合适的AOP框架和切面类型，从而实现业务逻辑的分离和切面的模块化。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值