Android ExceptionHandler

前言

不论软件还是硬件在运行的过程中，总会难以避免的发生异常。如何保证当程序发生异常后，还能正常的运行，而不影响用户体验，并将异常信息报告给响应的开发，将是软件开发者要考虑。本文介绍Android开发如何进行异常处理。

Java Exception

Android应用开发，使用的是Java语言进行编程，这也就不得不提Java中的异常。

Exception

异常将强制程序停止允许，并通知出现了什么问题，在异常处理的理想情况下，强制程序处理异常，并返回稳定状态。
Java编程语言使用异常处理错误以及其他异常事件。当在方法中出现错误时，该方法创建一个对象，并把它关闭的运行系统。对象，称为一个异常对象，包含有关错误的信息，包括它的类型和时发生错误的程序的状态。创建一个异常对象，交给到运行系统被称为抛出异常。
后一个方法抛出一个异常，运行时系统试图找到一些处理它。处理异常的一组可能的“东西”是已被称为去哪里出现了错误的方法，方法的有序列表。方法列表是被称为调用堆栈。

Java异常类型

1. 检查性异常：最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。例如：java.io.FileNotFoundException
2. 错误： 错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的，或者在读取文件时发生硬件错误导致读写文件异常。例如：java.io.IOError
3. 运行时异常： 运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。例如：NullPointerException
   注：Java7新特性，改善得异常处理：支持multicatch和final重抛，保证异常类型不被覆盖，让代码更整洁

catch (IOException|SQLException ex) {
    logger.log(ex);
    throw ex;
}

异常捕获

try-catch-finally

try {
    // code may throw exception
} catch (ExceptionType name) {
    // handle exception occur
} finally {
    // do some cleanup
}

官网注释：finally基本上会执行，除非在try-catch的执行过程中JVM退出，finally总会在try-catch之后执行。

java7开始有了自动回收资源的功能：try-with-resources(TWR)：自动进行资源的回收工作，即将创建资源的代码放入try的圆括号内，现有资源类大部分实现了AutoCloseable接口

// Java 7+
static String readFirstLineFromFile(String path) throws IOException {
    try (BufferedReader br =
                   new BufferedReader(new FileReader(path))) {
        return br.readLine();
    }
}

// Java 7-
static String readFirstLineFromFileWithFinallyBlock(String path)
                                                     throws IOException {
    BufferedReader br = new BufferedReader(new FileReader(path));
    try {
        return br.readLine();
    } finally {
        if (br != null) br.close();
    }
}

抛出异常

抛出一个Java中存在的异常类型，

public Object pop() {
    Object obj;

    if (size == 0) {
        throw new EmptyStackException();
    }

    obj = objectAt(size - 1);
    setObjectAt(size - 1, null);
    size--;
    return obj;
}

Java中定义了很多异常类型，有时，作为接口开发或者业务开发，需要抛出自定义异常类型，用于做不同的业务处理：
1. 需要一个Java未提供的异常
2. 用于区别不同业务的异常
3. 代码抛出了两个及以上的相关异常
4. 当你的代码会被其他人访问时
满足以上条件是可以自定义异常。

Java异常类图

Java异常类图，该图来自官网。

1. Error Class : 当java虚拟机发生动态链接失败或其他硬故障时，虚拟机将抛出一个错误。简单的程序通常不会捕获或抛出错误。
2. Exception Class ：大多数程序抛出和捕获从异常类派生的对象。一个异常表示发生了一个问题，但它不是一个严重的系统问题。大多数程序将抛出和捕获异常，而不是错误。

ExceptionHandler

通过异常的分析我们已经看到，在编写程序时，可以通过try-catch进行捕获，捕获那些被检查的异常类型，如果不进行处理，是无法编译的。但是除了被检查异常外还有运行时异常，运行时异常是无法确定的，可能在程序的任何地方抛出。
如何去捕获运行时异常，使程序在抛出运行时异常时不崩溃呢？可以看下try-catch的原理，其实，try-catch的实现，是通过给方法注册一个ExceptionHandler，当异常抛出时，会在堆栈最顶部的调用方法中寻找合适的ExceptionHandler，使用try-catch，相当于注册了一个ExceptionHandler进行异常处理。

因此，当运行时异常发生时，是否也可以通过注册一个ExceptionHandler进行处理呢？答案是肯定的。

在Java线程中存在一个defaultUncaughtHandler，就是默认的未捕获异常处理器，当线程中发生异常时，如果该异常未被捕获，最后会被defaultUncaughtHandler处理。

    /**
     * Holds the handler for uncaught exceptions in this Thread,
     * in case there is one.
     */
    private UncaughtExceptionHandler uncaughtHandler;

    /**
     * Holds the default handler for uncaught exceptions, in case there is one.
     */
    private static UncaughtExceptionHandler defaultUncaughtHandler;

通过自定义一个UncaughtExceptionHandler，并传给Thread可以达到目的。

    /**
     * Sets the default uncaught exception handler. This handler is invoked in
     * case any Thread dies due to an unhandled exception.
     *
     * @param handler
     *            The handler to set or null.
     */
    public static void setDefaultUncaughtExceptionHandler(UncaughtExceptionHandler handler) {
        Thread.defaultUncaughtHandler = handler;
    }

UncaughtExceptionHandler

UncaughtExceptionHandler是Thread中定义的一个接口，因此我们需要实现该接口。

    /**
     * Implemented by objects that want to handle cases where a thread is being
     * terminated by an uncaught exception. Upon such termination, the handler
     * is notified of the terminating thread and causal exception. If there is
     * no explicit handler set then the thread's group is the default handler.
     */
    public static interface UncaughtExceptionHandler {
        /**
         * The thread is being terminated by an uncaught exception. Further
         * exceptions thrown in this method are prevent the remainder of the
         * method from executing, but are otherwise ignored.
         *
         * @param thread the thread that has an uncaught exception
         * @param ex the exception that was thrown
         */
        void uncaughtException(Thread thread, Throwable ex);
    }

在接口中，需要实现uncaughtException方法，方法中有两个蚕食，一个是Thread，发送异常的线程，Throwable, 未捕获的异常。
因此，当自定义UncaughtExceptionHandler，已经能获取到发生异常的现场和抛出的异常，接下来就是如何处理异常了。

自定义UncaughtExceptionHandler

当未捕获的异常，抛出来后，肯定要进行处理，如果我们进行了自定义UncaughtExceptionHandler，一旦发现有我们不想处理的异常，一定要及时返回给系统处理，调用系统的默认异常处理器。
自定义异常处理步骤：
1.自定义类实现UncaughtExceptionHandler，实现uncaughtException
2.获取系统的defaultUncaughtHandler，保存，当出现不想处理的异常时，将异常处理交给defaultUncaughtHandler

    mDefaultHandler = Thread.getDefaultUncaughtExceptionHandler();

    if (!handleException(ex) && mDefaultHandler != null) {
        //如果没有处理则让系统默认的异常处理器来处理
        mDefaultHandler.uncaughtException(thread, ex);
    } else {
        // to do something what u want after handle exception
    }

3.自定义异常处理
当发生这种异常时，主要是要做两件是：保存当前异常发生时的环境信息，将异常信息发送至服务器或保存至本地。具体要保存哪些信息根据需求进行添加即可。

/**
     * 自定义错误处理,收集错误信息 发送错误报告等操作均在此完成.
     *
     * @param ex 抛出的异常
     * @return true:如果处理了该异常信息;否则返回false.
     */
    private boolean handleException(Throwable ex) {
        if (ex == null) {
            return false;
        }

        collectDeviceInfo(mContext);

        new Thread() {
            @Override
            public void run() {
                Looper.prepare();
                // send exception info to server
                Looper.loop();
            }
        }.start();
        // or save exception info to local file
        return true;
    }

参考

1. java.lang.Exception
2. Oracle Exception Lesson
3. ExceptionHandler
4. Default Exception Handler
5. java.lang.Thread