SpringBoot Aop

最新推荐文章于 2023-07-15 19:27:30 发布
最新推荐文章于 2023-07-15 19:27:30 发布
阅读量482 收藏 1
点赞数
分类专栏： Spring Cloud
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/RamboKitty/article/details/80640793
版权

SpringBoot Aop

Aop简介

面向切面编程,通过反射、代码织入实现在方法执行前、执行后调用切入函数，主要功能涉及日志记录，方法返回值处理、方法调用前资源准备等

切入点函数

1.execution
execution(方法修饰符(可选) 返回类型 方法名 参数 异常模式(可选))

方法通配符:
* 匹配任意字符，但是只能匹配一个元素
.. 匹配任意字符，可以匹配任意多个元素，表示类时，必须和*联合使用

+  必须跟在类名后面，如Horseman+，表示类本身和继承或扩展指定类的所有类

示例:
void chop(String,int)

匹配目标类任意修饰符方法、返回void、方法名chop、带有一个String和一个int型参数的方法

public void chop(*)

匹配目标类public修饰、返回void、方法名chop、带有一个任意类型参数的方法

public String *o*(..)

 匹配目标类public修饰、返回String类型、方法名中带有一个o字符、带有任意数量任意类型参数的方法

public void *o*(String,..)

 匹配目标类public修饰、返回void、方法名中带有一个o字符、带有任意数量任意类型参数，但第一个参数必须有且为String型的方法

也可以指定类：

public void examples.chap03.Horseman.*(..)

匹配Horseman的public修饰、返回void、不限方法名、带有任意数量任意类型参数的方法

public void examples.chap03.*man.*(..)

匹配以man结尾的类中public修饰、返回void、不限方法名、带有任意数量任意类型参数的方法

指定包：

public void examples.chap03.*.chop(..)

匹配examples.chap03包下所有类中public修饰、返回void、方法名chop、带有任意数量任意类型参数的方法

public void examples..*.chop(..)

匹配examples.包下和所有子包中的类中public修饰、返回void、方法名chop、带有任意数量任意类型参数的方法
2. @annotation()

表示标注了指定注解的目标类方法

例如 @annotation(org.springframework.transaction.annotation.Transactional) 表示标注了@Transactional的方法
3. args()

通过目标类方法的参数类型指定切点

例如 args(String) 表示有且仅有一个String型参数的方法
4. @args()

通过目标类参数的对象类型是否标注了指定注解指定切点

如 @args(org.springframework.stereotype.Service) 表示有且仅有一个标注了@Service的类参数的方法
5.within()

通过类名指定切点

如 with(examples.chap03.Horseman) 表示Horseman的所有方法
6. target()

通过类名指定，同时包含所有子类

如 target(examples.chap03.Horseman)  且Elephantman extends Horseman，则两个类的所有方法都匹配
7. @within()

匹配标注了指定注解的类及其所有子类

如 @within(org.springframework.stereotype.Service) 给Horseman加上@Service标注，则Horseman和Elephantman 的所有方法都匹配
8. @target()

所有标注了指定注解的类

如 @target(org.springframework.stereotype.Service) 表示所有标注了@Service的类的所有方法
9. this()

大部分时候和target()相同，区别是this是在运行时生成代理类后，才判断代理类与指定的对象类型是否匹配

逻辑运算符

表达式可由多个切点函数通过逻辑运算组成

  1. &&

与操作，求交集，也可以写成and

例如 execution(* chop(..)) && target(Horseman) 表示Horseman及其子类的chop方法

  1. ||

或操作，求并集，也可以写成or

例如 execution(* chop(..)) || args(String) 表示名称为chop的方法或者有一个String型参数的方法

  1. !

非操作，求反集，也可以写成not

例如 execution(* chop(..)) and !args(String) 表示名称为chop的方法但是不能是只有一个String型参数的方法

注解说明

1. @Aspect
作用把当前类标识为一个切面供容器读取
2. @Before
标识一个前置增强方法，相当于BeforeAdvice，在切入点调用前进行调用
3. @AfterReturning
后置增强，相当于AfterReturningAdvice，切入点方法正常退出返回后执行
4.@AfterThrowing
后置异常，相当于ThrowsAdvice，切入点方法抛出异常执行
5.@After
final增强，不管是抛出异常或者正常退出都会执行
6.@Aroud
环绕增强，完整控制切入方法调用前调用后以及方法是否执行
7. @Order
对于多个切面对一个切入点来说，控制哪个切面先执行可以使用@Order注解，值越小越先执行

示例

方法调用前置换参数、日志记录，方法调用后结果统计

package com.chanjet.bigdata.aop;

import com.chanjet.bigdata.entity.ProducesData;
import com.chanjet.bigdata.model.AccountInfo;
import com.chanjet.bigdata.restful.RestfulTemplateUtil;
import org.apache.commons.lang.StringUtils;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @program: pull_finance_data
 * @description: PullController aop配置 进行apply id置换  日志记录
 * @author: lipeng
 * @create: 2018-04-11 10:23
 **/
@Aspect
@Component
public class PullControllerAspect
{
    private final Logger logger = LoggerFactory.getLogger(getClass());

    private static final String ORG_ID = "orgId";

    private static final String PRODUCT_CD = "productCd";

    @Autowired
    private RestfulTemplateUtil restfulTemplateUtil;

    @Pointcut("execution( public * com.chanjet.bigdata.controller.PullController.*(..))")
    public void executeService()
    {

    }

    /**
     * 方法调用前 记录日志
     *
     * @param joinPoint
     * @return void
     * @author lipeng
     * @date 2018/4/11 15:19
     */
    @Before("executeService()")
    public void beforeInvokerInfoLog(JoinPoint joinPoint)
    {
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        Map<String, String[]> mapParams = request.getParameterMap();

        String method = joinPoint.getSignature().getName();
        StringBuffer sb = new StringBuffer();
        sb.append(method + " method be invoked,params is ");
        for (String key : mapParams.keySet())
        {
            sb.append(key + ":" + mapParams.get(key)[0] + " ");
        }
        logger.info(sb.toString());
    }

    /**
     * 目标方法返回后调用 记录查询到的条数
     *
     * @param joinPoint
     * @param result
     * @return void
     * @author lipeng
     * @date 2018/4/11 15:53
     */
    @AfterReturning(value = "executeService()", returning = "result")
    public void afterInvokerInfoLog(JoinPoint joinPoint, Object result)
    {
        int resultCount = 0;

        if(result == null)
        {
            return;
        }
        else if(result instanceof List)
        {
            resultCount = ((List) result).size();
        }
        else if(result instanceof Object[])
        {
            resultCount = ((Object[]) result).length;
        }
        else if(result instanceof ProducesData)
        {
            ProducesData producesData = (ProducesData) result;
            if(producesData.getDetails() != null)
            {
                resultCount = producesData.getDetails().size();
            }
        }
        else
        {
            return;
        }
        String method = joinPoint.getSignature().getName();
        logger.info(method + " method get result count: {}", resultCount);

    }

    /**
     * 环绕通知  接口调用前置换 org 参数
     *
     * @param proceedingJoinPoint
     * @return java.lang.Object
     * @author lipeng
     * @date 2018/4/11 14:44
     */
    @Around("executeService()")
    public Object applyIdAdapterOrgId(ProceedingJoinPoint proceedingJoinPoint) throws Throwable
    {
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        //获取http参数集合
        Map<String, String[]> httpMapParams = request.getParameterMap();
        //获取被调用方法参数集合
        Map<String, Integer> methodParams = getMethodParams(proceedingJoinPoint);
        //获取调用参数
        Object[] args = proceedingJoinPoint.getArgs();
        //参数置换
        Object[] targetArgs = applyIdAdapterOrgId(httpMapParams, args, methodParams);
        //调用方法
        return proceedingJoinPoint.proceed(targetArgs);
    }


    /**
     * 申请id 置换 org id
     *
     * @param httpMapParams
     * @param targetArgs
     * @param methodParams
     * @return java.lang.Object[]
     * @author lipeng
     * @date 2018/4/17 10:36
     */
    private Object[] applyIdAdapterOrgId(Map<String, String[]> httpMapParams, Object[] targetArgs, Map<String, Integer> methodParams)
    {

        //调用参数中有org id需要进行判断  如果是请求id进行rest调用查询org id
        if(!httpMapParams.containsKey(ORG_ID))
        {
            return targetArgs;
        }

        String applyId = httpMapParams.get(ORG_ID)[0];

        //applyId 是空 或者小于15位
        if(StringUtils.isEmpty(applyId) || applyId.length() < 15)
        {
            return targetArgs;
        }
        //查询apply id对应的org id
        AccountInfo resultAdapter = restfulTemplateUtil.getAccountInfo(applyId);
        //未查询到对应的org product_cd信息
        if(resultAdapter == null || StringUtils.isEmpty(resultAdapter.getOrgId()))
        {
            return targetArgs;
        }
        logger.info("!apply id: {} substitution org id: {}", applyId, resultAdapter.getOrgId());

        if(methodParams.containsKey(ORG_ID))
        {
            targetArgs[methodParams.get(ORG_ID)] = resultAdapter.getOrgId();
        }
        //调用方法存在productCd参数
        if(methodParams.containsKey(PRODUCT_CD))
        {
            //请求未携带productCd 或 携带的productCd为空
            if(!httpMapParams.containsKey(PRODUCT_CD) ||
                    StringUtils.isEmpty(httpMapParams.get(PRODUCT_CD) != null ? httpMapParams.get(PRODUCT_CD)[0] : ""))
            {
                targetArgs[methodParams.get(PRODUCT_CD)] = resultAdapter.getLoanProductsChanjet();
            }
        }

        targetArgs[methodParams.get("bookId")] = resultAdapter.getLoanAccountBookId();
        return targetArgs;
    }

    /**
     * 方法参数与对应的索引映射到 map集合
     *
     * @param proceedingJoinPoint
     * @return java.util.Map<java.lang.String               ,               java.lang.Integer>
     * @author lipeng
     * @date 2018/4/17 10:30
     */
    private Map<String, Integer> getMethodParams(ProceedingJoinPoint proceedingJoinPoint)
    {
        MethodSignature methodSignature = (MethodSignature) proceedingJoinPoint.getSignature();
        Method invokedMethod = methodSignature.getMethod();
        Map<String, Integer> methodParamsName = new HashMap<>();
        //每个参数只有一个注解 二维数组列行为0
        Annotation[][] parameterAnnotations = invokedMethod.getParameterAnnotations();
        if(parameterAnnotations != null)
        {
            for (int i = 0, size = parameterAnnotations.length; i < size; i++)
            {
                Annotation annotation = parameterAnnotations[i][0];
                if(annotation instanceof RequestParam)
                {
                    //注解转换成 RequestParam
                    RequestParam requestParam = (RequestParam) annotation;
                    //方法名称 + index
                    methodParamsName.put(requestParam.value(), i);
                }
                else if(annotation instanceof AopParam)
                {
                    //注解转换成 RequestParam
                    AopParam requestParam = (AopParam) annotation;
                    //方法名称 + index
                    methodParamsName.put(requestParam.value(), i);
                }
            }
        }

        return methodParamsName;
    }
}
RamboKitty
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Spring-AOP配置(注解及多方整合案例)
汤键的博客
09-19 2005
Spring-AOP配置(注解及多方整合案例)
spring事务配置多个切点，即多个execution
Dendy之Java小屋
07-24 1204
&lt;aop:config&gt; &lt;!-- 配置多个切点，&amp;&amp; || ! --&gt; &lt;aop:pointcut id="pc" expression="execution(public * com.wtas.*.service.*.*(..)) || execution(public * com.wtas.*.*.service.*.*(..)) ||...
Spring AOP切入点表达式+语法格式+通配符+书写技巧
阿博的博客
10-18 1312
Spring AOP切入点表达式+语法格式+通配符+写技巧书
实现Spring AOP 应用的几种方式
mawujun1234的专栏
04-22 1万+
 spring开发aop应用有三种方法:一:Spring 1.2版本中通过ProxyFactoryBean来实现aop,即通过动态代理来实现的,Aspect必须继承MethodBeforeAdvice,MethodAfterAdvice等张三class="org.springframework.aop.framework.ProxyFactoryBean">fbi 
SpringBoot使用AOP详解
半月的博客
05-27 5898
aop
SpringBoot AOP各种注解、自定义注解、鉴权使用案例（免费下载）
02-24
SpringBoot AOP，即面向切面编程，是Spring框架中的一个重要特性，用于实现代码的横切关注点，如日志记录、事务管理、权限验证等。AOP通过使用代理模式，将这些关注点与核心业务逻辑分离，使得代码更加模块化，更...
详解SpringBoot AOP 拦截器（Aspect注解方式）
08-30
SpringBoot AOP 拦截器（Aspect注解方式） 在 SpringBoot 项目中，AspectJ 是一种常用的 AOP 实现方式，通过使用 AspectJ 注解，可以轻松地实现方法拦截和增强。下面将详细介绍 SpringBoot AOP 拦截器的实现方式。 ...
SpringBoot AOP切面类三种写法（源代码）
01-27
SpringBoot AOP 写法一： @Before("execution(* com.bjpowernode.springboot07.javabean.Man.eat(..))") 一、AOP开发 1.1 概述 1.2使用方法 1.3创建项目并添加maven依赖 1.4 创建Javabean测试类 1.5 创建切面 1.6 ...
springboot AOP使用实例源码
12-20
在Springboot上使用AOP的简单实例源码，可以结合本人的文章一起学习理解 https://blog.csdn.net/vincent_yuan89/article/details/85128009
SpringBoot AOP方式实现多数据源切换的方法
08-27
SpringBoot AOP方式实现多数据源切换的方法 在本篇文章中，我们将介绍如何使用 SpringBoot AOP 方式实现多数据源切换的方法。这是一种非常实用的解决方案，能够解决多数据源配置和动态切换的问题。 多数据源配置 ...
SpringBoot中AOP的使用
热门推荐
07-08 3万+
文章目录提前预知准备工作相关注解 提前预知 本片博客主要介绍springboot中aop的使用，用过Spring框架的都知道，aop是spring框架的两大核心功能之一，还有一个就是ioc，下面我们就springboot中如何引入aop来做一下探讨 准备工作 相关注解 @Before ：前置通知，在方法执行之前执行 @After ：后置通知，在方法执行之后执行 @AfterRuturning ：返回通知，在方法返回结果之后执行 @AfterThrowing ：异常通知，在方法抛出异常之后执行 @Aroun
Spring Boot原理分析（三）：AOP
TracyCoder的博客
07-15 820
它使用注解来定义切面和通知操作，使用动态代理来生成代理对象，并在运行时将切面的通知操作织入到代理对象的方法调用中。一旦切面被织入到目标对象中，它可以在目标对象的方法执行前、执行后或异常抛出时插入额外的逻辑，从而实现横切关注点的功能。它使用 XML配置文件来定义切面、切点和通知操作等信息，使用 AOP 命名空间来声明和配置切面和通知操作等元素，从而实现代理对象的方法调用拦截和增强。它使用注解来定义切面和通知操作，使用动态代理来生成代理对象，并在运行时将切面的通知操作织入到代理对象的方法调用中。
SpringBoot使用AOP
weixin_34410662的博客
09-09 979
本文介绍SpringBoot中使用Spring AOP。 简介 AOP简介 AOP可能对于广大开发者耳熟能详，它是Aspect Oriented Programming的缩写，翻译成中文就是：面向切面编程。这个可能是面试中经常提到的问题，同时它也是Spring框架中一个重大的特性，AOP主要实现的目的是针对业务处理过程中的切面进行提取，它所面对的是处理过程中的某个步骤或阶段，以获得逻辑过程中...
Spring全家桶系列–SpringBoot之AOP详解
b_just的博客
05-26 406
面向方面编程（AOP）通过提供另一种思考程序结构的方式来补充面向对象编程（OOP）。 OOP中模块化的关键单元是类，而在AOP中，模块化单元是方面。 准备工作 首先，使用AOP要在build.gradle中加入依赖 //引入AOP依赖 compile "org.springframework.boot:spring-boot-starter-aop:${springBootVersion}" 然后在application.yml中加入 spring: aop: proxy-..
SpringBoot项目使用aop
qq_39176307的博客
05-12 3228
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、SpringBoot项目引入AOP依赖二、切面类代码1.引入库2.读入数据总结 前言 IOC和AOP是Spring中的两个核心的概念，简单介绍一下我的理解： IOC：控制反转，就是将以前由我们自己手动创建对象的过程交给了Spring，Spring帮助我们生产对象、管理对象、管理对象和对象之间的依赖关系。降低了代码的耦合度，方便我们后期对项目做维护。举个通俗一点的例子： 正常情况下，我们在家，饿了，自己做饭。 使用IOC情.
Spring Boot AOP 扫盲，实现接口访问的统一日志记录
沉默王二
02-22 7079
AOP 是 Spring 体系中非常重要的两个概念之一（另外一个是 IoC），今天这篇文章就来带大家通过实战的方式，在编程猫 SpringBoot 项目中使用 AOP 技术为 controller 层添加一个切面来实现接口访问的统一日志记录。 一、关于 AOP AOP，也就是 Aspect-oriented Programming，译为面向切面编程，是计算机科学中的一个设计思想，旨在通过切面技术为业务主体增加额外的通知（Advice），从而对声明为“切点”（Pointcut）的代码块进行统一管理和装饰。 这
Spring Boot 自定义注解实现AOP切面织入
橘子汁的博客
08-01 3470
自定义注解实现AOPAOP简要概述自定义注解annotation配置AOP切面使用 AOP简要概述 AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。 所谓的动态代理就是说AOP框架不会去改动原有代码，而是在内存中临时为方法生成一个AOP对象，这个对象在特定的切点做了增强处理。 Spring AOP中的动态代理主要有两种实现方式，JDK动态代理和CGLIB动态代理。JDK动态代理通过反射来接收被代理的类，
spring boot aop @Before注解 里面多层参数
i_am_a_kid的博客
10-22 2372
```java @Aspect @Component public class PagerAop { /** * 拦截DAO执行之前的参数，并初始化分页插件 * * @param joinPoint * @throws InterruptedException */ @Before("execution(java.util.List com.weein.admin.dao.*.select*(..))" + "||.
spring boot AOP @Before @After 最简单的切面
Teler的博客
08-30 2万+
写一个最简单明细的切面，希望可以复制了直接用。我会尽量把注释写详细 1.引入jar 因为我是用的springboot，所以只需要引入一个包，如果你习惯的是引入两个包 也可以引入下面的两个包 SpingBoot: <!--aop切面--> <dependency> <groupId>org.springframework.boot</groupId&...
Springboot Aop
最新发布
08-26
SpringBoot AOP是Spring框架的一个重要特性，用于实现面向切面编程。通过引入AOP依赖，我们可以简化开发操作，并且可以使用一些常用的注解来方便我们的开发。在SpringBoot中，我们可以使用`spring-boot-starter-aop`...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值