Spring的AOP开发简单示例

最新推荐文章于 2023-10-22 15:46:14 发布
最新推荐文章于 2023-10-22 15:46:14 发布
阅读量423 收藏
点赞数
文章标签： java aop spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Fujie1997/article/details/106449272
版权

SpringAOP支持方法级别的增强。
大致有
@Before:方法执行前执行
@After：方法执行后还没有返回时执行
@Around：环绕通知，在Before之前，在After之前。
@AfterReturning:方法返回结果之后执行
@AfterThrowing：返回异常时执行
@ @DeclareParents：给类增加接口
假设 增强service包下的所有方法 ：
目录结构 ：
在这里插入图片描述
切面类：

package com.fuyouj.aspect;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

/**
 * @Desc
 * @Author FuYouJ
 * @date 2020/5/30 22:27
 */
@Aspect
@Component
public class ServiceAspect {
    //定义需要切割的地方，下面的表达式的意思是 所有限制类型的  service 包下的所有类的所有方法（任意个数参数）
    @Pointcut(value = "execution(* com.fuyouj.service..*.*(..))")
    public void embed(){}
    //方法执行前执行
    @Before("embed()")
    public void before(JoinPoint joinPoint){
        System.out.println("开始调用"+joinPoint);
    }
    //执行完成还没有返回时执行
    @After("embed()")
    public void after(JoinPoint joinPoint){
        System.out.println("调用完成"+joinPoint);
    }

    /**
     * 通过环绕通知达到检测运行时的目的
     * @param joinPoint
     * @return
     */
    @Around("embed()")
    public Object around(JoinPoint joinPoint){
        long start = System.currentTimeMillis();
        //返回值
        Object returnValue = null;
        System.out.println("开始计时"+joinPoint);
        ProceedingJoinPoint point = (ProceedingJoinPoint) joinPoint;
        System.out.println("环绕完毕");
        try {
            returnValue = point.proceed();
        } catch (Throwable throwable) {
            System.out.println("执行失败，结束计时"+joinPoint);
            throwable.printStackTrace();
        }
        finally {
            long end = System.currentTimeMillis();
            System.out.println("耗时"+(end - start));

        }
        return  returnValue;
    }
//方法返回结果之后执行
    @AfterReturning(pointcut = "embed()",returning = "returnValue")
    public void afterReturning(JoinPoint joinPoint,Object returnValue){
        System.out.println("无论为空还是有值都会返回" + joinPoint + "返回值" + returnValue);
    }
    //返回异常时执行
    @AfterThrowing(pointcut = "embed()",throwing = "exception")
    public void afterThrowing(JoinPoint joinPoint,Exception exception){
        System.out.println(joinPoint+"抛出了异常"+exception.getMessage());
    }
    /**
     * 给类增加实现接口和接口的默认实现类
     */
    @DeclareParents(value = "com.fuyouj.controller..*",defaultImpl = com.fuyouj.aspect.ParentImpl.class)
    public Parent parent;
}

控制器里面调用service的方法

@Controller
public class HelloController {
    @Autowired
    private HelloService helloService;
    public void handleRequest(){
        helloService.sayHello();
        helloService.justWantToThrowException();
    }
}

@Controller
public class HiController {
    @Autowired
    private HiService hiService;
    public void handleRequest(){
        hiService.sayHi();
        System.out.println(hiService.justWantToSayHi());
    }
}

两个service

@Service
public class HelloServiceImpl implements HelloService {
    @Override
    public void sayHello() {
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Hello everyOne");
    }

    @Override
    public void justWantToThrowException() {
        throw new RuntimeException("抛出一个hello Exception");
    }
}

@Service
public class HiServiceImpl implements HiService {
    @Override
    public void sayHi() {
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Hi everyOne");
    }

    @Override
    public String justWantToSayHi() {
        return "justWantToSayHi";
    }
}

定义增强控制器的接口

public interface Parent {
    void parentMethod();
}

接口实现类

public class ParentImpl implements Parent {
    @Override
    public void parentMethod() {
        System.out.println("额外增加的方法执行了");
    }
}

不转换接口执行

@Configuration
@ComponentScan("com.fuyouj")
//识别AOP
@EnableAspectJAutoProxy
public class Entrance {
    public static void main(String[] args) {
       ApplicationContext applicationContext =  new AnnotationConfigApplicationContext(Entrance.class);
        HelloController helloController = (HelloController) applicationContext.getBean("helloController");
//        ((Parent)helloController).parentMethod();
        helloController.handleRequest();
        HiController hiController = (HiController) applicationContext.getBean("hiController");
        hiController.handleRequest();
    }
}

执行结果：

开始计时execution(void com.fuyouj.service.HelloService.sayHello())
环绕完毕
开始调用execution(void com.fuyouj.service.HelloService.sayHello())
Hello everyOne
耗时2001
调用完成execution(void com.fuyouj.service.HelloService.sayHello())
无论为空还是有值都会返回execution(void com.fuyouj.service.HelloService.sayHello())返回值null
开始计时execution(void com.fuyouj.service.HelloService.justWantToThrowException())
环绕完毕
开始调用execution(void com.fuyouj.service.HelloService.justWantToThrowException())
执行失败，结束计时execution(void com.fuyouj.service.HelloService.justWantToThrowException())
耗时1
调用完成execution(void com.fuyouj.service.HelloService.justWantToThrowException())
无论为空还是有值都会返回execution(void com.fuyouj.service.HelloService.justWantToThrowException())返回值null
开始计时execution(void com.fuyouj.service.HiService.sayHi())
环绕完毕
开始调用execution(void com.fuyouj.service.HiService.sayHi())
java.lang.RuntimeException: 抛出一个hello Exception
	at com.fuyouj.service.impl.HelloServiceImpl.justWantToThrowException(HelloServiceImpl.java:25)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	at java.lang.reflect.Method.invoke(Method.java:498)
	at org.springframework.aop.support.AopUtils.invokeJoinpointUsingReflection(AopUtils.java:344)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.invokeJoinpoint(ReflectiveMethodInvocation.java:198)
	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:186)
	at org.springframework.aop.aspectj.MethodInvocationProceedingJoinPoint.proceed(MethodInvocationProceedingJoinPoint.java:88)
	at com.fuyouj.aspect.ServiceAspect.around(ServiceAspect.java:44)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	at java.lang.reflect.Method.invoke(Method.java:498)
	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:186)
	at org.springframework.aop.aspectj.AspectJAfterAdvice.invoke(AspectJAfterAdvice.java:47)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:186)
	at org.springframework.aop.framework.adapter.AfterReturningAdviceInterceptor.invoke(AfterReturningAdviceInterceptor.java:55)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:186)
	at org.springframework.aop.aspectj.AspectJAfterThrowingAdvice.invoke(AspectJAfterThrowingAdvice.java:62)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:186)
	at org.springframework.aop.interceptor.ExposeInvocationInterceptor.invoke(ExposeInvocationInterceptor.java:95)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:186)
	at org.springframework.aop.framework.JdkDynamicAopProxy.invoke(JdkDynamicAopProxy.java:212)
	at com.sun.proxy.$Proxy27.justWantToThrowException(Unknown Source)
	at com.fuyouj.controller.HelloController.handleRequest(HelloController.java:18)
	at com.fuyouj.controller.HelloController$$FastClassBySpringCGLIB$$71d20363.invoke(<generated>)
	at org.springframework.cglib.proxy.MethodProxy.invoke(MethodProxy.java:218)
	at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.invokeJoinpoint(CglibAopProxy.java:771)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:163)
	at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.proceed(CglibAopProxy.java:749)
	at org.springframework.aop.support.DelegatePerTargetObjectIntroductionInterceptor.doProceed(DelegatePerTargetObjectIntroductionInterceptor.java:119)
	at org.springframework.aop.support.DelegatePerTargetObjectIntroductionInterceptor.invoke(DelegatePerTargetObjectIntroductionInterceptor.java:107)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:186)
	at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.proceed(CglibAopProxy.java:749)
	at org.springframework.aop.framework.CglibAopProxy$DynamicAdvisedInterceptor.intercept(CglibAopProxy.java:691)
	at com.fuyouj.controller.HelloController$$EnhancerBySpringCGLIB$$13848a28.handleRequest(<generated>)
	at com.fuyouj.Entrance.main(Entrance.java:47)
Hi everyOne
耗时3001
调用完成execution(void com.fuyouj.service.HiService.sayHi())
无论为空还是有值都会返回execution(void com.fuyouj.service.HiService.sayHi())返回值null
开始计时execution(String com.fuyouj.service.HiService.justWantToSayHi())
环绕完毕
开始调用execution(String com.fuyouj.service.HiService.justWantToSayHi())
耗时0
调用完成execution(String com.fuyouj.service.HiService.justWantToSayHi())
无论为空还是有值都会返回execution(String com.fuyouj.service.HiService.justWantToSayHi())返回值justWantToSayHi
justWantToSayHi

Process finished with exit code 0

只测试给类增加接口

 public static void main(String[] args) {
       ApplicationContext applicationContext =  new AnnotationConfigApplicationContext(Entrance.class);
      
        HelloController helloController = (HelloController) applicationContext.getBean("helloController");
        ((Parent)helloController).parentMethod();
    }

运行
在这里插入图片描述
Spring的对一个地方多个AOP执行顺序如下图：
在这里插入图片描述
满足文章开头说的顺序，其实如果记不住这个图，还有个更好的记忆方式。
想象成同心圆。
在这里插入图片描述
先开始的后结束，后开始的先结束。

FuYouJ
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
spring aop简单应用示例
03-28
NULL 博文链接：https://fsh430623.iteye.com/blog/1226945
Spring AOP代码实现：实例演示与注解全解
热门推荐
Marion的博客
04-10 1万+
1 理解AOP 1.1 什么是AOP AOP（Aspect Oriented Programming），面向切面思想，是Spring的三大核心思想之一（两外两个：IOC-控制反转、DI-依赖注入）。 那么AOP为何那么重要呢？在我们的程序中，经常存在一些系统性的需求，比如权限校验、日志记录、统计等，这些代码会散落穿插在各个业务逻辑中，非常冗余且不利于维护。例如下面这个示意图： 有多少业务操作，就要写多少重复的校验和日志记录代码，这显然是无法接受的。当然，用面向对象的思想，我们可以把这些重复的代码抽离出来，写
Spring的AOP开发
qq_67786627的博客
09-06 57
AOP，Aspect Oriented Programming,面向切面编程，是对面向对象编程OOP的升华。OOP是纵向对一个事物的抽象，一个方法包括静态的属性信息，包括动态的方法信息等。而AOP是横向的对不同事物的抽象，属性与属性，方法与方法，对象与对象都可以组成一个切面，而用这种思维去设计编程的方式叫做面向切面编程。
Spring AOP 详细深入讲解+代码示例
最新发布
小电玩
10-22 393
Spring AOP（Aspect-Oriented Programming）是Spring框架提供的一种面向切面编程的技术。它通过将横切关注点（例如日志记录、事务管理、安全性检查等）从主业务逻辑代码中分离出来，以模块化的方式实现对这些关注点的管理和重用。在Spring AOP中，切面（Aspect）是一个模块化的关注点，它可以跨越多个对象，例如日志记录、事务管理等。切面通过定义切点（Pointcut）和增强（Advice）来介入目标对象的方法执行过程。
Spring AOP(面向切面开发)
wdy00000的博客
03-17 600
文章目录Spring AOPAOP概念面向对象：继承问题AOP思想AOP的实现原理-代理模式静态代理动态代理cglib代理spring aopaop的相关概念advise（增强）aop实例spring的事务管理事务的隔离级别 Spring AOP AOP： 面向切面的开发 AOP概念 面向对象：继承 继承： 软件复用（代码复用）， A类 a()方法， B extends A 问题升级 class A{ public void a(){ before(); 语
跟着小马哥学系列之 Spring AOP（Advisor 详解）
qq_42419406的博客
05-22 2803
学好路更宽，钱多少加班。 ——小马哥 简介 大家好，我是小马哥成千上万粉丝中的一员！2019年8月有幸在叩丁狼教育举办的猿圈活动中知道有这么一位大咖，从此结下了不解之缘！此系列在多次学习极客时间《小马哥讲Spring AOP 编程思想》基础上形成的个人一些总结。希望能帮助各位小伙伴， 祝小伙伴早日学有所成。 ...
SpringAOP:Spring AOP示例
05-06
SpringAOP Spring AOP（面向方面​​的编程）用于模块化“横截面”服务。 用一种简单的方式，我们可以说它是一个旨在拦截某些进程的组件，例如，在执行某个方法时，Spring AOP可以审核该执行方法，并在该方法执行...
spring2.5.6 aop简单示例
09-17
spring2.5.6 aop简单示例，导入可运行，包括必须jar包
spring aop简单示例.rar
12-13
aop的原理基于java动态代理模式，本资源是spring的aop运用简单示例，用于帮助初学者理解和运用aop技术
spring中AOP 注解开发示例详解
08-31
主要介绍了spring中AOP注解开发的相关资料，文中介绍的很详细，需要的朋友可以参考借鉴，下面来一起看看吧。
【Spring篇】AOP案例
Javascript_tsj的博客
05-20 2916
AOP的知识就已经讲解完了，接下来对于AOP的知识进行一个总结。
Spring的AOP及其开发
m0_61622830的博客
04-14 520
1. Spring的AOP 1.1 AOP 概念 AOP为Aspect Oriented Programming的缩写，意为面向切面编程，是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。 AOP是OOP的延续，是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而降低各部分之间的耦合度，提高程序可用性，提高开发效率。 1.2 AOP的作用及其优势 作用：在程序运行期间，在不修改源码的情况下对方法进行功能增强。 优势：减少
Spring Aop的开发步骤
qq_419111582的博客
11-29 317
1.编写核心业务代码（目标类和目标方法） package com.itweiting.aop; public class Target implements TargetInterface{ public void save(){ System.out.println("这是一个目标方法......"); } } 这是一个目标类接口 package com.itweiting.aop; public interface TargetInterface { public
spring系列：八、spring aop开发
laonxs的博客
03-20 95
spring aop概述功能术语aop实现动态代理jdk动态代理cglib动态代理spring aop 传统编程基于动态代理的经典aop开发基于aspectj切面的经典aop开发spring 整合 aspectj 实现 aop基于xml方式基于annotation方式 概述 aop（aspect oriented programming），面向切面编程。通过预编译方式和运行期动态代理实现程序维护...
Spring的AOP开发（三）
c17315377559的博客
07-30 104
一、AOP的定义 AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 二、AOP...
Spring AOP 详解
qq_62939743的博客
08-28 925
spring aop详解
Spring AOP 代码示例
DavinDeng的博客
03-17 466
SpringAOP 区分三个概念 类， 对象， 类对象 User u = new User(); User为一个类 u为一个User类的对象 User.class是User的类对象 AOP01 IUserService.java package com.qfedu.aop01; import java.util.List; public interface IUserService...
SpringAOP简单案例
cm777的博客
03-28 3535
简介 AOP的使用非常常见，但是他们的执行顺序，以及作为我们进入核心代码前的校验，是如何在校验失败不然他进入核心方法的 一、AOP的五大通知 前置通知：Before 环绕通知：Around 后置通知：After 后置返回通知：AfterReturning 后置异常通知：AfterThrowing 执行顺序如下图所示： 二、AOP的使用方式 1.定义一个切入点，这里以自定义注解的方式实现 package com.cloud.industryapi.test; import java.lang.a
Spring Aop的使用（含示例）
m0_51212267的博客
11-20 2409
介绍 在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 使用场景 日志记录 权限验证 全局异常处理 浏览记录 等 原理：动态代理 jdk动态
springAOP的使用示例
04-01
以下是一个简单的 springAOP 的使用示例： 1. 创建一个接口和实现类 ```java public interface HelloService { void sayHello(); } public class HelloServiceImpl implements HelloService { public void sayHello() { System.out.println("Hello, World!"); } } ``` 2. 创建一个切面类 ```java @Aspect @Component public class LoggingAspect { @Before("execution(* com.example.service.*.*(..))") public void logBefore(JoinPoint joinPoint) { System.out.println("Method " + joinPoint.getSignature().getName() + " is about to be executed."); } } ``` 3. 在 Spring 配置文件中配置 AOP ```xml <bean id="helloService" class="com.example.service.impl.HelloServiceImpl"/> <aop:aspectj-autoproxy/> <bean id="loggingAspect" class="com.example.aspect.LoggingAspect"/> ``` 4. 测试 ```java public class Test { public static void main(String[] args) { ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml"); HelloService helloService = (HelloService) context.getBean("helloService"); helloService.sayHello(); } } ``` 输出结果： ``` Method sayHello is about to be executed. Hello, World! ``` 在这个示例中，我们使用 AOP 实现了在 HelloService 的 sayHello() 方法执行前输出一条日志的功能。具体实现是通过在 LoggingAspect 类中定义一个 logBefore() 方法，并使用 @Before 注解告诉 Spring 在方法执行前执行该方法。在 Spring 配置文件中，我们使用 <aop:aspectj-autoproxy/> 开启了 AOP 功能，并将 LoggingAspect 类作为一个 Bean 配置了进去。最后，在测试代码中，我们通过 ApplicationContext 获取到 HelloService 的实例，并调用其 sayHello() 方法，触发 AOP 在方法执行前输出日志的功能。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值