aop切面编程实现MongoDB 日志存储

最新推荐文章于 2023-07-31 17:30:27 发布
最新推荐文章于 2023-07-31 17:30:27 发布
阅读量959 收藏 1
点赞数
分类专栏： mongodb 文章标签： mongodb aop
原文链接：https://blog.csdn.net/fwk19840301/article/details/80099193
版权
本文介绍了一种使用AOP切面编程结合MongoDB进行日志存储的方法，包括实体类、Service层、Mapper层、AOP切面编程类、YML配置、测试类及Maven配置，实现了按日期查询和标题查询的日志检索功能。
摘要由CSDN通过智能技术生成

实现了平常数据存mysql。日志数据存MongoDB的功能

2018.5.16更新 添加了按日期时间段的查询，更正了title查询，修改了返回值为时间格式

一、日志的bean类

package com.johnfnash.learn.mongodb.entity;

import org.springframework.data.mongodb.core.index.CompoundIndex;
import org.springframework.data.mongodb.core.index.CompoundIndexes;
import org.springframework.data.mongodb.core.mapping.Document;

import java.text.SimpleDateFormat;
import java.util.Date;

@Document(collection = "LoggerInfo")
@CompoundIndexes(
        @CompoundIndex(name = "title", def = "{ title : 1 }")
)
public class LoggerInfo {

    private static final long serialVersionUID = 4495390935587105239L;

    private String title;

    private Date createDate;

    private String createDateStr;

    private Object[] arguments;

    private String targetName;

    private String methodName;

    private Object result;

    private String ip;

    public LoggerInfo() {
    }

    public LoggerInfo(String title, Date createDate, Object[] arguments, Object result, String targetName, String methodName, String ip) {
        this.title = title;
        this.createDate = createDate;
        this.arguments = arguments;
        this.targetName = targetName;
        this.methodName = methodName;
        this.result = result;
        this.ip = ip;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public Date getCreateDate() {
        return new Date();
    }

    public void setCreateDate(Date createDate) {
        this.createDate = createDate;
    }

    public String getCreateDateStr() {
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        return sdf.format(this.createDate);
    }

    public void setCreateDateStr(String createDateStr) {
        this.createDateStr = createDateStr;
    }

    public Object[] getArguments() {
        return arguments;
    }

    public void setArguments(Object[] arguments) {
        this.arguments = arguments;
    }

    public String getTargetName() {
        return targetName;
    }

    public void setTargetName(String targetName) {
        this.targetName = targetName;
    }

    public String getMethodName() {
        return methodName;
    }

    public void setMethodName(String methodName) {
        this.methodName = methodName;
    }

    public Object getResult() {
        return result;
    }

    public void setResult(Object result) {
        this.result = result;
    }

    public String getIp() {
        return ip;
    }

    public void setIp(String ip) {
        this.ip = ip;
    }
}

二、service层

package com.johnfnash.learn.mongodb.service;

import com.johnfnash.learn.mongodb.entity.LoggerInfo;
import com.johnfnash.learn.mongodb.mapper.LoggerInfoRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@Service
@Transactional(readOnly = true)
public class LoggerInfoService {

    @Autowired
    private LoggerInfoRepository infoRepository;

    @Transactional(readOnly = false)
    public void addLoggerInfo(LoggerInfo loggerInfo) {
        infoRepository.addLoggerInfo(loggerInfo);
    }

    public List<LoggerInfo> getLoggerInfoListByTitle(String title) {
        return infoRepository.getLoggerInfo(title);
    }

    public List<LoggerInfo> getLoggerInfoListByDate(String startDate, String endDate) {
        return infoRepository.getLoggerBetweenTime(startDate, endDate);
    }

}

三、mapper层

package com.johnfnash.learn.mongodb.mapper;

import com.johnfnash.learn.mongodb.entity.LoggerInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Sort;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.stereotype.Repository;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;

@Repository
public class LoggerInfoRepository {

    @Autowired
    private MongoTemplate mongoTemplate;

    public List<LoggerInfo> getLoggerInfo(String title) {
        Query query = new Query();
        Criteria criteria = Criteria.where("title").is(title);
        query.addCriteria(criteria);
        query.with(new Sort(Sort.Direction.DESC, "createDate"));
        return mongoTemplate.find(query, LoggerInfo.class);
    }

    public List<LoggerInfo> getLoggerBetweenTime(String startDate, String endDate) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date sdate = null, edate = null;
        try {
            sdate = sdf.parse(startDate);
            edate = sdf.parse(endDate);
        } catch (ParseException e) {
            System.out.println("时间转换错误======");
            e.printStackTrace();
        }

        Query query = new Query();
        Criteria criteria = new Criteria();
        if (sdate != null && edate != null) {
            criteria = Criteria.where("createDate").gte(sdate).lte(edate);
        }
        query.addCriteria(criteria);
        return mongoTemplate.find(query, LoggerInfo.class);
    }

    public void addLoggerInfo(LoggerInfo loggerInfo) {
        mongoTemplate.insert(loggerInfo);
    }

}

四、aop切面编程类

package com.johnfnash.learn.mongodb.config;

import com.johnfnash.learn.mongodb.entity.LoggerInfo;
import com.johnfnash.learn.mongodb.service.LoggerInfoService;
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.context.annotation.Configuration;

import java.util.Date;

@Aspect
@Configuration
public class LoggerInfoAspect {

    private Logger logger = LoggerFactory.getLogger(getClass());

    @Autowired
    private LoggerInfoService loggerInfoService;

    @Pointcut("execution(* com.johnfnash.learn.mongodb.service.*.get*(..))")
    public void executeService() {
    }

    @Around("executeService()")
    public Object doAround(ProceedingJoinPoint joinPoint) throws ClassNotFoundException {
        Object result = null; // 返回值
        LoggerInfo loggerInfo;

        String targetName = joinPoint.getTarget().getClass().getName();
        String methodName = joinPoint.getSignature().getName();
        System.out.println("方法名称："+methodName);
        Object[] args = joinPoint.getArgs();

        try {
            result = joinPoint.proceed();
            loggerInfo = new LoggerInfo("正确日志", new Date(), args, result, targetName, methodName, "");
            loggerInfoService.addLoggerInfo(loggerInfo);
        } catch (Throwable e) {
            String message = e.getMessage();
            loggerInfo = new LoggerInfo("错误日志", new Date(), args, message, targetName, methodName, "");
            loggerInfoService.addLoggerInfo(loggerInfo);
            logger.error("规则切面发生异常", e);
        }


        return result;
    }

}

五、yml文件

spring.data.mongodb.host=127.0.0.1
spring.data.mongodb.port=27017
spring.data.mongodb.database=admin

六、测试类

package com.johnfnash.learn.mongodb.controller;

import com.johnfnash.learn.mongodb.entity.LoggerInfo;
import com.johnfnash.learn.mongodb.service.LoggerInfoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
@RequestMapping("/logger")
public class LoggerController {

    @Autowired
    private LoggerInfoService loggerInfoService;

    @GetMapping("/listByTitle")
    public List<LoggerInfo> getLoggerInfo(@RequestParam("title") String title){
        List<LoggerInfo> loggerInfos = loggerInfoService.getLoggerInfoListByTitle(title);
        return loggerInfos;
    }

    @GetMapping("/listByDate")
    public List<LoggerInfo> getInfoByDate(@RequestParam("startDate") String startDate , @RequestParam("endDate") String endDate){
        List<LoggerInfo> loggerInfos = loggerInfoService.getLoggerInfoListByDate(startDate, endDate);
        return loggerInfos;
    }

}

七、pom文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.1.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.johnfnash.learn</groupId>
    <artifactId>mongodb-aspect</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>mongodb</name>
    <description>Mongodb project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-mongodb</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-mongodb</artifactId>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

本文转自：aop切面编程实现MongoDB 日志存储（升级版）

MongoDB中4种日志的详细介绍
12-16
前言 任何一种数据库都有各种各样的日志，MongoDB也不例外。MongoDB中有4种日志，分别是系统日志、Journal日志、oplog主从日志、慢查询日志等。这些日志记录着MongoDB数据库不同方面的踪迹。下面分别介绍这几种日志。 系统日志 系统日志在MongoDB数据库中很重要，它记录着MongoDB启动和停止的操作，以及服务器在运行过程中发生的任何异常信息。 配置系统日志的方法比较简单，在启动mongod时指定logpath参数即可 mongod -logpath=/data/log/mongodb/serverlog.log -logappend 系统日志会向logpath
SpringBoot+AOP日志服务
最新发布
12-13
SpringBoot+AOP日志服务是将流行的Java框架Spring Boot与面向切面编程（AOP）技术结合，用于实现高效、灵活的日志管理。在Spring Boot项目中，AOP可以帮助我们以非侵入式的方式记录应用运行时的行为，尤其是对于业务...
aop切面编程实现MongoDB 日志存储（升级版）
fwk19840301的博客
04-26 2046
实现了平常数据存mysql。日志数据存MongoDB的功能一、日志的bean类 import lombok.Data; import org.springframework.data.mongodb.core.index.CompoundIndex; import org.springframework.data.mongodb.core.index.CompoundIndexes; import...
http请求中必备的字符段_Spring Boot中使用log4j实现http请求日志入mongodb
weixin_39814126的博客
11-23 125
之前在《使用AOP统一处理Web请求日志》一文中介绍了如何使用AOP统一记录web请求日志。基本思路是通过aop去切web层的controller实现，获取每个http的内容并通过log4j将日志内容写到应用服务器的文件系统中。但是当我们在集群中部署应用之后，应用请求的日志被分散记录在了不同应用服务器的文件系统上，这样分散的存储并不利于我们对日志内容的检索。解决日志分散问题的方案多种多样，本文思路...
在SpringBoot中用SpringAOP实现日志记录功能
whxwkb的博客
03-06 321
在SpringBoot中用SpringAOP实现日志记录功能 背景： 我需要在一个SpringBoot的项目中的每个controller加入一个日志记录，记录关于请求的一些信息。 代码类似于: 　　logger.info(request.getRequestUrl()); 之类的。 代码不难，但由于Controller的数量不少，干起来也是体力活。所以想到了用Spring AOP来解决...
spring集成mongodb通过aop记录业务日志
weixin_30919919的博客
05-23 176
1. 编辑 pom.xml 添加 maven 依赖 <!-- mongodb --> <dependency> <groupId>org.mongodb</groupId> <artifactId>mongo-java-driver</artifactId> ...
AOP自定义注解保存到MongoDB数据库
赵达宇的博客
07-31 222
/当前模块描述//请求方法aop：面向切面编程。将于业务无关，却对多个对象产生影响的的公共行为和逻辑。常用来保存系统日志。//根据你的包来//根据你的包来//这个是我的工具类，解析请求里的token拿userId的@Aspect@Component@Autowired@Autowired//切点表达式 拿执行方法的相关参数//拿方法上的注解//注解上的value//当前操作时间//执行方法//结束时间//耗时。
Spring AOP+Annotation切面式注解实现自定义系统日志
一位葛先生
03-18 954
写在前面：此实现感谢我大杰哥 后期我大杰哥会有针对此日志实现的优化，包括注入LogUserService 的懒加载问题 切面编程和自定义注解的技术博客自行研究 【SpringBoot笔记8】Spring AOP 面向切面编程（应用篇） 自定义注解详细介绍 目标： 实现用户操作、操作方法、执行结果的一站式记录 思路： 1. 使用切面编程的方式处理用户操作中系统调用方法的环绕通知式记录，包括调用前获得...
Spring boot 使用logback AOP实现HTTP请求日志入MongoDB
lin_tuer的博客
10-29 2347
Spring boot 使用logback AOP实现HTTP请求日志入MongoDBMongoDB安装与远程访问参考链接–[在ubuntu上安装mongodb] 安装MongoDB 1.1 为软件包管理系统导入公钥 Ubuntu 软件包管理工具为了保证软件包的一致性和可靠性需要用 GPG 密钥检验软件包。使用下列命令导入 MongoDB 的 GPG 密钥 （ MongoD
基于Spring的AOP与JPA集成MySQL和MongoDB实践指南
资源摘要信息:"本资源标题...通过这个资源包，开发者可以学习到如何使用Spring Security构建安全的应用程序、如何利用Spring AOP进行面向切面编程、以及如何通过JPA与MySQL和MongoDB这两种数据库进行集成和数据交互。
记一次MongoDB性能问题(从MySQL迁移到MongoDB)
12-16
公司为这个项目专门配备了几台高性能务器，清一色的双路四核超线程CPU，外加32G内存，运维人员安装好MongoDB后，就交我手里了，我习惯于在使用新服务器前先看看相关日志，了解一下基本情况，当我浏览MongoDB日志时，发现一些警告信息： WARNING: You are running on a NUMA machine. We suggest launching mongod like this to avoid performance problems: numactl –interleave=all mongod [other options] 当时我并不太清楚NUMA是什么东西，所以
spring aop切点记录日志到mongodb 注解版
程门立雪的博客
07-12 1890
package com.jk.aspectj; import java.util.Date; import javax.servlet.http.HttpServletRequest; import org.apache.commons.lang3.StringUtils; import org.aspectj.lang.JoinPoint; import org.aspectj.lang...
动态获取MongoTemplate
it_boy_elite的博客
05-12 726
自定义MongoTemplate; Java动态获取MongoTemplate
MongoDB入门篇--启动mongodb
思想上移，行动下移
12-10 1670
跟着高校平台的项目有一段时间了，一直在接触“新”的技术，突然有种被开“小灶”的感觉，每天都在汲取营养~~。可是由于时间和任务的限制有些方面只是初步了解了一些，更深入的知识点 还有待研究。          因为我们的系统板块中根据业务需求需要存储大量图片信息，在考虑诸多因素对比之后决定用mongodb。关于这块儿也是简单地了解了一下，所以今天只是从入门的角度出发
SpringBoot配置mongodb打印日志
Cyms,BgXmSfXtsj !!!! Battle Each Moment !!!!
05-05 1628
mongodb日志配置： 在 application.yml添加配置： #mongodb打印日志 logging: level: org.springframework.data.mongodb.core.MongoTemplate: DEBUG 如果使用的是 application.properties，则是： #mongodb打印日志 logging.level.org.spri...
spring使用MongoDB，用来存报错日志
anrenxiao9916的博客
07-23 255
1.引入包 <!-- spring data mongoDB依赖 --> <dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-data-mongodb&l...
使用Spring Boot 记录 MongoDB查询 日志(Log)
白石的专栏
11-11 3743
在本文中，我们研究了如何为 Spring Data MongoDB 启用调试日志记录级别。
Java中关于Aspectj面向切面与mongodb的应用(保存操作日志)
qq_41012810的博客
07-16 286
package com.aspectj; import java.util.Date; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpSession; import org.apache.maven.surefire.shade.org.apache.maven.shared.utils...
SpringBoot 操作 MongoTemplate
Mephisto180502的博客
04-27 2131
SpringBoot 操作 mongoTemplate
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值