springboot封装异常（捕获全局异常，做相应处理）

最新推荐文章于 2024-11-22 16:36:45 发布

原创最新推荐文章于 2024-11-22 16:36:45 发布 · 1.7k 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#springboot #异常处理

java开发专栏收录该内容

32 篇文章

订阅专栏

本文详细介绍了如何在Java中自定义异常类，包括继承RuntimeException和ESSException，以及如何使用GlobalExceptionHandler来统一处理异常，返回定制化的错误信息。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1.重写ESSException

import lombok.Data;
import risktech.learning.common.Result;

/**
 * @author cs
 * @time 2018/3/6
 */
@Data
public class SignInvalidException extends ESSException {

    private Result result;

    public SignInvalidException(String message) {
        super(message);
    }

    public SignInvalidException(String message, Throwable cause) {
        super(message, cause);
    }
}

2.重写RuntimeException

/**
 * @author cs
 * @time 2018/3/6
 */
public class ESSException extends RuntimeException {

    public ESSException(String message) {
        super(message);
    }


    public ESSException(String message, Throwable cause) {
        super(message, cause);
    }
}

3.重写ResponseEntityExceptionHandler

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.context.request.ServletWebRequest;
import org.springframework.web.context.request.WebRequest;
import org.springframework.web.servlet.NoHandlerFoundException;
import org.springframework.web.servlet.mvc.method.annotation.ResponseEntityExceptionHandler;
import risktech.learning.common.Result;

import javax.servlet.http.HttpServletRequest;

/**
 * @author cs
 * @time 2018/3/7
 */
@ControllerAdvice
public class GlobalExceptionHandler extends ResponseEntityExceptionHandler {

    private static Logger logger = LoggerFactory.getLogger(GlobalExceptionHandler.class);

    @Override
    protected ResponseEntity<Object> handleExceptionInternal(Exception ex, Object body, HttpHeaders headers, HttpStatus status, WebRequest request) {
        HttpServletRequest httpServletRequest = ((ServletWebRequest) request).getRequest();
        String requestUrl = httpServletRequest.getRequestURI();
        if (ex instanceof NoHandlerFoundException && requestUrl.equals("/")) {
            //过滤心跳检测
        } else {
            String ip = IpUtil.getIpAddr(httpServletRequest);
            logger.error(String.format("请求来源:%s,请求地址:%s", ip, httpServletRequest.getRequestURI()), ex);
        }

        Result result = Result.buildErrorMsg(ex.getMessage(), "0010010008");
        result.setData(body);
        return new ResponseEntity<Object>(result, status);
    }

    @ExceptionHandler(value = Exception.class)
    @ResponseBody
    public Result handleException(HttpServletRequest request, Exception e) throws Exception {
        String ip = IpUtil.getIpAddr(request);
        logger.error(String.format("请求来源:%s,请求地址:%s", ip, request.getRequestURI()), e);
        Result result = null;
        if (e instanceof SignInvalidException) {
            result = ((SignInvalidException) e).getResult();
        }

        if (result == null) {
            result = Result.buildErrorMsg(e.getMessage(), "0010010008");
        }
        return result;
    }
}

4.其他相关类

import javax.servlet.http.HttpServletRequest;

/**
 * @author json
 * @time 2018/3/29
 */
public class IpUtil {
    public static String getIpAddr(HttpServletRequest request) {
        String ip = request.getHeader("x-forwarded-for");
        System.out.println("x-forwarded-for ip: " + ip);
        if (ip != null && ip.length() != 0 && !"unknown".equalsIgnoreCase(ip)) {
            // 多次反向代理后会有多个ip值，第一个ip才是真实ip
            if (ip.indexOf(",") != -1) {
                ip = ip.split(",")[0];
            }
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("Proxy-Client-IP");
            System.out.println("Proxy-Client-IP ip: " + ip);
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("WL-Proxy-Client-IP");
            System.out.println("WL-Proxy-Client-IP ip: " + ip);
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("HTTP_CLIENT_IP");
            System.out.println("HTTP_CLIENT_IP ip: " + ip);
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("HTTP_X_FORWARDED_FOR");
            System.out.println("HTTP_X_FORWARDED_FOR ip: " + ip);
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("X-Real-IP");
            System.out.println("X-Real-IP ip: " + ip);
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getRemoteAddr();
            System.out.println("getRemoteAddr ip: " + ip);
        }
        System.out.println("获取客户端ip: " + ip);
        return ip;
    }
}

import lombok.Data;

/**
 * @author cs
 * @time 2018/1/30
 */
@Data
public class Result {
    private Object data;
    private String errorMessage;
    private String errorCode;
    private boolean success;


    public static Result buildErrorMsg(String errorMessage, String errorCode) {
        Result result = new Result();
        result.setErrorCode(errorCode);
        result.setErrorMessage(errorMessage);
        result.setSuccess(false);
        return result;
    }

    public static Result buildSuccessMsg(Object data) {
        Result result = new Result();
        result.setData(data);
        result.setSuccess(true);
        return result;
    }

    public static Result buildSuccessMsg() {
        Result result = new Result();
        result.setSuccess(true);
        return result;
    }
}