springboot+aop+线程池+ip2region+mybatisplus实现异步系统日志记录

最新推荐文章于 2024-09-06 11:22:20 发布
最新推荐文章于 2024-09-06 11:22:20 发布
阅读量1.4k 收藏 5
点赞数
分类专栏： JavaEE 文章标签： 线程池 异步 ip2region aop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/iwlnner/article/details/127073722
版权

公司系统需要新增一个需求，可以在需要的地方记录下接口调用的日志。手动在每个需要的接口里面写记录日志的功能不现实，所以这个需求嘛，首选aop切面，废话不多说，搞起

使用ip2region是为了根据客户端ip得到客户端的归属地，没有该需求的话不必引入该依赖

首先创建系统日志(sys_log)表结构，这里用的是postgresql

CREATE SEQUENCE "sde"."sys_log_seq"
INCREMENT 1
MINVALUE  1
MAXVALUE 9223372036854775807
START 1
CACHE 1;

DROP TABLE IF EXISTS "sde"."sys_log";
CREATE TABLE "sde"."sys_log" (
     "id" varchar(255) COLLATE "pg_catalog"."default" NOT NULL DEFAULT nextval('"sde".sys_log_seq'::regclass),
     "description" varchar(255) COLLATE "pg_catalog"."default" DEFAULT NULL::character VARYING,
     "account" varchar(255) COLLATE "pg_catalog"."default" DEFAULT NULL::character varying,
     "user_id" varchar(255) COLLATE "pg_catalog"."default" DEFAULT NULL::character varying,
     "ip" varchar(255) COLLATE "pg_catalog"."default" DEFAULT NULL::character varying,
     "q_cell_core" varchar(255) COLLATE "pg_catalog"."default" DEFAULT NULL::character varying,
     "url" varchar(255) COLLATE "pg_catalog"."default" DEFAULT NULL::character VARYING,
     "req_method" varchar(255) COLLATE "pg_catalog"."default" DEFAULT NULL::character VARYING,
     "req_param" text COLLATE "pg_catalog"."default" DEFAULT NULL::character VARYING,
     "header" text COLLATE "pg_catalog"."default" DEFAULT NULL::character VARYING,
     "stack_trace" text COLLATE "pg_catalog"."default" DEFAULT NULL::character VARYING,
     "type" varchar(4) COLLATE "pg_catalog"."default" DEFAULT NULL::character VARYING,
     "create_time" timestamp
)
;
COMMENT ON COLUMN "sde"."sys_log"."id" IS 'id';
COMMENT ON COLUMN "sde"."sys_log"."description" IS '描述';
COMMENT ON COLUMN "sde"."sys_log"."account" IS '账号';
COMMENT ON COLUMN "sde"."sys_log"."user_id" IS '用户id';
COMMENT ON COLUMN "sde"."sys_log"."ip" IS 'IP地址';
COMMENT ON COLUMN "sde"."sys_log"."q_cell_core" IS '归属地';
COMMENT ON COLUMN "sde"."sys_log"."url" IS '请求路径';
COMMENT ON COLUMN "sde"."sys_log"."req_method" IS '请求类型';
COMMENT ON COLUMN "sde"."sys_log"."req_param" IS '请求参数';
COMMENT ON COLUMN "sde"."sys_log"."header" IS '请求头';
COMMENT ON COLUMN "sde"."sys_log"."stack_trace" IS '异常栈信息';
COMMENT ON COLUMN "sde"."sys_log"."type" IS '日志类型';
COMMENT ON COLUMN "sde"."sys_log"."create_time" IS '创建时间';
COMMENT ON TABLE "sde"."sys_log" IS '系统日志表';

-- ----------------------------
-- Primary Key structure for table sys_log
-- ----------------------------
ALTER TABLE "sde"."sys_log" ADD CONSTRAINT "sys_log_pkey" PRIMARY KEY ("id");

然后导入aop和ip2region的所需依赖（一些包含mybatisplus在内的springboot基础依赖就不再放出来了）

<dependency>
    <groupId>org.lionsoul</groupId>
    <artifactId>ip2region</artifactId>
    <version>1.7.2</version>
</dependency>

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

将下载的ip2region.db文件放到项目的resources目录下

在这里插入图片描述

创建SysLog实体类

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;

import java.io.Serializable;
import java.util.Date;

/**
 * @Author iwlnner
 * @Date 2022-09-05 17:28
 * @Description
 * @Version 1.0
 */
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@ApiModel(value = "SysLog对象", description = "系统日志")
public class SysLog implements Serializable {

    @ApiModelProperty(value = "主键")
    @TableId(value = "id", type = IdType.AUTO)
    private String id;

    @ApiModelProperty(value = "描述")
    private String description;

    @ApiModelProperty(value = "账号")
    private String account;

    @ApiModelProperty(value = "用户id")
    private String userId;

    @ApiModelProperty(value = "IP地址")
    private String ip;

    @ApiModelProperty(value = "归属地")
    private String qCellCore;

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

    @ApiModelProperty(value = "请求方式")
    private String reqMethod;

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

    @ApiModelProperty(value = "请求头")
    private String header;

    @ApiModelProperty(value = "异常信息栈")
    private String stackTrace;

    @ApiModelProperty(value = "日志类型")
    private String type;

    @ApiModelProperty(value = "创建时间")
    private Date createTime;
}

准备工作到此结束，接下来要动脑子了，由于暂时不清楚生成日志的目标是在哪些包的哪些类下，不确定，所以切入点（Pointcut）不能是execution表达式来指定某些类了，因此使用自定义注解就显得更加灵活了

接下来创建自定义注解我起名叫Logx

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @Author iwlnner
 * @Date 2022-09-05 17:40
 * @Description 该注解实现的目标是：Logx注解贴在哪个接口上，
 * 客户端调用这个接口就会生成操作日志并存储到表sys_log中,
 * 由于考虑到不能影响到接口的响应速度，所以这个生成日志操作用异步线程处理
 * @Version 1.0
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Logx {

    /**
     * 日志描述
     * @return
     */
    String value() default "";

}

创建ip工具类IpUtils.java以及请求参数转化工具类RequestUtil.java(两者可合并成一个工具类)

import org.lionsoul.ip2region.DataBlock;
import org.lionsoul.ip2region.DbConfig;
import org.lionsoul.ip2region.DbSearcher;
import org.lionsoul.ip2region.Util;

import java.io.ByteArrayOutputStream;
import java.io.InputStream;

 /**
 * @Author iwlnner
 * @Date 2022-09-06 16:55
 * @Description ip查询处理
 * @Version 1.0
 */
public final class IpUtils {

    private static final String UNKOWN_ADDRESS = "未知位置";

    /**
     * 根据IP获取地址
     *
     * @return 国家|区域|省份|城市|ISP
     */
    public static String getAddress(String ip) throws Exception {
        return getAddress(ip, DbSearcher.MEMORY_ALGORITYM);
    }

    /**
     * 根据IP获取归属地
     *
     * @param ip
     * @param algorithm 查询算法
     * @return 国家|区域|省份|城市|ISP
     */
    public static String getAddress(String ip, int algorithm) {
        DbSearcher searcher = null;
        //java8自动关闭流
        try(InputStream is=IpUtils.class.getClassLoader().getResourceAsStream("ip2region.db");
            ByteArrayOutputStream baos=new ByteArrayOutputStream()){
            if (!Util.isIpAddress(ip)) {
                return UNKOWN_ADDRESS;
            }
            //将ip2region.db文件读取到字节数组输出流
            byte[] buffer=new byte[1024*4];
            int len=0;
            while ((len=is.read(buffer))!=-1){
                baos.write(buffer,0,len);
            }
            //字节输出流转化为字节数组
            byte[] bytes = baos.toByteArray();
            searcher = new DbSearcher(new DbConfig(), bytes);
            DataBlock dataBlock;
            //选择查询算法
            switch (algorithm) {
                case DbSearcher.BTREE_ALGORITHM:
                    dataBlock = searcher.btreeSearch(ip);
                    break;
                case DbSearcher.BINARY_ALGORITHM:
                    dataBlock = searcher.binarySearch(ip);
                    break;
                case DbSearcher.MEMORY_ALGORITYM:
                    dataBlock = searcher.memorySearch(ip);
                    break;
                default:
                    return UNKOWN_ADDRESS;
            }
            return dataBlock.getRegion();
        }catch (Exception e){
            e.printStackTrace();
        }
        return UNKOWN_ADDRESS;
    }

    public static void main(String[] args) throws Exception {
        //System.out.println(IpUtils.getAddress("136.27.231.86"));
        //System.out.println(IpUtils.getAddress("101.227.131.220"));
        System.out.println(IpUtils.getAddress("183.160.213.85"));
    }
}

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;

import javax.servlet.http.HttpServletRequest;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;

/**
 * @Author iwlnner
 * @Date 2022-09-06 17:27
 * @Description
 * @Version 1.0
 */
public class RequestUtil {

	//将请求参数转化成json格式
    public static String getRequestParamsJson(HttpServletRequest request){
        Map<String, String[]> parameterMap = request.getParameterMap();
        ObjectMapper objectMapper=new ObjectMapper();
        String paramJson = null;
        try {
            paramJson = objectMapper.writeValueAsString(parameterMap);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return paramJson;
    }

	//将请求头转化成json格式
    public static String getRequestHeaderJson(HttpServletRequest request){
        Map<String,String> headerMap=new HashMap<>();
        Enumeration<String> headerNames = request.getHeaderNames();
        while (headerNames.hasMoreElements()){
            String key = headerNames.nextElement();
            headerMap.put(key,request.getHeader(key));
        }
        ObjectMapper objectMapper=new ObjectMapper();
        String headerJson = null;
        try {
            headerJson = objectMapper.writeValueAsString(headerMap);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return headerJson;
    }

	//由于公司使用了nginx代理，所以不能直接通过request.getRemoteAddr()获取，使用该方法获取真实ip的前提要保证nginx开启相关配置，后续会进行说明
    public static String getIpAddr(HttpServletRequest request) {
        if (request == null) {
            return "unknown";
        } else {
            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("X-Forwarded-For");
            }

            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.getHeader("X-Real-IP");
            }

            if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
                ip = request.getRemoteAddr();
            }

            return "0:0:0:0:0:0:0:1".equals(ip) ? "127.0.0.1" : ip;
        }
    }
}

然后是SysLog的service，mapper相关业务类

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.IService;
import com.fw.hs.entity.SysLog;
import com.fw.hs.vo.query.SysLogQuery;

/**
 * 系统日志操作
 */
public interface ISysLogService extends IService<SysLog> {

    IPage<SysLog> getList(SysLogQuery query);

    SysLog detail(String id);
}

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.fw.hs.entity.SysLog;
import com.fw.hs.mapper.SysLogMapper;
import com.fw.hs.service.ISysLogService;
import com.fw.hs.vo.query.SysLogQuery;
import org.springframework.stereotype.Service;

/**
 * 系统日志
 */
@Service
public class SysLogServiceImpl extends ServiceImpl<SysLogMapper, SysLog> implements ISysLogService {

    @Override
    public IPage<SysLog> getList(SysLogQuery query) {
        return baseMapper.getList(new Page<>(query.getPageNum(),query.getPageSize()),query);
    }

    @Override
    public SysLog detail(String id) {
        return baseMapper.selectById(id);
    }
}

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.fw.hs.entity.SysLog;
import com.fw.hs.vo.query.SysLogQuery;
import org.apache.ibatis.annotations.Param;

/**
 * 系统日志
 */
public interface SysLogMapper extends BaseMapper<SysLog> {

    IPage<SysLog> getList(Page<SysLog> page, @Param("query") SysLogQuery query);
}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.fw.hs.mapper.SysLogMapper">

    <select id="getList" resultType="com.fw.hs.entity.SysLog">
        select * from sys_log
        <where>
            <if test="query.type!='' and query.type!=null">
                and type=#{query.type}
            </if>
        </where>
    </select>
</mapper>

该有的都齐活了，于是编写最重要的aop增强类业务代码

import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.fw.hs.annotation.Logx;
import com.fw.hs.entity.SysLog;
import com.fw.hs.service.ISysLogService;
import com.fw.hs.utils.IpUtils;
import com.fw.hs.utils.RequestUtil;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.apache.http.HttpEntity;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;

import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.Method;
import java.util.Date;
import java.util.concurrent.*;

@Aspect
@Slf4j
public class SysLogAspect {
	
	//远程调用接口地址，以便获取当前系统登录用户信息
    @Value("${fw.bpm:http://demo:8008}")
    private String bpmUrl;
    @Autowired
    private HttpServletRequest request;
    @Autowired
    private ISysLogService sysLogService;
    //公司应用服务器是cpu密集型服务器，核心线程数=系统核数+1
    private static final int MAXPOOLSIZE=Runtime.getRuntime().availableProcessors() + 1;

	//环绕通知
    @Around("@annotation(logx)")
    public Object around(ProceedingJoinPoint point, Logx logx) {
        Object obj=null;
        SysLog sysLog=new SysLog();
        sysLog.setType("操作日志");
        try{
        	//执行目标方法
            obj = point.proceed();
        } catch (Throwable throwable) {
            sysLog.setStackTrace(throwable.getStackTrace().toString());
            sysLog.setType("异常日志");
            writeData(point,sysLog,logx);
            throwable.printStackTrace();
        }
        //增强逻辑
        writeData(point,sysLog,logx);
        return obj;
    }

    private void writeData(ProceedingJoinPoint point,SysLog sysLog,Logx logx) {
    	//为了减轻服务器某一（理论上）高峰时刻的压力，以及减小创建-销毁线程的系统开销，使用线程池来托管线程
        ThreadPoolExecutor threadPool=new ThreadPoolExecutor(5
                ,MAXPOOLSIZE
                ,10L
                ,TimeUnit.SECONDS
                ,new LinkedBlockingDeque<>(3)
                ,Executors.defaultThreadFactory()
                ,new ThreadPoolExecutor.CallerRunsPolicy());
        try{
        	/*
        	这里一定要注意了，牵扯到request的操作不要放到线程里面，否则会有意想不到的“惊喜”，
        	避免这么做的原因简单来说会影响request域的生命周期，导致其他接口在复用该request对象的时候，
        	得到的是一个"被污染"的request,从而导致在某一段时间内，系统内某个原本正常的接口，
        	接收不到请求参数，这么说或许比较抽象，但如果你的业务中不需要用到request对象，那便再好不过了
        	*/
            String url = request.getRequestURI();
            //截取cookie中的token，放入请求头中
            String cookie = request.getHeader("Cookie");
            String requestMethod = request.getMethod();
            String requestParams = RequestUtil.getRequestParamsJson(request);
            String requestHeader = RequestUtil.getRequestHeaderJson(request);
            String ip = RequestUtil.getIpAddr(request);
            log.info("获取到当前请求客户端IP================》"+ip);
            //这里可以选择功能更加强大的CompletableFuture来实现
            FutureTask<SysLog> futureTask=new FutureTask(()->{
            	//为了防止该匿名内部类中的代码异常被子线程吞掉，try-catch它
                try {
                    String desc = logx.value();
                    if (StrUtil.isEmpty(desc)) {
                    	//如果没有为@Logx注解指定value,则获取被贴方法中@ApiOperation注解的value(接口注释)
                        MethodSignature signature = (MethodSignature) point.getSignature();
                        //获取目标方法，即被@Logx注解贴的方法
                        Method targetMethod = signature.getMethod();
                        //获取ApiOperation注解对象
                        ApiOperation annotation = targetMethod.getAnnotation(ApiOperation.class);
                        if (annotation != null) {
                            desc = annotation.value();
                        }
                    }
                    String qCellCore="未知位置";
                    if(StrUtil.isNotEmpty(ip)) {
                        qCellCore = IpUtils.getAddress(ip);
                    }
                    //获取当前用户
                    CloseableHttpClient client = HttpClients.createDefault();
                    HttpGet httpGet = new HttpGet(bpmUrl + "/fw/org/userResource/userMsg");
                    String auth = "";
                    if (StrUtil.isNotEmpty(cookie) && cookie.indexOf("Authorization=") >= 0) {
                        String authStr = cookie.substring(cookie.indexOf("Authorization="));
                        if(authStr.indexOf(";")>0) {
                            auth = authStr.substring(14, authStr.indexOf(";"));
                        }else {
                            auth=authStr.substring(14);
                        }
                    }
                    httpGet.setHeader("Authorization", auth);
                    HttpEntity entity = client.execute(httpGet).getEntity();
                    if (entity != null) {
                        String body = EntityUtils.toString(entity, "utf-8");
                        JSONObject jsonObject = JSON.parseObject(body);
                        if (jsonObject.getJSONObject("data") != null) {
                            JSONObject userJson = jsonObject.getJSONObject("data").getJSONObject("user");
                            String account = (String) userJson.get("account");
                            String userId = (String) userJson.get("userId");
                            sysLog.setAccount(account);
                            sysLog.setUserId(userId);
                        }
                    }
                    sysLog.setDescription(desc);
                    sysLog.setIp(ip);
                    sysLog.setQCellCore(qCellCore);
                    sysLog.setUrl(url);
                    sysLog.setReqMethod(requestMethod);
                    sysLog.setReqParam(requestParams);
                    sysLog.setHeader(requestHeader);
                    sysLog.setCreateTime(new Date());
                    sysLogService.save(sysLog);
                }catch (Throwable t){
                    t.printStackTrace();
                    log.error("*************生成系统日志异常："+t.getMessage());
                }
                return sysLog;
            });
            //不需要获取线程计算结果，所以用execute方法即可
            threadPool.execute(futureTask);
        }finally{
            threadPool.shutdown();
        }
    }
}

那么到此，整个日志记录功能基本上已经实现了，先来感受一下效果

在这里插入图片描述

但是，别忘了，前面说的nginx真实ip相关配置还没有改，那么来吧，打开服务器上的nginx.conf文件，找到反向代理对应的location块，加上下面这段配置

proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header REMOTE-HOST $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;

加上之后效果

在这里插入图片描述

然后重启nginx服务和本地后端服务，访问上面被贴了@Logx注解的接口，查看数据库

在这里插入图片描述

成功生成了日志记录！

iwlnner
关注
专栏目录
maxwell‘s + mysql + springboot + mybatisplus (部分技术) 打造业务数据级审计日志
ava1749144759的博客
05-17 861
文章部分内容作者并没有实现, 目前也只在构思!!! 文章部分内容作者并没有实现, 目前也只在构思!!! 文章部分内容作者并没有实现, 目前也只在构思!!! 业务日志 简单业务 简单业务日志只需要自己手撸一个aop切面,通过织入点实现一些功能就可以实现 较为简单 简单业务 数据审计通常用作"审计系统" 的一部分进行开发例如 用户行为审计 流量审计.... 简单业务 + 简单业务 实现样例: 用户 模块 时间 数据 详情 张三 目录 202.
springBoot+aop+自定义注解+本地线程实现统一接口日志及接口响应时长
02-01
springboot+拦截器+aop+自定义注解+本地线程实现统一接口日志记录，记录下接口所在模块、接口描述、接口请求参数、接口返回参数、接口请求时间以及接口耗时用于接口优化，接口记录参数以及操作人防止使用人员误操作...
Mybatis日志
TvTToT的博客
08-27 217
1. 日志工厂 如果一个数据库的操作出现了异常，日志就是最好的排错助手，在Mybatis中具体使用哪一个日志实现需要在设置中指定 **STDOUT_LOGGING：**标准日志工厂实现 在mybatis-config.xml中配置 <settings> <setting name="logImpl" value="STDOUT_LOGGING"/> </settings> 2. LOG4J Log4j是Apache的一个开源项目，通过使用Lo
使用Spring Boot和ip2region实现应用的IP定位功能
最新发布
weixin_42593549的博客
09-06 748
本文还有配套的精品资源，点击获取 简介：本文指导如何在基于Spring Boot的Web应用程序中集成ip2region库，以实现用户IP地址的地理位置定位。通过依赖添加、数据加载、服务接口创建、服务使用以及测试和优化等步骤，使应用能够快速准确地进行IP定位。此外，还提供了关于定位准确性以及遵守隐私政策和法律法规的注意事项。 1. Spring Boot与ip2r...
自定义Springboot Aop异步写入日志
蒯厅博客
09-28 434
自定义Springboot Aop异步写入日志
SpringAop+异步任务实现日志记录
qq_61273171的博客
03-22 1486
AOP（面向切面编程）用于将横切关注点从核心的业务逻辑中抽离出来。横切关注点是与核心功能无关但是又散布在多个部分的关注点，如日志记录、事务管理、错误处理等。AOP的目的是提高代码的复用性、模块性、可维护性。
Spring AOP + 异步任务实现日志记录（操作日志、异常日志）参考ruoyi
qq_52227892的博客
10-17 5450
AOP（Aspect-Oriented Programming，面向切面编程）是一种编程范例，用于将横切关注点（cross-cutting concerns）从应用程序的核心逻辑中分离出来。横切关注点是那些与应用程序的核心功能无关但又散布在多个部分的关注点，如日志记录、事务管理、安全性、错误处理和性能优化。AOP的目标是提高代码的模块性、可维护性和可重用性。
SpringBoot+AOP+TraceID.pdf
01-04
SpringBoot+AOP+TraceID.pdf 本文档主要讲解了 SpringBoot 中 AOP（Aspect Oriented Programming）的应用和 TraceID 的实现。 AOP 基本概念 AOP 的 existence 目的是为了解耦，使得一组类可以共享相同的行为。在 ...
详解springboot+aop+Lua分布式限流的最佳实践
08-19
详解springboot+aop+Lua分布式限流的最佳实践 本文主要介绍了springboot+aop+Lua分布式限流的最佳实践，涵盖了限流的定义、限流的重要性、限流方案等多个方面。 一、什么是限流？为什么要限流？ 限流是指限制系统...
基于springboot+mvc+freemarker+aop实现校友信息管理系统源码.zip
01-08
1、基于springboot+mvc+freemarker+aop实现校友信息管理系统源码.zip 2、该资源包括项目的全部源码，下载可以直接使用！ 3、本项目适合作为计算机、数学、电子信息等专业的课程设计、期末大作业和毕设项目，作为参考...
使用SpringBoot+AOP实现可插拔式日志的示例代码
08-25
使用 AOP 实现可插拔式日志的示例代码，能够很好地记录系统中的日志信息，方便我们debug 和优化系统。 本文详细介绍了使用 SpringBoot+AOP 实现可插拔式日志的示例代码，包括创建 SysLog 注解、SysLogAspect 类，...
Springboot接口项目如何使用AOP记录日志
08-19
主要介绍了Springboot接口项目如何使用AOP记录日志,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
spring aop使用异步的方式批量处理系统日志
RAVEEE的博客
05-14 3550
在软件开发的过程中，进行系统日志记录是必不可少的，我利用了Spring aop 自定义注解 面向切面编程 队列 异步 批量处理的方式 完成了我们系统的日志记录，提升了日志记录的性能。 首先 ：编写自定义注解，使用该注解注解在controller层的方法上，便于后续的aop记录日志。 /** * @author 徐塬峰 2019/4/14 * 以自定义注解的方式记录日志 * 注解在方法......
系统的异步操作日志记录 ：自定注解+AOP+异步
chuanchengdabing的博客
03-15 1390
将该任务交由jdk提供的一个ScheduledExecutorService（定时任务线程池）来执行进行插入，这样就避免了系统在插入操作日志时如果出现异常了从而导致业务功能无法正常返回。该注解标记在Contrller接口的方法上，通过切面的方式记录日志，在方法返回和抛异常的时候执行。基于request中的请求参数和 方法的返回值 方法抛出的异常信息 为操作日志实体类设置属性。将操作日志实体类入库的操作定义为一个TimeTask任务。在我们的系统中定义了一个Log注解。在AOP切面中构建操作日志的实体类。
aop的应用使用aop完成日志的记录
wr_java的博客
09-06 546
自定义注解，用来记录用户的操作和一些基本信息 package com.soecode.lyf.log.annatation; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; /** * Create by wws on 20
SpringBoot整合MyBatis-plus layui框架异步crud
暗武逢天的博客
06-22 1万+
SpringBoot整合MyBatis-plus layui框架异步crud 首先创建springboot空项目 1.引入所需的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="htt
Springboot通过AOP和Async实现异步日志入库
Meta39的博客
10-27 3056
Springboot通过AOP和Async实现异步日志入库
Java多线程实战-异步操作日志记录解决方案(AOP+注解+多线程)
热门推荐
qq_35716689的博客
03-16 25万+
异步日志记录是一种提升系统性能和可维护性的有效手段。牵着猫散步的鼠鼠。通过将日志记录操作异步化，不仅可以减少对业务处理流程的影响，还可以提高日志处理的灵活性和扩展性。然而，实现异步日志记录机制也伴随着一定的挑战，如日志的实时性、顺序性和丢失风险等问题。
异步线程记录日志
m0_71409306的博客
07-26 969
异步线程记录日志
SpringBoot+AOP+Lua分布式限流实战解析
"详解springboot+aop+Lua分布式限流的最佳实践" 本文将深入探讨如何在Spring Boot项目中结合AOP（面向切面编程）和Lua实现高效的分布式限流策略。限流是保障系统稳定性和高可用性的重要技术手段，尤其对于处理大...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值