SpringBoot之集成Spring AOP

最新推荐文章于 2024-01-02 23:22:09 发布
最新推荐文章于 2024-01-02 23:22:09 发布
阅读量263 收藏
点赞数
分类专栏： spring 文章标签： spring aop

本文转自：http://lib.csdn.net/article/microservice/60453?knId=1899

在开始之前，我们先把需要的jar包添加到工程里。新增Maven依赖如下：

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
接下来，我们进入正题。这里的涉及的通知类型有：前置通知、后置最终通知、后置返回通知、后置异常通知、环绕通知，下面我们就具体的来看一下怎么在SpringBoot中添加这些通知。
首先我们先创建一个Aspect切面类： 
@Component
@Aspect
public class WebControllerAop {

}
指定切点： 
    //匹配com.zkn.learnspringboot.web.controller包及其子包下的所有类的所有方法
    @Pointcut("execution(* com.zkn.learnspringboot.web.controller..*.*(..))")
    public void executeService(){

    }
接着我们再创建一个Controller请求处理类： 
package com.zkn.learnspringboot.web.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * Created by zkn on 2016/11/19.
 */
@RestController
@RequestMapping("/aop")
public class AopTestController {

}

前置通知

配置前置通知： 
    /**
     * 前置通知，方法调用前被调用
     * @param joinPoint
     */
    @Before("executeService()")
    public void doBeforeAdvice(JoinPoint joinPoint){
        System.out.println("我是前置通知!!!");
        //获取目标方法的参数信息
        Object[] obj = joinPoint.getArgs();
        //AOP代理类的信息
        joinPoint.getThis();
        //代理的目标对象
        joinPoint.getTarget();
        //用的最多 通知的签名
        Signature signature = joinPoint.getSignature();
        //代理的是哪一个方法
        System.out.println(signature.getName());
        //AOP代理类的名字
        System.out.println(signature.getDeclaringTypeName());
        //AOP代理类的类（class）信息
        signature.getDeclaringType();
        //获取RequestAttributes
        RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
        //从获取RequestAttributes中获取HttpServletRequest的信息
        HttpServletRequest request = (HttpServletRequest) requestAttributes.resolveReference(RequestAttributes.REFERENCE_REQUEST);
        //如果要获取Session信息的话，可以这样写：
        //HttpSession session = (HttpSession) requestAttributes.resolveReference(RequestAttributes.REFERENCE_SESSION);
        Enumeration<String> enumeration = request.getParameterNames();
        Map<String,String> parameterMap = Maps.newHashMap();
        while (enumeration.hasMoreElements()){
            String parameter = enumeration.nextElement();
            parameterMap.put(parameter,request.getParameter(parameter));
        }
        String str = JSON.toJSONString(parameterMap);
        if(obj.length > 0) {
            System.out.println("请求的参数信息为："+str);
        }
    }
注意：这里用到了JoinPoint和RequestContextHolder。通过JoinPoint可以获得通知的签名信息，如目标方法名、目标方法参数信息等。通过RequestContextHolder来获取请求信息，Session信息。
接下来我们在Controller类里添加一个请求处理方法来测试一下前置通知： 
    @RequestMapping("/testBeforeService.do")
    public String testBeforeService(String key,String value){

        return "key="+key+"  value="+value;
    }
前置通知拦截结果如下所示：

后置返回通知

配置后置返回通知的代码如下： 
    /**
     * 后置返回通知
     * 这里需要注意的是:
     *      如果参数中的第一个参数为JoinPoint，则第二个参数为返回值的信息
     *      如果参数中的第一个参数不为JoinPoint，则第一个参数为returning中对应的参数
     * returning 限定了只有目标方法返回值与通知方法相应参数类型时才能执行后置返回通知，否则不执行，对于returning对应的通知方法参数为Object类型将匹配任何目标返回值
     * @param joinPoint
     * @param keys
     */
    @AfterReturning(value = "execution(* com.zkn.learnspringboot.web.controller..*.*(..))",returning = "keys")
    public void doAfterReturningAdvice1(JoinPoint joinPoint,Object keys){

        System.out.println("第一个后置返回通知的返回值："+keys);
    }

    @AfterReturning(value = "execution(* com.zkn.learnspringboot.web.controller..*.*(..))",returning = "keys",argNames = "keys")
    public void doAfterReturningAdvice2(String keys){

        System.out.println("第二个后置返回通知的返回值："+keys);
    }
Controller里添加响应的请求处理信息来测试后置返回通知： 
    @RequestMapping("/testAfterReturning.do")
    public String testAfterReturning(String key){

        return "key=: "+key;
    }
    @RequestMapping("/testAfterReturning01.do")
    public Integer testAfterReturning01(Integer key){

        return key;
    }
当发送请求为：http://localhost:8001/aop/testAfterReturning.do?key=testsss&value=855sss时，处理结果如图所示：
当发送请求为：http://localhost:8001/aop/testAfterReturning01.do?key=55553&value=855sss时，处理结果如图所示：

后置异常通知

后置异常通知的配置方式如下： 
    /**
     * 后置异常通知
     *  定义一个名字，该名字用于匹配通知实现方法的一个参数名，当目标方法抛出异常返回后，将把目标方法抛出的异常传给通知方法；
     *  throwing 限定了只有目标方法抛出的异常与通知方法相应参数异常类型时才能执行后置异常通知，否则不执行，
     *      对于throwing对应的通知方法参数为Throwable类型将匹配任何异常。
     * @param joinPoint
     * @param exception
     */
    @AfterThrowing(value = "executeService()",throwing = "exception")
    public void doAfterThrowingAdvice(JoinPoint joinPoint,Throwable exception){
        //目标方法名：
        System.out.println(joinPoint.getSignature().getName());
        if(exception instanceof NullPointerException){
            System.out.println("发生了空指针异常!!!!!");
        }
    }
Controller里配置响应的请求处理类： 
    @RequestMapping("/testAfterThrowing.do")
    public String testAfterThrowing(String key){

        throw new NullPointerException();
    }
后置异常通知方法的处理结果如下所示：

后置最终通知

后置最终通知的配置方式如下： 
    /**
     * 后置最终通知（目标方法只要执行完了就会执行后置通知方法）
     * @param joinPoint
     */
    @After("executeService()")
    public void doAfterAdvice(JoinPoint joinPoint){

        System.out.println("后置通知执行了!!!!");
    }
Controller类配置相应的请求处理类： 
    @RequestMapping("/testAfter.do")
    public String testAfter(String key){

        throw new NullPointerException();
    }
    @RequestMapping("/testAfter02.do")
    public String testAfter02(String key){

        return key;
    }
当发送请求为：http://localhost:8001/aop/testAfter.do?key=55553&value=855sss

当发送请求为：http://localhost:8001/aop/testAfter02.do?key=55553&value=855sss


环绕通知

环绕通知的配置方式如下： 
    /**
     * 环绕通知：
     *   环绕通知非常强大，可以决定目标方法是否执行，什么时候执行，执行时是否需要替换方法参数，执行完毕是否需要替换返回值。
     *   环绕通知第一个参数必须是org.aspectj.lang.ProceedingJoinPoint类型
     */
    @Around("execution(* com.zkn.learnspringboot.web.controller..*.testAround*(..))")
    public Object doAroundAdvice(ProceedingJoinPoint proceedingJoinPoint){
        System.out.println("环绕通知的目标方法名："+proceedingJoinPoint.getSignature().getName());
        try {
            Object obj = proceedingJoinPoint.proceed();
            return obj;
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        return null;
    }
Controller对应的请求处理类如下： 
    @RequestMapping("/testAroundService.do")
    public String testAroundService(String key){

        return "环绕通知："+key;
    }
当发送请求为：http://localhost:8001/aop/testAroundService.do?key=55553

当发送请求为:http://localhost:8001/aop/testAfter02.do?key=55553&value=855sss时，不符合环绕通知的切入规则，所以环绕通知不会 执行。
完整的AOP配置代码如下： 
package com.zkn.learnspringboot.aop;

import com.alibaba.fastjson.JSON;
import com.google.common.collect.Maps;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import java.util.Enumeration;
import java.util.Map;

/**
 * Created by zkn on 2016/11/18.
 */
@Component
@Aspect
public class WebControllerAop {

    //匹配com.zkn.learnspringboot.web.controller包及其子包下的所有类的所有方法
    @Pointcut("execution(* com.zkn.learnspringboot.web.controller..*.*(..))")
    public void executeService(){

    }

    /**
     * 前置通知，方法调用前被调用
     * @param joinPoint
     */
    @Before("executeService()")
    public void doBeforeAdvice(JoinPoint joinPoint){
        System.out.println("我是前置通知!!!");
        //获取目标方法的参数信息
        Object[] obj = joinPoint.getArgs();
        //AOP代理类的信息
        joinPoint.getThis();
        //代理的目标对象
        joinPoint.getTarget();
        //用的最多 通知的签名
        Signature signature = joinPoint.getSignature();
        //代理的是哪一个方法
        System.out.println(signature.getName());
        //AOP代理类的名字
        System.out.println(signature.getDeclaringTypeName());
        //AOP代理类的类（class）信息
        signature.getDeclaringType();
        //获取RequestAttributes
        RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
        //从获取RequestAttributes中获取HttpServletRequest的信息
        HttpServletRequest request = (HttpServletRequest) requestAttributes.resolveReference(RequestAttributes.REFERENCE_REQUEST);
        //如果要获取Session信息的话，可以这样写：
        //HttpSession session = (HttpSession) requestAttributes.resolveReference(RequestAttributes.REFERENCE_SESSION);
        Enumeration<String> enumeration = request.getParameterNames();
        Map<String,String> parameterMap = Maps.newHashMap();
        while (enumeration.hasMoreElements()){
            String parameter = enumeration.nextElement();
            parameterMap.put(parameter,request.getParameter(parameter));
        }
        String str = JSON.toJSONString(parameterMap);
        if(obj.length > 0) {
            System.out.println("请求的参数信息为："+str);
        }
    }

    /**
     * 后置返回通知
     * 这里需要注意的是:
     *      如果参数中的第一个参数为JoinPoint，则第二个参数为返回值的信息
     *      如果参数中的第一个参数不为JoinPoint，则第一个参数为returning中对应的参数
     * returning 限定了只有目标方法返回值与通知方法相应参数类型时才能执行后置返回通知，否则不执行，对于returning对应的通知方法参数为Object类型将匹配任何目标返回值
     * @param joinPoint
     * @param keys
     */
    @AfterReturning(value = "execution(* com.zkn.learnspringboot.web.controller..*.*(..))",returning = "keys")
    public void doAfterReturningAdvice1(JoinPoint joinPoint,Object keys){

        System.out.println("第一个后置返回通知的返回值："+keys);
    }

    @AfterReturning(value = "execution(* com.zkn.learnspringboot.web.controller..*.*(..))",returning = "keys",argNames = "keys")
    public void doAfterReturningAdvice2(String keys){

        System.out.println("第二个后置返回通知的返回值："+keys);
    }

    /**
     * 后置异常通知
     *  定义一个名字，该名字用于匹配通知实现方法的一个参数名，当目标方法抛出异常返回后，将把目标方法抛出的异常传给通知方法；
     *  throwing 限定了只有目标方法抛出的异常与通知方法相应参数异常类型时才能执行后置异常通知，否则不执行，
     *      对于throwing对应的通知方法参数为Throwable类型将匹配任何异常。
     * @param joinPoint
     * @param exception
     */
    @AfterThrowing(value = "executeService()",throwing = "exception")
    public void doAfterThrowingAdvice(JoinPoint joinPoint,Throwable exception){
        //目标方法名：
        System.out.println(joinPoint.getSignature().getName());
        if(exception instanceof NullPointerException){
            System.out.println("发生了空指针异常!!!!!");
        }
    }

    /**
     * 后置最终通知（目标方法只要执行完了就会执行后置通知方法）
     * @param joinPoint
     */
    @After("executeService()")
    public void doAfterAdvice(JoinPoint joinPoint){

        System.out.println("后置通知执行了!!!!");
    }

    /**
     * 环绕通知：
     *   环绕通知非常强大，可以决定目标方法是否执行，什么时候执行，执行时是否需要替换方法参数，执行完毕是否需要替换返回值。
     *   环绕通知第一个参数必须是org.aspectj.lang.ProceedingJoinPoint类型
     */
    @Around("execution(* com.zkn.learnspringboot.web.controller..*.testAround*(..))")
    public Object doAroundAdvice(ProceedingJoinPoint proceedingJoinPoint){
        System.out.println("环绕通知的目标方法名："+proceedingJoinPoint.getSignature().getName());
        try {//obj之前可以写目标方法执行前的逻辑
            Object obj = proceedingJoinPoint.proceed();//调用执行目标方法
            return obj;
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        return null;
    }
}
完整的Controller类代码如下: 
package com.zkn.learnspringboot.web.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * Created by zkn on 2016/11/19.
 */
@RestController
@RequestMapping("/aop")
public class AopTestController {

    @RequestMapping("/testBeforeService.do")
    public String testBeforeService(String key,String value){

        return "key="+key+"  value="+value;
    }
    @RequestMapping("/testAfterReturning.do")
    public String testAfterReturning(String key){

        return "key=: "+key;
    }
    @RequestMapping("/testAfterReturning01.do")
    public Integer testAfterReturning01(Integer key){

        return key;
    }
    @RequestMapping("/testAfterThrowing.do")
    public String testAfterThrowing(String key){

        throw new NullPointerException();
    }
    @RequestMapping("/testAfter.do")
    public String testAfter(String key){

        throw new NullPointerException();
    }
    @RequestMapping("/testAfter02.do")
    public String testAfter02(String key){

        return key;
    }
    @RequestMapping("/testAroundService.do")
    public String testAroundService(String key){

        return "环绕通知："+key;
    }
}

_西西_open
关注
专栏目录
基于Springboot的Spring AOP学习记录
jacksonary的博客
11-22 2640
一、AOP概述AOP(面对切面编程)是对OOP(面向对象编程)的补充，总体来说，编程范式包含：面向过程编程、面向对象编程、函数式编程、事件驱动编程、面向切面编程。AOP的出现主要是为了解决如下的几个问题： 1.代码重复性的问题 2.关注点的分离（包含了水平分离：展示层->服务层->持久层；垂直分离：模块划分(订单、库存等)；切面分离：分离功能性需求与非功能性需求）AOP使用优势： 1.集中处理
springboot 简单集成 spring security（一）
aimeng555的博客
04-10 2225
1、spring security 简介 Spring Security是一个能够为基于Spring的企业应用系统提供声明式的安全访问控制解决方案的安全框架。它提供了一组可以在Spring应用上下文中配置的Bean，充分利用了Spring IoC，DI（控制反转Inversion of Control ,DI:Dependency Injection 依赖注入）和AOP（面向切面编程）功能，为应用系统提供声明式的安全访问控制功能，减少了为企业系统安全控制编写大量重复代码的工作。（转自百度百科） 2、spri
SpringBoot中对Spring AOP的实现
xzy的博客
10-25 469
IOC 控制反转，也就是IOC容器，我们可以在容器中事先创建对象，后面用到对象的时候就不用再new了，可以直接从IOC容器里面取出来。DI 依赖注入，就是说Spring的对象是在配置文件里面配置的，可以在配置文件里面把一个对象注入给另外一个对象。AOP 面向切面编程，可以大大的解耦，把一些无关业务逻辑的代码单独的抽取出来如下图：使用上面的切面的话，就会切入注解是@GetMapping的所有方法。
Spring Boot中整合AOP
zhouym_的博客
09-06 382
我们知道aop它是一种面向切面编程的技术，它是基于动态代理实现的，在spring中就有两种实现方式，一种是基于based-schema方式实现的，还有一种是基于aspectj实现的，可以参考之前的博客Spring中aop的两种实现方式 有一个场景，当我们项目上线，上线之后出现了运行很慢的情况，这时候我想知道到底在那个环节出问题了，这时候我们就可以通过AOP来做了，可以通过打印日志来确定问题在哪一块...
SpringBoot整合AOP
chy1984的博客
05-25 1579
如果是通过目标类的其它方法去调用目标方法（目标类内部调用目标方法），则代理（aop）不生效，此种情况需要通过 AopContext 获取代理（目标类实例），通过代理来调用目标方法。1、因为要在切面类中调用（目标类的）目标方法，所以目标方法要用 public 修饰才能被代理、调用，aop才会生效。使用最多的是aspectj，平时所说的sping aop也往往是指这种方式，此处介绍的也是aspectj的使用。2、要直接通过目标类来调用目标方法，代理（aop）才会生效，eg.
详解SpringBoot之集成Spring AOP
08-30
详解SpringBoot之集成Spring AOP SpringBoot是一款基于Java的开源框架，提供了rapid.Application Development的能力，帮助开发者快速构建松散耦合的应用程序。Spring AOP是Spring框架中的一个重要组件，提供了面向...
浅谈SpringBoot集成Redis实现缓存处理(Spring AOP实现)
08-28
SpringBoot集成Redis实现缓存处理(Spring AOP实现) 本文主要介绍了如何使用SpringBoot框架集成Redis实现缓存处理，通过Spring AOP（面向切面编程）实现缓存处理。下面是相关知识点的总结： 一、需求分析 在开源...
图书管理系统（SpringBoot+SpringMVC+SpringAOP+Spring+IoC ）
最新发布
08-02
本图书管理系统基于SpringBoot、SpringMVC、SpringAOP和Spring IoC等核心技术构建，旨在提供一个高效、灵活且可扩展的图书管理解决方案。系统具备用户管理、图书信息管理、借阅管理和统计分析等功能模块，通过友好的...
SpringBoot深度解析：集成Spring AOP实战指南
在SpringBoot中集成Spring AOP主要是为了实现面向切面的编程，它允许我们在不修改原有业务代码的情况下，插入额外的功能，如日志记录、事务管理、性能监控等。首先，我们需要在项目中引入对应的依赖，通过在Maven的...
【SpringBoot】SpingBoot整合AOP
ykletters的专栏
06-18 316
说起spring，我们知道其最核心的两个功能就是AOP（面向切面）和IOC（控制反转），这边文章来总结一下SpringBoot如何整合使用AOP。 一、示例应用场景：对所有的web请求做切面来记录日志。
springboot 整合aop
qq_31024823的博客
12-26 204
一. 加依赖  &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spring-boot-starter-aop&lt;/artifactId&gt; &lt;/dependenc...
springboot整合aop
jattxgt的博客
03-26 316
1、导入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency> 2、定义切面类 package com.xiao...
【使用篇】springboots整合AOP
binggoling
07-13 393
小白篇springboot干货使用-springboots整合AOP切面使用
Spring及SpringBoot中AOP的使用
tiantiantbtb的博客
10-30 258
-当下所有的jar包都需要手动添加依赖,并且需要确定依赖的关系,对初学者不友好-->--引入SpringBean-->--引入AOP 以下三个包-->--引入context包-->--Spring核心包-->--引入表达式jar包-->--引入日志依赖-->--引入AOP包-->--引入测试包-->SpringBoot中使用AOP。Spring中AOP示例。
spring aop思想和spring boot aop配置
好幸运
03-28 218
一、AOP(面向切面编程) 轻松理解AOP思想(面向切面编程)https://www.cnblogs.com/Wolfmanlq/p/6036019.html 需要从不同的角度来看待同一个事物。这里的“方面”，指的是事物的外在特性在不同观察角度下的体现。而在AOP中，Aspect的含义，可能更多的理解为“切面”比较合适。可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态...
springboot中引入AOP切面编程
码农从0到1
01-02 915
这样才能被自动扫描到。在com.lingyi.mybatis.aop包下创建一个TimeCustomAspect.java的AOP类，增强方法执行的行为。1、首先，确保已经添加了相关依赖。经过测试，编写的AOP切面编程程序生效，AOP会根据切点表达式自动进行切面处理。当符合条件的方法调用发生时，就会执行相应的通知逻辑。2、创建切面类（Aspect）并定义切点（Pointcut）、前置通知（Before Advice）等逻辑。3、测试，登录swagger UI界面，访问controller层某个接口。
SpringBoot+Gradle实现AOP
david的博客
11-29 2984
1.搭建SpringBoot+Gradle项目，可参考：《SpringBoot+Gradle运行简单Demo Eclipse》 2.在gradle.build中添加jar包引用：package com.david.translate.aspect;import javax.servlet.http.HttpServletRequest;import org.aspectj.lang.JoinPoi
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值