前言

世界上没有完美的代码，你永远不知道bug什么时候会来……

/** 不要犹豫了，赶紧给你的代码上份保险吧，不要三四千，不要一两千，只要花10分钟复制下代码就好啦！*/ 算了，这段话假装没有看见吧……

分析

对于所有的客户端程序来说，环境的复杂性和不可控性总会导致各种各样意料之外的bug。这点对是国内的安卓开发者来说尤为明显。
首先安卓就有多个版本，从2.X到9.X，其次国内厂商的多种定制ROM更加剧了这个复杂程度……
总而言之，稳定性测试是保障客户端稳定性的一种手段，收集更多异常信息，复现问题解决问题。

那么当Android客户端发生闪退时，是如何捕获到闪退信息的呢？

Java的异常

Java语言在设计之初就提供了相对完美的异常处理机制，所有的异常类是从java.lang,Exception类继承的子类，Exception类是Throwable类的子类，除了Exception,Throwable还有一个子类Error，在java中只有Throwable类型的实例才可以被抛出（throw）或者（catch）,它是异常处理机制的基本组成部分。

Exception和Error
Exception和Error体现了Java平台设计者对不同异常情况的分类，Exception是程序正常运行中，可以预料的意外情况，可能并且应该被捕获。Error是指在正常情况下，不太可能出现的情况，绝大部分的Error都会导致程序处理非正常的，不可恢复的状态，例如典型的OutOfMemoryError.

Exception分为可检查异常（checked）和不检查异常（unchecked）异常，可检查异常必须在代码里显式进行捕获处理，这是编译期检查的一部分。不检查异常是所谓的运行时异常，类似NullPointException,ArrayIndexOutOfBoundsException,不会在编译器进行检查。

扩展知识

关于异常捕获的基本原则：
1.尽量不要捕获类似Exception这样的异常，应该捕获特定的异常。
2.不要生吞异常（swallow），因为这样可能会导致非常难以诊断的诡异情况。
3.try-catch代码段会产生额外的性能开销，换个角度，它往往会影响JVM对代码进行优化，所以建议仅仅捕获有必要的代码，尽量不要一个大的try包住整段的代码。
4.Java每实例化一个Exception，都会对当时的栈进行快照，这是一个非常重的操作，如果很频繁，这个开销就不能被忽略了。

RuntimeException的异常导致的app崩溃，应该如何来捕获？

Android全局异常捕获Android应用不可避免的发生crash,也就是崩溃，不同厂商的Rom,硬件导致的兼容性问题，都会导致应该异常或者崩溃。
接下来看一下Thread类里面的UncaugthExceptionHandler静态接口，ThreadGroup是它的子类，抽象方法uncaughtException(Thread t,Throwable e)。
官方文档是这样介绍的，
Thread.UncauthExceptionHandler接口，uncaught exception发生，一个线程突然停止，它的处理者（handler）,就会被调用。
JVM会通过Thread.getUncauthException()查询线程的UncaughtExceptionHandler,同时唤起处理者的uncaughtException方法，thread和exception作为参数传递，

如果一个线程没有UncaughtExceptionHandker，这时ThreadGroup对象作为该线程的UncaughtExceptionHandler,ThreadGroup没有明确的需求处理异常，它可以把调用传递给default uncauth exception handler.下面通过一个demo演示全局异常捕获

Thread.UncaughtExceptionHandler是一个当线程由于未捕获的异常突然终止而调用处理程序的接口.
当线程由于未捕获的异常即将终止时，Java虚拟机将使用它来查询其UncaughtExceptionHandler的线程Thread.getUncaughtExceptionHandler()，并将调用处理程序的 uncaughtException方法，将线程和异常作为参数传递。如果一个线程没有显示它的UncaughtExceptionHandler，那么它的ThreadGroup对象充当它的 UncaughtExceptionHandler。如果ThreadGroup对象没有处理异常的特殊要求，它可以将调用转发到默认的未捕获的异常处理程序。

实现

因此我们可以自定一个类去实现该接口，该类主要用于收集错误信息和保存错误信息.

/**
 * 作用:
 * 1.收集错误信息
 * 2.保存错误信息
 */
public class CrashHandler implements Thread.UncaughtExceptionHandler {

    private static CrashHandler sInstance = null;
    private Thread.UncaughtExceptionHandler mDefaultHandler;
    private Context mContext;
    // 保存手机信息和异常信息
    private Map<String, String> mMessage = new HashMap<>();

    public static CrashHandler getInstance() {
        if (sInstance == null) {
            synchronized (CrashHandler.class) {
                if (sInstance == null) {
                    synchronized (CrashHandler.class) {
                        sInstance = new CrashHandler();
                    }
                }
            }
        }
        return sInstance;
    }

    private CrashHandler() {
    }

    /**
     * 初始化默认异常捕获
     *
     * @param context context
     */
    public void init(Context context) {
        mContext = context;
        // 获取默认异常处理器
        mDefaultHandler = Thread.getDefaultUncaughtExceptionHandler();
        // 将此类设为默认异常处理器
        Thread.setDefaultUncaughtExceptionHandler(this);
    }

    @Override
    public void uncaughtException(Thread t, Throwable e) {
        if (!handleException(e)) {
            // 未经过人为处理,则调用系统默认处理异常,弹出系统强制关闭的对话框
            if (mDefaultHandler != null) {
                mDefaultHandler.uncaughtException(t, e);
            }
        } else {
            // 已经人为处理,系统自己退出
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e1) {
                e1.printStackTrace();
            }
            Process.killProcess(Process.myPid());
            System.exit(1);
        }
    }

    /**
     * 是否人为捕获异常
     *
     * @param e Throwable
     * @return true:已处理 false:未处理
     */
    private boolean handleException(Throwable e) {
        if (e == null) {// 异常是否为空
            return false;
        }
        new Thread() {// 在主线程中弹出提示
            @Override
            public void run() {
                Looper.prepare();
                Toast.makeText(mContext, "捕获到异常", Toast.LENGTH_SHORT).show();
                Looper.loop();
            }
        }.start();
        collectErrorMessages();
        saveErrorMessages(e);
        return false;
    }

    /**
     * 1.收集错误信息
     */
    private void collectErrorMessages() {
        PackageManager pm = mContext.getPackageManager();
        try {
            PackageInfo pi = pm.getPackageInfo(mContext.getPackageName(), PackageManager.GET_ACTIVITIES);
            if (pi != null) {
                String versionName = TextUtils.isEmpty(pi.versionName) ? "null" : pi.versionName;
                String versionCode = "" + pi.versionCode;
                mMessage.put("versionName", versionName);
                mMessage.put("versionCode", versionCode);
            }
            // 通过反射拿到错误信息
            Field[] fields = Build.class.getFields();
            if (fields != null && fields.length > 0) {
                for (Field field : fields) {
                    field.setAccessible(true);
                    try {
                        mMessage.put(field.getName(), field.get(null).toString());
                    } catch (IllegalAccessException e) {
                        e.printStackTrace();
                    }
                }
            }
        } catch (PackageManager.NameNotFoundException e) {
            e.printStackTrace();
        }
    }

    /**
     * 2.保存错误信息
     *
     * @param e Throwable
     */
    private void saveErrorMessages(Throwable e) {
        StringBuilder sb = new StringBuilder();
        for (Map.Entry<String, String> entry : mMessage.entrySet()) {
            String key = entry.getKey();
            String value = entry.getValue();
            sb.append(key).append("=").append(value).append("\n");
        }
        Writer writer = new StringWriter();
        PrintWriter pw = new PrintWriter(writer);
        e.printStackTrace(pw);
        Throwable cause = e.getCause();
        // 循环取出Cause
        while (cause != null) {
            cause.printStackTrace(pw);
            cause = e.getCause();
        }
        pw.close();
        String result = writer.toString();
        sb.append(result);
        String time = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.CHINA).format(new Date());
        String fileName = "crash-" + time + "-" + System.currentTimeMillis() + ".log";
        // 有无SD卡
        if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
            String path = Environment.getExternalStorageDirectory().getPath() + "crash/";
            File dir = new File(path);
            if (!dir.exists()) dir.mkdirs();
            FileOutputStream fos = null;
            try {
                fos = new FileOutputStream(path + fileName);
                fos.write(sb.toString().getBytes());
            } catch (Exception e1) {
                e1.printStackTrace();
            } finally {
                if (fos != null) {
                    try {
                        fos.close();
                    } catch (IOException e1) {
                        e1.printStackTrace();
                    }
                }
            }
        }
    }
}