使用AOP实现对接口的实时监控

已于 2024-01-13 16:05:02 修改
阅读量1.6k 收藏 10
点赞数 5
分类专栏： # spring # 框架 文章标签： aop java
于 2021-08-18 10:30:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45752401/article/details/119774117
版权

在这里插入图片描述

📫 作者简介：「子非我鱼」，专注于研究全栈
🔥 三连支持：欢迎 ❤️关注、👍点赞、👉收藏三连，支持一下博主~

文章目录

引言

在 Java 开发中，AOP（面向切面编程）是一种强大的编程范式，它允许我们在程序运行时动态地横切应用的关注点。本文将介绍如何使用 AOP 实现对 Java 接口的实时监控，以便了解接口方法的执行情况。

步骤一：创建日志注解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface LogAnno {

    /**
     * 日志名称
     */
    String description() default "";


    /**
     * 记录日志的操作类型
     */
    String type();
}
步骤二：自定义线程连接池
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @author myqxin
 */
public class ThreadPoolUtil {

    /**
     * 线程缓冲队列
     */
    private static BlockingQueue<Runnable> bqueue = new ArrayBlockingQueue<Runnable>(100);
    /**
     * 核心线程数，会一直存活，即使没有任务，线程池也会维护线程的最少数量
     */
    private static final int SIZE_CORE_POOL = 5;
    /**
     * 线程池维护线程的最大数量
     */
    private static final int SIZE_MAX_POOL = 10;
    /**
     * 线程池维护线程所允许的空闲时间
     */
    private static final long ALIVE_TIME = 2000;

    private static ThreadPoolExecutor pool = new ThreadPoolExecutor(SIZE_CORE_POOL, SIZE_MAX_POOL, ALIVE_TIME, TimeUnit.MILLISECONDS, bqueue, new ThreadPoolExecutor.CallerRunsPolicy());

    static {

        pool.prestartAllCoreThreads();
    }

    public static ThreadPoolExecutor getPool() {
        return pool;
    }

    public static void main(String[] args) {
        System.out.println(pool.getPoolSize());
    }
}
步骤三：创建日志类
package com.myqxin.sx.modules.base.entity;

import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;

import java.io.Serializable;
import java.util.Map;

import com.myqxin.sx.common.utils.ObjectUtil;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;

/**
 * <p>
 *
 * </p>
 *
 * @author myqxin
 * @since 2021-08-06
 */
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("sx_log")
@Builder
@AllArgsConstructor//创建全参的构造方法，配合@Builder
@ApiModel(value = "SxLog对象", description = "操作日志实体类")
public class SxLog implements Serializable {

    private static final long serialVersionUID = 1L;

    @TableId(value = "id", type = IdType.AUTO)
    private Integer id;

    public SxLog() {

    }

    @ApiModelProperty(value = "操作人")
    private String operateor;

    @ApiModelProperty(value = "操作类型")
    private String operateType;

    @ApiModelProperty(value = "操作日期")
    private String operateDate;


    @ApiModelProperty(value = "方法操作名称")
    private String name;

    @ApiModelProperty(value = "请求路径")
    private String requestUrl;

    @ApiModelProperty(value = "请求类型")
    private String requestType;

    @ApiModelProperty(value = "请求参数")
    private String requestParam;

    @ApiModelProperty(value = "请求结果")
    private String requestBody;

    @ApiModelProperty(value = "ip")
    private String ip;

    @ApiModelProperty(value = "ip信息")
    private String ipInfo;

    @ApiModelProperty(value = "花费时间")
    private Integer costTime;

    /**
     * 转换请求参数为Json
     *
     * @param paramMap
     */
    public void setMapToParams(Map<String, String[]> paramMap) {
        // TODO 实现map转json字符串
        this.requestParam = ObjectUtil.mapToString(paramMap);
    }
}
步骤四：创建日志类Mapper
import com.myqxin.sx.modules.base.entity.SxLog;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;

/**
 * <p>
 *  Mapper 接口
 * </p>
 *
 * @author myqxin
 * @since 2021-08-06
 */
public interface SxLogMapper extends BaseMapper<SxLog> {

}
步骤五：创建日志service接口及实现类
public interface SxLogService extends IService<SxLog> {

    public boolean addLog(SxLog sxLog);

}

@Service
public class SxLogServiceImpl extends ServiceImpl<SxLogMapper, SxLog> implements SxLogService {

    @Override
    public boolean addLog(SxLog sxLog) {
        return super.save(sxLog);
    }
}
步骤六：创建日志切面类
package com.myqxin.sx.common.aop;

import com.myqxin.sx.common.annotation.LogAnno;
import com.myqxin.sx.common.utils.IpInfoUtil;
import com.myqxin.sx.common.utils.ThreadPoolUtil;
import com.myqxin.sx.modules.base.entity.SxLog;
import com.myqxin.sx.modules.base.service.mybatis.SxLogService;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.NamedThreadLocal;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.Method;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

/**
 * @author: myqxin
 * @Desc:
 * @create: 2021-08-06 15:11
 **/
@Aspect
@Component
@Slf4j
public class LogAopAspect {

    private static final ThreadLocal<Date> beginTimeThreadLocal = new NamedThreadLocal<Date>("ThreadLocal beginTime");

    @Autowired
    private SxLogService sxLogService;

    @Autowired(required = false)
    private HttpServletRequest request;

    @Autowired
    private IpInfoUtil ipInfoUtil;

    /**
     * Controller层切点,注解方式
     */
    //@Pointcut("execution(* *..controller..*Controller*.*(..))")
    @Pointcut("@annotation(com.myqxin.sx.common.annotation.LogAnno)")
    public void controllerAspect() {

    }

    /**
     * 前置通知 (在方法执行之前返回)用于拦截Controller层记录用户的操作的开始时间
     *
     * @param joinPoint 切点
     * @throws InterruptedException
     */
    @Before("controllerAspect()")
    public void doBefore(JoinPoint joinPoint) throws InterruptedException {

        //线程绑定变量（该数据只有当前请求的线程可见）
        Date beginTime = new Date();
        beginTimeThreadLocal.set(beginTime);
    }

    /**
     * 后置通知(在方法执行之后返回) 用于拦截Controller层操作
     * 此注解能对返回值作处理
     * @param joinPoint 切点
     */
   // @AfterReturning(value = "controllerAspect()", returning = "result")
   // public void after(JoinPoint joinPoint, Object result) {}


    /**
     * 后置通知(在方法执行之后返回) 用于拦截Controller层操作
     *
     * @param joinPoint 切点
     */
    @After("controllerAspect()")
    public void after(JoinPoint joinPoint) {
        try {
            Object[] objs = joinPoint.getArgs();
            if (objs != null && objs.length > 0) {
                for (Object object : objs) {
                    if (object instanceof HttpServletRequest) {
                        request = (HttpServletRequest) object;
                        break;
                    }
                }
            }

            SxLog log = new SxLog();
            // 创建日期
            LocalDateTime now = LocalDateTime.now();
            String format = now.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH-mm-ss"));
            log.setOperateDate(format);
            //日志标题
            log.setName(getControllerMethodInfo(joinPoint).get("description").toString());
            //操作类型
            log.setOperateType(getControllerMethodInfo(joinPoint).get("type").toString());
            //日志请求url
            log.setRequestUrl(request.getRequestURI());
            //请求方式
            log.setRequestType(request.getMethod());
            //请求参数
            Map<String, String[]> logParams = request.getParameterMap();
            log.setMapToParams(logParams);
            //请求用户
            log.setOperateor("myqxin");
            //请求IP
            log.setIp(ipInfoUtil.getIpAddr(request));
            //请求开始时间
            Date logStartTime = beginTimeThreadLocal.get();
            long beginTime = beginTimeThreadLocal.get().getTime();
            long endTime = System.currentTimeMillis();
            //请求耗时
            Long logElapsedTime = endTime - beginTime;
            log.setCostTime(logElapsedTime.intValue());

            //调用线程保存至ES
            ThreadPoolUtil.getPool().execute(new SaveSystemLogThread(log, sxLogService));

        } catch (Exception e) {
            log.error("AOP后置通知异常", e);
        }
    }

    /**
     * 保存日志至数据库
     */
    private static class SaveSystemLogThread implements Runnable {

        private SxLog sxLog;
        private SxLogService sxLogService;

        public SaveSystemLogThread(SxLog sxLog, SxLogService logService) {
            this.sxLog = sxLog;
            this.sxLogService = logService;
        }

        @Override
        public void run() {
            sxLogService.addLog(sxLog);
        }
    }

    /**
     * 获取注解中对方法的描述信息 用于Controller层注解
     *
     * @param joinPoint 切点
     * @return 方法描述
     * @throws Exception
     */
    public static Map<String, Object> getControllerMethodInfo(JoinPoint joinPoint) throws Exception {

        Map<String, Object> map = new HashMap<String, Object>(16);
        //获取目标类名
        String targetName = joinPoint.getTarget().getClass().getName();
        //获取方法名
        String methodName = joinPoint.getSignature().getName();
        //获取相关参数
        Object[] arguments = joinPoint.getArgs();
        //生成类对象
        Class targetClass = Class.forName(targetName);
        //获取该类中的方法
        Method[] methods = targetClass.getMethods();

        String description = "";
        String type = null;

        for (Method method : methods) {
            if (!method.getName().equals(methodName)) {
                continue;
            }
            Class[] clazzs = method.getParameterTypes();
            if (clazzs.length != arguments.length) {
                //比较方法中参数个数与从切点中获取的参数个数是否相同，原因是方法可以重载哦
                continue;
            }
            description = method.getAnnotation(LogAnno.class).description();
            type = method.getAnnotation(LogAnno.class).type();
            map.put("description", description);
            map.put("type", type);
        }
        return map;
    }
}
步骤七：创建获取ip工具类
package com.myqxin.sx.common.utils;


import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import java.net.InetAddress;
import java.net.UnknownHostException;


/**
 * @author myqxin
 */
@Slf4j
@Component
public class IpInfoUtil {

    /**
     * 获取客户端IP地址
     *
     * @param request 请求
     * @return
     */
    public String getIpAddr(HttpServletRequest request) {

        String ip = request.getHeader("x-forwarded-for");
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("WL-Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getRemoteAddr();
            if (ip.equals("127.0.0.1")) {
                //根据网卡取本机配置的IP
                InetAddress inet = null;
                try {
                    inet = InetAddress.getLocalHost();
                } catch (UnknownHostException e) {
                    e.printStackTrace();
                }
                ip = inet.getHostAddress();
            }
        }
        // 对于通过多个代理的情况，第一个IP为客户端真实IP,多个IP按照','分割
        if (ip != null && ip.length() > 15) {
            if (ip.indexOf(",") > 0) {
                ip = ip.substring(0, ip.indexOf(","));
            }
        }
        if ("0:0:0:0:0:0:0:1".equals(ip)) {
            ip = "127.0.0.1";
        }
        return ip;
    }

}
步骤八：创建格式转化工具类
package com.myqxin.sx.common.utils;

import cn.hutool.core.util.StrUtil;
import com.google.gson.Gson;

import java.util.HashMap;
import java.util.Map;

/**
 * @author myqxin
 */
public class ObjectUtil {

    public static String mapToString(Map<String, String[]> paramMap){

        if (paramMap == null) {
            return "";
        }
        Map<String, Object> params = new HashMap<>(16);
        for (Map.Entry<String, String[]> param : paramMap.entrySet()) {

            String key = param.getKey();
            String paramValue = (param.getValue() != null && param.getValue().length > 0 ? param.getValue()[0] : "");
            String obj = StrUtil.endWithIgnoreCase(param.getKey(), "password") ? "你是看不见我的" : paramValue;
            params.put(key,obj);
        }
        return new Gson().toJson(params);
    }

    public static String mapToStringAll(Map<String, String[]> paramMap){

        if (paramMap == null) {
            return "";
        }
        Map<String, Object> params = new HashMap<>(16);
        for (Map.Entry<String, String[]> param : paramMap.entrySet()) {

            String key = param.getKey();
            String paramValue = (param.getValue() != null && param.getValue().length > 0 ? param.getValue()[0] : "");
            params.put(key, paramValue);
        }
        return new Gson().toJson(params);
    }
}
步骤九：使用注解
    @GetMapping("/register")
    @LogAnno(description = "注册接口",type = "注册")
    public BaseResult register(@RequestParam int[] arr,@RequestParam int aa) {
        System.err.println(arr);
        return BaseResult.ok("注册成功");
    }
步骤十：实现效果

在这里插入图片描述

结论

通过使用 AOP，我们能够轻松实现对接口方法的实时监控，而无需修改接口实现类的代码。这种方式使得我们可以在不影响原有逻辑的情况下，加入一些横切关注点，例如性能监控、日志记录等。 AOP 是一个强大的编程范式，能够提高代码的模块化和可维护性。

子非我鱼
关注
  • 5
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
springboot进阶-使用aop实现接口监控和全局异常处理
zxh1991811的博客
01-02 3083
AOP是什么 用过spring开发的程序员对AOP应该都不陌生，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。 简而言之，AOP就是为了减少我们纵向编码的复杂度，让我们可以更加的注重于业务实现。 AOP实战 准备工作 1.环境准备： jdk1.8+springboot2.1.5+idea（...
net core AOP日志 自定义接口监控
05-19
自定义接口日志监控，记录接口传入传出的参数日志，具体实现类请参照附件，最后在Startup.cs的Configure方法中添加以下代码即可： app.Use(async (context, next) => { context.Request.EnableBuffering(); await next.Invoke(); }); app.UseMiddleware<CustomMonitorMiddleware>();
java实现一个动态监控系统，监控接口请求超时的趋势
热门推荐
weixin_44976692的博客
05-24 2万+
比如，当某个渠道的平均响应时间连续几个时间窗口内超过设定的阈值（比如800ms），或者超时率超过设定的阈值时，触发异常检测。当某个渠道的平均响应时间连续几个时间窗口内超过设定的阈值（比如800ms），或者超时率超过设定的阈值时，触发异常检测。每次请求完成时，记录下请求的发起时间和结束时间，计算出请求的响应时间。将收集到的响应时间数据按照3分钟的时间窗口进行聚合，统计每个时间段内所有请求的平均响应时间或超时率。对于每个时间窗口的统计数据，计算最近几个时间窗口内的平均响应时间变化情况，或者超时率的变化情况。
AOP实现接口耗时监控
deoppressoliber的博客
05-15 1004
@Aspect @Component @Slf4j public class ControllerTimeAop { // service层的统计日志/耗时(方法所在的包) public static final String POINT = "execution (* cn.xy.os.contrlller.*.*(..))"; @Autowired InterfaceSlowService interfaceSlowService; @Pointcut(".
使用AOP实现一个接口监视器
bugMakker的博客
07-11 477
使用AOP实现一个接口监视器 一、背景 二、开发思路 三、AOP 四、演示 五、总结
AOP实现接口请求日志，耗时记录
wayne_youlu的博客
10-09 426
很多时候后端排查问题，我们要确认用户到底请求了哪些接口，接口的入参和返回是怎么样的。又或者是接口耗时有多高。这些东西都可以通过日志去排查，我们只需要将每次的请求记录日志。要如何优雅的实现接口日志呢？有的人喜欢用拦截器，有的人喜欢用aop。后面我们会讨论下这两种方案的优劣。
使用Springboot AOP进行请求接口异常监控
Sagitarioo的博客
05-23 1285
使用aop进行接口调用日志监控
利用AOP监控Java接口响应超时
MIYAOW
10-11 3167
  为什么要监控 　　服务化接口是提供服务的，接口正确性、稳定性是最最重要的，在保证正确的同时需要尽量提高接口响应时间。 　　有的团队会有专门的工具来对系统响应时间、吞吐量做监控，但如果团队没有这种“待遇”就需要自己来做一些工具为自己的代码提供服务。 自己动手,丰衣足食 　　AOP + Annotation 简陋实现，能达到目的 　　AOP : 使用环绕方式对接口拦截,在拦截接口前后记...
AOP结合注解实现项目中接口调用情况监控
qq_44749491的博客
11-23 5872
一文学会项目中如何进行接口调用情况监控的实用功能
使用AOP Around实现接口拦截，计算接口访问时间，优化接口
qq_44199087的博客
02-28 2615
通过AOP拦截接口请求，计算接口访问时间，并存入数据库从而统计程序所有接口的访问效率，从而达到针对性优化策略，下面我直接通过代码进行讲解。 package com.wk.zh.admin.constants; import com.alibaba.fastjson.JSONArray; import com.wk.zh.admin.model.SysInterfaceLog; import co...
深入浅析Spring 的aop实现原理
09-02
6. **代理创建**：Spring根据目标类是否实现接口选择使用JDK动态代理或CGLIB动态代理创建代理对象。代理对象在调用目标方法时，会执行相应的通知逻辑。 7. **使用代理对象**：在应用中，不再直接调用目标对象，而是...
SpringBoot如何使用AOP+Redis实现接口限流实现全过程（值得珍藏）
01-21
总结：通过 Spring Boot 结合 AOP 和 Redis，我们可以轻松实现接口限流，保护系统免受过量请求的影响。这种方式既灵活又高效，能够适应各种不同的限流需求。在实践中，根据实际情况调整限流策略，结合监控工具，可以...
java使用动态代理来实现AOP(日志记录)的实例代码共6
10-29
Java动态代理是Java编程中一个非常重要的特性，它允许我们在运行时创建代理对象，这些代理对象可以代替原对象执行某些额外的操作，例如日志记录、性能监控、事务管理等，这些都是面向切面编程（AOP）的核心应用场景...
Spring 使用AspectJ 实现 AOP
04-18
在Spring中，我们可以使用AspectJ来实现AOP，AspectJ是一个强大的AOP框架，它可以与Spring无缝集成，提供更细粒度的控制。 首先，让我们了解一下AOP中的通知类型： 1. **前置通知**（Before Advice）：在目标方法...
SpringBoot使用AOP记录接口操作日志
何哥的博客
01-07 2万+
前言：我们项目中可能有这种需求，每个人请求了哪些接口？做了什么事情？参数是什么？重要的接口我们需要记日志以便查找。我们不可能在每个接口中去一一处理，可以借助Spring提供的AOP能力+自定义注解轻松应对。 ...
redis+spring面试题
github_36510643的博客
07-21 302
redis+spring面试题
Java-Lambda
最新发布
lizhiwei21的博客
07-21 333
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 568
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
python接口监控
07-28
对于Python接口监控，可以使用Python编写一个监控程序来实现。根据引用\[1\]中的描述，可以通过监控第三方接口的调用过程中是否出现大量错误来判断接口是否存在问题，并及时采取措施。 在Python中，可以使用一些库和工具来实现接口监控。例如，可以使用Python的requests库来发送HTTP请求并获取接口的响应。通过监控接口的响应状态码和返回数据，可以判断接口是否正常工作。 此外，还可以使用Python的日志库来记录接口的调用情况和错误信息。通过查看日志文件，可以及时发现接口调用中的异常情况，并进行分析和处理。 另外，引用\[2\]中提到的Django框架也可以用于接口监控。Django是一个强大的Python Web框架，可以用于构建Web应用程序。通过Django的管理界面，可以方便地查看和管理接口的调用情况。 总之，通过编写Python监控程序，结合使用相关库和工具，可以实现对接口的实时监控和错误处理，以提高接口的可靠性和稳定性。 #### 引用[.reference_title] - *1* [使用Python写一个小小的项目监控](https://blog.csdn.net/zhongyi_yang/article/details/46122073)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^koosearch_v1,239^v3^insert_chatgpt"}} ] [.reference_item] - *2* *3* [如何用Python搭建监控平台](https://blog.csdn.net/qq_35030548/article/details/131425745)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^koosearch_v1,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

子非我鱼

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

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

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

打赏作者

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

抵扣说明：

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

余额充值