Android自定义数据库异步操作

平时我们在开发Android应用的时候，数据库操作是无法避免的，之前开发过程中，一直没太去在意在主线程中操作数据库，毕竟一般的数据库操作都在毫秒级的，但是考虑到极限的情况下，万一数据库要插入上万条数据呢，这样就会卡死主线程，导致应用使用不流畅，用户体验很差。
为了解决这个问题，我找了很多开源的数据库开源框架，比如OrmLite什么的，虽然这些框架都很好用，也很高大上，用了什么映射等等，Api也很简单，但是我觉得作为程序猿，一直使用别人写好的框架，语言也不是原生的数据库操作语言，那如果你用习惯之后，回头想想，你还会随便写出数据库的操作函数吗？
项目上正好有时间优化，我就去研究了一下异步数据库，我发现Google有一个AsyncQueryHandler这个类，主要用来查询系统级的数据，因为它需要确定的Uri，通过它，我写了一个关于本地数据库异步操作的类，可以给大家分享下。

import android.content.ContentValues;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Looper;
import android.os.Message;

import com.example.jianglei.asyncsqlite.Logger;

import java.util.List;


/** * 数据库异步框架 * Created by jianglei on 2016/4/6. */
public class AsyncHandler extends Handler {

    private static final String TAG = "MasAsyncQueryHandler";

    public static final long SUCCESS = 1;
    public static final long FAIL = -1;

    private static final int EVENT_ARG_SINGLE_INSERT = 0;
    private static final int EVENT_ARG_MULTI_INSERT = 1;
    private static final int EVENT_ARG_QUERY = 2;
    private static final int EVENT_ARG_UPDATE = 3;
    private static final int EVENT_ARG_DELETE = 4;
    private static final int EVENT_INIT_DATABASE = 5;

    private static Looper sLooper = null;

    private Handler mWorkerThreadHandler;

    private IAsyncHandlerCallback mIAsyncHandlerCallback;

    protected static class SqliteArgs {
        public SQLiteDatabase db;
        public String table;
        public Handler handler;
        public IAsyncHandlerCallback callback;
    }

    protected static final class InsertSingleArgs extends SqliteArgs {
        public String nullColumnHack;
        public ContentValues values;
        public long result;
    }

    protected static final class InsertMultiArgs extends SqliteArgs {
        public String nullColumnHack;
        public List<ContentValues> valuesList;
        public long result;
    }

    protected static final class QueryArgs extends SqliteArgs {
        public boolean distinct;
        public String[] columns;
        public String whereClause;
        public String[] whereArgs;
        public String groupBy;
        public String having;
        public String orderBy;
        public String limit;
        public Cursor result;
    }

    protected static final class UpdateArgs extends SqliteArgs {
        public ContentValues values;
        public String whereClause;
        public String[] whereArgs;
        public long result;
    }

    protected static final class DeleteArgs extends SqliteArgs {
        public String whereClause;
        public String[] whereArgs;
        public long result;
    }

    protected static final class InitArgs extends SqliteArgs {
        public DataBase dbOpenHelper;
        public SQLiteDatabase result;
    }

    public AsyncHandler() {
        super();
        synchronized (AsyncHandler.class) {
            if (sLooper == null) {
                HandlerThread thread = new HandlerThread(TAG);
                thread.start();
                sLooper = thread.getLooper();
            }
        }
        mWorkerThreadHandler = new WorkerHandler(sLooper);
    }

    /** * 初始化数据库 * * @param token 插入数据库标识 * @param dbOpenHelper 数据库 */
    public void initDataBase(int token, DataBase dbOpenHelper, IInitDatabaseCallback callback) {
        Message msg = mWorkerThreadHandler.obtainMessage(token);
        msg.arg1 = EVENT_INIT_DATABASE;

        InitArgs args = new InitArgs();
        args.handler = this;
        args.dbOpenHelper = dbOpenHelper;
        args.callback = callback;

        msg.obj = args;
        mWorkerThreadHandler.sendMessage(msg);
    }

    /** * 单条插入数据库 * * @param token 插入数据库标识 * @param db 数据库对象 * @param table 数据库表名 * @param nullColumnHack 当values为空时设置的空列数据 * @param values 插入数据库内容 */
    public void startSingleInsert(int token, SQLiteDatabase db, String table, String nullColumnHack, ContentValues values, ISingleInsertCallback callback) {
        Message msg = mWorkerThreadHandler.obtainMessage(token);
        msg.arg1 = EVENT_ARG_SINGLE_INSERT;

        InsertSingleArgs args = new InsertSingleArgs();
        args.handler = this;
        args.db = db;
        args.table = table;
        args.nullColumnHack = nullColumnHack;
        args.values = values;
        args.callback = callback;

        msg.obj = args;
        mWorkerThreadHandler.sendMessage(msg);
    }

    /** * 多条插入数据库 * * @param token 插入数据库标识 * @param db 数据库对象 * @param table 数据库表名 * @param nullColumnHack 当values为空时设置的空列数据 * @param valuesList 插入数据库内容 */
    public void startMultiInsert(int token, SQLiteDatabase db, String table, String nullColumnHack, List<ContentValues> valuesList, IMultiInsertCallback callback) {
        Message msg = mWorkerThreadHandler.obtainMessage(token);
        msg.arg1 = EVENT_ARG_MULTI_INSERT;

        InsertMultiArgs args = new InsertMultiArgs();
        args.handler = this;
        args.db = db;
        args.table = table;
        args.nullColumnHack = nullColumnHack;
        args.valuesList = valuesList;
        args.callback = callback;

        msg.obj = args;
        mWorkerThreadHandler.sendMessage(msg);
    }

    /** * 查询数据库 * * @param token 插入数据库标识 * @param db 数据库对象 * @param table 数据库表名 * @param distinct 是否去除重复项 * @param columns 查询的列数组 * @param whereClause 条件 * @param whereArgs 条件参数数组 * @param groupBy 分组依据 * @param having 过滤 * @param orderBy 排序 * @param limit 限制条数 */
    public void startQuery(int token, SQLiteDatabase db, boolean distinct, String table, String[] columns, String whereClause, String[] whereArgs,
                           String groupBy, String having, String orderBy, String limit, IQueryCallback callback) {
        Message msg = mWorkerThreadHandler.obtainMessage(token);
        msg.arg1 = EVENT_ARG_QUERY;

        QueryArgs args = new QueryArgs();
        args.handler = this;
        args.db = db;
        args.distinct = distinct;
        args.table = table;
        args.columns = columns;
        args.whereClause = whereClause;
        args.whereArgs = whereArgs;
        args.groupBy = groupBy;
        args.having = having;
        args.orderBy = orderBy;
        args.limit = limit;
        args.callback = callback;

        msg.obj = args;
        mWorkerThreadHandler.sendMessage(msg);
    }

    /** * 更新数据库 * * @param token 插入数据库标识 * @param db 数据库对象 * @param table 数据库表名 * @param values 更新的内容 * @param whereClause 条件 * @param whereArgs 条件参数数组 */
    public void startUpdate(int token, SQLiteDatabase db, String table, ContentValues values, String whereClause, String[] whereArgs, IUpdateCallback callback) {
        Message msg = mWorkerThreadHandler.obtainMessage(token);
        msg.arg1 = EVENT_ARG_UPDATE;

        UpdateArgs args = new UpdateArgs();
        args.handler = this;
        args.db = db;
        args.table = table;
        args.values = values;
        args.whereClause = whereClause;
        args.whereArgs = whereArgs;
        args.callback = callback;

        msg.obj = args;
        mWorkerThreadHandler.sendMessage(msg);
    }

    /** * 删除数据库某条 * * @param token 插入数据库标识 * @param db 数据库对象 * @param table 数据库表名 * @param whereClause 条件 * @param whereArgs 条件参数数组 */
    public void startDelete(int token, SQLiteDatabase db, String table, String whereClause, String[] whereArgs, IDeleteCallback callback) {
        Message msg = mWorkerThreadHandler.obtainMessage(token);
        msg.arg1 = EVENT_ARG_DELETE;

        DeleteArgs args = new DeleteArgs();
        args.handler = this;
        args.db = db;
        args.table = table;
        args.whereClause = whereClause;
        args.whereArgs = whereArgs;
        args.callback = callback;

        msg.obj = args;
        mWorkerThreadHandler.sendMessage(msg);
    }

    /** * 数据库处理 */
    protected class WorkerHandler extends Handler {
        public WorkerHandler(Looper looper) {
            super(looper);
        }

        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            int token = msg.what;
            int event = msg.arg1;

            InsertSingleArgs insertSingleArgs;
            InsertMultiArgs insertMultiArgs;
            QueryArgs queryArgs;
            UpdateArgs updateArgs;
            DeleteArgs deleteArgs;
            InitArgs initArgs;

            Message reply;
            switch (event) {
                case EVENT_ARG_SINGLE_INSERT:
                    insertSingleArgs = (InsertSingleArgs) msg.obj;
                    insertSingleArgs.result = insertSingleArgs.db.insertOrThrow(insertSingleArgs.table,
                            insertSingleArgs.nullColumnHack, insertSingleArgs.values);
                    if ((int) insertSingleArgs.result == -1) {
                        Logger.e(TAG + " ---->> insert single args failed!");
                        insertSingleArgs.result = FAIL;
                    } else {
                        insertSingleArgs.result = SUCCESS;
                    }
                    reply = insertSingleArgs.handler.obtainMessage(token);
                    reply.obj = insertSingleArgs;
                    break;
                case EVENT_ARG_MULTI_INSERT:
                    insertMultiArgs = (InsertMultiArgs) msg.obj;
                    insertMultiArgs.db.beginTransaction();
                    for (ContentValues values : insertMultiArgs.valuesList) {
                        insertMultiArgs.result = insertMultiArgs.db.insertOrThrow(insertMultiArgs.table,
                                insertMultiArgs.nullColumnHack, values);
                        if ((int) insertMultiArgs.result == -1) {
                            Logger.e(TAG + " ---->> insert multi args failed!");
                            insertMultiArgs.result = FAIL;
                            break;
                        } else {
                            insertMultiArgs.result = SUCCESS;
                        }
                    }
                    insertMultiArgs.db.setTransactionSuccessful();
                    insertMultiArgs.db.endTransaction();
                    reply = insertMultiArgs.handler.obtainMessage(token);
                    reply.obj = insertMultiArgs;
                    break;
                case EVENT_ARG_QUERY:
                    queryArgs = (QueryArgs) msg.obj;
                    Cursor cursor;
                    try {
                        cursor = queryArgs.db.query(queryArgs.distinct, queryArgs.table,
                                queryArgs.columns, queryArgs.whereClause, queryArgs.whereArgs,
                                queryArgs.groupBy, queryArgs.having, queryArgs.orderBy, queryArgs.limit);
                        // 调用这个方法会使得主线程小小的加速，此处先遍历cursor，之后在主线程中去遍历取值时会加速，好像是这样的
                        if (cursor != null) {
                            cursor.getCount();
                        }
                    } catch (Exception e) {
                        Logger.e(TAG + " ---->> Exception thrown during handling EVENT_ARG_QUERY", e);
                        cursor = null;
                    }
                    queryArgs.result = cursor;
                    reply = queryArgs.handler.obtainMessage(token);
                    reply.obj = queryArgs;
                    break;
                case EVENT_ARG_UPDATE:
                    updateArgs = (UpdateArgs) msg.obj;
                    updateArgs.result = updateArgs.db.update(updateArgs.table, updateArgs.values, updateArgs.whereClause, updateArgs.whereArgs);
                    if ((int) updateArgs.result <= 0) {
                        Logger.e(TAG + " ---->> update args failed!");
                        updateArgs.result = FAIL;
                    } else {
                        updateArgs.result = SUCCESS;
                    }
                    reply = updateArgs.handler.obtainMessage(token);
                    reply.obj = updateArgs;
                    break;
                case EVENT_ARG_DELETE:
                    deleteArgs = (DeleteArgs) msg.obj;
                    deleteArgs.result = deleteArgs.db.delete(deleteArgs.table, deleteArgs.whereClause, deleteArgs.whereArgs);
                    if ((int) deleteArgs.result <= 0) {
                        Logger.e(TAG + " ---->> delete args failed!");
                        deleteArgs.result = FAIL;
                    } else {
                        deleteArgs.result = SUCCESS;
                    }
                    reply = deleteArgs.handler.obtainMessage(token);
                    reply.obj = deleteArgs;
                    break;
                case EVENT_INIT_DATABASE:
                    initArgs = (InitArgs) msg.obj;
                    initArgs.result = initArgs.dbOpenHelper.getWritableDatabase();
                    reply = initArgs.handler.obtainMessage(token);
                    reply.obj = initArgs;
                    break;
                default:
                    return;
            }
            reply.arg1 = msg.arg1;
            reply.sendToTarget();
        }
    }

    /** * 数据库处理结果回调 */
    @Override
    public void handleMessage(Message msg) {
        super.handleMessage(msg);
        int token = msg.what;
        int event = msg.arg1;

        switch (event) {
            case EVENT_ARG_SINGLE_INSERT:
                InsertSingleArgs insertSingleArgs = (InsertSingleArgs) msg.obj;
                if (insertSingleArgs.callback != null) {
                    if (insertSingleArgs.result == SUCCESS) {
                        ((ISingleInsertCallback) insertSingleArgs.callback).onSingleInsertComplete(token, insertSingleArgs.result);
                    } else {
                        insertSingleArgs.callback.onAsyncOperateFailed();
                    }
                }
                break;
            case EVENT_ARG_MULTI_INSERT:
                InsertMultiArgs insertMultiArgs = (InsertMultiArgs) msg.obj;
                if (insertMultiArgs.callback != null) {
                    if (insertMultiArgs.result ==SUCCESS) {
                        ((IMultiInsertCallback) insertMultiArgs.callback).onMultiInsertComplete(token, insertMultiArgs.result);
                    } else {
                        insertMultiArgs.callback.onAsyncOperateFailed();
                    }
                }
                break;
            case EVENT_ARG_QUERY:
                QueryArgs queryArgs = (QueryArgs) msg.obj;
                if (queryArgs.callback != null) {
                    if (queryArgs.result != null) {
                        ((IQueryCallback) queryArgs.callback).onQueryComplete(token, queryArgs.result);
                    } else {
                        queryArgs.callback.onAsyncOperateFailed();
                    }
                }
                break;
            case EVENT_ARG_UPDATE:
                UpdateArgs updateArgs = (UpdateArgs) msg.obj;
                if (updateArgs.callback != null) {
                    if (updateArgs.result == SUCCESS) {
                        ((IUpdateCallback) updateArgs.callback).onUpdateComplete(token, updateArgs.result);
                    } else {
                        updateArgs.callback.onAsyncOperateFailed();
                    }
                }
                break;
            case EVENT_ARG_DELETE:
                DeleteArgs deleteArgs = (DeleteArgs) msg.obj;
                if (deleteArgs.callback != null) {
                    if (deleteArgs.result == SUCCESS) {
                        ((IDeleteCallback) deleteArgs.callback).onDeleteComplete(token, deleteArgs.result);
                    } else {
                        deleteArgs.callback.onAsyncOperateFailed();
                    }
                }
                break;
            case EVENT_INIT_DATABASE:
                InitArgs initArgs = (InitArgs) msg.obj;
                if (initArgs.callback != null) {
                    if (initArgs.result != null) {
                        ((IInitDatabaseCallback) initArgs.callback).onInitDatabaseComplete(token, initArgs.result);
                    } else {
                        initArgs.callback.onAsyncOperateFailed();
                    }
                }
                break;
            default:
                return;
        }
    }
}

如上，即为主要的异步类，主要是先通过一个Handler去操作数据库，然后用另一个Handler去回调给调用者，注意其中的Looper不是主线程的消息队列，下面是异步操作的回调，用于通知发起数据库操作的地方这次数据库操作的结果：

/** * 数据库异步操作结果回调基类 * Created by jianglei on 2016/4/6. */
public interface IAsyncHandlerCallback {

    void onAsyncOperateFailed();

}

public interface IInitDatabaseCallback extends IAsyncHandlerCallback {

    /** * 初始化成功 */
    void onInitDatabaseComplete(int token, SQLiteDatabase db);
}

public interface ISingleInsertCallback extends IAsyncHandlerCallback {
    /** * 单条插入成功 */
    void onSingleInsertComplete(int token, long result);
}

public interface IMultiInsertCallback extends IAsyncHandlerCallback {

    /** * 多条插入成功 */
    void onMultiInsertComplete(int token, long result);
}

public interface IQueryCallback extends IAsyncHandlerCallback{

    /** * 查询成功 */
    void onQueryComplete(int token, Cursor cursor);
}

public interface IUpdateCallback extends IAsyncHandlerCallback {

    /** * 更新成功 */
    void onUpdateComplete(int token, long result);
}

public interface IDeleteCallback extends IAsyncHandlerCallback {

    /** * 删除成功 */
    void onDeleteComplete(int token, long result);
}

使用也是很简单的，在项目上，在自定义的DataBaseOpenHelper中初始化的时候初始化一下，然后实现下上面的接口，就可以通过这个DataBaseOpenHelper区调用方法异步操作数据库，这样就不会影响主线程的操作，大家可以使用StrictMode去检测下。

下面是我自定义的异步数据库操作，欢迎大家看看和提出问题：https://github.com/jianglei199212/AsyncSqlite