日志存储到MongoDB

日志存储

存储到MongoDB

依赖项

<!-- Spring AOP 动态代理 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

<!-- Spring整合MongoDB -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>

Spring Boot配置文件

# spring配置
spring:
  data:
    mongodb:
      # MongoDB数据库主机地址
      host: localhost
      # 端口号
      port: 27017
      # 所用数据库
      database: mydb
      # username: root
      # password: 123456
      # auto-index-creation: true

实体类 MyLogs

package com.aprildawn.questionaire_survey.utils;

import lombok.Data;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;

/**
 * 日志记录实体类
 */
@Data
@Document(collection = "mylogs")//设置MongoDB集合名称
public class LogInMongoDB {

    /**
     * 主键id
     */
    @Id
    private String id;

    /**
     * 所在包
     */
    private String packages;

    /**
     * 类名
     */
    private String classname;

    /**
     * 方法名
     */
    private String method;

    /**
     * 日志级别
     */
    private String level;

    /**
     * 请求时间
     */
    private String date;

    /**
     * 用户ip地址
     */
    private String ip;

    /**
     * 用户所用浏览器
     */
    private String browser;

    /**
     * 用户终端系统
     */
    private String system;

    /**
     * 客户端请求端口：用户发起请求的客户端所使用的端口号
     */
    private String remoteport;

    /**
     * 服务器响应端口：浏览器发送请求时连接到的服务器端口
     */
    private String serverport;

    /**
     * 服务器本地端口：当前处理请求的服务器上的本地端口
     */
    private String localport;
}

日志动态代理类: MyLogsConfig

package com.aprildawn.questionaire_survey.utils;

import eu.bitwalker.useragentutils.UserAgent;
import jakarta.servlet.http.HttpServletRequest;
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.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.BasicQuery;
import org.springframework.stereotype.Component;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;

/**
 * 日志持久化到MongoDB
 */
@Component
@Aspect
public class MyLogsConfig {

    @Autowired
    private MongoTemplate mongoTemplate;

    @Autowired
    private HttpServletRequest request;


    //切点的注解  是指那些方法需要被执行"AOP"

    /**
     * 公共切点方法 - 可以减少重复代码量
     * 用于指定要需要日志记录的类
     */
    @Pointcut("execution(* com.aprildawn.questionaire_survey.controller.*.*(..))")
    public void logPoinCut(){}//定义一个切入点

    /**
     * [AOP 环绕通知]
     * @param joinpoint 连接点
     * JoinPoint是连接点的意思我们要获取到的如类名，方法名，请求参数等都是从连接点中取出来的
     */
    @Around(value="logPoinCut()")
    public Object afterLog(ProceedingJoinPoint joinpoint) throws Throwable {

        System.out.println("====================================================");
        System.out.println("[AOP 环绕通知] 日志记录开始");
        //实例化日志实体对象
        MyLogs myLogs = new MyLogs();

        //所在包位置
        myLogs.setPackages(joinpoint.getTarget().getClass().getPackageName());
        //所在类名
        myLogs.setClassname(joinpoint.getTarget().getClass().getSimpleName());
        //方法名
        myLogs.setMethod(joinpoint.getSignature().getName());
        //方法传入参数名
        Object[] args = joinpoint.getArgs();
        List list = Arrays.asList(args);
        //System.out.println(list.get(0).toString() != null); true
        //System.out.println(list.get(0).toString() != "{}"); false
        if (list.get(0).toString()!= null&&list.get(0).toString()!="{}"){
            myLogs.setReqparam(list.toString());
        }else {
            myLogs.setReqparam("NULL");
        }
        //实例化日志对象
        Logger logger =  LoggerFactory.getLogger(joinpoint.getTarget().getClass());
        //设置日志级别
        myLogs.setLevel(getLogLevel(logger));
        //实例并初始化简单日期格式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //设置日期
        myLogs.setDate(sdf.format(new Date()));
        //获取用户代理信息
        String userAgent = request.getHeader("User-Agent");
        //通过用户代理对象解析解析用户代理信息
        UserAgent agent = UserAgent.parseUserAgentString(userAgent);
        //获取用户访问所用浏览器
        String BrowserName = agent.getBrowser().getName();
        //获取用户访问设备系统
        String SystemName = agent.getOperatingSystem().getName();
        System.out.println("客户端系统信息：\n浏览器："+BrowserName+"\n操作系统："+SystemName);

        //获取用户ip地址
        String ip = request.getRemoteAddr();
        //发起请求的客户端所使用的端口号
        int port = request.getRemotePort();
        //浏览器发送请求时连接到的服务器端口
        int port1 = request.getServerPort();
        //当前处理请求的服务器上的本地端口
        int port2 = request.getLocalPort();

        myLogs.setIp(ip);
        myLogs.setBrowser(BrowserName);
        myLogs.setSystem(SystemName);
        myLogs.setRemoteport(String.valueOf(port));
        myLogs.setServerport(String.valueOf(port1));
        myLogs.setLocalport(String.valueOf(port2));


        //持久化到MongoDB
        MyLogs a = mongoTemplate.save(myLogs);

        System.out.println("[AOP 环绕通知] 日志记录完成！");
        System.out.println("====================================================");
        System.out.println("返回值："+ a);
        //查询
        BasicQuery query = new BasicQuery("{ level :  'INFO' }");//指定属性查询
        BasicQuery query1 = new BasicQuery("{ date :  'INFO' }");//指定时间范围查询
        List<MyLogs> result = mongoTemplate.find(query, MyLogs.class);
        System.out.println("MongoDB查询测试：");
        for (MyLogs logs : result) {
            System.out.println(logs.toString());
        }

        //修改
        //BasicUpdate update = new BasicUpdate("{id}");

        //删除
        System.out.println("====================================================");

        // 返回目标方法的返回值给外界调用者
        return joinpoint.proceed(args);
    }

    /**
     * 获取日志级别
     * @param logger 日志对象
     * @return String
     */
    public String getLogLevel(Logger logger){
        if (logger.isTraceEnabled()){
            return "TRACE";
        } else if (logger.isDebugEnabled()) {
            return "DEBUG";
        } else if (logger.isInfoEnabled()) {
            return "INFO";
        } else if (logger.isWarnEnabled()) {
            return "WARN";
        } else if (logger.isErrorEnabled()) {
            return "ERROR";
        }else {
            return "NULL";
        }
    }
}

这样就配置好了，去使用吧！