SpringBoot自定义AOP 升级版本

已于 2022-04-17 20:21:44 修改
阅读量1.3k 收藏 2
点赞数
分类专栏： SpringBoot 文章标签： 自定义AOP
于 2022-04-17 16:06:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq873113580/article/details/124231099
版权

基础版见这个

SpringBoot AOP 实现请求日志记录_Teln_小凯的博客-CSDN博客_springboot请求日志记录引入依赖<dependency> <groupId>aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>1.5.4</version> </dependency>监控类代码，目前只做了控制台输出，后续自己切换到文本或者数据库中pachttps://blog.csdn.net/qq873113580/article/details/123933646下面是升级版

依赖

<dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.8</version>
        </dependency>

自定义监控日志类

package com.java.core.com.annotation;

import com.java.core.com.enums.BusinessType;

import java.lang.annotation.*;

@Target({ ElementType.PARAMETER, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Log
{
    /**
     * 模块
     */
    public String title() default "";

    /**
     * 功能
     */
    public BusinessType businessType() default BusinessType.OTHER;

    /**
     * 是否保存请求的参数
     */
    public boolean isSaveRequestData() default true;

    /**
     * 是否保存响应的参数
     */
    public boolean isSaveResponseData() default true;
}

枚举

package com.java.core.com.enums;

public enum BusinessType
{
    /**
     * 其它
     */
    OTHER,
    /**
     * 获取
     */
    GET,
    /**
     * 新增
     */
    INSERT,

    /**
     * 修改
     */
    UPDATE,

    /**
     * 删除
     */
    DELETE,

    /**
     * 授权
     */
    GRANT,

    /**
     * 导出
     */
    EXPORT,

    /**
     * 导入
     */
    IMPORT,

    /**
     * 强退
     */
    FORCE,

    /**
     * 生成代码
     */
    GENCODE,

    /**
     * 清空
     */
    CLEAN,
}

controller用法

@ApiOperation(value = "刷新登录状态")
    @Log(title = "在线用户", businessType = BusinessType.UPDATE)
    @PreAuthorize("hasAuthority('sys:userOnline:insert') || hasAuthority('sys:userOnline:edit')")
    @PostMapping(value = "/refreshToken")
    public HttpResult refreshToken(HttpServletRequest request){
        //在线用户
        SysUserOnline onlineUser= WebApp.getOnlineUser(request,"","");
        //保存到数据库
        return HttpResult.ok(sysUserOnlineService.saveOnline(onlineUser));
    }

请求后的监控，和报错的监控

package com.java.core.web.config;

import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.support.spring.PropertyPreFilters;
import com.java.core.com.annotation.Log;
import com.java.core.com.enums.BusinessStatus;
import com.java.core.com.utils.StringUtils;
import com.java.core.com.utils.http.AddressUtils;
import com.java.core.com.utils.http.IpUtils;
import com.java.core.com.utils.spring.SpringUtils;
import com.java.core.com.vo.HttpResult;
import com.java.core.core.security.JwtTokenUtils;
import com.java.core.entity.master.SysOperLog;
import com.java.core.service.system.SysOperLogService;
import com.java.core.service.system.SysUserOnlineService;
import eu.bitwalker.useragentutils.UserAgent;
import io.jsonwebtoken.Claims;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;
import org.springframework.validation.BindingResult;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Collection;
import java.util.Date;
import java.util.Map;

//处理AOP切面请求日志
@Slf4j
@Component
@Aspect
public class OperLogConfig {
    /** 排除敏感属性字段 */
    public static final String[] EXCLUDE_PROPERTIES = { "salt","sessionId","password", "oldPassword", "newPassword", "confirmPassword" };

    // 配置织入点
    @Pointcut("@annotation(com.java.core.com.annotation.Log)")
    public void pointcut()
    {
    }
    /**
     * 处理完请求后执行
     *
     * @param joinPoint 切点
     */
    @AfterReturning(pointcut = "@annotation(controllerLog)", returning = "result")
    public void requestAfter(JoinPoint joinPoint, Log controllerLog, Object result) throws Exception {
        handleLog(joinPoint, controllerLog, null, result);
    }

    /**
     * 拦截异常操作
     *
     * @param joinPoint 切点
     * @param e 异常
     */
    @AfterThrowing(value = "@annotation(controllerLog)", throwing = "e")
    public void doAfterThrowing(JoinPoint joinPoint, Log controllerLog, Exception e) throws Exception {
        handleLog(joinPoint, controllerLog, e, null);
    }

    private void handleLog(final JoinPoint joinPoint, Log controllerLog, final Exception e, Object result) throws Exception {
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        //浏览器信息
        UserAgent userAgent = UserAgent.parseUserAgentString(request.getHeader("User-Agent"));

        String token = request.getHeader(JwtTokenUtils.AUTHORITIES);

        Claims claims =JwtTokenUtils.getClaimsFromToken(token);
        String userId=claims.getSubject();
        String userName = claims.getAudience();


        SysOperLog dbLog=new SysOperLog();
        // 设置标题
        dbLog.setTitle(controllerLog.title());
        // 设置action动作
        dbLog.setBusiness_type(controllerLog.businessType().ordinal());
        // 设置方法名称
        String className = joinPoint.getTarget().getClass().getName();
        String methodName = joinPoint.getSignature().getName();
        dbLog.setMethod(className + "." + methodName + "()");
        dbLog.setRequest_method(request.getMethod());
        dbLog.setBrowser(userAgent.getBrowser().getName());
        dbLog.setOs(userAgent.getOperatingSystem().getName());
        dbLog.setOper_user_id(userId);
        dbLog.setOper_user_name(userName);
        dbLog.setOper_url(request.getRequestURI());
        dbLog.setOper_ip(IpUtils.getIpAddr(request));
        dbLog.setOper_location(AddressUtils.getRealAddressByIP(dbLog.getOper_ip()));
        dbLog.setJson_result(StringUtils.substring(JSONObject.toJSONString(result),0,2000));
        if (e != null)
        {
            dbLog.setStatus(BusinessStatus.FAIL.ordinal());
            dbLog.setError_msg(StringUtils.substring(e.getMessage(), 0, 2000));
        }else {
            dbLog.setStatus(BusinessStatus.SUCCESS.ordinal());
            dbLog.setError_msg("");
        }
        dbLog.setOper_time(new Date());
        if(result!=null){
            //设置参数
            setRequestValue(joinPoint,request,dbLog);
        }
        //保存参数
        SpringUtils.getBean(SysOperLogService.class).insertOperlog(dbLog);
    }
    /**
     * 获取请求的参数，放到log中
     *
     * @param operLog 操作日志
     * @throws Exception 异常
     */
    private void setRequestValue(JoinPoint joinPoint, HttpServletRequest request, SysOperLog operLog) throws Exception
    {
        Map<String, String[]> map = request.getParameterMap();
        if (StringUtils.isNotEmpty(map))
        {
            String params = JSONObject.toJSONString(map, excludePropertyPreFilter());
            operLog.setOper_param(StringUtils.substring(params, 0, 2000));
        }
        else
        {
            Object args = joinPoint.getArgs();
            if (StringUtils.isNotNull(args))
            {
                String params = argsArrayToString(joinPoint.getArgs());
                operLog.setOper_param(StringUtils.substring(params, 0, 2000));
            }
        }
    }
    /**
     * 忽略敏感属性
     */
    public PropertyPreFilters.MySimplePropertyPreFilter excludePropertyPreFilter()
    {
        return new PropertyPreFilters().addFilter().addExcludes(EXCLUDE_PROPERTIES);
    }
    /**
     * 参数拼装
     */
    private String argsArrayToString(Object[] paramsArray)
    {
        String params = "";
        if (paramsArray != null && paramsArray.length > 0)
        {
            for (Object o : paramsArray)
            {
                if (StringUtils.isNotNull(o) && !isFilterObject(o))
                {
                    try
                    {
                        Object jsonObj = JSONObject.toJSONString(o, excludePropertyPreFilter());
                        params += jsonObj.toString() + " ";
                    }
                    catch (Exception e)
                    {
                    }
                }
            }
        }
        return params.trim();
    }
    /**
     * 判断是否需要过滤的对象。
     *
     * @param o 对象信息。
     * @return 如果是需要过滤的对象，则返回true；否则返回false。
     */
    @SuppressWarnings("rawtypes")
    public boolean isFilterObject(final Object o)
    {
        Class<?> clazz = o.getClass();
        if (clazz.isArray())
        {
            return clazz.getComponentType().isAssignableFrom(MultipartFile.class);
        }
        else if (Collection.class.isAssignableFrom(clazz))
        {
            Collection collection = (Collection) o;
            for (Object value : collection)
            {
                return value instanceof MultipartFile;
            }
        }
        else if (Map.class.isAssignableFrom(clazz))
        {
            Map map = (Map) o;
            for (Object value : map.entrySet())
            {
                Map.Entry entry = (Map.Entry) value;
                return entry.getValue() instanceof MultipartFile;
            }
        }
        return o instanceof MultipartFile || o instanceof HttpServletRequest || o instanceof HttpServletResponse
                || o instanceof BindingResult;
    }
}

实现效果

Teln_小凯
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
一个注解搞定，记录项目日志
java_beautiful的博客
06-20 2070
最近正在录制 TienChin 项目视频～采用 Spring Boot+Vue3 技术栈，里边会涉及到各种好玩的技术，小伙伴们来和我一起做一个完成率超 90% 的项目。 前段时间做了一个支线任务，现在还是回到我们的主线上面来，继续完成 TienChin 项目。 小伙伴们知道我最近在录制 TienChin 项目视频教程，这是一个基于 RuoYi-Vue 脚手架的项目，用过这个脚手架的小伙伴可能知道，这个脚手架有一个功能，就是如果你需要记录下来一个接口的操作信息，那么只需要在 Controller 接口中加
无处不在的Spring AOP事务及踩过的坑
03-01
无处不在的Spring AOP事务及踩过的坑.......................
oracle RETURNING 子句使用方法
09-10
主要介绍了oracle RETURNING 子句使用方法,需要的朋友可以参考下
Spring AOP @Aspect 基本用法
02-10
1、@Aspect放在类头上，把这个类作为一个切面。 2、 @Pointcut放在方法头上，定义一个可被别的方法引用的切入点表达式。 3、5种通知。 3.1、@Before，前置通知，放在方法头上。 3.2、@After，后置【finally】通知，放在方法头上。 3.3、@AfterReturning，后置【try】通知，放在方法头上，使用returning来引用方法返回值。 3.4、@AfterThrowing，后置【catch】通知，放在方法头上，使用throwing来引用抛出的异常。 3.5、@Around，环绕通知，放在方法头上，这个方法要决定真实的方法是否执行，而且必须有返回值。
Spring AOP定义AfterReturning增加实例分析
08-25
主要介绍了Spring AOP定义AfterReturning增加,结合实例形式分析了Spring面相切面AOP定义AfterReturning增加相关操作技巧与使用注意事项,需要的朋友可以参考下
如何在Spring Boot中使用@AfterReturning注解
最新发布
07-28
在本文中，我们介绍了Spring Boot AOP中的@AfterReturning注解，它用于定义在目标方法成功返回后执行的切面逻辑。我们通过一个图书管理系统的实例演示了@AfterReturning的使用方式，并在成功查询图书时记录了查询的时间和返回的结果。 AOP的强大之处在于它允许我们在不修改原有业务逻辑代码的情况下，将横切关注点（如日志记录、安全检查等）与业务逻辑分离。这样，我们可以更好地实现代码的复用和模块化，提高了应用程序的可维护性和可扩展性。 总体而言，Spring Boot AOP为我们提供了一个优雅且强大的方式来管理代码中的横切关注点，使得我们可以更专注于业务逻辑的实现，而不必担心这些横切关注点的具体实现。
若依框架----源码分析（@Log）
03-23 3621
若依框架----源码分析（@Log）
spring 自定义注解实现日志统一处理
野孩子的专栏
03-01 2379
需求：通过注解的方式 统一处理controller和service的日志（实现上可能不太严谨，主要是实现流程）原理：先自定义注解。用aop切面拦截方法的使用，看是否有对应的自定义的注解，如果有，在切面中进行日志的统一打印，可以获取到加了注解方法的类名、方法名、参数。如果想每个方法传进来不同信息，可以在自定义注解里写上参数，这样在使用时就可以带进来不同信息。例如，spring自带的注解@Resour...
用户操作日志（通过自定义注解和Aspect结合完成）
xushuai2333333的博客
11-07 846
用户操作日志（通过自定义注解和Aspect结合完成）
SpringBoot_AOP增强编程
Java后端技术栈
06-30 1002
目前发现的全网最好的aop文章，大佬博客链接：Spring boot中使用aop详解_天涯泪小武的博客-CSDN博客_spring使用aopAOP是spring的两大功能模块之一，功能非常强大，为解耦提供了非常优秀的解决方案。现在就以springboot中aop的使用来了解一下aop。创建一个springboot的web项目，勾选aop，pom如下： 创建个controller 创建一个aspect切面类 启动项目模拟正常执行的情况，访问http://localhost:8080/first，看
解决springboot的aop切面不起作用问题(失效的排查)
08-19
主要介绍了解决springboot的aop切面不起作用问题(失效的排查)，具有很好的参考价值，希望对大家有所帮助。 一起跟随小编过来看看吧
springboot 脱敏自定义注解
03-25
springboot 脱敏自定义注解 SpringAOP
Springboot整合Aop.zip
03-10
Springboot整合AOP AOP概念：面向切面编程：扩展功能不修改源代码实现 AOP采用横向抽取机制，取代传统的纵向继承体系重复性代码（性能监视，事务管理，安全检查，缓存）
springBoot+aop+自定义注解+本地线程实现统一接口日志及接口响应时长
02-01
内容概要：springboot+拦截器+aop+自定义注解+本地线程实现统一接口日志记录，记录下接口所在模块、接口描述、接口请求参数、接口返回参数、接口请求时间以及接口耗时用于接口优化，接口记录参数以及操作人防止使用...
SpringBoot+AOP+TraceID.pdf
01-04
SpringBoot+AOP+TraceID.pdf
springbooot自定义操作日志记录注解
kings_的博客
02-09 387
自定义操作日志记录注解 package com.ruoyi.common.annotation; import java.lang.annotation.Documented; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; im
SpringBoot项目如何优雅的实现操作日志记录
BASK2312的博客
11-24 1220
日志一般使用的是注解类型的切点表达式，我们先创建一个日志注解，当spring容器扫描到有此注解的方法就会进行增强。@Target({ ElementType.PARAMETER, ElementType.METHOD }) // 注解放置的目标位置,PARAMETER: 可用在参数上 METHOD：可用在方法级别上@Retention(RetentionPolicy.RUNTIME) // 指明修饰的注解的生存周期 RUNTIME：运行级别保留/*** 模块*//*** 功能*//**
Spring AOP 记录操作日志
bobozai86的博客
02-01 4557
第一步，定义两个注解，Controller层注解，Service层注解。 package com.iie.log; import java.lang.annotation.*; /** * Created by bo on 2017/12/25. * 用户拦截Controller层操作注解，起切点表达式作用，明确切面应该从哪里注入 */ @Target({ElementType.PAR
Spring AOP+注解方式实现系统日志记录
qq_42102911的博客
05-12 1271
在上篇文章中，我们使用了AOP思想实现日志记录的功能，代码中采用了指定连接点方式（@Pointcut(“execution(* com.nowcoder.community.controller.(…))”)），指定后不需要在进行任何操作就可以记录日志了，但是如果我们对某些controller不想记录日志，就需要更改指定的切点，灵活性较差。因此采用注解+AOP方式，实现更灵活的日志记录功能。
springboot 自定义aop
03-28
Spring Boot允许我们使用自定义AOP来定制业务逻辑。AOP（面向切面编程）是一种编程范式，可以在不改变原有代码的情况下，对现有代码进行增强。 下面是自定义AOP的步骤： 1. 创建一个切面类，使用@Aspect注解标注该类。该类中需要定义一个或多个切点和通知方法。 ```java @Aspect @Component public class MyAspect { @Pointcut("execution(* com.example.demo.service.*.*(..))") public void pointcut() { } @Around("pointcut()") public Object around(ProceedingJoinPoint pjp) throws Throwable { // 前置通知 System.out.println("Before method execute..."); // 执行目标方法 Object result = pjp.proceed(); // 后置通知 System.out.println("After method execute..."); return result; } } ``` 上述代码中，@Pointcut注解定义了一个切点，切点表达式指定了需要增强的方法，这里指定为com.example.demo.service包下的所有方法。@Around注解定义了一个环绕通知方法，该方法在目标方法执行前后分别执行前置通知和后置通知。 2. 在应用程序入口类上添加@EnableAspectJAutoProxy注解，启用Spring的AOP功能。 ```java @SpringBootApplication @EnableAspectJAutoProxy public class DemoApplication { public static void main(String[] args) { SpringApplication.run(DemoApplication.class, args); } } ``` 3. 在需要增强的方法上添加自定义注解，并在切面类中定义一个针对该注解的切点。 ```java @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD) public @interface MyAnnotation { } ``` ```java @Aspect @Component public class MyAspect { @Pointcut("@annotation(com.example.demo.annotation.MyAnnotation)") public void pointcut() { } @Around("pointcut()") public Object around(ProceedingJoinPoint pjp) throws Throwable { // 前置通知 System.out.println("Before method execute..."); // 执行目标方法 Object result = pjp.proceed(); // 后置通知 System.out.println("After method execute..."); return result; } } ``` 上述代码中，@MyAnnotation注解用于标注需要增强的方法，@Pointcut注解定义一个针对@MyAnnotation注解的切点，@Around注解定义一个环绕通知方法，该方法在目标方法执行前后分别执行前置通知和后置通知。 4. 在需要增强的方法上添加@MyAnnotation注解。 ```java @Service public class UserServiceImpl implements UserService { @Override @MyAnnotation public void addUser(User user) { System.out.println("Add user: " + user.getName()); } } ``` 上述代码中，addUser方法上添加了@MyAnnotation注解，表示该方法需要增强。 5. 运行应用程序，观察控制台输出。 ```java Before method execute... Add user: Alice After method execute... ``` 上述输出结果表明，自定义AOP已经生效，增强逻辑被成功执行。 总结：Spring Boot允许我们使用自定义AOP来定制业务逻辑，可以通过定义切面类、切点、通知方法等方式来实现增强逻辑。在实际应用中，我们可以根据具体需求来制定相应的AOP策略，从而提高应用程序的可扩展性和可维护性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值