Android崩溃异常捕获方法

开发中最让人头疼的是应用突然爆炸，然后跳回到桌面。而且我们常常不知道这种状况会何时出现，在应用调试阶段还好，还可以通过调试工具的日志查看错误出现在哪里。但平时使用的时候给你闹崩溃，那你就欲哭无泪了。
那么今天主要讲一下如何去捕捉系统出现的unchecked异常。何为unchecked异常呢，换句话说就是指非受检异常，它不能用try-catch来显示捕捉。

我们先从exception讲起。exception分为两类：一种是checkedexception，一种是uncheckedexception。这两种exception的区别主要是checkedexception需要用try...catch...显示的捕获，而uncheckedexception不需要捕获。通常uncheckedexception又叫做runtimeexception。《effective java》指出：对于可恢复的条件使用被检查的异常（checkedexception），对于程序错误（言外之意不可恢复，大错已经酿成）使用运行时异常（runtimeexception）。我们常见的runtimeexcepiton有illegalargumentexception、illegalstateexception、nullpointerexception、indexoutofboundsexception等等。对于那些checkedexception就不胜枚举了，我们在编写程序过程中try...catch...捕捉的异常都是checkedexception。io包中的ioexception及其子类，这些都是checkedexception。

一、使用uncaughtexceptionhandler来捕获unchecked异常

uncaughtexception处理类,当程序发生uncaught异常的时候,由该类来接管程序,并记录发送错误报告。
直接上代码吧

				?

									import java.io.file;

									import java.io.fileoutputstream;

									import java.io.printwriter;

									import java.io.stringwriter;

									import java.io.writer;

									import java.lang.thread.uncaughtexceptionhandler;

									import java.lang.reflect.field;

									import java.text.dateformat;

									import java.text.simpledateformat;

									import java.util.date;

									import java.util.hashmap;

									import java.util.locale;

									import java.util.map;

									import java.util.map.entry;

									import java.util.regex.matcher;

									import java.util.regex.pattern;

									import android.annotation.suppresslint;

									import android.content.context;

									import android.content.pm.packageinfo;

									import android.content.pm.packagemanager;

									import android.content.pm.packagemanager.namenotfoundexception;

									import android.os.build;

									import android.os.environment;

									import android.os.looper;

									import android.util.log;

									import android.widget.toast;

									/**

									* uncaughtexception处理类,当程序发生uncaught异常的时候,有该类来接管程序,并记录发送错误报告.

									* 

									* @author user

									* 

									*/

									@suppresslint("sdcardpath")

									public class crashhandler implements uncaughtexceptionhandler {

									public static final string tag = "test";

									// crashhandler 实例

									private static crashhandler instance = new crashhandler();

									// 程序的 context 对象

									private context mcontext;

									// 系统默认的 uncaughtexception 处理类

									private thread.uncaughtexceptionhandler mdefaulthandler;

									// 用来存储设备信息和异常信息

									private map<string, string> infos = new hashmap<string, string>();

									// 用来显示toast中的信息

									private static string error = "程序错误，额，不对，我应该说，服务器正在维护中，请稍后再试";

									private static final map<string, string> regexmap = new hashmap<string, string>();

									// 用于格式化日期,作为日志文件名的一部分

									private dateformat formatter = new simpledateformat("yyyy-mm-dd-hh-mm-ss",

									locale.china);

									/** 保证只有一个 crashhandler 实例 */

									private crashhandler() {

									//

									}

									/** 获取 crashhandler 实例 ,单例模式 */

									public static crashhandler getinstance() {

									initmap();

									return instance;

									}

									/**

									* 初始化

									* 

									* @param context

									*/

									public void init(context context) {

									mcontext = context;

									// 获取系统默认的 uncaughtexception 处理器

									mdefaulthandler = thread.getdefaultuncaughtexceptionhandler();

									// 设置该 crashhandler 为程序的默认处理器

									thread.setdefaultuncaughtexceptionhandler(this);

									log.d("test", "crash:init");

									}

									/**

									* 当 uncaughtexception 发生时会转入该函数来处理

									*/

									@override

									public void uncaughtexception(thread thread, throwable ex) {

									if (!handleexception(ex) && mdefaulthandler != null) {

									// 如果用户没有处理则让系统默认的异常处理器来处理

									mdefaulthandler.uncaughtexception(thread, ex);

									log.d("test", "defalut");

									} else {

									try {

									thread.sleep();

									} catch (interruptedexception e) {

									log.e(tag, "error : ", e);

									}

									// 退出程序

									android.os.process.killprocess(android.os.process.mypid());

									// mdefaulthandler.uncaughtexception(thread, ex);

									system.exit();

									}

									}

									/**

									* 自定义错误处理，收集错误信息，发送错误报告等操作均在此完成

									* 

									* @param ex

									* @return true：如果处理了该异常信息；否则返回 false

									*/

									private boolean handleexception(throwable ex) {

									if (ex == null) {

									return false;

									}

									// 收集设备参数信息

									// collectdeviceinfo(mcontext);

									// 保存日志文件

									savecrashinfofile(ex);

									// 使用 toast 来显示异常信息

									new thread() {

									@override

									public void run() {

									looper.prepare();

									toast.maketext(mcontext, error, toast.length_long).show();

									looper.loop();

									}

									}.start();

									return true;

									}

									/**

									* 收集设备参数信息

									* 

									* @param ctx

									*/

									public void collectdeviceinfo(context ctx) {

									try {

									packagemanager pm = ctx.getpackagemanager();

									packageinfo pi = pm.getpackageinfo(ctx.getpackagename(),

									packagemanager.get_activities);

									if (pi != null) {

									string versionname = pi.versionname == null ? "null"

									: pi.versionname;

									string versioncode = pi.versioncode + "";

									infos.put("versionname", versionname);

									infos.put("versioncode", versioncode);

									}

									} catch (namenotfoundexception e) {

									log.e(tag, "an error occured when collect package info", e);

									}

									field[] fields = build.class.getdeclaredfields();

									for (field field : fields) {

									try {

									field.setaccessible(true);

									infos.put(field.getname(), field.get(null).tostring());

									log.d(tag, field.getname() + " : " + field.get(null));

									} catch (exception e) {

									log.e(tag, "an error occured when collect crash info", e);

									}

									}

									}

									/**

									* 保存错误信息到文件中 *

									* 

									* @param ex

									* @return 返回文件名称,便于将文件传送到服务器

									*/

									private string savecrashinfofile(throwable ex) {

									stringbuffer sb = gettraceinfo(ex);

									writer writer = new stringwriter();

									printwriter printwriter = new printwriter(writer);

									ex.printstacktrace(printwriter);

									throwable cause = ex.getcause();

									while (cause != null) {

									cause.printstacktrace(printwriter);

									cause = cause.getcause();

									}

									printwriter.close();

									string result = writer.tostring();

									sb.append(result);

									try {

									long timestamp = system.currenttimemillis();

									string time = formatter.format(new date());

									string filename = "crash-" + time + "-" + timestamp + ".log";

									if (environment.getexternalstoragestate().equals(

									environment.media_mounted)) {

									string path = environment.getexternalstoragedirectory()

									+ "/crash/";

									file dir = new file(path);

									if (!dir.exists()) {

									dir.mkdirs();

									}

									fileoutputstream fos = new fileoutputstream(path + filename);

									fos.write(sb.tostring().getbytes());

									fos.close();

									}

									return filename;

									} catch (exception e) {

									log.e(tag, "an error occured while writing file...", e);

									}

									return null;

									}

									/**

									* 整理异常信息

									* @param e

									* @return

									*/

									public static stringbuffer gettraceinfo(throwable e) {

									stringbuffer sb = new stringbuffer();

									throwable ex = e.getcause() == null ? e : e.getcause();

									stacktraceelement[] stacks = ex.getstacktrace();

									for (int i = ; i < stacks.length; i++) {

									if (i == ) {

									seterror(ex.tostring());

									}

									sb.append("class: ").append(stacks[i].getclassname())

									.append("; method: ").append(stacks[i].getmethodname())

									.append("; line: ").append(stacks[i].getlinenumber())

									.append("; exception: ").append(ex.tostring() + "\n");

									}

									log.d(tag, sb.tostring());

									return sb;

									}

									/**

									* 设置错误的提示语

									* @param e

									*/

									public static void seterror(string e) {

									pattern pattern;

									matcher matcher;

									for (entry<string, string> m : regexmap.entryset()) {

									log.d(tag, e+"key:" + m.getkey() + "; value:" + m.getvalue());

									pattern = pattern.compile(m.getkey());

									matcher = pattern.matcher(e);

									if(matcher.matches()){

									error = m.getvalue();

									break;

									}

									}

									}

									/**

									* 初始化错误的提示语

									*/

									private static void initmap() {

									// java.lang.nullpointerexception

									// java.lang.classnotfoundexception

									// java.lang.arithmeticexception

									// java.lang.arrayindexoutofboundsexception

									// java.lang.illegalargumentexception

									// java.lang.illegalaccessexception

									// secturityexception

									// numberformatexception

									// outofmemoryerror 

									// stackoverflowerror 

									// runtimeexception 

									regexmap.put(".*nullpointerexception.*", "嘿，无中生有~boom!");

									regexmap.put(".*classnotfoundexception.*", "你确定你能找得到它？");

									regexmap.put(".*arithmeticexception.*", "我猜你的数学是体育老师教的，对吧？");

									regexmap.put(".*arrayindexoutofboundsexception.*", "恩，无下限=无节操，请不要跟我搭话");

									regexmap.put(".*illegalargumentexception.*", "你的出生就是一场错误。");

									regexmap.put(".*illegalaccessexception.*", "很遗憾，你的信用卡账号被冻结了，无权支付");

									regexmap.put(".*secturityexception.*", "死神马上降临");

									regexmap.put(".*numberformatexception.*", "想要改变一下自己形象？去泰国吧，包你满意");

									regexmap.put(".*outofmemoryerror.*", "或许你该减减肥了");

									regexmap.put(".*stackoverflowerror.*", "啊，啊，憋不住了！");

									regexmap.put(".*runtimeexception.*", "你的人生走错了方向，重来吧");

									}

									}

二、建立一个application来全局监控

				?

									import android.app.application;

									public class crashapplication extends application {

									@override

									public void oncreate() {

									super.oncreate();

									crashhandler crashhandler = crashhandler.getinstance();

									crashhandler.init(getapplicationcontext());

									}

									}

最后在配置文件中加入注册信息

				?

									<application android:name=".crashapplication" ... />

和权限

				?

									<!--uses-permission android:name="android.permission.access_network_state" /-->

									<uses-permission android:name="android.permission.write_external_storage" />