Android全局异常捕获机制

原创 2017年06月15日 21:26:45

文章背景
程序猿或是程序媛们在开发Android项目的时候,经常出现各种奇葩的Crash,有可能是服务端返回数据的原因所造成的、也可能是客户端自己的原因。我个人认为出现Bug并不是那么的重要,快速定位问题才是解决问题的开始、如果我们有一个能够帮助我们快速定位异常的机制,那么不仅在开发的效率上提高,而且在维护成本也会在一定程度上降低成本。
那么目前主流的第三方Bug分析框架有腾讯的Bugly和友盟都能够很好的统计分析各种Crash等Bug,但是在我们做项目中,难免面对的用户是政府或银行等客户,这类客户有一些硬性的的要求,就是不允许嵌入第三方的框架,有可能是安全方面的担心,怕被监控或是盗取数据等。
另一方面来讲,现在的第三方库提供商,总说自己的sdk特牛逼、然而一下载下来一看就有几十兆、甚至有几百兆、如果嵌入太多的第三方sdk会增大apk大小、若是互联网产品,包越大越难在用户手机上存活。

文章目标
为我们的项目提供一个异常捕获跟踪处理机制,我认为应包含捕获异常、写入异常数据到SD卡中、定时上传异常数据给服务端、服务端统计分析异常、最终目标为解决异常从而提高代码的健壮性。

下面提供一个客户端这边的异常处理类,先上个演示效果图:

效果图

异常信息打印效果:

异常信息打印效果图

日志写入效果图:

日志写入效果图

异常处理类:

    package com.example.yangdechengapplication.tools;

import android.content.Context;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.os.Build;
import android.os.Looper;
import android.text.format.Time;
import android.util.Log;
import android.view.Gravity;
import android.widget.Toast;

import java.io.File;
import java.io.FileOutputStream;
import java.io.FilenameFilter;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.io.Writer;
import java.lang.reflect.Field;
import java.util.Arrays;
import java.util.Properties;
import java.util.TreeSet;

/**
 * Created by Administrator on 2017/6/15.
 */

public class CrashHandler implements Thread.UncaughtExceptionHandler {

    /** Debug Log tag*/
    public static final String TAG = "CrashHandler";
    /** 是否开启日志输出,在Debug状态下开启,
     * 在Release状态下关闭以提示程序性能
     * */
    public static final boolean DEBUG = true;
    /** 系统默认的UncaughtException处理类 */
    private Thread.UncaughtExceptionHandler mDefaultHandler;
    /** CrashHandler实例 */
    private static CrashHandler INSTANCE;
    /** 程序的Context对象 */
    private Context mContext;
    /** 使用Properties来保存设备的信息和错误堆栈信息*/
    private Properties mDeviceCrashInfo = new Properties();
    private static final String VERSION_NAME = "versionName";
    private static final String VERSION_CODE = "versionCode";
    private static final String STACK_TRACE = "STACK_TRACE";
    /** 错误报告文件的扩展名 */
    private static final String CRASH_REPORTER_EXTENSION = ".cr";

    private static  Object syncRoot = new Object();

    /** 保证只有一个CrashHandler实例 */
    private CrashHandler() {}

    /** 获取CrashHandler实例 ,单例模式*/
    public static CrashHandler getInstance() {
       /* if (INSTANCE == null) {
            INSTANCE = new CrashHandler();
        }
        return INSTANCE;*/
        // 防止多线程访问安全,这里使用了双重锁
        if (INSTANCE == null)
        {

            synchronized (syncRoot)
            {

                if (INSTANCE == null)
                {
                    INSTANCE =  new CrashHandler();
                }
            }
        }
        return INSTANCE;
    }

    /**
     * 初始化,注册Context对象,
     * 获取系统默认的UncaughtException处理器,
     * 设置该CrashHandler为程序的默认处理器
     * @param ctx
     */
    public void init(Context ctx) {
        mContext = ctx;
        mDefaultHandler = Thread.getDefaultUncaughtExceptionHandler();
        Thread.setDefaultUncaughtExceptionHandler(this);
    }

    /**
     * 当UncaughtException发生时会转入该函数来处理
     */
    @Override
    public void uncaughtException(Thread thread, Throwable ex) {
        if (!handleException(ex) && mDefaultHandler != null) {
            //如果用户没有处理则让系统默认的异常处理器来处理
            mDefaultHandler.uncaughtException(thread, ex);
        } else {
            //Sleep一会后结束程序
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                Log.e(TAG, "Error : ", e);
            }
            android.os.Process.killProcess(android.os.Process.myPid());
            System.exit(10);
        }
    }

    /**
     * 自定义错误处理,收集错误信息
     * 发送错误报告等操作均在此完成.
     * 开发者可以根据自己的情况来自定义异常处理逻辑
     * @param ex
     * @return true:如果处理了该异常信息;否则返回false
     */
    private boolean handleException(Throwable ex) {
        if (ex == null) {
            Log.w(TAG, "handleException --- ex==null");
            return true;
        }
        final String msg = ex.getLocalizedMessage();
        if(msg == null) {
            return false;
        }
        //使用Toast来显示异常信息
        new Thread() {
            @Override
            public void run() {
                Looper.prepare();

                if(DEBUG){
                    Log.d(TAG, "异常信息->"+msg);
                    Toast toast = Toast.makeText(mContext, "程序出错,即将退出:\r\n" + msg,
                            Toast.LENGTH_LONG);
                    toast.setGravity(Gravity.CENTER, 0, 0);
                    toast.show();

                    //保存错误报告文件
                    LogToFile.w("my",msg);**//这句话可以先注释掉,这是我单独写的一个log写入类,下面已提供了该类**
                }
//              MsgPrompt.showMsg(mContext, "程序出错啦", msg+"\n点确认退出");
                Looper.loop();
            }
        }.start();
        //收集设备信息
        collectCrashDeviceInfo(mContext);
        //保存错误报告文件
        //saveCrashInfoToFile(ex);
        //发送错误报告到服务器
        //sendCrashReportsToServer(mContext);
        return true;
    }

    /**
     * 在程序启动时候, 可以调用该函数来发送以前没有发送的报告
     */
    public void sendPreviousReportsToServer() {
        sendCrashReportsToServer(mContext);
    }
    /**
     * 把错误报告发送给服务器,包含新产生的和以前没发送的.
     * @param ctx
     */
    private void sendCrashReportsToServer(Context ctx) {
        String[] crFiles = getCrashReportFiles(ctx);
        if (crFiles != null && crFiles.length > 0) {
            TreeSet<String> sortedFiles = new TreeSet<String>();
            sortedFiles.addAll(Arrays.asList(crFiles));
            for (String fileName : sortedFiles) {
                File cr = new File(ctx.getFilesDir(), fileName);
                postReport(cr);
                cr.delete();// 删除已发送的报告
            }
        }
    }
    private void postReport(File file) {
        // TODO 发送错误报告到服务器
    }

    /**
     * 获取错误报告文件名
     * @param ctx
     * @return
     */
    private String[] getCrashReportFiles(Context ctx) {
        File filesDir = ctx.getFilesDir();
        FilenameFilter filter = new FilenameFilter() {
            public boolean accept(File dir, String name) {
                return name.endsWith(CRASH_REPORTER_EXTENSION);
            }
        };
        return filesDir.list(filter);
    }

    /**
     * 保存错误信息到文件中
     * @param ex
     * @return
     */
    private String saveCrashInfoToFile(Throwable ex) {
        Writer info = new StringWriter();
        PrintWriter printWriter = new PrintWriter(info);
        ex.printStackTrace(printWriter);
        Throwable cause = ex.getCause();
        while (cause != null) {
            cause.printStackTrace(printWriter);
            cause = cause.getCause();
        }
        String result = info.toString();
        printWriter.close();
        mDeviceCrashInfo.put("EXEPTION", ex.getLocalizedMessage());
        mDeviceCrashInfo.put(STACK_TRACE, result);
        try {
            //long timestamp = System.currentTimeMillis();
            Time t = new Time("GMT+8");
            t.setToNow(); // 取得系统时间
            int date = t.year * 10000 + t.month * 100 + t.monthDay;
            int time = t.hour * 10000 + t.minute * 100 + t.second;
            String fileName = "crash-" + date + "-" + time + CRASH_REPORTER_EXTENSION;
            FileOutputStream trace = mContext.openFileOutput(fileName,
                    Context.MODE_PRIVATE);
            mDeviceCrashInfo.store(trace, "");
            trace.flush();
            trace.close();
            return fileName;
        } catch (Exception e) {
            Log.e(TAG, "an error occured while writing report file...", e);
        }
        return null;
    }

    /**
     * 收集程序崩溃的设备信息
     *
     * @param ctx
     */
    public void collectCrashDeviceInfo(Context ctx) {
        try {
            PackageManager pm = ctx.getPackageManager();
            PackageInfo pi = pm.getPackageInfo(ctx.getPackageName(),
                    PackageManager.GET_ACTIVITIES);
            if (pi != null) {
                mDeviceCrashInfo.put(VERSION_NAME,
                        pi.versionName == null ? "not set" : pi.versionName);
                mDeviceCrashInfo.put(VERSION_CODE, ""+pi.versionCode);
            }
        } catch (PackageManager.NameNotFoundException e) {
            Log.e(TAG, "Error while collect package info", e);
        }
        //使用反射来收集设备信息.在Build类中包含各种设备信息,
        //例如: 系统版本号,设备生产商 等帮助调试程序的有用信息
        //具体信息请参考后面的截图
        Field[] fields = Build.class.getDeclaredFields();
        for (Field field : fields) {
            try {
                field.setAccessible(true);
                mDeviceCrashInfo.put(field.getName(), ""+field.get(null));
                if (DEBUG) {
                    Log.d(TAG, field.getName() + " : " + field.get(null));
                }
            } catch (Exception e) {
                Log.e(TAG, "Error while collect crash info", e);
            }
        }
    }


}

使用方法:

package com.example.yangdechengapplication;

import android.app.Application;

import com.example.yangdechengapplication.tools.CrashHandler;
import com.example.yangdechengapplication.tools.LogToFile;

/**
 * Created by Administrator on 2017/6/15.
 */

public class MyApplication extends Application {
    private final static float HEAP_UTILIZATION = 0.75f;
    private final static int MIN_HEAP_SIZE = 6* 1024* 1024 ;
    @Override
    public void onCreate() {
        super.onCreate();

        // 异常处理,不需要处理时注释掉这两句即可!
        CrashHandler crashHandler = CrashHandler.getInstance();
        // 注册crashHandler
        crashHandler.init(getApplicationContext());


    }
}

开始测试:
package com.example.yangdechengapplication;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;

import com.example.yangdechengapplication.tools.LogToFile;

public class MainActivity extends AppCompatActivity {

Button btn_crashHandler;
@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    btn_crashHandler=(Button)findViewById(R.id.btn_crashHandler);
    btn_crashHandler.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {

            int a= Integer.parseInt("q");//当用户点击按钮的时候特意写了一个异常
            //LogToFile.w("my","我在测试文件读写66666666666啊");
        }
    });
}

}

LogToFile(异常日志写入类,已单独抽取出来了,也算职责分明吧)
注:写入日志需要在配置文件中加上文件读写权限

 <!--往sdcard中写入数据的权限 -->
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"></uses-permission>
    <!--在sdcard中创建/删除文件的权限 -->
    <uses-permission android:name="android.permission.MOUNT_UNMOUNT_FILESYSTEMS"></uses-permission>
package com.example.yangdechengapplication.tools;

import android.content.Context;
import android.os.Environment;
import android.util.Log;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;

/**
 * Created by Administrator on 2017/6/15.
 */

public class LogToFile {

    //日志是否需要读写开关
    public static final boolean DEBUG_FLAG = false;
    private static String TAG = "LogToFile";

    private static String logPath = null;//log日志存放路径

    private static SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd_HH-mm-ss", Locale.US);//日期格式;

    private static Date date = new Date();//因为log日志是使用日期命名的,使用静态成员变量主要是为了在整个程序运行期间只存在一个.log文件中;

    /**
     * 初始化,须在使用之前设置,最好在Application创建时调用
     *
     * @param context
     */
    public static void init(Context context) {
        logPath = getFilePath(context) + "/Logs";//获得文件储存路径,在后面加"/Logs"建立子文件夹
    }

    /**
     * 获得文件存储路径
     *
     * @return
     */
    private static String getFilePath(Context context) {

        if (Environment.MEDIA_MOUNTED.equals(Environment.MEDIA_MOUNTED) || !Environment.isExternalStorageRemovable()) {//如果外部储存可用
            return context.getExternalFilesDir(null).getPath();//获得外部存储路径,默认路径为 /storage/emulated/0/Android/data/com.waka.workspace.logtofile/files/Logs/log_2016-03-14_16-15-09.log
        } else {
            return context.getFilesDir().getPath();//直接存在/data/data里,非root手机是看不到的
        }
    }

    private static final char VERBOSE = 'v';

    private static final char DEBUG = 'd';

    private static final char INFO = 'i';

    private static final char WARN = 'w';

    private static final char ERROR = 'e';

    public static void v(String tag, String msg) {
        if(DEBUG_FLAG){
            writeToFile(VERBOSE, tag, msg);
        }

    }

    public static void d(String tag, String msg) {
        if(DEBUG_FLAG){
            writeToFile(DEBUG, tag, msg);
        }
    }

    public static void i(String tag, String msg) {
        if(DEBUG_FLAG){
            writeToFile(INFO, tag, msg);
        }

    }

    public static void w(String tag, String msg) {
        if(DEBUG_FLAG){
            writeToFile(WARN, tag, msg);
        }
    }

    public static void e(String tag, String msg) {
        if(DEBUG_FLAG){
            writeToFile(ERROR, tag, msg);
        }

    }

    /**
     * 将log信息写入文件中
     *
     * @param type
     * @param tag
     * @param msg
     */
    private static void writeToFile(char type, String tag, String msg) {

        if (null == logPath) {
            Log.e(TAG, "logPath == null ,未初始化LogToFile");
            return;
        }

        String fileName = logPath + "/log_" + dateFormat.format(new Date()) + ".log";//log日志名,使用时间命名,保证不重复
        String log = dateFormat.format(date) + " " + type + " " + tag + " " + msg + "\n";//log日志内容,可以自行定制

        //如果父路径不存在
        File file = new File(logPath);
        if (!file.exists()) {
            file.mkdirs();//创建父路径
        }

        FileOutputStream fos = null;//FileOutputStream会自动调用底层的close()方法,不用关闭
        BufferedWriter bw = null;
        try {

            fos = new FileOutputStream(fileName, true);//这里的第二个参数代表追加还是覆盖,true为追加,flase为覆盖
            bw = new BufferedWriter(new OutputStreamWriter(fos));
            bw.write(log);

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (bw != null) {
                    bw.close();//关闭缓冲流
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

其实正确的做法应该是在开发过程中就养成良好的编码习惯和敏锐的嗅觉才对,能够使用各种设计模式编写出可维护、可扩展、可复用、灵活性好的程序、避免出现不必要的Bug,作为团队中的一员我们应该驾驭好自己的一亩三分地。
注:在我的前期博客中已经提供了几种常用的设计模式文章,能够对大家有所帮助。

Demo下载地址:
http://download.csdn.net/download/xinanheishao/9873151

相关文章推荐

Android自定义捕获Application全局异常

大家都知道,现在安装Android系统的手机版本和设备千差万别,在模拟器上运行良好的程序安装到某款手机上说不定就出现崩溃的现象,开发者个人不可能购买所有设备逐个调试,所以在程序发布出去之后,如果出现了...
  • jdsjlzx
  • jdsjlzx
  • 2012年05月27日 13:16
  • 44669

Android 全局异常捕获

今天就来说说作为程序猿的我们每天都会遇到的东西bug,出bug不可怕可怕的是没有出bug时的堆栈信息,那么对于bug的信息收集就显得尤为重要了,一般用第三方bugly或者友盟等等都能轻易收集,但是由于...

在Android中自定义捕获Application全局异常

现在安装 Android 系统的手机和设备千差万别,在模拟器上运行良好的程序安装到某款手机上说不定就出现崩溃的现象,开发者个人不可能购买所有设备逐个调试,所以在程序发布出去之后,如果出现了崩溃现象,开...

Android异常处理——UncaughtExceptionHandler捕获全局异常

Android系统的“程序异常退出”,给应用的用户体验造成不良影响。为了捕获应用运行时异常并给出友好提示,便可继承UncaughtExceptionHandler类来处理。通过Thread.setDe...

Android全局异常捕获,不退出应用,让应用正常运行下去!

Android全局异常捕获,不退出应用,让应用正常运行下去! 当App发现异常后,如果程序没有处理,将交给虚拟机进行处理,通常会弹出一个对话框,然后退出应用。但大多数的应用可能对后续流程影 响不大,...

Android应用全局异常处理

当我们做android客户端产品的时候为了让用户有更好的体验,我们需要拦截系统的异常弹出事件,并且将这些异常以比较“优雅”的方式反馈给用户,当然我们还要把这些异常提交到服务器上以便于程序员分析产生这些...
  • itachi85
  • itachi85
  • 2013年06月15日 16:57
  • 10274

详解Android全局异常的捕获处理

这篇文章主要为大家介绍了Android全局异常的捕获处理,为什么要进行捕获处理,如何进行捕获处理,想要了解的朋友可以参考一下 在Android开发中在所难免的会出现程序crash,俗称崩溃。用户的随...

Android全局异常捕获

在Android开发中在所难免的会出现程序crash,俗称崩溃。用户的随意性访问出现测试时未知的Bug导致我们的程序crash,此时我们是无法直接获取的错误log的,也就无法修复Bug。这就会极大的影...
  • lx_yoyo
  • lx_yoyo
  • 2016年08月29日 23:40
  • 304

Android全局异常捕获并弹窗提示

Android 难免有崩溃的时候,但是崩溃了该如何处理呢?虽然那天有位同仁说 “既然崩溃了,用户体验就差了,心里会想这是毛APP,下次也不想用了” ,所以检查BUG以防崩溃是必须的,但是也需要一个后备...
  • hx7013
  • hx7013
  • 2016年12月14日 09:36
  • 1544

详解Android全局异常的捕获处理

这篇文章主要为大家介绍了Android全局异常的捕获处理,为什么要进行捕获处理,如何进行捕获处理,想要了解的朋友可以参考一下 在Android开发中在所难免的会出现程序crash,俗...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Android全局异常捕获机制
举报原因:
原因补充:

(最多只允许输入30个字)