精华内容
下载资源
问答
  • SpringBoot全局异常捕获
    2021-08-01 18:30:02
    @ControllerAdvice
    public class GlobalExceptionHandler  {
     
        @ExceptionHandler(RuntimeException.class)
        //@ExceptionHandler({IllegalArgumentException.class, IllegalStateException.class})
        @ResponseStatus(value = HttpStatus.BAD_REQUEST)
        @ResponseBody
        public JsonResult errorHandler(Exception ex) {
            //记录日志
            log.error("参数异常捕获", ex);
            return JSON; //返回错误信息
        }
    }
    
    更多相关内容
  • 主要介绍了Springboot全局异常捕获及try catch区别解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • springboot全局异常捕获

    2021-09-05 16:46:04
    实现SpringBoot全局异常捕获,实现友好的反馈
  • springboot 全局异常捕获

    背景

    开发的时候总会问,可不可以在controller层抛出异常。实际上肯定是不行的,但是开发系统的时候总会有意外发生,如果控制器抛出异常那么前端就会尴尬。当然还有种才毕业的时候常做的事,那就是每个控制器里面的方法都try catch。于是就想着要是可以做个全局异常拦击那就好了。

    实现

    @ControllerAdvice
    @Slf4j
    public class GlobalExceptionHandler {
    
        /**
         * 处理自定义的业务异常
         * @param req
         * @param e
         * @return
         */
        @ExceptionHandler(value = BizException.class)
        @ResponseBody
        public ResultDTO bizExceptionHandler(HttpServletRequest req, BizException e){
            log.error("发生业务异常!原因是:{}",e.getErrorMsg());
            return ResultDTO.fail(e.getErrorCode(),e.getErrorMsg());
        }
    
        /**
         * 处理空指针的异常
         * @param req
         * @param e
         * @return
         */
        @ExceptionHandler(value =NullPointerException.class)
        @ResponseBody
        public ResultDTO exceptionHandler(HttpServletRequest req, NullPointerException e){
            log.error("发生空指针异常!原因是:",e);
            return ResultDTO.fail();
        }
    
    
        /**
         * 处理其他异常
         * @param req
         * @param e
         * @return
         */
        @ExceptionHandler(value =Exception.class)
        @ResponseBody
        public ResultDTO exceptionHandler(HttpServletRequest req, Exception e){
            log.error("未知异常!原因是:",e);
            return ResultDTO.fail();
        }
    
    }
    

    其中ResultDTO是我自己封装的,这个仁者见仁智者见智,大家根据自己的情况封装就好。注意:如果是前后端分离的项目,请一定要注意加注解**@ResponseBody**,否则异常后返回就是报找不到界面。

    如有问题,希望大家评论区留言多多指教!如觉得写得还可以,就给一个赞吧!

    展开全文
  • SpringBoot中有一个ControllerAdvice的注解,使用该注解表示开启了全局异常捕获,我们只需在自定义一个方法使用ExceptionHandler注解然后定义捕获异常的类型即可对这些捕获的异常进行统一的处理。 我们根据下面的...

    首先还是Maven的相关依赖:

    
      <properties>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
            <java.version>1.8</java.version>
            <maven.compiler.source>1.8</maven.compiler.source>
            <maven.compiler.target>1.8</maven.compiler.target>
        </properties>
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>1.5.17.RELEASE</version>
            <relativePath />
        </parent>
        <dependencies>
            <!-- Spring Boot Web 依赖 核心 -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            <!-- Spring Boot Test 依赖 -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
    
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>fastjson</artifactId>
                <version>1.2.41</version>
            </dependency>
        </dependencies>
        
    

    配置文件这块基本不需要更改,全局异常的处理只需在代码中实现即可。

    代码编写

    SpringBoot的项目已经对有一定的异常处理了,但是对于我们开发者而言可能就不太合适了,因此我们需要对这些异常进行统一的捕获并处理。SpringBoot中有一个ControllerAdvice的注解,使用该注解表示开启了全局异常的捕获,我们只需在自定义一个方法使用ExceptionHandler注解然后定义捕获异常的类型即可对这些捕获的异常进行统一的处理。

    我们根据下面的这个示例来看该注解是如何使用吧。

    示例代码:

    
    @ControllerAdvice
    public class MyExceptionHandler {
    
        @ExceptionHandler(value =Exception.class)
    	public String exceptionHandler(Exception e){
    		System.out.println("未知异常!原因是:"+e);
           	return e.getMessage();
        }
    }
    
    

    上述的示例中,我们对捕获的异常进行简单的二次处理,返回异常的信息,虽然这种能够让我们知道异常的原因,但是在很多的情况下来说,可能还是不够人性化,不符合我们的要求。
    那么我们这里可以通过自定义的异常类以及枚举类来实现我们想要的那种数据吧。

    自定义基础接口类

    首先定义一个基础的接口类,自定义的错误描述枚举类需实现该接口。
    代码如下:

    
    public interface BaseErrorInfoInterface {
        /** 错误码*/
    	 String getResultCode();
    	
    	/** 错误描述*/
    	 String getResultMsg();
    }
    
    

    自定义枚举类

    然后我们这里在自定义一个枚举类,并实现该接口。
    代码如下:

    
    public enum CommonEnum implements BaseErrorInfoInterface {
    	// 数据操作错误定义
    	SUCCESS("200", "成功!"), 
    	BODY_NOT_MATCH("400","请求的数据格式不符!"),
    	SIGNATURE_NOT_MATCH("401","请求的数字签名不匹配!"),
    	NOT_FOUND("404", "未找到该资源!"), 
    	INTERNAL_SERVER_ERROR("500", "服务器内部错误!"),
    	SERVER_BUSY("503","服务器正忙,请稍后再试!")
    	;
    
    	/** 错误码 */
    	private String resultCode;
    
    	/** 错误描述 */
    	private String resultMsg;
    
    	CommonEnum(String resultCode, String resultMsg) {
    		this.resultCode = resultCode;
    		this.resultMsg = resultMsg;
    	}
    
    	@Override
    	public String getResultCode() {
    		return resultCode;
    	}
    
    	@Override
    	public String getResultMsg() {
    		return resultMsg;
    	}
    
    }
    
    

    自定义异常类

    然后我们在来自定义一个异常类,用于处理我们发生的业务异常。
    代码如下:

    
    public class BizException extends RuntimeException {
    
    	private static final long serialVersionUID = 1L;
    
    	/**
    	 * 错误码
    	 */
    	protected String errorCode;
    	/**
    	 * 错误信息
    	 */
    	protected String errorMsg;
    
    	public BizException() {
    		super();
    	}
    
    	public BizException(BaseErrorInfoInterface errorInfoInterface) {
    		super(errorInfoInterface.getResultCode());
    		this.errorCode = errorInfoInterface.getResultCode();
    		this.errorMsg = errorInfoInterface.getResultMsg();
    	}
    	
    	public BizException(BaseErrorInfoInterface errorInfoInterface, Throwable cause) {
    		super(errorInfoInterface.getResultCode(), cause);
    		this.errorCode = errorInfoInterface.getResultCode();
    		this.errorMsg = errorInfoInterface.getResultMsg();
    	}
    	
    	public BizException(String errorMsg) {
    		super(errorMsg);
    		this.errorMsg = errorMsg;
    	}
    	
    	public BizException(String errorCode, String errorMsg) {
    		super(errorCode);
    		this.errorCode = errorCode;
    		this.errorMsg = errorMsg;
    	}
    
    	public BizException(String errorCode, String errorMsg, Throwable cause) {
    		super(errorCode, cause);
    		this.errorCode = errorCode;
    		this.errorMsg = errorMsg;
    	}
    	
    
    	public String getErrorCode() {
    		return errorCode;
    	}
    
    	public void setErrorCode(String errorCode) {
    		this.errorCode = errorCode;
    	}
    
    	public String getErrorMsg() {
    		return errorMsg;
    	}
    
    	public void setErrorMsg(String errorMsg) {
    		this.errorMsg = errorMsg;
    	}
    
    	public String getMessage() {
    		return errorMsg;
    	}
    
    	@Override
    	public Throwable fillInStackTrace() {
    		return this;
    	}
    
    }
    
    

    自定义数据格式

    顺便这里我们定义一下数据的传输格式。
    代码如下:

    
    public class ResultBody {
    	/**
    	 * 响应代码
    	 */
    	private String code;
    
    	/**
    	 * 响应消息
    	 */
    	private String message;
    
    	/**
    	 * 响应结果
    	 */
    	private Object result;
    
    	public ResultBody() {
    	}
    
    	public ResultBody(BaseErrorInfoInterface errorInfo) {
    		this.code = errorInfo.getResultCode();
    		this.message = errorInfo.getResultMsg();
    	}
    
    	public String getCode() {
    		return code;
    	}
    
    	public void setCode(String code) {
    		this.code = code;
    	}
    
    	public String getMessage() {
    		return message;
    	}
    
    	public void setMessage(String message) {
    		this.message = message;
    	}
    
    	public Object getResult() {
    		return result;
    	}
    
    	public void setResult(Object result) {
    		this.result = result;
    	}
    
    	/**
    	 * 成功
    	 * 
    	 * @return
    	 */
    	public static ResultBody success() {
    		return success(null);
    	}
    
    	/**
    	 * 成功
    	 * @param data
    	 * @return
    	 */
    	public static ResultBody success(Object data) {
    		ResultBody rb = new ResultBody();
    		rb.setCode(CommonEnum.SUCCESS.getResultCode());
    		rb.setMessage(CommonEnum.SUCCESS.getResultMsg());
    		rb.setResult(data);
    		return rb;
    	}
    
    	/**
    	 * 失败
    	 */
    	public static ResultBody error(BaseErrorInfoInterface errorInfo) {
    		ResultBody rb = new ResultBody();
    		rb.setCode(errorInfo.getResultCode());
    		rb.setMessage(errorInfo.getResultMsg());
    		rb.setResult(null);
    		return rb;
    	}
    
    	/**
    	 * 失败
    	 */
    	public static ResultBody error(String code, String message) {
    		ResultBody rb = new ResultBody();
    		rb.setCode(code);
    		rb.setMessage(message);
    		rb.setResult(null);
    		return rb;
    	}
    
    	/**
    	 * 失败
    	 */
    	public static ResultBody error( String message) {
    		ResultBody rb = new ResultBody();
    		rb.setCode("-1");
    		rb.setMessage(message);
    		rb.setResult(null);
    		return rb;
    	}
    
    	@Override
    	public String toString() {
    		return JSONObject.toJSONString(this);
    	}
    
    }
    
    

    自定义全局异常处理类

    最后我们在来编写一个自定义全局异常处理的类。
    代码如下:

    
    @ControllerAdvice
    public class GlobalExceptionHandler {
    	private static final Logger logger = LoggerFactory.getLogger(GlobalExceptionHandler.class);
    	
    	/**
    	 * 处理自定义的业务异常
    	 * @param req
    	 * @param e
    	 * @return
    	 */
        @ExceptionHandler(value = BizException.class)  
        @ResponseBody  
    	public  ResultBody bizExceptionHandler(HttpServletRequest req, BizException e){
        	logger.error("发生业务异常!原因是:{}",e.getErrorMsg());
        	return ResultBody.error(e.getErrorCode(),e.getErrorMsg());
        }
    
    	/**
    	 * 处理空指针的异常
    	 * @param req
    	 * @param e
    	 * @return
    	 */
    	@ExceptionHandler(value =NullPointerException.class)
    	@ResponseBody
    	public ResultBody exceptionHandler(HttpServletRequest req, NullPointerException e){
    		logger.error("发生空指针异常!原因是:",e);
    		return ResultBody.error(CommonEnum.BODY_NOT_MATCH);
    	}
    
    
        /**
            * 处理其他异常
         * @param req
         * @param e
         * @return
         */
        @ExceptionHandler(value =Exception.class)
    	@ResponseBody
    	public ResultBody exceptionHandler(HttpServletRequest req, Exception e){
        	logger.error("未知异常!原因是:",e);
           	return ResultBody.error(CommonEnum.INTERNAL_SERVER_ERROR);
        }
    }
    
    

    因为这里我们只是用于做全局异常处理的功能实现以及测试,所以这里我们只需在添加一个实体类和一个控制层类即可。

    实体类

    又是万能的用户表 ()

    代码如下:

    
    public class User implements Serializable{
    	private static final long serialVersionUID = 1L;
    	/** 编号 */
    	 private int id;
    	 /** 姓名 */
    	 private String name;
    	 /** 年龄 */
    	 private int age;
    	 
    	 public User(){
    	 }
    
    	public int getId() {
    		return id;
    	}
    	
    	public void setId(int id) {
    		this.id = id;
    	}
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	public int getAge() {
    		return age;
    	}
    
    	public void setAge(int age) {
    		this.age = age;
    	}
    
    	public String toString() {
    		return JSONObject.toJSONString(this);
    	}
    }
    

    Controller 控制层

    控制层这边也比较简单,使用Restful风格实现的CRUD功能,不同的是这里我故意弄出了一些异常,好让这些异常被捕获到然后处理。这些异常中,有自定义的异常抛出,也有空指针的异常抛出,当然也有不可预知的异常抛出(这里我用类型转换异常代替),那么我们在完成代码编写之后,看看这些异常是否能够被捕获处理成功吧!

    代码如下:

    
    @RestController
    @RequestMapping(value = "/api")
    public class UserRestController {
    
    	@PostMapping("/user")
        public boolean insert(@RequestBody User user) {
        	System.out.println("开始新增...");
        	//如果姓名为空就手动抛出一个自定义的异常!
            if(user.getName()==null){
                throw  new BizException("-1","用户姓名不能为空!");
            }
            return true;
        }
    
        @PutMapping("/user")
        public boolean update(@RequestBody User user) {
        	System.out.println("开始更新...");
           //这里故意造成一个空指针的异常,并且不进行处理
            String str=null;
            str.equals("111");
            return true;
        }
    
        @DeleteMapping("/user")
        public boolean delete(@RequestBody User user)  {
            System.out.println("开始删除...");
            //这里故意造成一个异常,并且不进行处理
            Integer.parseInt("abc123");
            return true;
        }
    
        @GetMapping("/user")
        public List<User> findByUser(User user) {
        	System.out.println("开始查询...");
            List<User> userList =new ArrayList<>();
            User user2=new User();
            user2.setId(1L);
            user2.setName("xuwujing");
            user2.setAge(18);
            userList.add(user2);
            return userList;
        }
        
    }
    
    

    App 入口

    和普通的SpringBoot项目基本一样。

    代码如下:

    
    @SpringBootApplication
    public class App 
    {
        public static void main( String[] args )
        {
    		SpringApplication.run(App.class, args);
    		System.out.println("程序正在运行...");
        }
    }
    展开全文
  • springboot全局捕获异常

    2018-07-05 08:42:05
    springboot全局捕获异常springboot全局捕获异常springboot全局捕获异常
  • springboot全局异常捕获404这种url不存在的异常处理

    一、配置文件设置 NoHandlerFoundException 异常抛出和不建立静态资源映射

    spring:
      mvc:
        throw-exception-if-no-handler-found: true
      web:
        resources:
          add-mappings: false
    

    二、全局异常中增加 NoHandlerFoundException 的捕获处理

    @Slf4j
    @RestControllerAdvice
    public class GlobalExceptionHandler {
        /**
         * NoHandlerFoundException 异常捕获处理
         * 请求的接口不存在
         */
        @ExceptionHandler(NoHandlerFoundException.class)
        public <T> Response<T> noHandlerFoundExceptionHandler(HttpServletRequest request, NoHandlerFoundException e) {
            log.error("BAD_REQUEST|{}|{}: {}|{}", null != request ? request.getRequestURI() : "", e.getClass().getSimpleName(), e.getMessage(), null != request ? HttpClientUtil.getIpAddress() : "");
            return Response.warn(StatusCode.REQUEST_NOT_ALLOWED);
        }
    }
    
    展开全文
  • 总结 后端任何地方抛出异常,被全局异常捕获后,就会封装成一个携带有errorCode和errorDesc的ApiResult给前端,http状态码保证是正常的(200)。 然后前端就能通过ApiResult.code来判断接口是否调用成功,并做相应...
  • SpringBoot项目中,定义了全局异常捕获类,但是当在Filter校验Token失败后抛出异常时,无法捕获异常。 原因分析: SpringBoot中,通过@ControllerAdvice+@ExceptionHandler实现的全局异常捕获类,只捕获Controller...
  • 全局异常捕获 什么是异常?程序在启动或者运行时没有按照预期的执行,在执行途中发生某种未知的错误,导致程序非正常停止或者报错。 在我们的程序中,肯定会伴随着很多的异常,启动时:空对象、找不到数据库、...
  • } } 接着是,全局异常Handler, GlobalExceptionHandler.java: /** @Author:JCccc @Description: @Date: created in 15:29 2019/5/3 */ @ControllerAdvice public class GlobalExceptionHandler { private static...
  • 一、编写全局异常捕获的类 @ControllerAdvice public class BaseExceptionHandler { @ExceptionHandler(value = Exception.class) @ResponseBody public Result error(Exception e) { e.printStackTrace(); ...
  • 经过几个小时的努力终于爬出了这个坑,总结一下全局异常捕获失效的常见错误 springboot 扫描包的时候出了问题,自己去扫包的地方检查清除,你的idea中 GlobalExceptionHandler 如果起作用了就会有这个小图标 ...
  • spring boot的全局异常处理类,可以通过注解@ControllerAdvice来实现,代码如下: package com.example.config; import org.springframework.web.bind.annotation.ControllerAdvice; import org.springframework....
  • 在做项目的时候需要对自定义异常做...1、全局异常捕捉处理 @ControllerAdvice( annotations = {RestController.class} ) public class ExceptionHandlerAdvice { private static final Logger LOGGER = L...
  • 本文只是配置一个简单的全局异常捕获,如有需要可以根据实际情况开发其它异常和自定义的异常。 web页面跳转 项目结构如下: MyExceptionHandler.java import javax.servlet.http.HttpServletRequest; import ...
  • 由于项目中有的地方会出现异常,当出现次数多了之后,手写try-catch感觉十分的麻烦,于是查阅资料发现可以使用SpringBoot中的@ControllerAdivce注解来处理异常,并通过AOP的方式记录错误日志。 添加依赖 <...
  • 前言上一篇文章说到,参数校验,往往需要和全局异常拦截器来配套使用,使得返回的数据结构永远是保持一致的。参数异常springboot默认的返回结构:{"timestamp": "2019-04-25T13:09:02.196+0000","status": 400,...
  • 1、项目中会使用异常捕获,然而每个controller方法都...在springboot中使用@ControllerAdvice注解实现全局异常捕获,代码如下: @ControllerAdvice(basePackage="com.cjs.example.controller") public cl...
  • Springboot 全局异常捕获

    千次阅读 2017-04-30 16:58:02
    Springboot 全局异常捕获springboot 全局异常捕获,首先创建一个 SmaugExceptionUtil 用于捕获全局异常 代码如下@ControllerAdvice public class SmaugExceptionUtil { @ExceptionHandler(Exception.class) @...
  • 新建全局异常捕获类 @ControllerAdvice public class GlobalExceptionHandler { @ExceptionHandler(value=Exception.class) @ResponseBody public Map<String, Object> exceptionHandlerMy(HttpServletR...
  • 以前写过一篇全局异常抓取以及日志log使用的文章, 今天我们再来单独优化一下这个全局异常抓取,并结合统一的接口返回类。 首先,我们先定义一个错误码接口(其实是返回码接口),里面包含返回码和错误描述,...
  • SpringBoot 全局异常拦截捕获处理 本篇文章主要介绍的是SpringBoot项目进行全局异常的处理。 SpringBoot的项目已经对有一定的异常处理了,但是对于我们开发者而言可能就不太合适了,因此我们需要对这些异常进行统一...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,864
精华内容 2,345
关键字:

springboot全局异常捕获

spring 订阅