Android ExceptionHandler

前言

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

Java Exception

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

Exception

异常将强制程序停止允许，并通知出现了什么问题，在异常处理的理想情况下，强制程序处理异常，并返回稳定状态。

Java编程语言使用异常处理错误以及其他异常事件。当在方法中出现错误时，该方法创建一个对象，并把它关闭的运行系统。对象，称为一个异常对象，包含有关错误的信息，包括它的类型和时发生错误的程序的状态。创建一个异常对象，交给到运行系统被称为抛出异常。

后一个方法抛出一个异常，运行时系统试图找到一些处理它。处理异常的一组可能的“东西”是已被称为去哪里出现了错误的方法，方法的有序列表。方法列表是被称为调用堆栈。

Java异常类型

检查性异常：最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。例如：java.io.FileNotFoundException

错误： 错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的，或者在读取文件时发生硬件错误导致读写文件异常。例如：java.io.IOError

运行时异常： 运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。例如：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异常类图，该图来自官网。



Error Class : 当java虚拟机发生动态链接失败或其他硬故障时，虚拟机将抛出一个错误。简单的程序通常不会捕获或抛出错误。

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;
}

参考

java.lang.Exception

Oracle Exception Lesson

ExceptionHandler

Default Exception Handler

java.lang.Thread