扫码关注官方微信

扫码下载APP
返回顶部
首页 > 资讯 > 后端开发 > Python >SpringBoot搭建全局异常拦截
  • 916

0
分享到

SpringBoot搭建全局异常拦截

2024-04-02 19:04:59 916人浏览 薄情痞子

Python 官方文档：入门教程 => 点击学习

摘要

目录2.controller 测试3.启动 SpringBoot 工程4.测试5.基于springboot自身的全局异常统一处理6.aop也可以实现异常的全局处理

1.异常拦截类的创建


package com.liqi.WEB.core.exception;
 
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestControllerAdvice;
 
import com.liqi.common.base.Constants;
import com.liqi.common.base.ResultBean;
import com.liqi.common.exception.BusinessInterfaceException;
import com.liqi.common.exception.bean.ErrorBean;
 
import lombok.extern.slf4j.Slf4j;
 

@RestControllerAdvice
@Slf4j
public class InterfaceExceptionHandler {
 
	
	@ResponseBody
	@ExceptionHandler(BusinessInterfaceException.class)
	public String businessInterfaceException(BusinessInterfaceException e) {
		log.error(e.getMessage(), e);
		ErrorBean error = e.getError();
		ResultBean resultBean = new ResultBean(error.hashCode(), error.getErrORMsg());
		return resultBean.toString();
	}
 
	
	@ExceptionHandler(RuntimeException.class)
	@ResponseBody
	public String runtimeException(RuntimeException e) {
		log.error(e.getMessage(), e);
		// 返回 JOSN
		ResultBean resultBean = new ResultBean(Constants.INTERFACE_MSG_301, Constants.INTERFACE_MSG_301_TEXT);
		return resultBean.toString();
	}
 
	
	@ExceptionHandler(Exception.class)
	@ResponseBody
	public String exception(Exception e) {
		log.error(e.getMessage(), e);
		ResultBean resultBean = new ResultBean(Constants.INTERFACE_MSG_301, Constants.INTERFACE_MSG_301_TEXT);
		// 返回 JOSN
		return resultBean.toString();
	}
}

2.controller 测试


package com.springboot_Error.ErrorController;
        
        import org.springframework.stereotype.Controller;
        import org.springframework.web.bind.annotation.RequestMapping;
        
        @Controller
        public class ErrorControllerTest {
            //全局异常拦截 测试
            @RequestMapping("/ErrorTest")
            public String index2(){
                System.err.println("请求成功！");
                int i = 1/0; //这里会有一个运算异常
                return "index";
            }
            
        }

3.启动 springboot 工程


package com.springboot_Error.ErrorRun;
        
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.annotation.ComponentScan;
 
        
        //扫描 com.springboot_Error.ErrorController 包下 controller 注解过的类
        @ComponentScan(basePackages={"com.springboot_Error.ErrorController"})
        @EnableAutoConfiguration
        public class ErrorRun {
            
            public static void main(String[] args) {
                SpringApplication.run(ErrorRun.class, args);
            }
            
        }

4.测试



@RequestMapping(value = "/api/test")  
public Object myext() {
    throw new BusinessInterfaceException("500", "my ext异常");
}

经过测试发现可以捕获到Controller层的异常，当前前提是Controller层没有对异常进行catch处理，如果Controller层对异常进行了catch处理，那么在这里就不会捕获到Controller层的异常了，所以这一点要注意。

5.基于Springboot自身的全局异常统一处理

主要是实现ErrorController接口或者继承AbstractErrorController抽象类或者继承BasicErrorController类

以下是网上一位博主给出的示例代码，博客地址为：https://blog.csdn.net/king_is_everyone/article/details/53080851


 
@Controller
@RequestMapping(value = "error")
@EnableConfigurationProperties({ServerProperties.class})
public class ExceptionController implements ErrorController {
 
    private ErrorAttributes errorAttributes;
 
    @Autowired
    private ServerProperties serverProperties;
 
 
    
    @Autowired
    public ExceptionController(ErrorAttributes errorAttributes) {
        Assert.notNull(errorAttributes, "ErrorAttributes must not be null");
        this.errorAttributes = errorAttributes;
    }
 
 
    
    @RequestMapping(produces = "text/html",value = "404")
    public ModelAndView errorHtml404(HttpServletRequest request,
                                  HttpServletResponse response) {
        response.setStatus(getStatus(request).value());
        Map<String, Object> model = getErrorAttributes(request,
                isIncludeStackTrace(request, MediaType.TEXT_HTML));
        return new ModelAndView("error/404", model);
    }
 
    
    @RequestMapping(value = "404")
    @ResponseBody
    public ResponseEntity<Map<String, Object>> error404(HttpServletRequest request) {
        Map<String, Object> body = getErrorAttributes(request,
                isIncludeStackTrace(request, MediaType.TEXT_HTML));
        HttpStatus status = getStatus(request);
        return new ResponseEntity<Map<String, Object>>(body, status);
    }
 
    
    @RequestMapping(produces = "text/html",value = "500")
    public ModelAndView errorHTML500(HttpServletRequest request,
                                  HttpServletResponse response) {
        response.setStatus(getStatus(request).value());
        Map<String, Object> model = getErrorAttributes(request,
                isIncludeStackTrace(request, MediaType.TEXT_HTML));
        return new ModelAndView("error/500", model);
    }
 
 
    
    @RequestMapping(value = "500")
    @ResponseBody
    public ResponseEntity<Map<String, Object>> error500(HttpServletRequest request) {
        Map<String, Object> body = getErrorAttributes(request,
                isIncludeStackTrace(request, MediaType.TEXT_HTML));
        HttpStatus status = getStatus(request);
        return new ResponseEntity<Map<String, Object>>(body, status);
    }
 
 
    
    protected boolean isIncludeStackTrace(HttpServletRequest request,
                                          MediaType produces) {
        ErrorProperties.IncludeStacktrace include = this.serverProperties.getError().getIncludeStacktrace();
        if (include == ErrorProperties.IncludeStacktrace.ALWAYS) {
            return true;
        }
        if (include == ErrorProperties.IncludeStacktrace.ON_TRACE_PARAM) {
            return getTraceParameter(request);
        }
        return false;
    }
 
 
    
    private Map<String, Object> getErrorAttributes(HttpServletRequest request,
                                                   boolean includeStackTrace) {
        RequestAttributes requestAttributes = new ServletRequestAttributes(request);
        return this.errorAttributes.getErrorAttributes(requestAttributes,
                includeStackTrace);
    }
 
    
    private boolean getTraceParameter(HttpServletRequest request) {
        String parameter = request.getParameter("trace");
        if (parameter == null) {
            return false;
        }
        return !"false".equals(parameter.toLowerCase());
    }
 
    
    private HttpStatus getStatus(HttpServletRequest request) {
        Integer statusCode = (Integer) request
                .getAttribute("javax.servlet.error.status_code");
        if (statusCode == null) {
            return HttpStatus.INTERNAL_SERVER_ERROR;
        }
        try {
            return HttpStatus.valueOf(statusCode);
        }
        catch (Exception ex) {
            return HttpStatus.INTERNAL_SERVER_ERROR;
        }
    }
 
    
    @Override
    public String getErrorPath() {
        return "";
    }
 
}

6.AOP也可以实现异常的全局处理


@Component
@Aspect
public class ExceptionAspectController {
    public static final Logger logger = LoggerFactory.getLogger(ExceptionAspectController.class);
 
    @Pointcut("execution(* com.test.test.*.*(..))")//此处基于自身项目的路径做具体的设置
    public void pointCut(){}
 
    @Around("pointCut()")
    public Object handleControllerMethod(ProceedingJoinPoint pjp) {
        Stopwatch stopwatch = Stopwatch.createStarted();
 
        APIResponse<?> apiResponse;
        try {
            logger.info("执行Controller开始: " + pjp.getSignature() + " 参数：" + Lists.newArrayList(pjp.getArgs()).toString());
            apiResponse = (APIResponse<?>) pjp.proceed(pjp.getArgs());
            logger.info("执行Controller结束: " + pjp.getSignature() + "， 返回值：" + apiResponse.toString());
            logger.info("耗时：" + stopwatch.stop().elapsed(TimeUnit.MILLISECONDS) + "(毫秒).");
        } catch (Throwable throwable) {
            apiResponse = handlerException(pjp, throwable);
        }
 
        return apiResponse;
    }
 
    private APIResponse<?> handlerException(ProceedingJoinPoint pjp, Throwable e) {
        APIResponse<?> apiResponse = null;
        if(e.getClass().isAssignableFrom(MessageCenterException.class) ){
            MessageCenterException messageCenterException = (MessageCenterException)e;
            logger.error("RuntimeException{方法：" + pjp.getSignature() + "， 参数：" + pjp.getArgs() + ",异常：" + messageCenterException.getException().getMessage() + "}", e);
            apiResponse = messageCenterException.getApiResponse();
        } else if (e instanceof RuntimeException) {
            logger.error("RuntimeException{方法：" + pjp.getSignature() + "， 参数：" + pjp.getArgs() + ",异常：" + e.getMessage() + "}", e);
            apiResponse = new APIResponse(APIResponse.FAIL,null,e.getMessage());
        } else {
            logger.error("异常{方法：" + pjp.getSignature() + "， 参数：" + pjp.getArgs() + ",异常：" + e.getMessage() + "}", e);
            apiResponse = new APIResponse(APIResponse.FAIL,null,e.getMessage());
        }
 
        return apiResponse;
    }
}

到此这篇关于SpringBoot搭建全局异常拦截的文章就介绍到这了,更多相关Springboot全局异常内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！

您可能感兴趣的文档:

--结束END--

本文标题: SpringBoot搭建全局异常拦截

本文链接: https://lsjlt.com/news/129350.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

猜你喜欢
  • SpringBoot搭建全局异常拦截
    目录2.controller 测试3.启动 springboot 工程4.测试5.基于Springboot自身的全局异常统一处理6.AOP也可以实现异常的全局处理 ...
    99+
    2024-04-02
  • SpringBoot切面拦截@PathVariable参数及抛出异常的全局处理方式
    目录SpringBoot切面拦截@PathVariable参数及抛出异常的全局处理例如：为了方便统一验证，基于切面来实现数据的验证全局异常处理异常原因：java.lang.refle...
    99+
    2024-04-02
  • ASP.NET Core中实现全局异常拦截的完整步骤
    前言 异常是一种运行时错误，当异常没有得到适当的处理，很可能会导致你的程序意外终止，这篇就来讨论一下如何在 ASP.Net Core MVC 中实现全局异常处理，我会用一些 样...
    99+
    2022-06-07
    net 异常 ASP.NET core ASP
  • SpringBoot全局异常处理 | Java
    ⭐简单说两句⭐ 作者：后端小知识 CSDN个人主页：后端小知识 🔎GZH：后端小知识 🎉欢迎关注🔎点赞👍收藏⭐️留言...
    99+
    2023-10-12
    java spring boot 后端
  • Java Springboot全局异常处理
    目录前言一、思路？二、步骤1.自定义接口：2.自定义错误枚举3.自定义异常类4.异常捕获5.在代码中抛异常总结前言 对于作为菜鸟程序员的我来说，经常在controller使用try-...
    99+
    2024-04-02
  • 全面了解SpringBoot拦截器
    在本文中，我们将详细介绍SpringBoot中的拦截器，包括拦截器的概念、作用、实现方式、执行顺序、生命周期以及高级应用。最后，我们还将探讨拦截器的性能优化策略和常见问题。 1. 拦截器的概念和作用 1.1 什么是拦截器 拦截器（Inter...
    99+
    2023-08-19
    spring boot spring java 原力计划
  • SpringBoot全局异常处理方式
    目录SpringBoot全局异常处理springboot全局异常处理——@ControllerAdvice+ExceptionHandler一、全局捕获异常后，返回json给浏览器二...
    99+
    2024-04-02
  • springboot全局异常处理详解
    一、单个controller范围的异常处理package com.xxx.secondboot.web;import org.springframework.web.bind.annotation.ExceptionHandler;impo...
    99+
    2023-05-31
    spring boot 全局异常
  • springboot拦截器如何创建
    本文小编为大家详细介绍“springboot拦截器如何创建”，内容详细，步骤清晰，细节处理妥当，希望这篇“springboot拦截器如何创建”文章能帮助大家解决疑惑，下面跟着小编的思路慢慢深入，一起来学习新知识吧。一、创建一个MyInter...
    99+
    2023-07-06
  • java异常处理拦截器详情
    使用异常处理拦截器，可以不用写那么多try…catch…。 我有个功能，就是前端提交短信内容到后端，后端进行一系列的处理，其中是要将短信内容提交到公共短信接口。微服务框架，公共短信接...
    99+
    2024-04-02
  • SpringBoot全局异常处理方案分享
    目录一 业务场景二 全局系统异常类一）全局系统异常类二） 包装异常返回结果给前端，修改自定义异常三 返回案例一 业务场景 调用接口时需要对属性进行校验，比如属性长度，当属性为邮箱时校...
    99+
    2024-04-02
  • SpringBoot 全局异常处理——解决404/500
    SpringBoot 全局异常处理——解决404/500 SpringBoot要全局处理 Spring Boot 应用程序中的 HTTP 404 和 500 错误，您可以自定义一个异常处理器类，并使用...
    99+
    2023-09-28
    spring boot java 后端
  • SpringBoot全局异常问题如何解决
    这篇文章主要介绍“SpringBoot全局异常问题如何解决”的相关知识，小编通过实际案例向大家展示操作过程，操作方法简单快捷，实用性强，希望这篇“SpringBoot全局异常问题如何解决”文章能帮助大家解决问题。SpringBoot 是为了...
    99+
    2023-07-06
  • 如何使用SpringBoot处理全局异常
    如何使用SpringBoot处理全局异常 使用@ControllerAdvice 和 @ExceptionHandler处理全局异常 参考： @ControllerAdvice@ResponseBod...
    99+
    2023-10-27
    spring boot java 后端 异常处理
  • springboot实现全局异常处理及自定义异常类
    目录全局异常处理及自定义异常类全局异常处理定义一个业务异常的枚举全局异常处理配置springboot Restful使用springboot 返回 ModelAndView全局异常处...
    99+
    2024-04-02
  • SpringBoot配置全局异常处理器捕获异常详解
    目录1.前言2.全局异常并处理的方法一（@ControllerAdvice 和 @ExceptionHandler）3.全局异常并处理的方法二 (AOP)总结1.前言 任何系统，我们...
    99+
    2023-05-14
    spring boot全局异常处理 springboot捕获异常 springboot异常处理机制
  • SpringBoot怎么配置全局异常处理器捕获异常
    本篇内容主要讲解“SpringBoot怎么配置全局异常处理器捕获异常”，感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷，实用性强。下面就让小编来带大家学习“SpringBoot怎么配置全局异常处理器捕获异常”吧!1.前言任何系统，我们不...
    99+
    2023-07-05
  • springboot框架的全局异常怎么处理
    这篇文章主要介绍“springboot框架的全局异常怎么处理”，在日常操作中，相信很多人在springboot框架的全局异常怎么处理问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答”springboot框架的全局...
    99+
    2023-06-13
  • SpringBoot全局异常处理方式是什么
    这篇文章主要讲解了“SpringBoot全局异常处理方式是什么”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“SpringBoot全局异常处理方式是什么”吧！SpringBoot全局异常处理为...
    99+
    2023-06-25
  • 使用Fly怎么拦截全局Ajax请求
    本篇文章给大家分享的是有关使用Fly怎么拦截全局Ajax请求，小编觉得挺实用的，因此分享给大家学习，希望大家阅读完这篇文章后可以有所收获，话不多说，跟着小编一起来看看吧。原理无论你的应用是通过那个框架或库发起的 Ajax 请求，最终都会回归...
    99+
    2023-06-08
软考高级职称资格查询
热门wiki
近期文章
推荐阅读
热门问答
热门标签
编程网，编程工程师的家园，是目前国内优秀的开源技术社区之一，形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容，为IT开发者提供了一个发现、使用、并交流开源技术的平台。

  • 官方手机版

  • 微信公众号

  • 商务合作