SpringBoot架构实战：拦截器+全局异常+日志追踪一体化解决方案

于 2025-02-14 15:14:29 发布
阅读量1.3k 收藏 41
点赞数 36
分类专栏： java 文章标签： spring boot 架构 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_26533645/article/details/145633256
版权

SpringBoot架构实战：拦截器+全局异常+日志追踪一体化解决方案

概述

本文介绍企业级Java项目中常用的日志链路追踪、统一异常处理、权限拦截等核心功能的实现方案。通过AOP切面、自定义拦截器、线程上下文管理等技术手段，实现以下核心功能：

  • 全链路日志追踪
  • 统一异常处理机制
  • 接口权限验证
  • 请求耗时监控
  • 标准化日志格式

一、核心功能模块

1.1 全局日志切面（WebControllerAop）

  • 实现原理：基于Spring AOP的环绕通知
  • 核心功能：
    • 请求参数/响应结果格式化
    • 接口耗时计算（精确到秒）
    • 请求事件名称映射
    • 文件类型请求特殊处理
    • 线程上下文初始化
import cn.hutool.core.date.DateUtil;
import com.alibaba.fastjson.JSON;
import ****.infrastructure.general.constants.Constants;
import ****.infrastructure.general.constants.ReqUrlConstants;
import ****.infrastructure.general.util.LogUtil;
import ****.infrastructure.general.util.ThreadLocalUtil;
import com.google.common.collect.Maps;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

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

/**
 * @author: guohong
 */

@Slf4j
@Aspect
@Component
public class WebControllerAop {

    /**
     * 指定切点
     * 匹配 com.example.demo.controller包及其子包下的所有类的所有方法
     */
    @Pointcut("execution(public * ****.apis.controller.*.*(..)) || execution(public * ****.apis.*.controller.*.*(..))")
    public void webLog() {
    }

    /**
     * 环绕通知,环绕增强，相当于MethodInterceptor
     *
     * @param joinPoint
     * @return
     */
    @Around("webLog()")
    public Object arround(ProceedingJoinPoint joinPoint) throws Throwable {
        long startTime = System.currentTimeMillis();
        //获取目标方法的参数信息
        Signature signature = joinPoint.getSignature();
        String args;
        if (ReqUrlConstants.FILE_URL_MAP.containsKey(signature.getDeclaringTypeName())) {
            args = "【文件流类型】";
        } else {
            args = formatArgs(joinPoint);
        }

        //AOP代理类的类（class）信息
        signature.getDeclaringType();
        // 接收到请求，记录请求内容
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        if (attributes == null) {
            Object o = joinPoint.proceed();
            //记录日志
            log.info("接收请求-{} \n 请求ID：{} \n 请求地址： {} \n token： {} \n 入参 : {}  \n 出参 : {} \n 请求时间：{} \n 响应时间：{} \n 耗时：{}秒",
                    "", LogUtil.idEnd(), "",  "", args, formatRet(o), DateUtil.date(startTime), DateUtil.now(), (System.currentTimeMillis() - startTime) / 1000d);
            ThreadLocalUtil.remove();
            return o;
        }
        HttpServletRequest req = attributes.getRequest();
        String logId = req.getHeader(Constants.PROCESS_ID);
        if (StringUtils.isBlank(logId)) {
            LogUtil.createId();
        } else {
            ThreadLocalUtil.set(Constants.THREAD_NO, logId);
        } 
        String token = req.getHeader(Constants.CAR_TOKEN);

        String eventName = getEventName(req.getRequestURL().toString());
        String reqName = "系统接口：" + eventName + " " + joinPoint.getSignature().getDeclaringTypeName() + "." + joinPoint.getSignature().getName() + "()";
        String reqUrl = req.getMethod() + " " + req.getRequestURL().toString();
        HashMap<String, String> map = Maps.newHashMap();
        map.put(Constants.THREAD_REQ_NAME, reqName);
        map.put(Constants.THREAD_REQ_URL, reqUrl);
        map.put(Constants.THREAD_REQ_PARAM, args);
        map.put(Constants.THREAD_REQ_TIME, startTime + "");
        ThreadLocalUtil.set(Constants.THREAD_REQ_PARAM, map);

        //执行目标方法
        Object o = joinPoint.proceed();

        //记录日志
        log.info("接收请求：{} \n 请求ID：{} \n 请求地址： {} \n token： {} \n 入参 : {}  \n 出参 : {} \n 请求时间：{} \n 响应时间：{} \n 耗时：{}秒",
                eventName, LogUtil.idEnd(), reqUrl, token, args, formatRet(o), DateUtil.date(startTime), DateUtil.now(), (System.currentTimeMillis() - startTime) / 1000d);

        //移除所有线程map,防止线程复用导致的变量错乱及内存溢出
        ThreadLocalUtil.remove();
        return o;
    }

    private String formatArgs(JoinPoint joinPoint) {
        String args = Arrays.toString(joinPoint.getArgs());
        try {
            StringBuilder argsBuild = new StringBuilder();
            Object[] argsArray = joinPoint.getArgs();
            if (argsArray.length >= 1) {
                argsBuild.append(JSON.toJSONString(argsArray[0]));
            }
            if (StringUtils.length(argsBuild.toString()) > 0) {
                return argsBuild.toString();
            }
        } catch (Exception ignored) {
            return args;
        }
        return args;
    }

    private Object formatRet(Object ret) {
        try {
            String retJson = JSON.toJSONString(ret);
            if (StringUtils.isNotBlank(retJson)) {
                return retJson;
            }
        } catch (Exception ignored) {
            return ret;
        }
        return ret;
    }

    /**
     * 根据请求url 获取对应的业务名称
     *
     * @param requestURL
     * @return
     */
    private static String getEventName(String requestURL) {
        if (StringUtils.isBlank(requestURL)) {
            return "未知URL";
        }
        for (Map.Entry<String, String> entry : ReqUrlConstants.MAP.entrySet()) {
            if (StringUtils.contains(requestURL, entry.getKey())) {
                return entry.getValue();
            }
        }
        return "未配置事件";
    }

}

1.2 统一异常处理（GlobalExceptionHandler）

  • 异常分类处理：
    • 文件上传异常（MultipartException）
    • 参数校验异常（MethodArgumentNotValidException）
    • 业务异常（ApiException）
    • 未捕获异常兜底处理
    • java代码：

import cn.hutool.core.date.DateUtil;
import ****.infrastructure.general.constants.Constants;
import ****.infrastructure.general.util.LogUtil;
import ****.infrastructure.general.util.ThreadLocalUtil;
import ****commons.base.Result;
import ****commons.exception.ApiException;
import ****commons.exception.ErrorResultCode;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.tomcat.util.http.fileupload.impl.FileSizeLimitExceededException;
import org.apache.tomcat.util.http.fileupload.impl.SizeLimitExceededException;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
import org.springframework.http.HttpStatus;
import org.springframework.util.CollectionUtils;
import org.springframework.validation.BindingResult;
import org.springframework.validation.ObjectError;
import org.springframework.web.HttpMediaTypeNotSupportedException;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.MissingServletRequestParameterException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import org.springframework.web.multipart.MultipartException;

import javax.servlet.http.HttpServletRequest;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.StringJoiner;

@Slf4j
@RestControllerAdvice
@Order(Ordered.HIGHEST_PRECEDENCE) // 设置最高优先级
public class GlobalExceptionHandler {
    @Value(value = "${spring.servlet.multipart.max-file-size}")
    String singleMaxFileSize;
    @Value(value = "${spring.servlet.multipart.max-request-size}")
    String maxRequestSize;


    /**
     *  文件上传错误
     * @param req
     * @param ex
     * @return
     */
    @ResponseBody
    @ExceptionHandler(value = MultipartException.class)
    @ResponseStatus(HttpStatus.OK)
    public Result<Object> MultipartExceptionHandler(HttpServletRequest req, MultipartException ex) {

        if (ex.getCause().getCause() instanceof FileSizeLimitExceededException) {
            return formatResult(ErrorResultCode.CLIENT_DATA_EXE.getErrorCode(), "单个文件上传大小不能超过" + singleMaxFileSize, ex);
        } else if (ex.getCause().getCause() instanceof SizeLimitExceededException) {
            return formatResult(ErrorResultCode.CLIENT_DATA_EXE.getErrorCode(), "请求的总上传文件大小不能超过" + maxRequestSize, ex);
        } else {
            return formatResult(ErrorResultCode.CLIENT_DATA_EXE.getErrorCode(), "上传文件失败", ex);
        }
    }
    /**
     * 其他错误
     */
    @ResponseBody
    @ExceptionHandler({Exception.class})
    @ResponseStatus(HttpStatus.OK)
    public Result<Object> exception(HttpServletRequest req, Exception ex) {
        return formatResult(ErrorResultCode.SYSTEM_ERROR.getErrorCode(), "系统异常:" + ex.getMessage(), ex);
    }
    //运行时异常
    @ResponseBody
    @ExceptionHandler(RuntimeException.class)
    @ResponseStatus(HttpStatus.OK)
    public Result<Object> runtimeExceptionHandler(HttpServletRequest req, RuntimeException ex) {
        return formatResult(ErrorResultCode.SYSTEM_ERROR.getErrorCode(), "执行异常:" + ex.getMessage(), ex);
    }
    /**
     * 业务异常
     */
    @ResponseBody
    @ExceptionHandler({ApiException.class})
    @ResponseStatus(HttpStatus.OK)
    public Result<Object> ApiExceptionHandler(ApiException e) {
        log.error("Message: {}", e.getMessage(), e);
        return formatResult(e.getResultCode().getErrorCode(), e.getResultCode().getError(), e);
    }

    @ResponseBody
    @ExceptionHandler({MissingServletRequestParameterException.class})
    @ResponseStatus(HttpStatus.OK)
    public Result<Object> missingServletRequestParameterExceptionHandler(MissingServletRequestParameterException e) {
        log.error("Message: {}", e.getMessage(), e);
        return formatResult(ErrorResultCode.PARAM_REQUIRED.getErrorCode(), String.format(ErrorResultCode.PARAM_REQUIRED.getError(), e.getParameterName()), e);
    }

    @ResponseBody
    @ExceptionHandler({MethodArgumentNotValidException.class})
    @ResponseStatus(HttpStatus.OK)
    public Result<Object> methodArgumentNotValidExceptionHandler(MethodArgumentNotValidException e) {
        log.error("Message: {}", e.getMessage(), e);
        return formatResult(ErrorResultCode.PARAM_REQUIRED.getErrorCode(), String.format(ErrorResultCode.PARAM_REQUIRED.getError(), this.getBindingResultErrors(e.getBindingResult())), e);
    }

    @ResponseBody
    @ExceptionHandler({HttpMediaTypeNotSupportedException.class})
    @ResponseStatus(HttpStatus.OK)
    public Result<Object> httpMediaTypeNotSupportedExceptionHandler(HttpMediaTypeNotSupportedException e) {
        log.error("Message: {}", e.getMessage(), e);
        return formatResult(ErrorResultCode.REQUEST_TYPE_ERROR.getErrorCode(), ErrorResultCode.REQUEST_TYPE_ERROR.getError(), e);
    }
    

    private <T extends Throwable> Result<Object> formatResult(String errorCode, String errorMsg, T ex) {

        Map<String, String> reqMap = ThreadLocalUtil.get(Constants.THREAD_REQ_PARAM);
        long startTime = System.currentTimeMillis();
        String reqName = "内部处理";
        String url = "";
        String param = "";
        if (!CollectionUtils.isEmpty(reqMap)){
            if (StringUtils.isNotBlank(reqMap.get(Constants.THREAD_REQ_TIME))) {
                startTime = Long.parseLong(reqMap.get(Constants.THREAD_REQ_TIME));
            }
            if (StringUtils.isNotBlank(reqMap.get(Constants.THREAD_REQ_NAME))) {
                reqName = reqMap.get(Constants.THREAD_REQ_NAME);
            }
            if (StringUtils.isNotBlank(reqMap.get(Constants.THREAD_REQ_URL))) {
                url = reqMap.get(Constants.THREAD_REQ_URL);
            }
            if (StringUtils.isNotBlank(reqMap.get(Constants.THREAD_REQ_PARAM))) {
                param = reqMap.get(Constants.THREAD_REQ_PARAM);
            }
        }
        
        //获取异常信息
        StringJoiner err = new StringJoiner("/n/r ");
        StackTraceElement[] stackTrace = ex.getStackTrace();
        if (null != stackTrace) {
            for (int i = 0; i < (Math.min(stackTrace.length, 100)); i++) {
                err.add(stackTrace[i].toString());
            }
        }
        //记录日志
        log.info("响应异常-{} \n 请求ID：{} \n 请求url: {} \n 入参 : {}  \n 出参 : {} \n 请求时间：{}  \n 响应时间： {} \n 耗时：{}秒",
                reqName, LogUtil.idEnd(),url, param,
                "异常代码:" + errorCode + " 异常信息:" + errorMsg + "-" + ex.getMessage()+"/n/r" + err, 
                startTime, DateUtil.now(), (System.currentTimeMillis() - startTime) / 1000);
        
        //移除所有线程map,防止线程复用导致的变量错乱及内存溢出
        ThreadLocalUtil.remove();
        return new Result(errorCode, errorMsg);
    }


    private String getBindingResultErrors(BindingResult bindingResult) {
        StringBuilder sb = new StringBuilder();
        if (bindingResult.hasErrors()) {
            List<ObjectError> list = bindingResult.getAllErrors();
            Iterator var4 = list.iterator();

            while(var4.hasNext()) {
                ObjectError error = (ObjectError)var4.next();
                sb.append(error.getDefaultMessage() + ",");
            }
        }

        return sb.toString();
    }
}
  • 统一响应格式：
    {"code":"ERROR_001","msg":"参数校验失败"}

1.3 权限拦截器（RequestInterceptor）

  • 安全校验流程：
    1. Token有效性验证
    2. Redis缓存用户信息
    3. 权限服务远程调用
    4. 用户上下文传递
  • 支持功能：
    • 外部用户权限标识
    • Token自动续期（60天）
    • 用户信息线程级缓存
  • **配置类：

import cn.hutool.extra.spring.SpringUtil;
import ****.aop.RequestInterceptor;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class InterceptorConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //连接所有
        registry.addInterceptor(SpringUtil.getBean(RequestInterceptor.class))
                .addPathPatterns("/**")
                .excludePathPatterns(
                		"/login" 
                        ,"/we-chat/**"
                );
    }

}

拦截器：


import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import ****.apis.controller.BaseController;
import ****.client.model.UserAuthDto;
import ****.client.model.UserInfoDto;
import ****.infrastructure.general.constants.Constants;
import ****.infrastructure.redis.RedisUtil;
import ****.util.JsonUtils;
import ****commons.exception.ApiException;
import ****commons.exception.ErrorResultCode;
import ****skyauth.dto.R;
import ****skyauth.dto.UserAuthBaseDto;
import ****skyauth.service.AuthService;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.concurrent.TimeUnit;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

@Component
public class RequestInterceptor implements HandlerInterceptor {

    @Autowired
    RedisUtil redisUtil;

    @Autowired
    BaseController baseController;

    @Autowired
    AuthService authService;

    @Override   
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        boolean result = false;
        String token = request.getHeader(Constants.TOKEN);
        if(ObjectUtil.isEmpty(token)){
            ApiException.newThrow(ErrorResultCode.TOKEN_IS_NULL);
        }
        //从缓存中查找此token有没有存在
        UserInfoDto userInfo = JSONObject.parseObject(String.valueOf(redisUtil.getCache(token)), UserInfoDto.class);
        //如果redis缓存为空，去查一次天权系统查看token，然后放入redis中
        if(ObjectUtil.isEmpty(userInfo)){
            R r = authService.userPermission(Constants.SKYAUTH_APPID, token, new UserAuthBaseDto());
            Integer code = (Integer)r.get("code");
            //feign调用成功
            if(****.infrastructure.general.constants.HttpStatus.SUCCESS==code){
                Object data = r.get("data");
                if(ObjectUtil.isNotEmpty(data)){
                    UserAuthDto userAuthDto = JSON.parseObject(JSON.toJSONString(data), UserAuthDto.class);
                    userInfo = new UserInfoDto();
                    //添加外部用户权限标识
                    ObjectMapper objectMapper = new ObjectMapper();
                    JsonNode jsonNode = objectMapper.readTree(userAuthDto.getDepts().toString());
                    if (JsonUtils.containsFuncNormalList(jsonNode, Constants.IS_EXT_USER_RIGHTS)) {
                        userInfo.setIsExternal("1");
                    }
                    BeanUtils.copyProperties(userAuthDto,userInfo);
                    //feign调用成功且token依然有效
                    redisUtil.setCacheWithExpiration(token,JSONObject.toJSONString(userInfo),60, TimeUnit.DAYS);
                    request.setAttribute(Constants.USER_NAME,userInfo.getUserName());
                    request.setAttribute(Constants.USER_ID,userInfo.getUserId());
                    request.setAttribute(Constants.IS_EXTERNAL, userInfo.getIsExternal());
                    result = true;
                }else {
                    //这里是调用feign成功但是token校验失败了 返回401
                    ApiException.newThrow(ErrorResultCode.LOGIN_FAILED,"登陆已超时，请重新登录");
                }
            }else {
                //feign调用失败
                ApiException.newThrow(ErrorResultCode.CLIENT_DATA_EXE,(String)r.get("msg"));
            }
        }else{
            request.setAttribute(Constants.USER_NAME, userInfo.getUserName());
            request.setAttribute(Constants.USER_ID, userInfo.getUserId());
            request.setAttribute(Constants.IS_EXTERNAL, userInfo.getIsExternal());
            result = true;
        }
        return result;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        HandlerInterceptor.super.postHandle(request, response, handler, modelAndView);
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        HandlerInterceptor.super.afterCompletion(request, response, handler, ex);
    }

}

1.4 线程上下文管理

  • ThreadLocalUtil：
    • 线程安全的数据存储
    • 支持嵌套调用上下文传递
    • 自动清理机制

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

/**
* @Description: 线程共享类
*/
public class ThreadLocalUtil {

    private static ThreadLocal<Map<String, Object>> threadLocal = new ThreadLocal() {
        protected Map<String, Object> initialValue() {
            return new HashMap(4);
        }
    };

    public static Map<String, Object> getThreadLocal(){
        return threadLocal.get();
    }

    public static <T> T get(String key) {
        Map map = threadLocal.get();
        return (T)map.get(key);
    }

    public static <T> T get(String key,T defaultValue) {
        Map map = threadLocal.get();
        return (T)map.get(key) == null ? defaultValue : (T)map.get(key);
    }

    public static void set(String key, Object value) {
        Map map = threadLocal.get();
        map.put(key, value);
    }

    public static void set(Map<String, Object> keyValueMap) {
        Map map = threadLocal.get();
        map.putAll(keyValueMap);
    }

    public static void remove() {
        threadLocal.remove();
    }

    public static <T> T remove(String key) {
        Map map = threadLocal.get();
        return (T)map.remove(key);
    }
}
  • LogUtil：
    • 唯一日志ID生成（时间戳+UUID）
    • 多线程ID继承机制
    • 日志前缀自动追加

import cn.hutool.core.date.DateUtil;
import ****.infrastructure.general.constants.Constants;
import org.apache.commons.lang3.StringUtils;

import java.util.Date;
import java.util.UUID;

/**
* @Description: 线程日志处理类
*/
public class LogUtil {

    /**
     * 返回当前日志ID，如果为空则生成。拼接-和序号
     */
    public static String id() {

        String logId = ThreadLocalUtil.get(Constants.THREAD_NO);
        if (StringUtils.isEmpty(logId)) {
            logId = DateUtil.format(new Date(), "yyyyMMddHHmmss") + UUID.randomUUID().toString().replaceAll("-", "").substring(0, 16);
        }
        Long seq = ThreadLocalUtil.get(Constants.THREAD_SEQ);
        if (seq == null) {
            seq = 1L;
            ThreadLocalUtil.set(Constants.THREAD_SEQ, seq);
        } else {
            seq = seq + 1;
            ThreadLocalUtil.set(Constants.THREAD_SEQ, seq);
        }
        return logId + "^" + seq +"-";
    }

    /**
     * 返回当前日志ID，如果为空则生成。拼接-和序号
     */
    public static String idEnd() {
        return StringUtils.removeEnd(id(), "-");
    }
    
    /**
     * 返回当前日志ID，如果为空则生成。拼接-和序号
     */
    public static void createId() {
        String logId = ThreadLocalUtil.get(Constants.THREAD_NO);
        if (StringUtils.isEmpty(logId)) {
            logId = DateUtil.format(new Date(), "yyyyMMddHHmmss") + UUID.randomUUID().toString().replaceAll("-", "").substring(0, 16);
            ThreadLocalUtil.set(Constants.THREAD_NO, logId);
        }
    }
}

调用示例：

@PostMapping("/pullWxChatRecordScheduleTask")
    public String dingshirenwu(){
        try{
            //拉取聊天记录
            wxCompanyChatService.pullWxChatRecord(null);
            
            //查询时间倒序，配置时间内的（例如：三分钟）内里未被大模型扫描的群聊id集合
            List<String> groupIdList = wxCompanyChatService.getGroupId();
            log.info(LogUtil.id() + "获取有问题反馈的群ID {}", groupIdList);
            
            //启动线程池任务
            ExecutorService threadPool = LLmAnalysisChatRecordThread.getLlmAnalySisChatRecordThreadPool();
            for (String groupId : groupIdList) {
                String logId = ThreadLocalUtil.get(Constants.THREAD_NO);
                Long seq = ThreadLocalUtil.get(Constants.THREAD_SEQ);
                threadPool.submit(() -> {
                    //日志ID ：使用主线程日志ID + 子线程ID
                    ThreadLocalUtil.set(Constants.THREAD_NO, logId + "-" + Thread.currentThread().getId());
                    ThreadLocalUtil.set(Constants.THREAD_SEQ, seq);
                    wxGroupChatService.analysisGroupChatRecordByGroupId(groupId);
                });
            }
        }catch (Exception e){
            log.error(LogUtil.id() + "异常捕捉", e);
            return "失败";
        }
        return "成功";
    }

二、核心设计亮点

2.1 日志链路追踪方案

  • 唯一TraceID生成规则：yyyyMMddHHmmss+16位随机数
  • 多线程ID继承：主线程ID + 子线程ID
  • 日志要素包含：
    [请求时间] [序号][响应时间][耗时][入参][出参][异常堆栈]

2.2 性能优化策略

  • 文件类型请求参数特殊处理
  • Redis缓存用户信息（60天）
  • 异常堆栈智能截取（保留前100行）

2.3 安全控制

  • 白名单路径配置
  • 双重Token验证机制（本地缓存+远程验证）
  • 外部用户权限标识隔离

三、使用示例

3.1 基础日志记录

log.info(LogUtil.id() + "获取有问题反馈的群ID {}", groupIdList);

3.2 多线程场景

threadPool.submit(() -> {
    ThreadLocalUtil.set(Constants.THREAD_NO, logId + "-" + Thread.currentThread().getId());
    // 业务逻辑
});

四、部署注意事项

  1. 需要配置Redis连接信息
  2. 权限服务地址配置
  3. 文件上传大小限制参数：
    spring.servlet.multipart.max-file-size=10MB
spring.servlet.multipart.max-request-size=100MB

五、总结

本方案实现了企业级项目的三个核心需求：

  1. 可追踪性：全链路日志追踪能力
  2. 稳定性：统一异常处理机制
  3. 安全性：完善的权限验证体系

通过合理的线程上下文管理、AOP切面设计、异常处理规范，显著提升了系统的可维护性和问题排查效率。实际使用中可根据业务需求扩展日志采集维度，集成APM系统实现更完善的监控体系。

springboot使用拦截器收集用户的操作日志信息
qq_42379705的博客
10-24 1455
拦截器收集操作日志
Spring Boot使用AOP实现拦截器
null
09-26 1万+
新建GlobalException异常类，用于捕捉全局异常。super();@Override@Override自定义AOP，对接口入参进行非空校验和验签；并对接口返回参数进行签名。@Aspect@Component/*** 声明一个切入点，范围为controller包下所有的类* 注：作为切入点签名的方法必须返回void类型*//*** 前置通知：在某连接点之前执行的通知，但这个通知不能阻止连接点之前的执行流程（除非它抛出一个异常）
springboot拦截器记录接口日志信息
qq_37342720的博客
04-22 3412
继上一篇文章springboot 切点@Pointcut 过滤某个目录的类我又使用拦截器来记录日志信息。 spring拦截器 一般有两种 继承HandlerInterceptorAdapter 实现HandlerInterceptor 一般用作日志记录和登录校验使用。 主要有三种方法 preHandle：拦截于请求刚进入时，进行判断，需要boolean返回值，如果返回true将继续执行，如果返回false，将不进行执行。一般用于登录校验。 postHandle：拦截于方法成功返回后，视图渲..
springboot拦截器记录请求操作参数日志
11-29 1473
springboot用拦截器记录请求操作日志
一、springboot中使用拦截器记录日志（日志框架-logback）
燕少江湖
10-29 6870
一、在分布式项目中，会出现很多跟踪某个用户的每一次请求，定位用户请求过程中出现的问题，统计接口的响应时间、效率等。比如定位用户请求过程中出现的问题，这就需要知道用户请求的是哪个接口，即知道URI、请求参数，在接口中出现了什么问题，如果在日志中没有打印用户的请求参数、没有记录同一次请求相同的id之类的参数、那么定位问题是非常痛苦的。常见的日志框架有：log4j、log4j 2、 slf4j，Comm......
[转]spring boot 拦截器 或 Spring AOP 方式记录请求日志
tt____tt的专栏
09-15 1636
选择使用拦截器实现，在实现中遇到两个个问题: a. POST请求 @RequestBody 传的参数不知怎么获取？ b. 返回结果如何获取？ c.拦截器中service 无法注入；（已解决） 不知道有没有人遇到这种情况，拦截器没有解决上述问题，后来使用 spring AOP 处理。  《一》拦截器方式 @Configuration public class OptPermission...
分布式中间件之Dubbo详解
tdd18792032806的博客
07-29 3731
文章内容输出来源：拉勾教育Java高薪训练营 心得体会： 在拉勾教育高薪训练营里经过三个月多的学习，很辛苦但也收获很多，主要体现在：1.以前是工作遇到了哪方面的问题才去学习并解决，很难形成知识体系，在拉勾高薪训练营里课程内容很丰富，基础回顾加进阶讲解，完美的打造了个人的知识体系，为成为一名合格的架构师奠定了基础；2.值得一说的是“闯关式”的学习模式，若上一个模块的作业未完成就无法学习下一个模块，但有班主任和导师对个人的学习进行督促，可以让我们学员必须牢靠的掌握技术知识点；3.在知识点技术落地方面，以前只是听
工作中使用到的单词（软件开发）
热门推荐
sun0322
03-15 5万+
１．エイリアス 　　alias 别名 powershell使用 get-help 命令时，会得到与此命令 相关（别名）的命令 ２．プロキシ　proxy　代　理 ３．プロモート 　 promote 促进，提升 　　开发的系统新功能上线发布，有时会使用到这个词，比如 STプロモート 还有使用リリース这个词的。比如STリリース。个人认为两者含义相同。 ４．見逃し　み................................................................
【SpringBoot】拦截器实现统一访问日志
Robin的博客
03-06 824
/请求开始时间标识 private static final String LOGGER_SEND_TIME = "SEND_TIME";//请求日志实体标识 private static final String LOGGER_ACCESSLOG = "ACCESSLOG_ENTITY";/*** 进入SpringMVC的Controller之前开始记录日志实体//创建日志实体 AccessLog accessLog = new AccessLog();
springboot aop全局操作日志
qq_41100656的博客
12-17 531
springboot 日志处理
spring boot aop 统一处理日志
10-18
spring boot aop 统一处理日志 demo spring boot aop 统一处理日志 demo
springboot spring aop 拦截器注解方式实现脱敏
02-13
springboot spring aop 拦截器 注解方式实现脱敏（涉及到：pom.xml -->application.properties --->启动类-->拦截器）
SpringBoot全局日志打印
qq_41934680的博客
07-01 662
这里写自定义目录标题SpringBoot全局日志打印具体代码实现 SpringBoot全局日志打印 日志在项目中是一个非常重要的存在，但是在做项目的过程中，每次都要在项目中打印请求和响应的报文非常的 麻 烦，代码重复度高，所以在项目中进行全局日志的打印是非常又必要的。下面是具体代码的实现。此方法 可以解决日志打印的时候日志混乱打印的问题。 具体代码实现 package com.qhy.aspect; import com.alibaba.fastjson.JSON; import lo
springboot操作日志记录（使用拦截器）（待详细完善注意点）
u014104653的博客
08-09 3326
之所以重新定义改造，是因为HttpServletRequest 和 HttpServletResponse 这两个类的输出流只能被读取一次，再次读写将会读取不到任何内容，所以采用包装类进行改造，方便取请求的数据和响应的数据。用来标识哪些方法、操作需要被拦截（一般情况下，主要记录一些挂件业务的操作日志）以及简单介绍将要拦截的方法的内容是什么等等。5.配置controller中的方法，标识将要拦截的方法，下面是demo的信息。将来所有的日志记录代码就是写在这个里面，包含请求和响应数据的获取。......
SpringBoot-AOP-Logback用切面拦截操作日志（业务操作日志记录/拦截器VS过滤器）
usa_washington的博客
09-14 1705
SpringBoot-AOP-Logback
12-1 Springboot过滤拦截和日志处理
weixin_53415999的博客
12-02 1031
Springboot的日志默认日志框架：logback1.日志以文件的形式的保存 使用logback框架 ->(运行日志，开发中用于调式的，在开发中作为系统运行日志记录故障，从而追究问题根源)2.日志相关的表 记录用户相关操作信息 -> 需要我们去处理 -> 作为系统功能存在日志配置：SpringBoot默认日志输出目的地: console(控制台)在生产环境,日志肯定不是在控制台设置日志输出目的地：文件 SpringBoot加载logback的配置文件默认默认会加载classpath:logback-
springboot全局日志配置
郭峰学习足迹
06-21 3376
maven配置： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-log4j</artifactId> <version>1.3.8.RELEASE</versio...
springboot添加全局日志aop
最新发布
猿脑2.0的博客
06-14 521
在 Spring Boot 中添加全局日志 AOP（面向切面编程）可以通过定义一个切面（Aspect）来实现。切面允许你在不修改实际业务逻辑的情况下，对方法执行进行拦截和处理。完成以上步骤后，你的 Spring Boot 应用程序就会在匹配的方法执行前后添加日志记录了。最后，不要忘记在 Spring Boot 的主类或配置类上添加。，它会在方法成功执行后打印一条日志，包括方法的名称和返回值。确保你的切面类被 Spring 托管，可以通过在类上添加。，它会在方法执行前打印一条日志，以及一个后置通知。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值