SpringBoot统一接口响应、统一接口日志打印、全局异常处理器

已于 2024-07-05 20:52:05 修改
阅读量403 收藏 8
点赞数 4
文章标签： spring boot java 后端
于 2024-05-26 16:57:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32954567/article/details/139216852
版权

一.统一接口响应

1.定义

package com.example.base.common;

import lombok.Data;

/**
 * @version 1.0
 * @date 2024/5/22
 * @description 统一响应
 */
@Data
public class ResultData<T> {
    private Integer code;
    private String message;
    private T data;

    public ResultData() {

    }

    public ResultData(Integer code, String message) {
        super();
        this.code = code;
        this.message = message;
    }

    public ResultData(Integer code, String message, T data) {
        super();
        this.code = code;
        this.message = message;
        this.data = data;
    }

    public ResultData(ApiCode apiCode, T data) {
        super();
        this.code = apiCode.getCode();
        this.message = apiCode.getMessage();
        this.data = data;
    }

    public ResultData(ApiCode apiCode, String message, T data) {
        super();
        this.code = apiCode.getCode();
        this.message = message;
        this.data = data;
    }

    public static <T> ResultData<T> success(T data) {
        return new ResultData<>(ApiCode.SUCCESS, data);
    }

    public static <T> ResultData<T> fail(int code, String message) {
        return new ResultData<>(code, message);
    }
}

2.定义统一状态码

package com.example.base.common;

/**
 * @auth :
 */

public enum ApiCode {
    SUCCESS(200, "OK"),
    PARAMETER_ERROR(401, "参数有误"),
    FAIL(402, "处理失败"),
    FORBIDDEN(403, "已过期，请重新登录"),
    NOT_FOUND(404, "请求资源不存在"),
    REQUEST_METHOD_NOT_SUPPORTED(405, "不支持的请求方法"),
    ;

    private int code;

    private String message;

    ApiCode(int code, String message) {
        this.code = code;
        this.message = message;
    }

    public int getCode() {
        return code;
    }

    public String getMessage() {
        return message;
    }

}

3.controller接口使用

package com.example.base.controller;

import com.example.base.annotation.LegalEnum;
import com.example.base.annotation.RateLimit;
import com.example.base.common.ApiCode;
import com.example.base.common.ResultData;
import com.example.base.entity.Address;
import com.example.base.entity.WelcomeDto;
import com.example.base.enums.ScopeEnum;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.MediaType;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * @author 土
 * @version 1.0
 * @description controller
 */
@RestController
@RequestMapping("/hello")
@Slf4j
@RequiredArgsConstructor
@Validated
public class ApiController {
    @PostMapping(value = "addOne", produces = MediaType.APPLICATION_JSON_VALUE)
    public ResultData<List<Address>> addOne(@Validated @RequestBody WelcomeDto dto) {
        System.out.println("进来了");

        return ResultData.success(dto.getUserList().get(0).getAddressList());
    }
}

二.统一接口日志打印

1.定义打印的实体

package com.example.base.common.log;


import com.example.base.utils.JsonUtils;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;

/**
 * 请求日志
 *
 * @author 土
 * @date 2020/10/19 15:26
 */
@Data
@Slf4j
public class LogBean {
    private static final ThreadLocal<LogBean> LOG_BEAN_THREAD_LOCAL = ThreadLocal.withInitial(LogBean::new);

    private int code;
    private long startTime;
    private long consumeTime;
    private String path;
    // 表单参数
    private Object params;
    private Object result;
    private String error;
    private String ip;

    private String method;

    public static LogBean start() {
        LogBean logBean = LOG_BEAN_THREAD_LOCAL.get();
        logBean.setStartTime(System.currentTimeMillis());
        return logBean;
    }

    public static LogBean get() {
        return LOG_BEAN_THREAD_LOCAL.get();
    }

    public static void end() {
        LogBean logBean = get();
        logBean.setConsumeTime(System.currentTimeMillis() - logBean.getStartTime());
        logBean.print();
        LOG_BEAN_THREAD_LOCAL.remove();
    }

    private void print() {
        if (log.isInfoEnabled()) {
            log.info(JsonUtils.toJsonString(this));
        }
    }

}

2.定义接口请求拦截器

package com.example.base.aspect.interceptor;

import com.example.base.common.log.LogBean;
import com.example.base.utils.IpUtils;
import com.example.base.utils.JsonUtils;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.AsyncHandlerInterceptor;

import java.util.Enumeration;

/**
 * @author 土
 * @version 1.0
 * @date 2024/5/26
 * @description 接口请求拦截器
 */
public class LogInterceptor implements AsyncHandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        LogBean logBean = LogBean.start();
        logBean.setIp(IpUtils.getIpAddr(request));
        logBean.setPath(request.getRequestURI());
        logBean.setParams(getParameterJson(request));
        logBean.setMethod(request.getMethod());
        return true;
    }

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

    /**
     * 获取 RequestParam 从参数
     *
     * @param request
     * @return
     */
    private JsonNode getParameterJson(HttpServletRequest request) {
        ObjectNode json = JsonUtils.createObjectNode();
        Enumeration<String> names = request.getParameterNames();
        while (names.hasMoreElements()) {
            String name = names.nextElement();
            json.put(name, request.getParameter(name));
        }
        return json;
    }
}

获取请求IP地址工具类

package com.example.base.utils;

import jakarta.servlet.http.HttpServletRequest;

/**
 * 获取IP方法
 *
 * @author 土
 */
public class IpUtils {
    public static String getIpAddr(HttpServletRequest request) {
        if (request == null) {
            return "unknown";
        }
        String ip = request.getHeader("X-Real-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.getRemoteAddr();
        }
        return ip;
    }
     
}

3.注册请求拦截器

package com.example.base.config;

import com.example.base.aspect.interceptor.LogInterceptor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

/**
 * 通用配置
 *
 * @author
 */
@Configuration
@Slf4j
public class ResourcesConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new LogInterceptor())
        ;
    }
}

4.统一日志处理切面

package com.example.base.aspect;

import com.example.base.common.ResultData;
import com.example.base.common.log.LogBean;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.multipart.MultipartFile;

import java.lang.reflect.Parameter;
import java.util.Collection;
import java.util.Map;
import java.util.Optional;

/**
 * @author 土
 * @version 1.0
 * @date 2024/5/26
 * @description 统一日志处理切面
 */
@Aspect
@Component
@Slf4j
public class RestControllerAspect {
    @Pointcut("execution(public * com.example.base.controller..*.*(..))")
    public void controllerPointCut() {

    }

    /**
     * 输出接口入参
     *
     * @param joinPoint
     */
    @Before("controllerPointCut()")
    public void doBefore(JoinPoint joinPoint) {
        Optional.ofNullable(getRequestBody(joinPoint)).ifPresent(LogBean.get()::setParams);
    }

    @AfterReturning(pointcut = "controllerPointCut()", returning = "result")
    public void doAfterReturining(Object result) {
        handleWebLog(result);
    }

    private void handleWebLog(Object result) {
        LogBean logBean = LogBean.get();
        if (result instanceof ResultData) {
            logBean.setCode(((ResultData) result).getCode());
            logBean.setResult(result);
        }
    }

    /**
     * 获取 RequestBody 的参数
     *
     * @param joinPoint
     * @return
     */
    private Object getRequestBody(JoinPoint joinPoint) {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Object[] args = joinPoint.getArgs();//获取参数值
        Parameter[] parameters = signature.getMethod().getParameters();//获取参数名
        for (int i = 0; i < parameters.length; i++) {
            if (args[i] == null || isFilterObject(args[i])) {//大结构体类型的参数，则不处理
                continue;
            }
            RequestBody requestBody = parameters[i].getAnnotation(RequestBody.class);
            if (requestBody != null) {
                return args[i];//参数名和参数值一一对应起来的
            }
        }
        return null;
    }

    /**
     * 判断是否需要过滤的对象。
     *
     * @param o 对象信息。
     * @return 如果是需要过滤的对象，则返回true；否则返回false。
     */
    private boolean isFilterObject(final Object o) {
        Class<?> clazz = o.getClass();
        if (clazz.isArray()) {
            return clazz.getComponentType().isAssignableFrom(MultipartFile.class);
        } else if (Collection.class.isAssignableFrom(clazz)) {
            Collection collection = (Collection) o;
            for (Object value : collection) {
                return value instanceof MultipartFile;
            }
        } else if (Map.class.isAssignableFrom(clazz)) {
            Map map = (Map) o;
            for (Object value : map.entrySet()) {
                Map.Entry entry = (Map.Entry) value;
                return entry.getValue() instanceof MultipartFile;
            }
        }
        return o instanceof MultipartFile || o instanceof HttpServletRequest || o instanceof HttpServletResponse
                || o instanceof BindingResult;
    }
}

三.全局异常处理器

package com.example.base.common.exception;

import com.example.base.common.ApiCode;
import com.example.base.common.ResultData;
import com.example.base.common.log.LogBean;
import jakarta.validation.ConstraintViolationException;
import lombok.extern.slf4j.Slf4j;
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.RestControllerAdvice;

import java.util.Objects;

/**
 * @author t
 * @version 1.0
 * @date 2024/5/24
 * @description 全局异常处理器
 */
@Slf4j
@RestControllerAdvice
public class GlobalExceptionHandler<T> {
    /**
     * @param e
     * @return
     * @description jakarta包下面的注解使用     异常
     */
    @ExceptionHandler(ConstraintViolationException.class)
    public ResultData<T> validatedConstraintViolationException(ConstraintViolationException e) {
        return logAndResult(e, ApiCode.PARAMETER_ERROR, e.getMessage(), false);
    }

    /**
     * @param e
     * @return
     * @description 应用场景：校验@RequestParam定义的参数是否输入
     */
    @ExceptionHandler(MissingServletRequestParameterException.class)
    public ResultData<T> validMissingServletRequestParameterException(MissingServletRequestParameterException e) {
        String message = "参数" + e.getParameterName() + "不能为空";
        return logAndResult(e, ApiCode.PARAMETER_ERROR, message, false);
    }

    /**
     * @description 应用场景：参数前面有@RequestBody
     */
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResultData<T> validMethodArgumentNotValidException(MethodArgumentNotValidException e) {
        String message = Objects.requireNonNull(e.getBindingResult().getFieldError()).getDefaultMessage();
        return logAndResult(e, ApiCode.PARAMETER_ERROR, message, false);
    }

    private ResultData<T> logAndResult(Exception e, ApiCode apiCode, String message) {
        return logAndResult(e, apiCode, message, true);
    }

    private ResultData<T> logAndResult(Exception e, ApiCode apiCode, String message, boolean printErrorStack) {
        if (printErrorStack) {
            log.error(e.getMessage(), e);
        } else {
            log.warn(e.getMessage());
        }
        LogBean logBean = LogBean.get();
        logBean.setCode(apiCode.getCode());
        if (message != null) {
            logBean.setError(message);
        } else {
            logBean.setError(apiCode.getMessage());
        }
        ResultData<T> resultData = ResultData.fail(apiCode.getCode(), logBean.getError());
        logBean.setResult(resultData);
        return resultData;
    }
}
拷贝忍者_
关注
  • 4
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
springboot接口返回统一格式
wimxv的博客
05-05 1056
一个response的标准格式 status状态码 response描述，对本次状态码的描述 data数据，本次返回的数据 {"status":0,"desc":"成功","data":"test"} 初级程序员对response代码封装 对response的统一封装，是有一定的技术含量的 1把标准格式转化为代码 2把状态码存在枚举类里面 3加一个体验类 把返回的数...
springboot全局异常处理
07-14
总的来说，Spring Boot的全局异常处理机制使得我们可以集中管理错误处理，提供一致的错误响应，并且可以方便地进行日志记录和调试。在实际开发中，这是一项非常实用的功能，能够提升系统的稳定性和用户体验。
spring boot 统一JSON格式的接口返回结果的实现
10-16
主要介绍了spring boot 统一JSON格式的接口返回结果的实现，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
分享spring boot controller统一日志代码
diaoxiangan3537的博客
11-28 490
分享spring boot controller统一日志代码 最近项目需要做一个controller层的aop，主要解决下面问题： 1.controller日志统一打印输出json格式，兼容json和velocity 。 2.项目异常处理 3.异常邮件发送 ...
SpringBoot项目接口统一响应处理、统一异常处理、统一配置、接口验证
IManiy的博客
05-05 1759
ResponseBodyAdvice 接口实现自定义返回数据类型 api接口中都是需要定义一个统一的响应头来返回json数据 一般方法是通过在返回时构造一个响应头对象如下： public class ApiR extends HashMap<String, Object> { private static final long serialVersionUID = 1L; pub...
【基础篇】SpringBoot 统一接口响应与异常响应处理
BASK2312的博客
05-09 233
分词器的主要作用将用户输入的一段文本，按照一定逻辑，分析成多个词语的一种工具什么是分词器顾名思义，文本分析就是把全文本转换成一系列单词（term/token）的过程，也叫分词。在 ES 中，Analysis 是通过分词器（Analyzer）来实现的，可使用 ES 内置的分析器或者按需定制化分析器。举一个分词简单的例子：比如你输入，会自动帮你分成两个单词，一个是mastering，另一个是，可以看出单词也被转化成了小写的。分词器的构成分词器是专门处理分词的组件，分词器由以下三部分组成：组成部分。
springboot接口工具常用模板
05-13
- 可以通过`@ControllerAdvice`定义全局异常处理器，捕获并统一处理异常，返回统一格式的错误信息。 - `@ExceptionHandler`注解用于处理特定类型的异常。 5. **测试接口** 使用Spring Boot提供的`@SpringBoot...
SpringBootWeb 请求响应 分层解耦
02-14
- 自定义异常处理器，如`@ControllerAdvice`配合`@ExceptionHandler`，可以统一处理全局的异常。 10. **日志和监控**： - Spring Boot默认集成了Logback或Log4j进行日志记录，可以使用`@Slf4j`或`@Autowired`的...
后端异常统一处理解决方案
02-19
对于SSM框架，我们可以利用Spring MVC的`@ExceptionHandler`、`@ControllerAdvice`和`@ResponseStatus`等注解，定义全局的异常处理器，使得无论在哪个控制器抛出的异常，都能被这个处理器捕获并进行统一处理。...
springboot入门(全局 异常拦截)
03-01
如果想要统一处理所有未被其他异常处理器捕获的异常，可以创建一个没有指定异常类型的方法，它将会作为全局的“兜底”异常处理器。 7. **ResponseEntity和HttpStatus** 在处理异常时，我们通常会返回一个`...
spring 统一再处理接口返回的json数据
01-14
最近公司项目出现这样一个问题，公司的项目部署在政务云服务器，而政务云服务器所在网络是电信提供的，如果用户通过手机的非电信4G网络访问项目资源，比如MP4等，则会被电信拦截，导致访问极慢无法正常提供服务。为了解决这个问题需要用cdn服务来提供资源，以前的资源都是存在服务器上，因此需要做最小的调整切换cdn服务。 解决方案： 在spring框架下，可以利用ResponseBodyAdvice接口，实现该接口则能够在声明了ResponseBody注解的controller返回json数据前，统一对json数据做处理，将资源地址的url统一替换为cdn资源url。
SpringBoot自定义注解，AOP统一打印请求日志
菜园子丶For丨丶Tomorrow的博客
05-08 749
1、添加所需依赖 <!-- aop 依赖 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency> &l...
SpringBoot统一异常与接口响应
qq_41885073的博客
03-27 348
SpringBoot统一异常与接口响应处理
Spring Boot 项目统一结果，统一异常，统一日志：@ControllerAdvice和@ExceptionHandler 和 Logback
qq120631157的博客
05-29 458
Spring Boot 项目统一结果，统一异常，统一日志：@ControllerAdvice和@ExceptionHandler 和 Logback
SpringBoot接口 - 如何统一接口封装
DeveloperFire的博客
03-07 1487
面向资源是 REST 最明显的特征，对于同一个资源的一组不同的操作。资源是服务器上一个可命名的抽象概念，资源是以名词为核心来组织的，首先关注的是名词。REST 要求，必须通过统一的接口来对资源执行各种操作。REST 架构设计，遵循的各项标准和准则，就是 HTTP 协议的表现，换句话说，HTTP 协议就是属于 REST 架构的设计模式。这里以常见的状态码为例，包含responseCode 和 description两个属性。包含公共的接口返回时间，状态status, 消息message， 以及数据data。
Spring Boot 项目如何统一结果，统一异常，统一日志
热门推荐
吴名氏的博客
02-17 13万+
Spring Boot 项目如何统一结果，统一异常，统一日志
Springboot统一日志处理(Logback)
lovoo的博客
04-07 891
通过日志查看程序的运行过程，运行信息，异常信息等。
如何打印 springboot 框架中 接收请求的日志
最新发布
小子宝丁的博客
03-02 1103
在 Spring Boot 框架中，您可以使用日志来记录接收请求和发送响应的详细信息。Spring Boot 默认使用 SLF4J（Simple Logging Facade for Java）作为日志抽象层，并支持多种日志实现，如 Logback、Log4j2 等。，打印详细的请求和响应信息可能会导致日志文件变得很大，因此请谨慎使用，并根据实际需求调整日志级别和输出内容。的 Bean，它将打印请求的参数和负载。如果您使用其他日志实现，例如 Log4j2，您需要相应地添加相关的依赖。
springboot全局接口添加日志
02-22
Springboot支持全局日志记录，可以通过设置logback属性来实现。可以使用Springboot提供的logging.file或logging.path属性来配置日志文件，可以通过logging.pattern.console和logging.pattern.file属性来指定日志格式，也可以通过logging.level来设置日志级别。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值