springboot 统一结果响应，统一异常处理，统一请求参数非空校验，统一请求参数与响应结果日志打印

qq_41482600

已于 2024-03-11 15:54:11 修改

阅读量445

点赞数 5

分类专栏： springboot 文章标签： java 前端 javascript

于 2024-03-11 15:53:35 首次发布

本文链接：https://blog.csdn.net/qq_41482600/article/details/136626221

版权

springboot 专栏收录该内容

15 篇文章 1 订阅

订阅专栏

1、统一结果响应

1.1、ResultCodeEnum

package com.nrxt.nms.mon.pt.cascade.common;

import lombok.AllArgsConstructor;
import lombok.Getter;


@AllArgsConstructor
@Getter
public enum ResultCodeEnum {
    SUCCESS(200, "成功"),
    FAIL(500, "失败");

    private Integer code;
    private String msg;

}

1.2、Result

package com.nrxt.nms.mon.pt.cascade.common;

import lombok.Data;

@Data
public class Result<T> {
    private Integer code;
    private String msg;
    private T data;
    private Integer total;
}

1.3、ResultVO

package com.nrxt.nms.mon.pt.cascade.common;

public class ResultVO {

    /**
     * 成功
     *
     * @return
     */
    public static Result success() {
        Result result = new Result();
        result.setCode(ResultCodeEnum.SUCCESS.getCode());
        result.setMsg(ResultCodeEnum.SUCCESS.getMsg());
        return result;
    }

    /**
     * 成功返回数据
     *
     * @param data
     * @param <T>
     * @return
     */
    public static <T> Result<T> success(T data) {
        Result result = new Result();
        result.setCode(ResultCodeEnum.SUCCESS.getCode());
        result.setMsg(ResultCodeEnum.SUCCESS.getMsg());
        result.setData(data);
        return result;
    }

    /**
     * 成功返回数据，总条数
     *
     * @param data
     * @param total
     * @param <T>
     * @return
     */
    public static <T> Result<T> success(T data, int total) {
        Result result = new Result();
        result.setCode(ResultCodeEnum.SUCCESS.getCode());
        result.setMsg(ResultCodeEnum.SUCCESS.getMsg());
        result.setData(data);
        result.setTotal(total);
        return result;
    }

    /**
     * 失败
     *
     * @return
     */
    public static Result fail() {
        Result result = new Result();
        result.setCode(ResultCodeEnum.FAIL.getCode());
        result.setMsg(ResultCodeEnum.FAIL.getMsg());
        return result;
    }

    /**
     * 失败信息
     *
     * @param message
     * @return
     */
    public static Result fail(String message) {
        Result result = new Result();
        result.setCode(ResultCodeEnum.FAIL.getCode());
        result.setMsg(message);
        return result;
    }
}

1.4、NmsPtAppController

package com.nrxt.nms.mon.pt.cascade.controller;
import com.nrxt.nms.mon.pt.cascade.common.Result;
import com.nrxt.nms.mon.pt.cascade.entity.*;
import com.nrxt.nms.mon.pt.cascade.response.AppResponse;
import com.nrxt.nms.mon.pt.cascade.service.NmsPtAppService;
import com.nrxt.nms.mon.pt.cascade.utils.ByteArrayUtil;
import com.nrxt.nms.mon.pt.cascade.utils.DateUtils;
import com.nrxt.nms.mon.pt.cascade.utils.DrillUtils;
import javax.annotation.Resource;
import java.io.IOException;
import java.util.List;
import java.util.Map;


@RestController
@RequestMapping(value = "/appmonitor/ptcas")
public class NmsPtAppController {
    private static final Logger logger = Logger.getLogger(NmsPtAppController.class);

    @Resource
    NmsPtAppService nmsPtAppService;
	
	  /**
     * 系统级联监控查询
     *
     * @param nmsAppMonitorQuery
     * @return
     */
    @PostMapping("/queryFilterAppMonitor")
    public Result queryFilterAppMonitor(@RequestBody NmsAppMonitorQuery nmsAppMonitorQuery) {
		List<NmsAppMonitorDO> nmsAppMonitorDOList = nmsPtAppService.queryFilterAppMonitor(nmsAppMonitorQuery);
        return ResultVO.success(nmsAppMonitorDOList);
    }
}

2、统一异常处理

2.1、GlobalExceptionHandler

使用@ExceptionHandler注解捕获指定或自定义的异常
使用@ControllerAdvice集成@ExceptionHandler的方法到一个类中
必须定义一个通用的异常捕获方法，便于捕获未定义的异常信息
自定一个异常类，捕获针对项目或业务的异常
异常的对象信息补充到统一结果枚举中

package com.nrxt.nms.mon.pt.cascade.common;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;


/**
 * 异常处理
 *
 * @return
 */
@ControllerAdvice
@Slf4j
public class GlobalExceptionHandler {

     /**
     * 请求方法不正确
     * @param exception
     * @return
     */
    @ExceptionHandler(HttpRequestMethodNotSupportedException.class)
    public Result HttpRequestMethodNotSupportedException(HttpRequestMethodNotSupportedException e) {
        log.error(ExceptionUtil.getMessage(e));
        return ResultVO.fail([HttpRequest异常,请求方法不正确]);

    }

    /**
     * SysException异常处理
     * @param e
     * @return
     */
    @ExceptionHandler(value = BusinessException.class)
    public Result sysExceptionHandler(BusinessException e){
        log.error(ExceptionUtil.getMessage(e));
        return ResultVO.fail([SysException业务异常]);
    }

    /**
     * Exception异常处理
     * @param e
     * @return
     */
    @ExceptionHandler(value = Exception.class)
    public Result defaultErrorHandler(Exception e){
        log.error(ExceptionUtil.getMessage(e));
        return ResultVO.fail(e.getMessage());
    }


  
}

3、统一请求参数非空校验

3.1、spring-boot-starter-validation

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

3.2、ControllerExcepInterceptor

package com.nrxt.nms.mon.pt.cascade.common;

import org.springframework.validation.BindingResult;
import org.springframework.validation.ObjectError;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 请求参数非空校验统一异常处理
 */
@ControllerAdvice
public class ControllerExcepInterceptor {

    @ResponseBody
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public Result handleValidException(MethodArgumentNotValidException e){
        BindingResult bindingResult = e.getBindingResult();
        if(null != bindingResult && bindingResult.hasErrors()){
            List<ObjectError> errorList = bindingResult.getAllErrors();
            List<String> msgList = new ArrayList<>();
            errorList.forEach(objectError ->{
                msgList.add(objectError.getDefaultMessage());
            });
           return  ResultVO.fail(msgList.stream().collect(Collectors.joining(",")));
        }

        return ResultVO.success();
    }

}

3.3、NmsAppMonitorStatusQuery

package com.nrxt.nms.mon.pt.cascade.entity;

import lombok.Data;

import javax.validation.constraints.NotBlank;

@Data
public class NmsAppMonitorStatusQuery {

    @NotBlank(message = "ciId不能为空")
    private String ciId;

    @NotBlank(message = "级联监控状态不能为空")
    private String monitorStatus;


}

3.4、NmsPtAppController

package com.nrxt.nms.mon.pt.cascade.controller;
import com.nrxt.nms.mon.pt.cascade.common.Result;
import com.nrxt.nms.mon.pt.cascade.entity.*;
import com.nrxt.nms.mon.pt.cascade.response.AppResponse;
import com.nrxt.nms.mon.pt.cascade.service.NmsPtAppService;
import com.nrxt.nms.mon.pt.cascade.utils.ByteArrayUtil;
import com.nrxt.nms.mon.pt.cascade.utils.DateUtils;
import com.nrxt.nms.mon.pt.cascade.utils.DrillUtils;
import javax.annotation.Resource;
import java.io.IOException;
import java.util.List;
import java.util.Map;


@RestController
@RequestMapping(value = "/appmonitor/ptcas")
public class NmsPtAppController {
    private static final Logger logger = Logger.getLogger(NmsPtAppController.class);

    @Resource
    NmsPtAppService nmsPtAppService;
	
	/**
     * 修改系统级联监控状态
     *
     * @param nmsAppMonitorStatusQuery
     * @return
     */
    @PostMapping("/updateAppMonitorStatus")
    public Result updateAppMonitorStatus(@Valid @RequestBody NmsAppMonitorStatusQuery nmsAppMonitorStatusQuery) {
        return nmsPtAppService.updateAppMonitorStatus(nmsAppMonitorStatusQuery);
    }
}

4、统一请求参数与响应结果日志打印

4.1、RequestLogAspect

import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;
import org.springframework.util.StopWatch;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import org.springframework.web.multipart.MultipartFile;

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


@Slf4j
@Component
@Aspect
public class RequestLogAspect {
    @Pointcut("execution(* com.sou.controller..*(..))")
    public void requestServer() {
    }

    @Before("requestServer()")
    public void doBefore(JoinPoint joinPoint) {

        ServletRequestAttributes attributes = (ServletRequestAttributes)
                RequestContextHolder.getRequestAttributes();
        assert attributes != null;
        HttpServletRequest request = attributes.getRequest();
        try {
            log.info("request start》》》|IP:{}|URL：{}|header:{}|param:{}", request.getRemoteAddr(),
                    request.getRequestURL().toString(),
                    JSONObject.toJSONString(this.getHeader(request)), JSONObject.toJSONString(this.getRequestParams(joinPoint)));
        } catch (Exception e) {
            log.info("全局请求日志打印异常:", e);
        }

    }

    @Around("requestServer()")
    public Object doAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        Object result = proceedingJoinPoint.proceed();
        stopWatch.stop();
        try {
            log.info("response end》》》|result:{}|elapsedTime:{}", JSONObject.toJSONString(result), stopWatch.getTotalTimeMillis());
        } catch (Exception e) {
            log.info("全局响应日志打印异常:", e);
        }
        return result;
    }

    @After("requestServer()")
    public void doAfter(JoinPoint joinPoint) {
    }

    /**
     * 获取入参
     *
     * @param joinPoint
     * @return
     */
    private Map<String, Object> getRequestParams(JoinPoint joinPoint) {
        Map<String, Object> requestParams = new HashMap<>();
        //参数名
        String[] paramNames = ((MethodSignature) joinPoint.getSignature()).getParameterNames();
        //参数值
        Object[] paramValues = joinPoint.getArgs();
        for (int i = 0; i < paramNames.length; i++) {
            Object value = paramValues[i];
            //如果是文件对象
            if (value instanceof MultipartFile) {
                MultipartFile file = (MultipartFile) value;
                value = file.getOriginalFilename();
            }
            requestParams.put(paramNames[i], value);
        }
        return requestParams;
    }

    private Map<String, Object> getHeader(HttpServletRequest request) {
        Map<String, Object> headerParams = new HashMap<>(1);
        // 获取所有请求头名称并遍历
        Enumeration<String> headerNames = request.getHeaderNames();
        while (headerNames.hasMoreElements()) {
            String headerName = headerNames.nextElement();
            String headerValue = request.getHeader(headerName);
            headerParams.put(headerName, headerValue);
        }
        return headerParams;
    }
}