springboot封装异常(捕获全局异常,做相应处理)

本文详细介绍了如何在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;
    }
}

 

在 Spring Boot 中,可以通过实现一个全局异常处理器来捕获应用程序中的异常,并对异常进行统一处理。 实现一个全局异常处理器的步骤如下: 1. 创建一个异常处理器类,用于处理应用程序中的异常。 ```java @ControllerAdvice public class GlobalExceptionHandler { @ExceptionHandler(Exception.class) public ResponseEntity<ErrorResponse> handleException(Exception ex) { ErrorResponse errorResponse = new ErrorResponse("500", ex.getMessage()); return new ResponseEntity<>(errorResponse, HttpStatus.INTERNAL_SERVER_ERROR); } } ``` 2. 在异常处理器类上加上 @ControllerAdvice 注解,表示这是一个全局异常处理器。 3. 在异常处理器类中定义异常处理方法,使用 @ExceptionHandler 注解指定要处理异常类型。在异常处理方法中,可以处理异常并返回一个自定义的错误响应实体。 4. 在异常处理方法中使用 ResponseEntity 类来封装错误响应实体,并指定 HTTP 状态码。这里示例使用了 500 状态码。 5. 配置 Spring Boot 应用,使其能够扫描到异常处理器类。可以在启动类上加上 @ComponentScan 注解来指定扫描路径。 ```java @SpringBootApplication @ComponentScan(basePackages = "com.example.demo") public class DemoApplication { public static void main(String[] args) { SpringApplication.run(DemoApplication.class, args); } } ``` 以上就是在 Spring Boot 中实现全局异常处理的步骤。通过实现全局异常处理器,可以有效地统一处理应用程序中的异常
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值