Spring-AOP例子

最新推荐文章于 2024-08-03 17:33:52 发布
最新推荐文章于 2024-08-03 17:33:52 发布
阅读量560 收藏 2
点赞数 1
分类专栏： spring 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/h15835161250/article/details/113469406
版权

Spring-AOP例子

第一部分是前期准备，第二部分是基于注解的方式配置事务，第三部分基于.xml配置文件配置事务

一、准备

使用加减乘除方法测试，测试AOP

1.1 概览

在这里插入图片描述
在这里插入图片描述

1.2 jar包介绍 (lib)

在这里插入图片描述

junit测试
①junit-4.12.jar
②hamcrest-core-1.3.jar
Spring核心容器（4个：Beans，Core，Context，expression）
①spring-beans-5.3.1.jar
②spring-context-5.3.1.jar
③spring-core-5.3.1.jar----->依赖于jar包spring-jcl-5.3.1.jar
④spring-expression-5.3.1.jar
Spring aop
①spring-aop-5.3.1.jar
②spring-aspect-5.3.1.jar
③com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar
JdbcTemplate
①spring-jdbc-5.3.1.jar
②spring-orm-5.3.1.jar
③spring-tx-5.3.1.jar
连接数据库的驱动jar包和数据源
①mysql-connector-java-5.1.37-bin.jar
②druid-1.1.9.jar

1.3 方法（Calculator)

public interface Calculator {
    int add(int a,int b);
    int sub(int a,int b);
    int mul(int a,int b);
    int div(int a,int b);
}

1.4 实现类（CalculatorImpl)

public class CalculatorImpl implements Calculator {
    @Override
    public int add(int a, int b) {
        return a + b;
    }

    @Override
    public int sub(int a, int b) {
        return a - b;
    }

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

    @Override
    public int div(int a, int b) {
        return a / b;
    }
}

二、基于注解的方式配置事务

2.1 在实现类中添加@Controller注解 (CalculatorImpl)

@Controller("coc")
public class CalculatorImpl implements Calculator {
    @Override
    public int add(int a, int b) {
        return a + b;
    }

    @Override
    public int sub(int a, int b) {
        return a - b;
    }

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

    @Override
    public int div(int a, int b) {
        return a / b;
    }
}

2.2 通知事务 (LoggingAspect)

@Controller//交给Spring的IOC容器管理
@Aspect//声明该类是一个切面
public class LoggingAspect {

	//声明切入点表达式，在使用的地方通过方法名引用即可
    @Pointcut(value = "execution(* com.spring.aop.aspect.Calculator.*(..))")
    public void pointCut() {
    }

	//前置通知，在方法执行之前执行
    @Before(value = "pointCut()")
    public void beforeAdvice(JoinPoint joinPoint){
        //获取方法名
        String methodName = joinPoint.getSignature().getName();
        //获取参数
        Object[] args = joinPoint.getArgs();
        System.out.println("前置通知： "+methodName+" 方法，参数： "+ Arrays.toString(args));
    }

    //后置通知，在方法执行之后执行，不管是否发生异常
    @After("pointCut()")
    public void afterAdvice(JoinPoint joinPoint){
        //获取方法名
        String methodName = joinPoint.getSignature().getName();
        System.out.println("后置通知： "+methodName+" 方法");
    }

    //返回通知，在方法返回结果之后执行
    //pointcut属性：指定切入点表达式，跟value属性功能一样；returning属性：获取方法的返回值，并指定通知方法中入参的形参名
    @AfterReturning(pointcut = "pointCut()",returning = "result")
    public void afterReturning(JoinPoint joinPoint, Object result){
        //获取方法名
        String methodName = joinPoint.getSignature().getName();
        System.out.println("返回通知： "+methodName+" 方法，返回： "+result);
    }

    //异常通知，在方法执行抛出异常时执行
    //pointcut属性：指定切入点表达式，跟value属性功能一样；throwing属性：获取异常信息，并指定通知方法中入参的形参名
    @AfterThrowing(value = "execution(* Calculator.*(..))",throwing = "e")
    public void afterThrowing(JoinPoint joinPoint,Throwable e){
        //获取方法名
        String methodName = joinPoint.getSignature().getName();
        System.out.println("异常通知： "+methodName+" 方法，异常： "+e);
    }
}

2.3 .xml配置 (calculator.xml)

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

    <!--开启自动扫描包-->
    <context:component-scan base-package="com.spring.aop.aspect"/>

    <!--开启通知-->
    <aop:aspectj-autoproxy/>
</beans>

2.4 测试类 (testCalculator)

public class testCalculator {
    ApplicationContext ioc = new ClassPathXmlApplicationContext("calculator.xml");

    @Test
    public void test01() {
        Calculator calculator = (Calculator) ioc.getBean("coc");

        calculator.add(10, 2);//加
        calculator.sub(10, 2);//减
        calculator.mul(10, 2);//乘
        calculator.div(10, 0);//除：测试异常通知
    }
}

2.5 输出

在这里插入图片描述

改进为环绕通知

2.6 改进通知事务 (LoggingAspect)为环绕通知

@Controller
@Aspect
public class LoggingAspect {
    @Pointcut(value = "execution(* com.spring.aop.aspect.Calculator.*(..))")
    public void pointCut() {
    }
    
    //环绕通知，相当于动态代理的全过程
    @Around(value = "pointCut()")
    public Object aroundAdvice(ProceedingJoinPoint proceedingJoinPoint) {
        //获取方法名
        String methodName = proceedingJoinPoint.getSignature().getName();
        //获取参数
        Object[] args = proceedingJoinPoint.getArgs();
        Object result = null;
        try {
        	//前置通知
            System.out.println("前置通知： "+methodName+" 方法，参数： "+ Arrays.toString(args));
            //执行被代理对象的方法
            result = proceedingJoinPoint.proceed();
            //返回通知
            System.out.println("返回通知： "+methodName+" 方法，返回： "+result);
        } catch (Throwable e) {
        	//异常通知
            System.out.println("异常通知： "+methodName+" 方法，异常： "+e);
            e.printStackTrace();
        } finally {
        	//后置通知
            System.out.println("后置通知： "+methodName+" 方法");
        }
        return result;
    }
}

2.7 切面执行顺序

如果有两个事务通知，要规定其先后顺序就可以使用@Order()注解，设置value参数，越小执行越靠前，默认值为2147483647。
在切面类中直接注解
在这里插入图片描述

三、基于.xml配置文件配置事务

3.1 还原实现类（CalculatorImpl）

public class CalculatorImpl implements Calculator{

    @Override
    public int add(int a, int b) {
        return a + b;
    }

    @Override
    public int sub(int a, int b) {
        return a - b;
    }

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

    @Override
    public int div(int a, int b) {
        return a / b;
    }
}

3.2 事务通知（LoggingAspect)

public class LoggingAspect {
    //前置通知
    public void beforeAdvice(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        Object[] args = joinPoint.getArgs();
        System.out.println("前置通知:" + methodName + "方法，参数为：" + Arrays.toString(args));
    }

    //后置通知
    public void afterAdvice(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        System.out.println("后置通知：" + methodName + "方法。");
    }

    //异常通知
    public void afterThrowing(JoinPoint joinPoint, Throwable e) {
        String methodName = joinPoint.getSignature().getName();
        System.out.println("异常通知：" + methodName + "方法，异常:" + e);
    }

    //返回通知
    public void afterReturning(JoinPoint joinPoint,Object result){
        String methodName = joinPoint.getSignature().getName();
        System.out.println("返回通知：" + methodName+"方法，结果为：" + result);
    }
}

3.3 .xml配置 (calculator-xml.xml)

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

    <bean id="calculator" class="com.spring.aop.aspect.aop.CalculatorImpl"/>

    <bean id="loggingAspect2" class="com.spring.aop.aspect.aop.LoggingAspect"/>

    <aop:config>
        <aop:pointcut id="pointCut" expression="execution(* com.spring.aop.aspect.xml.CalculatorImpl.*(..))"/>
        <aop:aspect ref="loggingAspect2">
        	<!--前置通知-->
            <aop:before method="beforeAdvice" pointcut-ref="pointCut"/>
            <!--后置通知-->
            <aop:after method="afterAdvice" pointcut-ref="pointCut"/>
            <!--返回通知-->
            <aop:after-returning method="afterReturning" pointcut-ref="pointCut" returning="result"/>
            <!--异常通知-->
            <aop:after-throwing method="afterThrowing" pointcut-ref="pointCut" throwing="e"/>
        </aop:aspect>
    </aop:config>
</beans>

3.4 测试类 （testCalculator-xml)

public class TestCalculator {
    ApplicationContext ioc = new ClassPathXmlApplicationContext("calculator-xml.xml");

    @Test
    public void test01(){
        Calculator calculator = (Calculator) ioc.getBean("calculator");
        calculator.add(10, 2);
        calculator.sub(10, 2);
        calculator.mul(10, 2);
        calculator.div(10, 0);
    }
}

3.5 改进通知事务 (LoggingAspect)为环绕通知

public class LoggingAspect {
	//环绕通知，相当于动态代理的全过程
    public Object aroundAdvice(ProceedingJoinPoint proceedingJoinPoint){
        //获取方法名
        String methodName = proceedingJoinPoint.getSignature().getName();
        //获取参数
        Object[] args = proceedingJoinPoint.getArgs();
        Object result=null;
        try {
            //前置通知
            System.out.println("前置通知:" + methodName + "方法，参数为：" + Arrays.toString(args));
            //执行被代理对象的方法
            result = proceedingJoinPoint.proceed();
            //返回通知
            System.out.println("返回通知：" + methodName+"方法，结果为：" + result);
        } catch (Throwable e) {
            //异常通知e
            System.out.println("异常通知：" + methodName + "方法，异常:" + e);
            e.printStackTrace();
        } finally {
            //后置通知
            System.out.println("后置通知：" + methodName + "方法。");
        }
        return result;
    }
}

3.6 修改配置文件 （calculator-xml）

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

    <bean id="calculator" class="com.spring.aop.aspect.xml.CalculatorImpl"/>

    <bean id="loggingAspect" class="com.spring.aop.aspect.xml.LoggingAspect"/>

    <aop:config>
        <aop:pointcut id="pointCut" expression="execution(* com.spring.aop.aspect.xml.CalculatorImpl.*(..))"/>
        <aop:aspect ref="loggingAspect">
            <!--<!--前置通知-->
            <aop:before method="beforeAdvice" pointcut-ref="pointCut"/>
            <!--后置通知-->
            <aop:after method="afterAdvice" pointcut-ref="pointCut"/>
            <!--返回通知-->
            <aop:after-returning method="afterReturning" pointcut-ref="pointCut" returning="result"/>
            <!--异常通知-->
            <aop:after-throwing method="afterThrowing" pointcut-ref="pointCut" throwing="e"/>-->
            <!--环绕通知-->
            <aop:around method="aroundAdvice" pointcut-ref="pointCut"/>
    </aop:config>
</beans>

3.7 输出

在这里插入图片描述

Sunset、筱虎
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
实现spring-aop例子
灰太狼
04-01 1507
1.Spring aop的定义：Spring aop是spring的2大核心之一，又叫面向切面编程，是对oop的一种完善。通俗地说就是不改变原来的类的功能，额外地增加功能。所以aop采用的是动态代理模式：有java动态代理模式（默认），cglib动态代理模式。当需要代理的类不是接口类型的时候，Spring会自动切换为CGLIB来进行代理，也可以强制的选择使用CGLIB来进行代理动态代理分为两种： ...
spring-aop
03-17
Spring AOP，全称为Aspect-Oriented Programming（面向切面编程），是Spring框架的重要组成部分，它为Java应用程序提供了强大的横切关注点管理能力。在传统的面向对象编程中，我们往往需要在多个类或方法中重复编写...
SpringAOP 常见应用场景
Zyw907155124的博客
06-08 1481
常见应用场景:日志记录、权限检查、事务管理、异常处理、性能监控、缓存、参数校验和转换、API调用统计、SLF4J、Logback、Log4j等日志框架集成、自定义注解的处理。 1、AOP实现 性能监控；2、AOP实现 API调用统计；3、AOP实现 缓存；4、AOP实现自定义滑动窗口限流
spring-aop切面
ssehs的博客
02-17 1505
前言 切面(Aspect)是类(Class)的一个补充，两者正交互补，让spring的Ioc容器功能得到大大的增强。 使用Spring进行面向方面的编程 面向方面编程(AOP)是对面向对象编程(OOP)的补充，它提供了考虑程序结构的另一种方式。在OOP中模块化的关键单元是类，而在AOP中模块化的单元是方面。方面支持对跨多种类型和对象的关注点(如事务管理)进行模块化。(在AOP文献中，这种关注通常被称为“横切”关注。) Spring的一个关键组件是AOP框架。虽然Spring IoC容器不依赖于AOP(这意味
Spring - AOP - 介绍
weixin_43320796的博客
07-16 790
Spring 框架的一个关键组件是面向切面的编程(AOP)框架。面向切面的编程需要把程序逻辑分解成不同的部分称为所谓的关注点。跨一个应用程序的多个点的功能被称为横切关注点，这些横切关注点在概念上独立于应用程序的业务逻辑。在软件开发过程中有各种各样的很好的切面的例子，如日志记录、审计、声明式事务、安全性和缓存等。在 OOP 中，关键单元模块度是类，而在 AOP 中单元模块度是切面。依赖注入帮助你对应用程序对象相互解耦合，AOP 可以帮助你从它们所影响的对象中对横切关注点解耦。
Spring--AOP
qq_33807380的博客
03-15 901
Spring AOP（Aspect-Oriented Programming，面向切面编程）是Spring框架的一个核心特性，它允许开发者将横切关注（如日志、事务管理、安全性等）从业务逻辑中分离出来，从而提高代码的可重用性、可维护性和可扩展性。
spring-AOP
csdn_kafei的博客
08-29 439
spring-AOP 小例子
Spring---AOP与Annotation
weixin_44889526的博客
09-15 632
Spring---AOP面向切面编程AOP相关术语AOP通知类型AOP Schema通知类环绕通知（Around Advice）AspectJ中的Execution表达式 AOP相关术语 切面（Aspect）：一个关注点的模块化，这个关注点可能会横切多个对象。事务管理是J2EE应用中一个关于横切关 注点的很好的例子。在Spring AOP中，切面可以使用基于模式）或者基于@Aspect注解的方式来实现。 连接点（Joinpoint）：在程序执行过程中某个特定的点，比如某方法调用的时候或者处理异常的时
三、Spring-AOP
D_A_I_H_A_O的博客
04-29 939
AOP AOP：Aspect Oriented Programming 面向切面编程 AOP最早是AOP联盟组织提出的，指定的一套规范。 AOP通过提供另外一种思考程序结构的途经来弥补面向对象编程（OOP）的不足。在OOP中模块化的关键单元是类，而在AOP中模块化的单元则是切面。切面能对关注点进行模块化，例如横切多个类型和对象的事务管理。 AOP框架是Spring的一个重要组成部分。但是Spring IOC容器并不依赖于AOP，这意味着你有权利选择是否使用AOP，AOP做为Spring IOC容器的一个补
Spring-AOP详解及其使用
qq_43828345的博客
11-06 1207
Spring-AOP 1、AOP 基本概念 （1）面向切面编程（方面），利用 AOP 可以对业务逻辑的各个部分进行隔离，从而使得 业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。​ （2）通俗描述：不通过修改源代码方式，在主干功能里面添加新功能​ （3）使用登录例子说明 2、AOP（底层原理） ​ a）AOP 底层使用动态代理 ，动态代理有两种情况： 第一种 有接口情况，使用 JDK 动态代理 ；创建接口实现类代理对象，增强类的方法 第二种 没有接口情况，使用 CGLIB 动态
Spring-AOP基础（全在这里）
qq_43259860的博客
03-10 1349
可以看到我们三种After的执行顺序是先after类似于finally，然后是afterReturing,如果是有异常的话就是after和afterThrowing.通过配置的方式参考前面的配置。我们找到了切入点，我们需要执行的动作，在一个特定的Joint Poiont 进行操作。1 关于顺序问题我们可以看到在同一切面遵循环绕通知 -> 前置通知 -> 后置通知的顺序 当然后置通知里面又有分类，后文会进行介绍。2 前置通知，后置通知都是框架主动执行，只有环绕通知需要我们手动去调用。
spring-boot aop
01-23
Spring Boot AOP（面向切面编程）是一种强大的设计模式，它允许我们在不修改现有代码的情况下，插入额外的功能或监控代码。在Spring框架中，AOP主要用于日志记录、事务管理、性能统计等场景。本示例是关于如何在...
spring - aop.zip
06-10
Spring AOP（面向切面编程）是Spring框架的重要组成部分，它提供了一种在不修改源代码的情况下，通过插入额外行为来扩展对象的功能的方法。在Java应用程序中，AOP主要用于日志记录、性能度量、安全控制等跨切面的...
spring-nested-aop.zip_aop_spring aop
09-23
Spring AOP，全称Aspect-Oriented Programming（面向切面编程），是Spring框架的一个重要组成部分。它提供了一种模块化和声明式的方式来处理横切关注点，如事务管理、日志记录、性能监控等，这些关注点通常会分散在...
spring-aop.jar
07-31
《深入解析Spring AOP框架——以spring-aop.jar为例》 Spring AOP，全称Aspect Oriented Programming（面向切面编程），是Spring框架的核心部分之一，它为Java开发者提供了强大的面向切面的编程能力。本文将围绕...
免费【2024】springboot 大学生志愿者管理系统的设计与实现
最新发布
weixin_53646065的博客
08-03 648
系统根据现有的管理模块进行开发和扩展，采用面向对象的开发的思想和结构化的开发方法对大学生志愿者管理的现状进行系统调查。采用结构化的分析设计，该方法要求结合一定的图表，在模块化的基础上进行系统的开发工作。在设计中采用“自下而上”的思想，在大学生志愿者管理系统实现了志愿者、志愿组织、组织风采、志愿活动、组织报名、活动报名、留言板等的功能性。
【过滤器 vs 拦截器】SpringBoot中过滤器与拦截器：明智选择的艺术（如何在项目中做出明智选择）
weixin_68020300的博客
07-25 1265
本文深入剖析了SpringBoot框架下过滤器与拦截器的核心差异及应用场景，指导开发者在面对请求-响应周期中的不同需求时，如何做出最佳技术选择。无论是实现安全性、日志记录，还是权限控制与数据预处理，本文都将帮助你理解何时何地使用过滤器或拦截器，以构建更加高效、可维护的Web应用程序。通过对比二者的特性与优劣，本文旨在赋能开发者，使其在实际项目中灵活运用这两种强大工具，达成项目目标。
代理模式和Spring MVC
qq_63161848的博客
08-03 832
Spring的代理模式指的是Spring框架中使用代理对象来管理和增强目标对象的行为。AOP是通过动态代理实现的面向切面的编程，实现在不修改源代码的情况下给程序动态统一添加额外功能的一种技术。Spring MVC的三层架构基于MVC设计模式。它将应用程序的不同部分分为三个独立的层：模型层（Model）、视图层（View）和控制层（Controller）。
spring-aop 6.0.0 切入点注解
11-21
在Spring AOP中，切入点是指在程序执行过程中，我们要注入的代码的位置。Spring AOP支持使用注解来定义切入点，常用的注解有@Pointcut和@Around。下面是一个使用@Pointcut注解定义切入点的例子： ```java @Aspect @...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Sunset、筱虎

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值