java使用AOP切面获取请求日志并记录

最新推荐文章于 2024-07-17 02:36:28 发布
最新推荐文章于 2024-07-17 02:36:28 发布
阅读量4.7k 收藏 33
点赞数 3
分类专栏： java从入门到放弃
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/unhejing/article/details/114967946
版权

前言：为了完整的记录外部接口请求记录，记录内容包括：请求参数，响应参数，请求耗时，请求IP地址，请求成功还是失败，请求方法名称，请求接口地址等重要信息。

1.引入maven

<dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-aop</artifactId>
     <version>1.4.1.RELEASE</version>
</dependency>

备注：此包是为了在aop中获取request对象而引入 

2.日志记录model如下

package com.tjair.log.model;

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import javax.persistence.Column;
import javax.persistence.Id;
import javax.persistence.Table;
import java.util.Date;

@Table(name = "t_tjapi_log")
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class TjapiLog {
    @Id
    private Integer id;

    /**
     * 采购编码
     */
    @Column(name = "partnerId")
    private String partnerid;

    /**
     * 请求地址
     */
    private String url;

    /**
     * 接口描述
     */
    @Column(name = "api_name")
    private String apiName;

    /**
     * 请求时间
     */
    @Column(name = "create_time")
    private Date createTime;

    /**
     * 请求方式
     */
    private String method;

    /**
     * 请求参数
     */
    private String params;

    /**
     * 请求状态：1 成功 0 失败
     */
    private Integer status;

    /**
     * 请求IP
     */
    private String ip;

    /**
     * 请求来源地址
     */
    private String location;

    /**
     * 请求耗时
     */
    private Integer time;

    /**
     * 返回内容
     */
    private String response;
}

3.AOP切面如下

package com.tjair.tjapi.config;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.tjair.common.log.TjapiLogVo;
import com.tjair.common.util.IPUtil;
import com.tjair.tjapi.feign.LogFeignService;
import com.tjair.tjapi.util.HttpHelper;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.util.Date;
import java.util.Objects;


/**
 * @description 拦截所有控制器的返回，记录响应报文
 * @author unhejing
 * @date 2021-03-17 上午11:52:26
 */
@Aspect
@Configuration
@Slf4j
public class LogAspect {

    @Autowired
    private LogFeignService logFeignService;

    public LogAspect() {
    }

    @Pointcut("execution(public * com.tjair.tjapi.controller.*.*(..))")
    public void pointCutMethod() {
    }

    // 声明环绕通知
    @Around("pointCutMethod()")
    public Object doAround(ProceedingJoinPoint pjp) throws Throwable {
        Long startTime = System.currentTimeMillis();
        ApiOperation apiOperation = ((MethodSignature)pjp.getSignature()).getMethod().getAnnotation(ApiOperation.class);
        // 获取request对象
        RequestAttributes ra = RequestContextHolder.getRequestAttributes();
        ServletRequestAttributes sra = (ServletRequestAttributes) ra;
        HttpServletRequest request = sra.getRequest();
        Object ret = pjp.proceed();
        Long endTime = System.currentTimeMillis();
        TjapiLogVo tjapiLogVo = getTjapiLogVo(request,Objects.nonNull(apiOperation) ? apiOperation.value() : "",endTime-startTime,JSON.toJSONString(ret));
        // 添加日志
        addLog(tjapiLogVo);
        log.info("响应数据耗时{}:响应数据{}",endTime-startTime,JSON.toJSONString(ret));
        return ret;
    }

    public void addLog(TjapiLogVo tjapiLogVo) {
        log.info("添加日志:{}",JSON.toJSONString(tjapiLogVo));
        Long startTime = System.currentTimeMillis();
        logFeignService.addTjapiLog(tjapiLogVo);
        Long endtime = System.currentTimeMillis();
        log.info("添加日志耗时:{}",endtime-startTime);
    }


    private TjapiLogVo getTjapiLogVo(HttpServletRequest request,String apiName,Long time,String response) throws IOException {
        TjapiLogVo tjapiLogVo = new TjapiLogVo();
        String jsonBody = HttpHelper.getBodyString(request);
        log.info("请求参数:{}",jsonBody);
        JSONObject reqObj = Objects.nonNull(JSON.parseObject(jsonBody)) ? JSON.parseObject(jsonBody) : new JSONObject();
        JSONObject resObj = Objects.nonNull(JSON.parseObject(response)) ? JSON.parseObject(response) : new JSONObject();
        //设置请求参数
        tjapiLogVo.setParams(jsonBody);
        tjapiLogVo.setPartnerid(Objects.nonNull(reqObj.getString("partnerId")) ? reqObj.getString("partnerId") : "-1");
        // 设置IP地址
        tjapiLogVo.setIp(IPUtil.getIpAddr(request));
        // 设置位置
        tjapiLogVo.setLocation(IPUtil.getCityInfo(tjapiLogVo.getIp()));
        //设置请求方法,GET,POST...
        tjapiLogVo.setMethod(request.getMethod());
        //设置请求路径
        tjapiLogVo.setUrl(request.getRequestURI());
        // 设置请求方法名称
        tjapiLogVo.setApiName(apiName);
        // 设置创建时间
        tjapiLogVo.setCreateTime(new Date());
        // 设置请求状态
        Integer code = Objects.nonNull(resObj.getInteger("code")) ? resObj.getInteger("code") : 1;
        tjapiLogVo.setStatus(code);
        // 设置接口消耗时间
        tjapiLogVo.setTime(time.intValue());
        // 设置响应内容
        tjapiLogVo.setResponse(response);
        return tjapiLogVo;
    }
}

4.测试接口

package com.tjair.tjapi.controller;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.tjair.common.service.RedisUtils;
import com.tjair.common.util.Result;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author jingyujie
 * @create 2021-03-16 下午2:39
 **/
@RestController
@RequestMapping("/test")
@Api(tags = "测试API控制器")
public class TestController {

    @Autowired
    private RedisUtils redisUtils;
    
    @PostMapping("/apiTest")
    @ApiOperation("接口测试")
    public Result apiTest(@RequestBody JSONObject obj){
        return Result.returnSuccess("接口已联通，请求入参："+ JSON.toJSONString(obj));
    }

}

 

5.请求结果如下

备注说明：

1.LogFeignService是添加日志的service

2.IPUtil是获取IP和地址信息相关的工具类

3.HttpHelper是解析request中的请求参数的工具类

4.ApiOperation是获取接口的注解上面的接口描述

5.partnerId是我请求参数里面必传的用户编码

6.code是响应参数里面的状态码，用于判断接口是否请求成功

末尾附上工具类：

IPUtil.java

类中的/ip2region.db这个是一个地址库，可直接百度下载即可。

package com.tjair.common.util;

import org.apache.commons.io.FileUtils;
import org.lionsoul.ip2region.DataBlock;
import org.lionsoul.ip2region.DbConfig;
import org.lionsoul.ip2region.DbSearcher;
import org.lionsoul.ip2region.Util;

import javax.servlet.http.HttpServletRequest;
import java.io.File;
import java.lang.reflect.Method;

/**
 * ip操作相关工具类
 * @author jingyujie
 * @create 2020-06-24 下午2:11
 **/

public class IPUtil {

    public static String getCityInfo(String ip){
        try {
            //db
            String dbPath = IPUtil.class.getResource("/ip2region.db").getPath();
            System.out.println("路径："+dbPath);
            File file = new File(dbPath);
            if (file.exists() == false) {
                System.out.println("Error: Invalid ip2region.db file");
                String tmpDir = System.getProperties().getProperty("java.io.tmpdir");
                dbPath = tmpDir + "ip.db";
                System.out.println(dbPath);
                file = new File(dbPath);
                FileUtils.copyInputStreamToFile(IPUtil.class.getClassLoader().getResourceAsStream("classpath:ip2region.db"), file);
            }

            //查询算法
            int algorithm = DbSearcher.BTREE_ALGORITHM; //B-tree
            //DbSearcher.BINARY_ALGORITHM //Binary
            //DbSearcher.MEMORY_ALGORITYM //Memory
            DbSearcher searcher = null;
            try {
                DbConfig config = new DbConfig();
                searcher = new DbSearcher(config, dbPath);

                //define the method
                Method method = null;
                switch (algorithm) {
                    case DbSearcher.BTREE_ALGORITHM:
                        method = searcher.getClass().getMethod("btreeSearch", String.class);
                        break;
                    case DbSearcher.BINARY_ALGORITHM:
                        method = searcher.getClass().getMethod("binarySearch", String.class);
                        break;
                    case DbSearcher.MEMORY_ALGORITYM:
                        method = searcher.getClass().getMethod("memorySearch", String.class);
                        break;
                }

                DataBlock dataBlock = null;
                if (Util.isIpAddress(ip) == false) {
                    System.out.println("Error: Invalid ip address");
                }

                dataBlock = (DataBlock) method.invoke(searcher, ip);

                return dataBlock.getRegion();

            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (searcher != null) {
                    searcher.close();
                }
            }
            return null;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    public static String getIpAddr(HttpServletRequest request) {
        String ip = request.getHeader("x-forwarded-for");
        System.out.println("x-forwarded-for ip: " + ip);
        if (ip != null && ip.length() != 0 && !"unknown".equalsIgnoreCase(ip)) {
            // 多次反向代理后会有多个ip值，第一个ip才是真实ip
            if( ip.indexOf(",")!=-1 ){
                ip = ip.split(",")[0];
            }
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("Proxy-Client-IP");
            System.out.println("Proxy-Client-IP ip: " + ip);
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("WL-Proxy-Client-IP");
            System.out.println("WL-Proxy-Client-IP ip: " + ip);
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("HTTP_CLIENT_IP");
            System.out.println("HTTP_CLIENT_IP ip: " + ip);
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("HTTP_X_FORWARDED_FOR");
            System.out.println("HTTP_X_FORWARDED_FOR ip: " + ip);
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("X-Real-IP");
            System.out.println("X-Real-IP ip: " + ip);
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getRemoteAddr();
            System.out.println("getRemoteAddr ip: " + ip);
        }
        System.out.println("获取客户端ip: " + ip);
        return ip;
    }
}

 HttpHelper.java

此方法要获取request body参数还需要HttpServletRequestWrapper 实现对request body的二次读取，具体实现请自行百度。

package com.tjair.tjapi.util;

import javax.servlet.http.HttpServletRequest;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.charset.Charset;

public class HttpHelper {
    public static String getBodyString(HttpServletRequest request) throws IOException {
        StringBuilder sb = new StringBuilder();
        InputStream inputStream = null;
        BufferedReader reader = null;
        try {
            inputStream = request.getInputStream();
            reader = new BufferedReader(new InputStreamReader(inputStream, Charset.forName("UTF-8")));
            String line = "";
            while ((line = reader.readLine()) != null) {
                sb.append(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return sb.toString();
    }
}

 

 

unhejing
关注
专栏目录
springboot之aop切面获取请求
小秋的博客
02-04 5369
通过aop的切面，在方法执行之前切入，获取请求的地址、ip、类名、方法、参数等...
spring日志操作（AOP）
weixin_46913652的博客
03-30 415
使用spring的AOC切面可以实现日志的记录。 private final OperaLogManagement operaLogManagement; public OperaLogAspect(OperaLogManagement operaLogManagement) { this.operaLogManagement = operaLogManagement; } /** @annotation：用于匹配当前执行方法持有指定注解的方法
Spring-AOP 及 AOP获取request各项参数操作
最新发布
2401_85358173的博客
07-17 1175
其他的内容都可以按照路线图里面整理出来的知识点逐一去熟悉，学习，消化，不建议你去看书学习，最好是多看一些视频，把不懂地方反复看，学习了一节视频内容第二天一定要去复习，并总结成思维导图，形成树状知识网络结构，方便日后复习。这里还有一份很不错的《Java基础核心总结笔记》，特意跟大家分享出来目录：，学习，消化，不建议你去看书学习，最好是多看一些视频，把不懂地方反复看，学习了一节视频内容第二天一定要去复习，并总结成思维导图，形成树状知识网络结构，方便日后复习。
Java —— 基于注解的AOP切面实现 接口调用记录
简简单单记录
04-19 1650
一、预期效果 对所有@RequestMapping注解的接口全部记录接口调用情况并记入日志。 二、实现代码 tips: 这里使用了Lombok的@Slf4j实现日志 @Aspect @Component @Slf4j public class ReportApiCallTimesAspect { /*调用次数记录前缀,方便根据前缀获取所有接口的数据*/ public static final String WEB_API_CALL_COUNT = "web_api_call_count"; /
java AOP 切面和注解记录接口操作日志
qq_45698557的博客
01-27 2954
java 切面实现记录操作日志
java创建response对象_spring aop 获取request、response对象详解
weixin_31523667的博客
02-16 568
在网上看到有不少人说如下方式获取：1.在web.xml中添加监听org.springframework.web.context.request.RequestContextListener2.在aop类中有以下两种方式获取@AutowiredHttpServletRequest request; //这里可以获取到request或者HttpServletRequest request = ((Se...
【Java日志系列实践2】AOP切面实现业务日志
我的技术日常
04-05 4995
1 业务日志的标准 业务日志，也叫操作日志。主要功能： 记录用户行为，方便业务数据回溯与统计。 1.1 操作日志记录内容 操作日志记录主要内容：用户是谁，在什么时间，对什么数据，做了什么样的更改。 逻辑中必须增加业务日志的位置： （1）业务数据的变更处（新增、修改、删除） （2）特别分支条件、边界条件处。 1.2 业务常见的日志记录形式 ● 动态的文本记录，比如：2022-03-12 10:00 订单创建，创建用户“小新”，订单号：NO.123456 ”。 ● 修改类型的文本，包含修改前和修改后的
Java实现AOP切面记录日志实例
熟人介绍的的博客
01-19 4565
注：一个可以直接拿去用的aop切面保存系统操作日志的实例，应用框架为SpringMVC。 需求描述： 管理员要在系统中能看到每个账户的操作记录、时间、账户名称、ip。 实现步骤： 1、实现自定义注解MethodLog 2、建日志实体Bean 3、实现监听注解，调用切面实现类 4、配置启动对@AspectJ注解的支持及监听类 5、业务Controller引用 具体实现： 1、建一个接口类，内容如下 ...
Spring mvc mybatis plus 实现AOP 切面日志系统
12-19
本项目“Spring MVC Mybatis Plus 实现AOP 切面日志系统”旨在提供一个基础的日志记录框架，能够自动追踪和记录应用程序的关键操作，同时支持数据持久化到数据库中，方便后期分析和问题排查。下面将详细介绍这些技术...
获取RequestMapping所有的方法和路径|SpringMvc的Controller
05-16
通过编译文件的class路径，反射得到Class，获取RequestMapping对应注解和value路径
java切面获取reqiest,如何在Spring AOP中获取HttpServletRequest和HttpServletResponse对象
weixin_39609457的博客
03-15 1111
我想在建议之前在Spring AOP中获取响应对象.如果会话无效,我想重定向到登录页面,但无法在Before advice方法中获取HttpServletResponse对象.尝试以下方式.@Autowiredprivate HttpServletResponse response;public void setResponse(HttpServletResponse response) {thi...
AOP获取请求接口所有信息（入参类型、参数、执行时间、当前方法路径、响应参数、响应数据类型）
qq_16733389的博客
01-04 6448
日志输出实体 package com.log; import lombok.AllArgsConstructor; import lombok.Data; import java.util.List; import java.util.Map; @Data @AllArgsConstructor public class LiveLog { // 请求路径 private String requestPath; // 请求方法 private String reques
Java项目中基于AOP注解方式实现接口日志记录
Jnsone的博客
04-04 3009
日志记录，包括接口调用时间，参数，操作类型，自定义注解的方式去实现，涵盖了AOP的基本用法及常用注解
Aop切面获取日志，抓取异常日志，持久化日志，获取访问人ip地址
qq_44728024的博客
04-08 1832
1、添加一个切点 //配置切点 @Pointcut(value = "execution(* com.*.*.controller.*.*.*(..))") public void logPoincut() { } 2、配置class的环绕通知,使用在方法aspect()上注册的切入点 // 配置class的环绕通知,使用在方法aspect()上注册的切入点 @Around(value = "logPoincut()") public Object d
使用切面 获取请求url,请求参数,来源IP
YyCarry的博客
07-02 6606
切面类 @Slf4j @Aspect @Component public class RequestAspect { @Around("execution(public * com.yex.proxy.controller.ApiController.*(..))") public Object apiAround(ProceedingJoinPoint pPoint) throws Throwable { HttpServletRequest request = Requ
Java AOP 通过注解实现切面及通过注解改变返回值
weixin_43958683的博客
03-23 4960
面向切面编程、通过注解实现AOP
JAVA Controller层AOP实现通用日志记录
"JAVA实现通用日志记录方法，通过AOP在Controller层进行切面日志处理，以解决Filter和Interceptor中无法记录日志的问题。" 在Java开发中，记录日志是一项重要的任务，它有助于追踪程序运行状态、调试错误以及进行...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值