精华内容
下载资源
问答
  • 解决dubbo接口自定义异常捕捉问题,dubbo消费者可以捕捉到提供者所抛出的自定义异常
  • 在java多线程程序中,所有线程都不允许抛出未捕获的checked exception,也就是说各个线程需要自己把自己的checked exception处理掉,通过此篇文章给大家分享Java多线程之多线程异常捕捉,需要的朋友可以参考下
  • js异常捕获方法介绍

    2020-12-10 10:55:07
    //抛出异常 }finally{<BR> // 完成后执行的语句块,非必须<BR>} [removed] javascript Error 对象: name: 错误名称number: 错误号description: 描述信息 message: 错误信息 fileName: 错误发生的文件 stack: ...
  • 一个可以捕获全局异常的方法,省去在代码中进行异常方法的添加,并且直接输出日志
  • 本文只是配置一个简单的全局的异常捕获,如有需要可以根据实际情况开发其它异常和自定义的异常。 web页面跳转 项目结构如下: MyExceptionHandler.java import javax.servlet.http.HttpServletRequest; import ...
  • 那么今天主要讲一下如何去捕捉系统出现的Unchecked异常。何为Unchecked异常呢,换句话说就是指非受检异常,它不能用try-catch来显示捕捉。 我们先从Exception讲起。Exception分为两类:一种是CheckedException,一...
  • Android 全局异常捕获 今天就来说说作为程序猿的我们每天都会遇到的东西bug,出bug不可怕可怕的是没有出bug时的堆栈信息,那么对于bug的信息收集就显得尤为重要了,一般用第三方bugly或者友盟等等都能轻易收集,但是由于...
  • 通常来说,大家都是对Java中的Exception进行捕获和进行相应的处理,有些人说,error就无法捕获了。其实,error也是可以捕获的。Error和Exception都是Throwable的子类。既然可以catch Throwable,那么error也是可以...
  • 主要介绍了Springboot全局异常捕获及try catch区别解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 主要介绍了Spring异常捕获且回滚事务解决方案,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 有了他,你再也不用怕你的项目经理BB了,上线后 可以用它来包装你的bug,发生一切异常你可以自定义异常发生后的效果,重启APP?关掉?友情提示等等。
  • 主要介绍了详解Java中多线程异常捕获Runnable的实现的相关资料,希望通过本文能帮助到大家,让大家理解掌握这样的知识,需要的朋友可以参考下
  • 1、实现UncaughtExceptionHandler,在方法uncaughtException中处理没有捕获异常。 public class GlobalException implements UncaughtExceptionHandler { private final static GlobalException myCrashHandler ...
  • 主要介绍了解决python ThreadPoolExecutor 线程池中的异常捕获问题,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 可用于C++的程序开发时,非常方便的管理程序异常时自动生成dump文件的封装类
  • 自己编写异常类型 ,自定义错误异常进行全局捕捉。实现项目全局的拦截定义输出。。。
  • 详细看CSDN:https://blog.csdn.net/gc1329689056/article/details/83304205
  • 前言  使用scrapy进行大型爬取任务的时候(爬取耗时以天为...不管是哪种异常,我们都可以参考scrapy自带的retry中间件写法来编写自己的中间件。 正文  使用IDE,现在scrapy项目中任意一个文件敲上以下代码: from
  • Java全局异常捕获处理

    2021-07-21 10:49:36
    为了项目的正常运行中,异常捕获,记录也是非常重要的,方便我们排查问题,定位问题 定义异常 为了方便定位异常,自定义了几种异常类,方便我们快速定位异常。 基类 public class HttpException extends ...

    为了项目的正常运行中,异常捕获,记录也是非常重要的,方便我们排查问题,定位问题

    定义异常

    为了方便定位异常,自定义了几种异常类,方便我们快速定位异常。

    基类

    public class HttpException extends RuntimeException {
        protected String code;
        protected Integer httpStatusCode = 500;
    }
    
    

    ParameterException

    public class ParameterException extends HttpException {
        public ParameterException(String code){
            this.code = code;
            this.httpStatusCode = 400;
        }
    }
    

    ServerErrorException

    public class ServerErrorException extends HttpException {
        public ServerErrorException(String code) {
            this.code = code;
            this.httpStatusCode = 500;
        }
    }
    
    

    UnAuthenticatedException

    public class UnAuthenticatedException extends HttpException{
        public UnAuthenticatedException(String code){
            this.code = code;
            this.httpStatusCode = 401;
        }
    }
    
    

    ForbiddenException

    public class ForbiddenException extends HttpException {
        public ForbiddenException(String code) {
            this.code = code;
            this.httpStatusCode = 403;
        }
    }
    

    NotFoundException

    public class NotFoundException extends HttpException {
        public NotFoundException(String code){
            this.httpStatusCode = 404;
            this.code = code;
        }
    }
    
    

    这里定义了我在项目中常用的几种异常,也可根据实际情况定义自己所需的异常。

    捕获异常

    捕获异常需要用到一个注解@ControllerAdvice,关于它的详细解释可查看文档

    使用方法如下,定义一个异常捕获类

    @ControllerAdvice
    public class GlobalExceptionAdvice {
    
    }
    

    这个类就已经实现了捕获全局异常的功能,下面在加上上面定义的几种异常

    @ControllerAdvice
    public class GlobalExceptionAdvice {
      @ExceptionHandler(UnAuthenticatedException.class)
      public ResponseEntity unAuthenticatedException(UnAuthenticatedException e) {
          return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body(e.getCode());
      }
    
    
      @ExceptionHandler(ParameterException.class)
      public ResponseEntity handleParameterException(ParameterException e) {
          return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(e.getCode());
      }
    
      @ExceptionHandler(ForbiddenException.class)
      public ResponseEntity handleForbiddenException(ForbiddenException e) {
          return ResponseEntity.status(HttpStatus.FORBIDDEN).body(e.getCode());
      }
    
      @ExceptionHandler(NotFoundException.class)
      public ResponseEntity handleNotFoundException(NotFoundException e) {
          return ResponseEntity.status(HttpStatus.NOT_FOUND).body(e.getCode());
      }
    
      @ExceptionHandler(RuntimeException.class)
      public ResponseEntity handleRunTimeException(RuntimeException e) {
    
          return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(500);
      }
    
    
    }
    

    @ExceptionHandler注解表示该方法捕获的异常类型,就可以在不同的异常中进行不同的处理方式。

    记录异常

    捕获到异常之后我们要记录下来,方便我们对bug的追踪解决。

    记录方法有多种多样的,比如记录到数据库或者log文件中。我使用了第二种方式。

    加入依赖

       <dependency>
              <groupId>org.projectlombok</groupId>
              <artifactId>lombok</artifactId>
              <optional>true</optional>
          </dependency>
         <dependency>
              <groupId>commons-logging</groupId>
              <artifactId>commons-logging</artifactId>
              <version>1.2</version>
          </dependency>
          <dependency>
              <groupId>org.apache.logging.log4j</groupId>
              <artifactId>log4j-api</artifactId>
              <version>2.2</version>
          </dependency>
          <dependency>
              <groupId>org.apache.logging.log4j</groupId>
              <artifactId>log4j-core</artifactId>
              <version>2.2</version>
          </dependency>
          <dependency>
              <groupId>org.apache.logging.log4j</groupId>
              <artifactId>log4j-jcl</artifactId>
              <version>2.2</version>
          </dependency>
    

    增加日志配置文件

    logback.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <configuration>
    
      <!-- 控制台 appender, 几乎是默认的配置 -->
      <appender name="stdout" class="ch.qos.logback.core.ConsoleAppender">
          <encoder charset="UTF-8">
              <!-- 输出的日志文本格式, 其他的 appender 与之相同 -->
              <pattern> %d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} %L - %msg%n</pattern>
              <charset>UTF-8</charset>
          </encoder>
      </appender>
    
      <!-- info 级别的 appender -->
      <appender name="info" class="ch.qos.logback.core.rolling.RollingFileAppender">
          <!-- 日志写入的文件名, 可以是相对目录, 也可以是绝对目录, 如果上级目录不存在会自动创建 -->
          <file>./logs/info/log-stack.log</file>
          <!-- 如果是 true, 日志被追加到文件结尾; 如果是 false, 清空现存文件. 默认是true -->
          <append>true</append>
          <!-- 日志级别过滤器, 只打 INFO 级别的日志-->
          <filter class="ch.qos.logback.classic.filter.LevelFilter">
              <level>INFO</level>
              <!-- 下面2个属性表示: 匹配 level 的接受打印, 不匹配的拒绝打印 -->
              <onMatch>ACCEPT</onMatch>
              <onMismatch>DENY</onMismatch>
          </filter>
          <!-- 最常用的滚动策略, 它根据时间来制定滚动策略, 既负责滚动也负责触发滚动 -->
          <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
              <!-- 设置滚动文件规则, 如果直接使用 %d, 默认格式是 yyyy-MM-dd -->
              <fileNamePattern>./logs/info/log-stack.%d{yyyy-MM-dd}.log</fileNamePattern>
              <!-- 保留14天的日志 -->
              <maxHistory>30</maxHistory>
          </rollingPolicy>
          <!-- 定义日志输出格式 -->
          <encoder charset="UTF-8">
              <pattern> %d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} %L - %msg%n</pattern>
              <charset>UTF-8</charset>
          </encoder>
      </appender>
    
      <!-- error 级别的 appender -->
      <appender name="error" class="ch.qos.logback.core.rolling.RollingFileAppender">
          <file>./logs/error/log-stack.log</file>
          <append>true</append>
          <filter class="ch.qos.logback.classic.filter.LevelFilter">
              <level>ERROR</level>
              <onMatch>ACCEPT</onMatch>
              <onMismatch>DENY</onMismatch>
          </filter>
          <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
              <fileNamePattern>./logs/error/log-stack.%d{yyyy-MM-dd}.log</fileNamePattern>
              <!-- 保留7天的日志 -->
              <maxHistory>30</maxHistory>
          </rollingPolicy>
          <!-- 定义日志输出格式 -->
          <encoder charset="UTF-8">
              <pattern> %d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} %L - %msg%n</pattern>
              <charset>UTF-8</charset>
          </encoder>
      </appender>
      <!-- error 级别的 appender -->
      <appender name="debug" class="ch.qos.logback.core.rolling.RollingFileAppender">
          <file>./logs/debug/log-stack.log</file>
          <append>true</append>
          <filter class="ch.qos.logback.classic.filter.LevelFilter">
              <level>DEBUG</level>
              <onMatch>ACCEPT</onMatch>
              <onMismatch>DENY</onMismatch>
          </filter>
          <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
              <fileNamePattern>./logs/debug/log-stack.%d{yyyy-MM-dd}.log</fileNamePattern>
              <!-- 保留7天的日志 -->
              <maxHistory>30</maxHistory>
          </rollingPolicy>
          <!-- 定义日志输出格式 -->
          <encoder charset="UTF-8">
              <pattern> %d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} %L - %msg%n</pattern>
              <charset>UTF-8</charset>
          </encoder>
      </appender>
      <!-- 指定 com.github 下的日志打印级别, appender -->
      <logger name="com.github" level="debug" additivity="false">
          <appender-ref ref="stdout"/>
          <appender-ref ref="info"/>
          <appender-ref ref="error"/>
          <appender-ref ref="debug"/>
    
      </logger>
    
    
      <root level="info">
          <appender-ref ref="stdout"/>
          <appender-ref ref="info"/>
          <appender-ref ref="error"/>
      </root>
    
    </configuration>
    

    写入日志

    @ControllerAdvice
    @Slf4j
    public class GlobalExceptionAdvice {
        @ExceptionHandler(ParameterException.class)
        public ResponseEntity handleParameterException(ParameterException e) {
            log.error(e.getLocalizedMessage()); 
            return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(e.getCode());
        }
    }
    

    完善异常信息

    文章中的异常只定义了code,具体的异常信息可以写在配置文件中或者保存在数据库中,在捕获到异常之后,找到对应的描述信息返回调用者,增加友好度。

    完善记录日志

    以上如果发生了异常,在日志文件中是这样记录的

    10:19:32.024 [http-nio-8080-exec-2] ERROR c.g.e.d.advice.GlobalExceptionAdvice 41 - / by zero
    

    发现记录的行号是在GlobalExceptionAdvice类中,并非是代码真实的位置。

    如果要记录到代码的真实位置可以这样实现

     public  String getExceptionDetail(Exception e) {
    
            StringBuilder stringBuilder = new StringBuilder();
            stringBuilder.append(e.getClass() + System.getProperty("line.separator"));
            stringBuilder.append(e.getLocalizedMessage() + System.getProperty("line.separator"));
            StackTraceElement[] arr = e.getStackTrace();
            for (int i = 0; i < arr.length; i++) {
                stringBuilder.append(arr[i].toString() + System.getProperty("line.separator"));
    
            }
            return stringBuilder.toString();
        }
    
     log.error(getExceptionDetail(e));
    

    根据实际情况选择适合自己的方式

    完整代码

    Github

    Gitee

    展开全文
  • C++ 异常捕获详解

    2021-04-28 10:48:38
    C++ 提供了异常(Exception)机制,让我们能够捕获运行时错误,给程序一次“起死回生”的机会,或者至少告诉用户发生了什么再终止程序。 而 C++ 异常处理机制就可以让我们捕获并处理这些错误,然后我们可以让程序...

    为什么存在异常处理

    在程序运行时常会碰到一些错误,例如除数为 0、年龄为负数、数组下标越界等,这些运行时错误如果放任不管,系统就会执行默认的操作,终止程序运行,也就是我们常说的程序崩溃(Crash)。C++ 提供了异常(Exception)机制,让我们能够捕获运行时错误,给程序一次“起死回生”的机会,或者至少告诉用户发生了什么再终止程序。

    而 C++ 异常处理机制就可以让我们捕获并处理这些错误,然后我们可以让程序沿着一条不会出错的路径继续执行,或者不得不结束程序,但在结束前可以做一些必要的工作,例如将内存中的数据写入文件、关闭打开的文件、释放分配的内存等。

    程序的错误的三种分类

    程序的错误大致可以分为三种,分别是语法错误、逻辑错误和运行时错误:

    1. 语法错误在编译和链接阶段就能发现,只有 100% 符合语法规则的代码才能生成可执行程序。语法错误是最容易发现、最容易定位、最容易排除的错误,程序员最不需要担心的就是这种错误。

    2. 逻辑错误是说我们编写的代码思路有问题,不能够达到最终的目标,这种错误可以通过调试来解决。

    3. 运行时错误是指程序在运行期间发生的错误,例如除数为 0、内存分配失败、数组越界、文件不存在等。C++ 异常(Exception)机制就是为解决运行时错误而引入的。

    捕获异常的关键字和格式

    异常提供了一种转移程序控制权的方式。C++ 异常处理涉及到三个关键字:try、catch、throw

    throw: 当问题出现,程序通过throw抛出一个异常。
    catch: 在你想要处理问题的地方,通过异常处理程序捕获异常。
    try: try 块中的代码标识将被激活的特定异常。它后面允许跟着一个或多个 catch 块。

    1.单类型异常捕获

    try { 
    	//保护区,就是可能会出错的代码
    }
    
    catch( ExceptionName e1 ) {
    
    // 出错后,通过异常处理程序捕获异常
    }
    
    

    2.多类型异常捕获(使用多个catch捕获不同类型的异常)

    try { 
    	//保护区,就是可能会出错的代码
    }
    
    catch( ExceptionName e1 ) {
    
    // 出错后,通过异常处理程序捕获异常
    //如果try在不同场景会抛出不同异常,此时可尝试罗列多个 catch 语句,用于捕获不同类型异常
    }
    catch( ExceptionName e2 ) {
    // catch 块
    }
    catch( ExceptionName eN ) {
    // catch 块
    }
    

    3.全部类型捕获(缺点是你无法知道错误类型,只知道发送了错误)

    try{
    	//保护区
    }
    catch(...)  //这里使用...,表示会捕获所有类型的异常都会
    {
    	// catch 块
    }
    

    举例使用

    /**********		单catch捕获		****************/
    
    #include<iostream>
    #include<exception>
    #include<string>
    using namespace std;
    
    int Division(int& a, int& b)
    {
    	if (b == 0)
    		throw "除数不能为0";
    
    	return a / b;
    }
    
    int main()
    {
    	int m = 4, n = 0, res;
    	try {
    		res = Division(m, n);
    		cout << res << endl;
    	}catch(const char* e){
    		cout << e << endl;
    	}
    	return 0;
    }
    
    /**********		多catch捕获		****************/
    
    #include<iostream>
    #include<exception>
    #include<string>
    using namespace std;
    
    int Division(int& a, int& b)
    {
    	string sub = "除数不能为0";
    	if (b == 0)		//如果除数为0,throw一个string
    		throw sub;
    	else if (b < 0)	//如果除数为负数,throw一个const char*
    		throw "除数不允许为负数";
    	return a / b;
    }
    
    int main()
    {
    	//int m = 4, n = 2, res;
    	//int m = 4, n = 0, res;
    	//int m = 4, n = -1, res;
    	try {
    		res = Division(m, n);
    		res = Division(m, n);
    		res = Division(m, n);
    		cout << res << endl;
    	}catch(string e1){	// Exception is: 除数不能为0
    		cout << "Exception is: " << e1 << endl;
    	}
    	catch (const char* e2){// Exception is: 除数不允许为负数
    		cout << "Exception is: " << e2 << endl;
    	}
    	return 0;
    }
    

    C++ 标准异常

    C++语言本身或者标准库抛出的异常都是 exception 的子类,称为标准异常(Standard Exception)。你可以通过下面的语句来捕获所有的标准异常:

    try{
        //可能抛出异常的语句
    }catch(exception &e){
        //处理异常的语句
    }
    

    之所以使用引用,是为了提高效率。如果不使用引用,就要经历一次对象拷贝(要调用拷贝构造函数)的过程。

    exception 类位于 头文件中,它被声明为:

    class exception{
    public:
        exception () throw();  //构造函数
        exception (const exception&) throw();  //拷贝构造函数
        exception& operator= (const exception&) throw();  //运算符重载
        virtual ~exception() throw();  //虚析构函数
        virtual const char* what() const throw();  //虚函数
    }
    

    这里需要说明的是 what() 函数。what() 函数返回一个能识别异常的字符串,正如它的名字“what”一样,可以粗略地告诉你这是什么异常。不过C++标准并没有规定这个字符串的格式,各个编译器的实现也不同,所以 what() 的返回值仅供参考。

    下图展示了 exception 类的继承层次:
    在这里插入图片描述
    exception 类的直接派生类:

    异常名称说明
    logic_error逻辑错误
    runtime_error运行时错误
    bad_alloc使用 new 或 new[ ] 分配内存失败时抛出的异常
    bad_typeid使用 typeid 操作一个 NULL 指针,而且该指针是带有虚函数的类,这时抛出 bad_typeid 异常
    bad_cast使用 dynamic_cast 转换失败时抛出的异常
    ios_base::failureio 过程中出现的异常
    bad_exception这是个特殊的异常,如果函数的异常列表里声明了 bad_exception 异常,当函数内部抛出了异常列表中没有的异常时,如果调用的 unexpected() 函数中抛出了异常,不论什么类型,都会被替换为 bad_exception 类型

    logic_error 的派生类:

    异常名称说明
    length_error试图生成一个超出该类型最大长度的对象时抛出该异常,例如 vector 的 resize 操作
    domain_error参数的值域错误,主要用在数学函数中,例如使用一个负值调用只能操作非负数的函数
    out_of_range超出有效范围
    invalid_argument参数不合适。在标准库中,当利用string对象构造 bitset 时,而 string 中的字符不是 0 或1 的时候,抛出该异常

    runtime_error 的派生类:

    异常名称说明
    range_error计算结果超出了有意义的值域范围
    overflow_error算术计算上溢
    underflow_error算术计算下溢
    展开全文
  • 今天小编就为大家分享一篇python 自定义异常异常捕捉的方法,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 在这里我给大家简单的介绍下我们在MVC中自带的一种捕获异常的机制,它就是:Asp.Net中MVC的全局异常捕获。 MVC中的全局异常捕获简介: 全局异常捕获是微软在VS中自带的一种机制。在Asp.Net的MV...

    前言:

    在项目中我们都会对项目里的异常进行处理,一方面是为了用户交互性更好,另一方面也为我们的后期的维护提供了便利。在项目的过程中也许我们更多的是用try{}catch{}进行捕获异常。在这里我给大家简单的介绍下我们在MVC中自带的一种捕获异常的机制,它就是:Asp.Net中MVC的全局异常捕获。


    MVC中的全局异常捕获简介:

    全局异常捕获是微软在VS中自带的一种机制。在Asp.Net的MVC中默认提供了一个异常过滤器HandleError特性,使用该特性可以极为方便的捕捉并处理控制器和操作抛出的异常,它会自动的检测在程序中运行的错误,并且拿到错误的相关信息。在Asp.Net的MVC中的只要网站抛出异常,都会触发Global.asax中Application_Error事件,这个方法就是用来捕获异常的,在这个代码里面我们可以添加我们的业务代码(一般就是记录错误的日志以及异常的处理)。

    在MVC中还可以使用HandleErrorAttribute的特性标签来捕获异常,该特性主要用于具体操作方法上,在写项目中我们 一般很少用到。这里不给大家介绍了,大家想了解的话,百度就行了。


    MVC中的自定义异常捕获简介:

    在Asp.Net中不但可以用全局的异常捕获,微软也给我们提供了一种自定义的异常捕获,来满足我们的需求。当然在自定义的异常捕获中,我们底层还是用VS提供的HandleErrorAttribute的这个特性来实现的,在我们的自己定义的类中重写HandleErrorAttributeOnException()方法来实现我们的业务。


    MVC全局异常捕获代码演示:

    ①:在Global.asax里添加Application_Error事件(注意:Application_Start外部添加这个方法

            protected void Application_Error(Object sender, EventArgs e)
            {
                Exception lastError = Server.GetLastError();//获取异常
                if (lastError != null)
                {
                    //异常信息
                    string strExceptionMessage = string.Empty;
    
                    //对HTTP 404做额外处理,其他错误全部当成500服务器错误
                    HttpException httpError = lastError as HttpException;
                    if (httpError != null)
                    {
                        //获取错误代码
                        int httpCode = httpError.GetHttpCode();
                        //获取异常信息
                        strExceptionMessage = httpError.Message;
                        if (httpCode == 400 || httpCode == 404)
                        {
                            Response.StatusCode = 404;
                            //跳转到指定的静态404信息页面
                            Response.WriteFile("~/404.html");
                            //一定要调用Server.ClearError()否则会触发错误详情页(就是黄页)
                            Server.ClearError();
                            return;
                        }
                    }
                    strExceptionMessage = lastError.Message;//得到错误信息,可以写到日志里
    
                    /*-----------------------------------------------------
                     * 此处代码可根据需求进行日志记录,或者处理其他业务流程
                     * ---------------------------------------------------*/
                     /* 跳转到静态页面一定要用Response.WriteFile方法  */                
                    
                    //Response.StatusCode = 500;展示错误状态码
                    Response.WriteFile("~/error.html");
                    //一定要调用Server.ClearError()否则会触发错误详情页(就是黄页)
                    Server.ClearError();
                }
    
            }

    ②:注销掉FilterConfig类里的filters.Add(new HandleErrorAttribute()),否则会默认自定义

    ③:在web.con.fig配置节<system.web>里添加配置,关闭自定义的模式,否则VS会默认开启

    <customErrors mode="Off"></customErrors>
    <!--注意大小写-->

    ④:在控制器里写错误的代码

    运行结果:

    注意重点;小心大坑,大坑!!!,我差点没出来!坑死我了

    就是我们也按上面的步骤做了,为啥程序中断了,捕获不到异常。

    这是因为在VS里有个中断异常处理,如果你的程序中有错误会直接让程序中断,这时我们的所用的异常处理就无法发挥作用了。

    中断程序展示:

    解决办法:

    做完上一步的操作就能出现上面的效果了!

    全局异常捕获演示完毕!


    自定义异常捕获演示:

    在自定义演示里我把程序中的错误写到日志里。

    演示开始:

    ①:先自定义一个类,让这个类继承HandleErrorAttribute,并重写HandleErrorAttribute里的OnException方法

    public class MyErrorAttribute : HandleErrorAttribute
        {
           
                //创建静态队列
                public static Queue<Exception> ExceptionQueue = new Queue<Exception>();
                public override void OnException(ExceptionContext filterContext)
                {
                    //将异常信息写入队列中
                    ExceptionQueue.Enqueue(filterContext.Exception);
                    base.OnException(filterContext);
                   filterContext.HttpContext.Response.Redirect("~/error.html");
                }
        }

    ②:在FilterConfig这个类里注销原先的注册的HandleErrorAttribute

    ③:在Global.asax的Application_Start里进行开启线程,把捕获的错误写成日志

     protected void Application_Start()
            {
                AreaRegistration.RegisterAllAreas();
                FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
                RouteConfig.RegisterRoutes(RouteTable.Routes);
                BundleConfig.RegisterBundles(BundleTable.Bundles);
                string errorFilePath = Server.MapPath("~/errorFile/");//文件夹路径
                ThreadPool.QueueUserWorkItem(o =>
                {
                    while (true)
                    {
                        if (MyErrorAttribute.ExceptionQueue.Count > 0)
                        {
                            Exception ex = MyErrorAttribute.ExceptionQueue.Dequeue();
                            if (ex != null)
                            {
                                //将异常信息写到文件夹中,如果文件不存在则创建该文件
                                string fileName = DateTime.Now.ToString("yyyy-mm-dd");
                                File.AppendAllText(errorFilePath + fileName + ".txt", ex.ToString(), System.Text.Encoding.UTF8);
                            }
                            else
                            {
                                Thread.Sleep(500);
                            }
                        }
                        else
                        {
                            Thread.Sleep(500);
                        }
                    }
                });
            }

    ④:在一个控制器写错误的代码:

    注意:别忘了上面的那个坑

    运行结果展示:

    日志展示


     

    到这里ASP.Net的MVC中的全局异常捕获和自定义异常捕获就给大家简单的介绍完了!

    大家有什么更简洁方式,请留言!


    结尾:分享:

    真实是人生的命脉,是一切价值的根基。 —— 德莱塞

    展开全文
  • AndroidCrash全局崩溃异常捕获,友好的提示页面,收集手机信息+捕获异常信息,并上传到服务器,带重启APP功能。
  • android全局异常捕获 exception_global
  • 在做项目的时候需要对自定义异常捕获和处理,现在将代码记录下来便于以后查阅。 1、全局异常捕捉处理 @ControllerAdvice( annotations = {RestController.class} ) public class ExceptionHandlerAdvice { ...

    在做项目的时候需要对自定义异常做捕获和处理,现在将代码记录下来便于以后查阅。

    1、全局异常捕捉处理

    @ControllerAdvice(
        annotations = {RestController.class}
    )
    public class ExceptionHandlerAdvice {
        
        private static final Logger LOGGER = LoggerFactory.getLogger(this.getCLass());
        
        @ExceptionHandler(EntityTransException.class)
        public ResponseResult entityTransExceptionHandle(HttpServletRequest request,EntityTransException e){
            LOGGER.error("********************Throw EntityTransException.url:{} ERROR:{}********************",request.getRequestURL(), e.getMessage(), e);
            ResponseResult result = new ResponseResult();
            result.setSuccess(false);
            result.setMessage(ResultCode.ERROR_ENTITY_TRANS.getMessage() + "。异常原因:" + e.getMessage());
            result.setCode(ResultCode.ERROR_ENTITY_TRANS.getCode());
            return result;
        }
    
        @ExceptionHandler(SqlException.class)
        public ResponseResult sqlExceptionHandle(HttpServletRequest request,SqlException e){
            LOGGER.error("********************Throw SqlException.url:{} ERROR:{}********************",request.getRequestURL(), e.getMessage(), e);
            ResponseResult result = new ResponseResult();
            result.setSuccess(false);
            result.setMessage(ResultCode.ERROR_SQL_CHECK.getMessage() + "。异常原因:" + e.getMessage());
            result.setCode(ResultCode.ERROR_SQL_CHECK.getCode());
            return result;
        }
    
        @ExceptionHandler(Exception.class)
        public ResponseResult exceptionHandle(HttpServletRequest request,Exception e){
            LOGGER.error("********************Throw Exception.url:{} ERROR:{}********************",request.getRequestURL(), e.getMessage(), e);
            ResponseResult result = new ResponseResult();
            result.setSuccess(false);
            result.setMessage(ResultCode.ERROR.getMessage());
            result.setCode(ResultCode.ERROR.getCode());
            return result;
        }
    }

    2、自定义异常类

    package com.czgo.exception;
     
    /**
     * 自定义异常类(继承运行时异常)
     * @author zhangzhixiang
     * @version 2018/11/09
     */
    public class SqlException extends RuntimeException {
     
        private static final long serialVersionUID = 1L;
     
        /**
         * 错误编码
         */
        private String errorCode;
     
        /**
         * 消息是否为属性文件中的Key
         */
        private boolean propertiesKey = true;
         
        /**
         * 构造一个基本异常.
         *
         * @param cause 异常信息
         *            
         */
        public SqlException(Throwable cause)
        {
            super(cause);
        }
    
        /**
         * 构造一个基本异常.
         *
         * @param message 信息描述
         *            
         */
        public SqlException(String message)
        {
            super(message);
        }
     
        /**
         * 构造一个基本异常.
         *
         * @param errorCode 错误编码
         * @param message 信息描述
         *            
         */
        public SqlException(String errorCode, String message)
        {
            this(errorCode, message, true);
        }
     
        /**
         * 构造一个基本异常.
         *
         * @param errorCode 错误编码
         * @param message 
         *                 
         */
        public SqlException(String errorCode, String message, Throwable cause)
        {
            this(errorCode, message, cause, true);
        }
     
        /**
         * 构造一个基本异常.
         *
         * @param errorCode 错误编码
         * @param message 信息描述
         * @param propertiesKey 消息是否为属性文件中的Key
         *            
         */
        public SqlException(String errorCode, String message, boolean propertiesKey)
        {
            super(message);
            this.setErrorCode(errorCode);
            this.setPropertiesKey(propertiesKey);
        }
     
        /**
         * 构造一个基本异常.
         *
         * @param errorCode 错误编码
         * @param message 信息描述
         *            
         */
        public SqlException(String errorCode, String message, Throwable cause, boolean propertiesKey)
        {
            super(message, cause);
            this.setErrorCode(errorCode);
            this.setPropertiesKey(propertiesKey);
        }
     
        /**
         * 构造一个基本异常.
         *
         * @param message 信息描述
         * @param cause 根异常类(可以存入任何异常)
         *            
         */
        public SqlException(String message, Throwable cause)
        {
            super(message, cause);
        }
        
        public String getErrorCode()
        {
            return errorCode;
        }
     
        public void setErrorCode(String errorCode)
        {
            this.errorCode = errorCode;
        }
     
        public boolean isPropertiesKey()
        {
            return propertiesKey;
        }
     
        public void setPropertiesKey(boolean propertiesKey)
        {
            this.propertiesKey = propertiesKey;
        }
        
    }

    3、Controller层

    @RestController
    @RequestMapping("/user")
    public class FileController extends ExceptionHandlerAdvice {
        
        private final Logger logger = LoggerFactory.getLogger(this.getClass());
    
        @RequestMapping(value = "/selectByCondition", method = RequestMethod.POST)
        public ResponseResult selectByCondition() throws Exception {
            throw new EntityTransException("这是一个自定义实体转换异常,这条异常会在ExceptionHandlerAdvice的entityTransExceptionHandle方法中被拦截");
        }
    
        @RequestMapping(value = "/update", method = RequestMethod.POST)
        public ResponseResult update() throws Exception {
            throw new SqlException("这是一个自定义SQL异常,这条异常会在ExceptionHandlerAdvice的sqlExceptionHandle方法中被拦截");
        }
    
    }

    4、封装返回实体

    public class ResponseResult implements Serializable {
        
        private static final long serialVersionUID = 6054052582421291408L;
        
        private String message;
        private Object data;
        private int code;
        private boolean success;
        private Long total;
    
        public ResponseResult(){}
    
        public ResponseResult(boolean success, Object data) {
            this.success = success;
            this.data = data;
        }
    
        public ResponseResult(boolean success, String message, Object data) {
            this.success = success;
            this.message = message;
            this.data = data;
        }
    
        public String getMessage() {
            return message;
        }
    
        public ResponseResult setMessage(String message) {
            this.message = message;
            return this;
        }
    
        public Object getData() {
            return data;
        }
    
        public ResponseResult setData(Object data) {
            this.data = data;
            return this;
        }
    
        public boolean getSuccess() {
            return success;
        }
    
        public ResponseResult setSuccess(boolean success) {
            this.success = success;
            return this;
        }
    
        public int getCode() {
            return code;
        }
    
        public ResponseResult setCode(int code) {
            this.code = code;
            return this;
        }
    
        public Long getTotal() {
            return success;
        }
    
        public ResponseResult setTotal(Long total) {
            this.total = total;
            return this;
        }
    
    }

    5、补充

    @ControllerAdvice(
        annotations = {RestController.class}
    )
    public class ExceptionHandlerAdvice {
    
        private static final Logger LOGGER = LoggerFactory.getLogger(ExceptionHandlerAdvice.class);
    
        /**
         * 400错误
         *
         * @param e
         * @return java.lang.ResponseResult
         * @author zxzhang
         * @date 2019/6/27
         */
        @ExceptionHandler({HttpMessageNotReadableException.class, TypeMismatchException.class, MissingServletRequestParameterException.class})
        public ResponseResult requestNotReadable(HttpServletRequest request, HttpMessageNotReadableException e) {
            return resultFormat(request, ResponseEnum.RESPONSE_CODE_PARAM_ERR, e);
        }
    
        /**
         * 404错误
         *
         * @param e
         * @return java.lang.ResponseResult
         * @author zxzhang
         * @date 2019/6/27
         */
        @ExceptionHandler({NoHandlerFoundException.class})
        public ResponseResult requestNotReadable(HttpServletRequest request, NoHandlerFoundException e) {
            return resultFormat(request, ResponseEnum.RESPONSE_CODE_NOT_FOUND, e);
        }
    
        /**
         * 405错误
         *
         * @param e
         * @return java.lang.ResponseResult
         * @author zxzhang
         * @date 2019/6/27
         */
        @ExceptionHandler({HttpRequestMethodNotSupportedException.class})
        public ResponseResult request405(HttpServletRequest request, HttpRequestMethodNotSupportedException e) {
            return resultFormat(request, ResponseEnum.RESPONSE_CODE_METHOD_NOT_SUPPORT, e);
        }
    
        /**
         * 406错误
         *
         * @param e
         * @return java.lang.ResponseResult
         * @author zxzhang
         * @date 2019/6/27
         */
        @ExceptionHandler({HttpMediaTypeNotAcceptableException.class})
        public ResponseResult request406(HttpServletRequest request, HttpMediaTypeNotAcceptableException e) {
            return resultFormat(request, ResponseEnum.RESPONSE_CODE_TYPE_NOT_ACCEPTABLE, e);
        }
    
        /**
         * Throwable拦截器
         *
         * @param request
         * @param e
         * @return com.openailab.oascloud.common.model.ResponseResult
         * @author zxzhang
         * @date 2019/6/27
         */
        @ExceptionHandler(Throwable.class)
        public ResponseResult exceptionHandle(HttpServletRequest request, Throwable e) {
            return resultFormat(request, ResponseEnum.RESPONSE_CODE_FAIL, e);
        }
    
        /**
         * 格式封装
         *
         * @param request
         * @param responseEnum
         * @param e
         * @return com.openailab.oascloud.common.model.ResponseResult
         * @author zxzhang
         * @date 2019/6/27
         */
        private ResponseResult resultFormat(HttpServletRequest request, ResponseEnum responseEnum, Throwable e) {
            LOGGER.error("********************Throw Exception.url:{} ERROR:{}********************", request.getRequestURL(), e.getMessage(), e);
            ResponseResult result = new ResponseResult();
            result.setstatus(CommonConst.RESPONSE_FAIL);
            result.setMessage(responseEnum.getMsg());
            result.setCode(responseEnum.getCode());
            return result;
        }
    }

    全篇文章完全纯手打,如果觉得对您有帮助,记得加关注给好评哟~~

    展开全文
  • Android 异常捕获以及上传到服务器
  • java AOP异常捕获导致全局异常捕获不到 https://blog.csdn.net/qq_37262094/article/details/103532560
  • SpringBoot项目中,定义了全局异常捕获类,但是当在Filter校验Token失败后抛出异常时,无法捕获异常。 原因分析: SpringBoot中,通过@ControllerAdvice+@ExceptionHandler实现的全局异常捕获类,只捕获Controller...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 377,035
精华内容 150,814
关键字:

异常捕获