android sqlite数据库使用

最新推荐文章于 2024-09-14 15:37:53 发布
最新推荐文章于 2024-09-14 15:37:53 发布
阅读量597 收藏
点赞数
分类专栏： android 文章标签： 数据库 sqlite
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bsmmaoshenbo/article/details/61192393
版权

我这里只是贴代码，不做详细讲解，demo展示

1、DBHelper类，WeiXinDBManager

package com.yueniu.addcustomers.data.local;

import android.content.ContentValues;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.util.Log;

import com.yueniu.addcustomers.bean.MessageInfo;
import com.yueniu.addcustomers.bean.RcontactInfo;
import com.yueniu.addcustomers.bean.SubmitSourceInfo;
import com.yueniu.addcustomers.util.LogUtil;
import com.yueniu.addcustomers.util.WriteLogToSD;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * Date: 2015/1/6.
 */
public class WeiXinDBManager {
    private static final String TAG = "WeiXinDBManager";
    private AtomicInteger mOpenCounter = new AtomicInteger();
    private static WeiXinDBManager instance;
    private static WeixinDBHelper weixinDBHelper;
    private SQLiteDatabase mDatabase;

    private final String limit = "50";
    // 列定义
    private final String[] MESSAGE_COLUMNS = new String[]{"chat_type", "content", "chat_from", "chat_to", "datetime",
                                                        "initwechatfriend_number", "imgpath", "issend","wechat_number",
                                                        "msgSvrId","talkerId"};

    private final String[] RCONTACT = new String[]{"buddyname", "buddyphotourl", "imgid", "wxname","province","city",
                                                    "pyInitial","sex","pyQuanPin","iskeepUser","lastchattime",
                                                    "wechatfriend_number","initwechatfriend_number","show_head"};

    private final String[] ERRORSUBMITSOURCE = new String[]{"logid", "source"};

    private static synchronized void initializeInstance(WeixinDBHelper helper) {
        if (instance == null) {
            instance = new WeiXinDBManager();
            weixinDBHelper = helper;
        }
    }

    public static synchronized WeiXinDBManager getInstance(WeixinDBHelper helper) {
        if (instance == null) {
            initializeInstance(helper);
        }
        return instance;
    }

    private synchronized SQLiteDatabase getWritableDatabase() {
        if (mOpenCounter.incrementAndGet() == 1) {
            mDatabase = weixinDBHelper.getWritableDatabase();
        }
        return mDatabase;
    }

    private synchronized SQLiteDatabase getReadableDatabase() {
        if (mOpenCounter.incrementAndGet() == 1) {
            mDatabase = weixinDBHelper.getReadableDatabase();
        }
        return mDatabase;
    }

    private synchronized void closeDatabase() {
        if (mOpenCounter.decrementAndGet() == 0) {
            mDatabase.close();
        }
    }

    // 判断聊天记录里面是否存在信息
    public boolean isDataExistMessage() {
        int count = 0;
        Cursor cursor = null;
        try {
            mDatabase = getReadableDatabase();
            cursor = mDatabase.query(WeixinDBHelper.TABLE_NAME_MESSAGE, new String[]{"COUNT('X')"}, null, null, null, null, null);
            if (cursor.moveToFirst()) {
                count = cursor.getInt(0);
            }
            if (count > 0) return true;
        } catch (Exception e) {
            LogUtil.d(TAG, "isDataExistMessage open db error");
            WriteLogToSD.SaveToSDcard(TAG, "isDataExistMessage失败："+e.toString());
        } finally {
            if (cursor != null) {
                cursor.close();
            }
            if (mDatabase != null) {
                closeDatabase();
            }
        }

        return false;
    }

    /**
     * 插入数据库聊天记录
     *
     * @param messageInfos
     */
    public void insertMessage(List<MessageInfo> messageInfos) {

        if (messageInfos == null) {
            return;
        }
        try {
            mDatabase = getWritableDatabase();
            mDatabase.beginTransaction();

            int count = messageInfos.size();

            for (int i = 0; i < count; i++) {
                MessageInfo messageInfo = messageInfos.get(i);

                ContentValues contentValues = new ContentValues();
                contentValues.put("chat_type", messageInfo.getChat_type());
                contentValues.put("content", messageInfo.getContent());
                contentValues.put("chat_from", messageInfo.getChat_from());
                contentValues.put("chat_to", messageInfo.getChat_to());
                contentValues.put("datetime", messageInfo.getDatetime());
                contentValues.put("initwechatfriend_number", messageInfo.getInitwechatfriend_number());
                contentValues.put("imgpath", messageInfo.getImgpath());
                contentValues.put("issend", messageInfo.getIssend());
                contentValues.put("wechat_number",messageInfo.getWechat_number());
                contentValues.put("msgSvrId",messageInfo.getMsgSvrId());
                contentValues.put("talkerId",messageInfo.getTalkerId());
                mDatabase.insertOrThrow(WeixinDBHelper.TABLE_NAME_MESSAGE, null, contentValues);
            }
            mDatabase.setTransactionSuccessful();
            Log.e(TAG, "insertMessage:" + messageInfos.size());
        } catch (Exception e) {
            Log.e(TAG, "", e);
            WriteLogToSD.SaveToSDcard(TAG, "insertMessage失败:"+e.toString());
        } finally {
            if (mDatabase != null) {
                mDatabase.endTransaction();
                closeDatabase();
            }
        }
    }

    /**
     * 删除已上传的聊天记录
     *
     * @param messageInfos
     * @return
     */
    public boolean deleteMessage(List<MessageInfo> messageInfos) {
        if (messageInfos==null)
            return true;
        try {
            mDatabase = getWritableDatabase();
            mDatabase.beginTransaction();

            int count = messageInfos.size();
            for (int i = 0; i < count; i++) {
                MessageInfo messageInfo = messageInfos.get(i);
                mDatabase.delete(WeixinDBHelper.TABLE_NAME_MESSAGE, "datetime = ? and content= ?", new String[]{messageInfo.getDatetime(),messageInfo.getContent()});
            }
            mDatabase.setTransactionSuccessful();
            Log.e(TAG, "deleteMessage:" + messageInfos.size());
            return true;
        } catch (Exception e) {
            Log.e(TAG, "", e);
            WriteLogToSD.SaveToSDcard(TAG, "deleteMessage失败:"+e.toString());
        } finally {
            if (mDatabase != null) {
                mDatabase.endTransaction();
                closeDatabase();
            }
        }
        return false;
    }

    /**
     * 查询聊天记录
     *
     * @return
     */
    public List<MessageInfo> selectMessage(String wechat_number) {
        Cursor cursor = null;

        try {
            mDatabase = getReadableDatabase();
            cursor = mDatabase.query(WeixinDBHelper.TABLE_NAME_MESSAGE, MESSAGE_COLUMNS,
                    "wechat_number=? limit ?",
                    new String[]{wechat_number,limit},
                    null, null, null);

            if (cursor.getCount() > 0) {
                List<MessageInfo> messageInfos = new ArrayList<MessageInfo>(cursor.getCount());
                while (cursor.moveToNext()) {
                    MessageInfo messageInfo = parseMessageInfo(cursor);
                    messageInfos.add(messageInfo);
                }

                Log.e(TAG, "select:" + messageInfos.size());
                return messageInfos;
            }
        } catch (Exception e) {
            Log.e(TAG, "open fail", e);
            WriteLogToSD.SaveToSDcard(TAG, "selectMessage失败:"+e.toString());
        } finally {
            if (cursor != null) {
                cursor.close();
            }
            if (mDatabase != null) {
                closeDatabase();
            }
        }
        return null;
    }

    /**
     * 将查找到的数据转换成MessageInfo类
     */
    private MessageInfo parseMessageInfo(Cursor cursor) {
        MessageInfo messageInfo = new MessageInfo();
        messageInfo.setChat_type(cursor.getString(cursor.getColumnIndex("chat_type")));
        messageInfo.setContent(cursor.getString(cursor.getColumnIndex("content")));
        messageInfo.setChat_from(cursor.getString(cursor.getColumnIndex("chat_from")));
        messageInfo.setChat_to(cursor.getString(cursor.getColumnIndex("chat_to")));
        messageInfo.setDatetime(cursor.getString(cursor.getColumnIndex("datetime")));
        messageInfo.setInitwechatfriend_number(cursor.getString(cursor.getColumnIndex("initwechatfriend_number")));
        messageInfo.setImgpath(cursor.getString(cursor.getColumnIndex("imgpath")));
        messageInfo.setIssend(cursor.getString(cursor.getColumnIndex("issend")));
        messageInfo.setWechat_number(cursor.getString(cursor.getColumnIndex("wechat_number")));
        messageInfo.setMsgSvrId(cursor.getString(cursor.getColumnIndex("msgSvrId")));
        messageInfo.setTalkerId(cursor.getString(cursor.getColumnIndex("talkerId")));
        return messageInfo;
    }

    // 判断聊天联系人里面是否存在信息
    public boolean isDataExistContact() {
        int count = 0;
        Cursor cursor = null;
        try {
            mDatabase = getReadableDatabase();
            cursor = mDatabase.query(WeixinDBHelper.TABLE_NAME_Contact, new String[]{"COUNT('X')"}, null, null, null, null, null);
            if (cursor.moveToFirst()) {
                count = cursor.getInt(0);
            }
            if (count > 0) return true;
        } catch (Exception e) {
            LogUtil.d(TAG, "isDataExistContact open db error");
            WriteLogToSD.SaveToSDcard(TAG, "isDataExistContact失败:"+e.toString());
        } finally {
            if (cursor != null) {
                cursor.close();
            }
            if (mDatabase != null) {
                closeDatabase();
            }
        }
        return false;
    }

    /**
     * 插入数据库聊天记录
     *
     * @param rcontactInfos
     */
    public void insertRcontactInfo(List<RcontactInfo> rcontactInfos) {

        if (rcontactInfos == null) {
            return;
        }

        try {
            mDatabase = getWritableDatabase();
            mDatabase.beginTransaction();
            int count = rcontactInfos.size();
            for (int i = 0; i < count; i++) {
                RcontactInfo rcontactInfo = rcontactInfos.get(i);

                ContentValues contentValues = new ContentValues();
                contentValues.put("buddyname", rcontactInfo.getBuddyname());
                contentValues.put("buddyphotourl", rcontactInfo.getBuddyphotourl());
                contentValues.put("imgid", rcontactInfo.getImgid());
                contentValues.put("wxname", rcontactInfo.getWxname());
                contentValues.put("province", rcontactInfo.getProvince());
                contentValues.put("city", rcontactInfo.getCity());
                contentValues.put("pyInitial", rcontactInfo.getPyInitial());
                contentValues.put("sex", rcontactInfo.getSex());
                contentValues.put("pyQuanPin", rcontactInfo.getPyQuanPin());
                contentValues.put("iskeepUser", rcontactInfo.getIskeepUser());
                contentValues.put("lastchattime", rcontactInfo.getLastchattime());
                contentValues.put("wechatfriend_number", rcontactInfo.getWechatfriend_number());
                contentValues.put("initwechatfriend_number", rcontactInfo.getInitwechatfriend_number());
                contentValues.put("show_head", rcontactInfo.getShow_head());
                mDatabase.insertOrThrow(WeixinDBHelper.TABLE_NAME_Contact, null, contentValues);
            }
            mDatabase.setTransactionSuccessful();
            Log.e(TAG, "insertuserInfo:" + rcontactInfos.size());
        } catch (Exception e) {
            Log.e(TAG, "", e);
            WriteLogToSD.SaveToSDcard(TAG, "insertRcontactInfo失败:"+e.toString());
        } finally {
            if (mDatabase != null) {
                mDatabase.endTransaction();
                closeDatabase();
            }
        }
    }

    /**
     * 删除已上传的联系人
     *
     * @param rcontactInfos
     * @return
     */
    public boolean deleteRcontactInfos(List<RcontactInfo> rcontactInfos) {
        try {
            mDatabase = getWritableDatabase();
            mDatabase.beginTransaction();

            mDatabase.delete(WeixinDBHelper.TABLE_NAME_Contact, "", new String[]{});

            mDatabase.setTransactionSuccessful();
            Log.e(TAG, "deleteuserInfo:" + rcontactInfos.size());
            return true;
        } catch (Exception e) {
            Log.e(TAG, "", e);
            WriteLogToSD.SaveToSDcard(TAG, "deleteRcontactInfos失败:"+e.toString());
        } finally {
            if (mDatabase != null) {
                mDatabase.endTransaction();
                closeDatabase();
            }
        }
        return false;
    }


    /**
     * 查询聊天记录
     *
     * @return
     */
    public List<RcontactInfo> selectRcontactInfo() {
        Cursor cursor = null;

        try {
            mDatabase = getReadableDatabase();
            cursor = mDatabase.query(WeixinDBHelper.TABLE_NAME_Contact, RCONTACT,
                    "1==1 limit ?",
                    new String[]{limit},
                    null, null, null);

            if (cursor.getCount() > 0) {
                List<RcontactInfo> userInfos = new ArrayList<RcontactInfo>(cursor.getCount());
                while (cursor.moveToNext()) {
                    RcontactInfo userInfo = parseRcontactInfo(cursor);
                    userInfos.add(userInfo);
                }

                Log.e(TAG, "selectuserInfos:" + userInfos.size());
                return userInfos;
            }
        } catch (Exception e) {
            Log.e(TAG, "open fail", e);
            WriteLogToSD.SaveToSDcard(TAG, "selectRcontactInfo失败:"+e.toString());
        } finally {
            if (cursor != null) {
                cursor.close();
            }
            if (mDatabase != null) {
                closeDatabase();
            }
        }
        return null;
    }

    /**
     * 将查找到的数据转换成RcontactInfo类
     */
    private RcontactInfo parseRcontactInfo(Cursor cursor) {
        RcontactInfo userInfo = new RcontactInfo();

        userInfo.setBuddyname(cursor.getString(cursor.getColumnIndex("buddyname")));
        userInfo.setBuddyphotourl(cursor.getString(cursor.getColumnIndex("buddyphotourl")));
        userInfo.setImgid(cursor.getString(cursor.getColumnIndex("imgid")));
        userInfo.setWxname(cursor.getString(cursor.getColumnIndex("wxname")));
        userInfo.setProvince(cursor.getString(cursor.getColumnIndex("province")));
        userInfo.setCity(cursor.getString(cursor.getColumnIndex("city")));
        userInfo.setPyInitial(cursor.getString(cursor.getColumnIndex("pyInitial")));
        userInfo.setSex(cursor.getString(cursor.getColumnIndex("sex")));
        userInfo.setPyQuanPin(cursor.getString(cursor.getColumnIndex("pyQuanPin")));
        userInfo.setIskeepUser(cursor.getString(cursor.getColumnIndex("iskeepUser")));
        userInfo.setLastchattime(cursor.getString(cursor.getColumnIndex("lastchattime")));
        userInfo.setWechatfriend_number(cursor.getString(cursor.getColumnIndex("wechatfriend_number")));
        userInfo.setInitwechatfriend_number(cursor.getString(cursor.getColumnIndex("initwechatfriend_number")));
        userInfo.setShow_head(cursor.getString(cursor.getColumnIndex("show_head")));

        return userInfo;
    }

    /**
     * 插入一条上传错误信息
     * @param sourceInfo
     */
    public void insertErrorSubmitSource(SubmitSourceInfo sourceInfo){
        if (sourceInfo == null) {
            return;
        }
        try {
            mDatabase = getWritableDatabase();
            mDatabase.beginTransaction();

            ContentValues contentValues = new ContentValues();
            contentValues.put("logid", sourceInfo.getLogid());
            contentValues.put("source", sourceInfo.getSource());
            mDatabase.insertOrThrow(WeixinDBHelper.TABLE_NAME_ErrorSubmitSource, null, contentValues);
            mDatabase.setTransactionSuccessful();
        } catch (Exception e) {
            Log.e(TAG, "", e);
            WriteLogToSD.SaveToSDcard(TAG, "insertErrorSubmitSource失败:"+e.toString());
        } finally {
            if (mDatabase != null) {
                mDatabase.endTransaction();
                closeDatabase();
            }
        }
    }

    /**
     * 查询错误上传的信息
     */
    public SubmitSourceInfo selectErrorSubmitSource(){
        Cursor cursor = null;
        try {
            mDatabase = getReadableDatabase();
            cursor = mDatabase.query(WeixinDBHelper.TABLE_NAME_ErrorSubmitSource, ERRORSUBMITSOURCE,
                    "1==1 limit ?",
                    new String[]{"1"},
                    null, null, null);

            if (cursor.getCount() > 0) {
                SubmitSourceInfo sourceInfo = new SubmitSourceInfo();
                while (cursor.moveToNext()) {
                    sourceInfo.setLogid(cursor.getString(cursor.getColumnIndex("logid")));
                    sourceInfo.setSource(cursor.getString(cursor.getColumnIndex("source")));
                }
                return sourceInfo;
            }
        } catch (Exception e) {
            Log.e(TAG, "open fail", e);
            WriteLogToSD.SaveToSDcard(TAG, "selectErrorSubmitSource失败:"+e.toString());
        } finally {
            if (cursor != null) {
                cursor.close();
            }
            if (mDatabase != null) {
                closeDatabase();
            }
        }
        return null;
    }

    /**
     * 删除上传成功的数据
     * @param sourceInfo
     * @return
     */
    public boolean deleteErrorSubmitSource(SubmitSourceInfo sourceInfo){
        if (sourceInfo==null)
            return true;
        try {
            mDatabase = getWritableDatabase();
            mDatabase.beginTransaction();

            mDatabase.delete(WeixinDBHelper.TABLE_NAME_ErrorSubmitSource, "logid = ?", new String[]{sourceInfo.getLogid()});
            mDatabase.setTransactionSuccessful();
            return true;
        } catch (Exception e) {
            Log.e(TAG, "", e);
            WriteLogToSD.SaveToSDcard(TAG, "deleteErrorSubmitSource失败:"+e.toString());
        } finally {
            if (mDatabase != null) {
                mDatabase.endTransaction();
                closeDatabase();
            }
        }
        return false;
    }
}

2、数据库操作类  WeiXinDBManager 

package com.yueniu.addcustomers.data.local;

import android.content.ContentValues;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.util.Log;

import com.yueniu.addcustomers.bean.MessageInfo;
import com.yueniu.addcustomers.bean.RcontactInfo;
import com.yueniu.addcustomers.bean.SubmitSourceInfo;
import com.yueniu.addcustomers.util.LogUtil;
import com.yueniu.addcustomers.util.WriteLogToSD;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * Date: 2015/1/6.
 */
public class WeiXinDBManager {
    private static final String TAG = "WeiXinDBManager";
    private AtomicInteger mOpenCounter = new AtomicInteger();
    private static WeiXinDBManager instance;
    private static WeixinDBHelper weixinDBHelper;
    private SQLiteDatabase mDatabase;

    private final String limit = "50";
    // 列定义
    private final String[] MESSAGE_COLUMNS = new String[]{"chat_type", "content", "chat_from", "chat_to", "datetime",
                                                        "initwechatfriend_number", "imgpath", "issend","wechat_number",
                                                        "msgSvrId","talkerId"};

    private final String[] RCONTACT = new String[]{"buddyname", "buddyphotourl", "imgid", "wxname","province","city",
                                                    "pyInitial","sex","pyQuanPin","iskeepUser","lastchattime",
                                                    "wechatfriend_number","initwechatfriend_number","show_head"};

    private final String[] ERRORSUBMITSOURCE = new String[]{"logid", "source"};

    private static synchronized void initializeInstance(WeixinDBHelper helper) {
        if (instance == null) {
            instance = new WeiXinDBManager();
            weixinDBHelper = helper;
        }
    }

    public static synchronized WeiXinDBManager getInstance(WeixinDBHelper helper) {
        if (instance == null) {
            initializeInstance(helper);
        }
        return instance;
    }

    private synchronized SQLiteDatabase getWritableDatabase() {
        if (mOpenCounter.incrementAndGet() == 1) {
            mDatabase = weixinDBHelper.getWritableDatabase();
        }
        return mDatabase;
    }

    private synchronized SQLiteDatabase getReadableDatabase() {
        if (mOpenCounter.incrementAndGet() == 1) {
            mDatabase = weixinDBHelper.getReadableDatabase();
        }
        return mDatabase;
    }

    private synchronized void closeDatabase() {
        if (mOpenCounter.decrementAndGet() == 0) {
            mDatabase.close();
        }
    }

    // 判断聊天记录里面是否存在信息
    public boolean isDataExistMessage() {
        int count = 0;
        Cursor cursor = null;
        try {
            mDatabase = getReadableDatabase();
            cursor = mDatabase.query(WeixinDBHelper.TABLE_NAME_MESSAGE, new String[]{"COUNT('X')"}, null, null, null, null, null);
            if (cursor.moveToFirst()) {
                count = cursor.getInt(0);
            }
            if (count > 0) return true;
        } catch (Exception e) {
            LogUtil.d(TAG, "isDataExistMessage open db error");
            WriteLogToSD.SaveToSDcard(TAG, "isDataExistMessage失败："+e.toString());
        } finally {
            if (cursor != null) {
                cursor.close();
            }
            if (mDatabase != null) {
                closeDatabase();
            }
        }

        return false;
    }

    /**
     * 插入数据库聊天记录
     *
     * @param messageInfos
     */
    public void insertMessage(List<MessageInfo> messageInfos) {

        if (messageInfos == null) {
            return;
        }
        try {
            mDatabase = getWritableDatabase();
            mDatabase.beginTransaction();

            int count = messageInfos.size();

            for (int i = 0; i < count; i++) {
                MessageInfo messageInfo = messageInfos.get(i);

                ContentValues contentValues = new ContentValues();
                contentValues.put("chat_type", messageInfo.getChat_type());
                contentValues.put("content", messageInfo.getContent());
                contentValues.put("chat_from", messageInfo.getChat_from());
                contentValues.put("chat_to", messageInfo.getChat_to());
                contentValues.put("datetime", messageInfo.getDatetime());
                contentValues.put("initwechatfriend_number", messageInfo.getInitwechatfriend_number());
                contentValues.put("imgpath", messageInfo.getImgpath());
                contentValues.put("issend", messageInfo.getIssend());
                contentValues.put("wechat_number",messageInfo.getWechat_number());
                contentValues.put("msgSvrId",messageInfo.getMsgSvrId());
                contentValues.put("talkerId",messageInfo.getTalkerId());
                mDatabase.insertOrThrow(WeixinDBHelper.TABLE_NAME_MESSAGE, null, contentValues);
            }
            mDatabase.setTransactionSuccessful();
            Log.e(TAG, "insertMessage:" + messageInfos.size());
        } catch (Exception e) {
            Log.e(TAG, "", e);
            WriteLogToSD.SaveToSDcard(TAG, "insertMessage失败:"+e.toString());
        } finally {
            if (mDatabase != null) {
                mDatabase.endTransaction();
                closeDatabase();
            }
        }
    }

    /**
     * 删除已上传的聊天记录
     *
     * @param messageInfos
     * @return
     */
    public boolean deleteMessage(List<MessageInfo> messageInfos) {
        if (messageInfos==null)
            return true;
        try {
            mDatabase = getWritableDatabase();
            mDatabase.beginTransaction();

            int count = messageInfos.size();
            for (int i = 0; i < count; i++) {
                MessageInfo messageInfo = messageInfos.get(i);
                mDatabase.delete(WeixinDBHelper.TABLE_NAME_MESSAGE, "datetime = ? and content= ?", new String[]{messageInfo.getDatetime(),messageInfo.getContent()});
            }
            mDatabase.setTransactionSuccessful();
            Log.e(TAG, "deleteMessage:" + messageInfos.size());
            return true;
        } catch (Exception e) {
            Log.e(TAG, "", e);
            WriteLogToSD.SaveToSDcard(TAG, "deleteMessage失败:"+e.toString());
        } finally {
            if (mDatabase != null) {
                mDatabase.endTransaction();
                closeDatabase();
            }
        }
        return false;
    }

    /**
     * 查询聊天记录
     *
     * @return
     */
    public List<MessageInfo> selectMessage(String wechat_number) {
        Cursor cursor = null;

        try {
            mDatabase = getReadableDatabase();
            cursor = mDatabase.query(WeixinDBHelper.TABLE_NAME_MESSAGE, MESSAGE_COLUMNS,
                    "wechat_number=? limit ?",
                    new String[]{wechat_number,limit},
                    null, null, null);

            if (cursor.getCount() > 0) {
                List<MessageInfo> messageInfos = new ArrayList<MessageInfo>(cursor.getCount());
                while (cursor.moveToNext()) {
                    MessageInfo messageInfo = parseMessageInfo(cursor);
                    messageInfos.add(messageInfo);
                }

                Log.e(TAG, "select:" + messageInfos.size());
                return messageInfos;
            }
        } catch (Exception e) {
            Log.e(TAG, "open fail", e);
            WriteLogToSD.SaveToSDcard(TAG, "selectMessage失败:"+e.toString());
        } finally {
            if (cursor != null) {
                cursor.close();
            }
            if (mDatabase != null) {
                closeDatabase();
            }
        }
        return null;
    }

    /**
     * 将查找到的数据转换成MessageInfo类
     */
    private MessageInfo parseMessageInfo(Cursor cursor) {
        MessageInfo messageInfo = new MessageInfo();
        messageInfo.setChat_type(cursor.getString(cursor.getColumnIndex("chat_type")));
        messageInfo.setContent(cursor.getString(cursor.getColumnIndex("content")));
        messageInfo.setChat_from(cursor.getString(cursor.getColumnIndex("chat_from")));
        messageInfo.setChat_to(cursor.getString(cursor.getColumnIndex("chat_to")));
        messageInfo.setDatetime(cursor.getString(cursor.getColumnIndex("datetime")));
        messageInfo.setInitwechatfriend_number(cursor.getString(cursor.getColumnIndex("initwechatfriend_number")));
        messageInfo.setImgpath(cursor.getString(cursor.getColumnIndex("imgpath")));
        messageInfo.setIssend(cursor.getString(cursor.getColumnIndex("issend")));
        messageInfo.setWechat_number(cursor.getString(cursor.getColumnIndex("wechat_number")));
        messageInfo.setMsgSvrId(cursor.getString(cursor.getColumnIndex("msgSvrId")));
        messageInfo.setTalkerId(cursor.getString(cursor.getColumnIndex("talkerId")));
        return messageInfo;
    }

    // 判断聊天联系人里面是否存在信息
    public boolean isDataExistContact() {
        int count = 0;
        Cursor cursor = null;
        try {
            mDatabase = getReadableDatabase();
            cursor = mDatabase.query(WeixinDBHelper.TABLE_NAME_Contact, new String[]{"COUNT('X')"}, null, null, null, null, null);
            if (cursor.moveToFirst()) {
                count = cursor.getInt(0);
            }
            if (count > 0) return true;
        } catch (Exception e) {
            LogUtil.d(TAG, "isDataExistContact open db error");
            WriteLogToSD.SaveToSDcard(TAG, "isDataExistContact失败:"+e.toString());
        } finally {
            if (cursor != null) {
                cursor.close();
            }
            if (mDatabase != null) {
                closeDatabase();
            }
        }
        return false;
    }

    /**
     * 插入数据库聊天记录
     *
     * @param rcontactInfos
     */
    public void insertRcontactInfo(List<RcontactInfo> rcontactInfos) {

        if (rcontactInfos == null) {
            return;
        }

        try {
            mDatabase = getWritableDatabase();
            mDatabase.beginTransaction();
            int count = rcontactInfos.size();
            for (int i = 0; i < count; i++) {
                RcontactInfo rcontactInfo = rcontactInfos.get(i);

                ContentValues contentValues = new ContentValues();
                contentValues.put("buddyname", rcontactInfo.getBuddyname());
                contentValues.put("buddyphotourl", rcontactInfo.getBuddyphotourl());
                contentValues.put("imgid", rcontactInfo.getImgid());
                contentValues.put("wxname", rcontactInfo.getWxname());
                contentValues.put("province", rcontactInfo.getProvince());
                contentValues.put("city", rcontactInfo.getCity());
                contentValues.put("pyInitial", rcontactInfo.getPyInitial());
                contentValues.put("sex", rcontactInfo.getSex());
                contentValues.put("pyQuanPin", rcontactInfo.getPyQuanPin());
                contentValues.put("iskeepUser", rcontactInfo.getIskeepUser());
                contentValues.put("lastchattime", rcontactInfo.getLastchattime());
                contentValues.put("wechatfriend_number", rcontactInfo.getWechatfriend_number());
                contentValues.put("initwechatfriend_number", rcontactInfo.getInitwechatfriend_number());
                contentValues.put("show_head", rcontactInfo.getShow_head());
                mDatabase.insertOrThrow(WeixinDBHelper.TABLE_NAME_Contact, null, contentValues);
            }
            mDatabase.setTransactionSuccessful();
            Log.e(TAG, "insertuserInfo:" + rcontactInfos.size());
        } catch (Exception e) {
            Log.e(TAG, "", e);
            WriteLogToSD.SaveToSDcard(TAG, "insertRcontactInfo失败:"+e.toString());
        } finally {
            if (mDatabase != null) {
                mDatabase.endTransaction();
                closeDatabase();
            }
        }
    }

    /**
     * 删除已上传的联系人
     *
     * @param rcontactInfos
     * @return
     */
    public boolean deleteRcontactInfos(List<RcontactInfo> rcontactInfos) {
        try {
            mDatabase = getWritableDatabase();
            mDatabase.beginTransaction();

            mDatabase.delete(WeixinDBHelper.TABLE_NAME_Contact, "", new String[]{});

            mDatabase.setTransactionSuccessful();
            Log.e(TAG, "deleteuserInfo:" + rcontactInfos.size());
            return true;
        } catch (Exception e) {
            Log.e(TAG, "", e);
            WriteLogToSD.SaveToSDcard(TAG, "deleteRcontactInfos失败:"+e.toString());
        } finally {
            if (mDatabase != null) {
                mDatabase.endTransaction();
                closeDatabase();
            }
        }
        return false;
    }


    /**
     * 查询聊天记录
     *
     * @return
     */
    public List<RcontactInfo> selectRcontactInfo() {
        Cursor cursor = null;

        try {
            mDatabase = getReadableDatabase();
            cursor = mDatabase.query(WeixinDBHelper.TABLE_NAME_Contact, RCONTACT,
                    "1==1 limit ?",
                    new String[]{limit},
                    null, null, null);

            if (cursor.getCount() > 0) {
                List<RcontactInfo> userInfos = new ArrayList<RcontactInfo>(cursor.getCount());
                while (cursor.moveToNext()) {
                    RcontactInfo userInfo = parseRcontactInfo(cursor);
                    userInfos.add(userInfo);
                }

                Log.e(TAG, "selectuserInfos:" + userInfos.size());
                return userInfos;
            }
        } catch (Exception e) {
            Log.e(TAG, "open fail", e);
            WriteLogToSD.SaveToSDcard(TAG, "selectRcontactInfo失败:"+e.toString());
        } finally {
            if (cursor != null) {
                cursor.close();
            }
            if (mDatabase != null) {
                closeDatabase();
            }
        }
        return null;
    }

    /**
     * 将查找到的数据转换成RcontactInfo类
     */
    private RcontactInfo parseRcontactInfo(Cursor cursor) {
        RcontactInfo userInfo = new RcontactInfo();

        userInfo.setBuddyname(cursor.getString(cursor.getColumnIndex("buddyname")));
        userInfo.setBuddyphotourl(cursor.getString(cursor.getColumnIndex("buddyphotourl")));
        userInfo.setImgid(cursor.getString(cursor.getColumnIndex("imgid")));
        userInfo.setWxname(cursor.getString(cursor.getColumnIndex("wxname")));
        userInfo.setProvince(cursor.getString(cursor.getColumnIndex("province")));
        userInfo.setCity(cursor.getString(cursor.getColumnIndex("city")));
        userInfo.setPyInitial(cursor.getString(cursor.getColumnIndex("pyInitial")));
        userInfo.setSex(cursor.getString(cursor.getColumnIndex("sex")));
        userInfo.setPyQuanPin(cursor.getString(cursor.getColumnIndex("pyQuanPin")));
        userInfo.setIskeepUser(cursor.getString(cursor.getColumnIndex("iskeepUser")));
        userInfo.setLastchattime(cursor.getString(cursor.getColumnIndex("lastchattime")));
        userInfo.setWechatfriend_number(cursor.getString(cursor.getColumnIndex("wechatfriend_number")));
        userInfo.setInitwechatfriend_number(cursor.getString(cursor.getColumnIndex("initwechatfriend_number")));
        userInfo.setShow_head(cursor.getString(cursor.getColumnIndex("show_head")));

        return userInfo;
    }

    /**
     * 插入一条上传错误信息
     * @param sourceInfo
     */
    public void insertErrorSubmitSource(SubmitSourceInfo sourceInfo){
        if (sourceInfo == null) {
            return;
        }
        try {
            mDatabase = getWritableDatabase();
            mDatabase.beginTransaction();

            ContentValues contentValues = new ContentValues();
            contentValues.put("logid", sourceInfo.getLogid());
            contentValues.put("source", sourceInfo.getSource());
            mDatabase.insertOrThrow(WeixinDBHelper.TABLE_NAME_ErrorSubmitSource, null, contentValues);
            mDatabase.setTransactionSuccessful();
        } catch (Exception e) {
            Log.e(TAG, "", e);
            WriteLogToSD.SaveToSDcard(TAG, "insertErrorSubmitSource失败:"+e.toString());
        } finally {
            if (mDatabase != null) {
                mDatabase.endTransaction();
                closeDatabase();
            }
        }
    }

    /**
     * 查询错误上传的信息
     */
    public SubmitSourceInfo selectErrorSubmitSource(){
        Cursor cursor = null;
        try {
            mDatabase = getReadableDatabase();
            cursor = mDatabase.query(WeixinDBHelper.TABLE_NAME_ErrorSubmitSource, ERRORSUBMITSOURCE,
                    "1==1 limit ?",
                    new String[]{"1"},
                    null, null, null);

            if (cursor.getCount() > 0) {
                SubmitSourceInfo sourceInfo = new SubmitSourceInfo();
                while (cursor.moveToNext()) {
                    sourceInfo.setLogid(cursor.getString(cursor.getColumnIndex("logid")));
                    sourceInfo.setSource(cursor.getString(cursor.getColumnIndex("source")));
                }
                return sourceInfo;
            }
        } catch (Exception e) {
            Log.e(TAG, "open fail", e);
            WriteLogToSD.SaveToSDcard(TAG, "selectErrorSubmitSource失败:"+e.toString());
        } finally {
            if (cursor != null) {
                cursor.close();
            }
            if (mDatabase != null) {
                closeDatabase();
            }
        }
        return null;
    }

    /**
     * 删除上传成功的数据
     * @param sourceInfo
     * @return
     */
    public boolean deleteErrorSubmitSource(SubmitSourceInfo sourceInfo){
        if (sourceInfo==null)
            return true;
        try {
            mDatabase = getWritableDatabase();
            mDatabase.beginTransaction();

            mDatabase.delete(WeixinDBHelper.TABLE_NAME_ErrorSubmitSource, "logid = ?", new String[]{sourceInfo.getLogid()});
            mDatabase.setTransactionSuccessful();
            return true;
        } catch (Exception e) {
            Log.e(TAG, "", e);
            WriteLogToSD.SaveToSDcard(TAG, "deleteErrorSubmitSource失败:"+e.toString());
        } finally {
            if (mDatabase != null) {
                mDatabase.endTransaction();
                closeDatabase();
            }
        }
        return false;
    }
}
3、使用 

final SubmitSourceInfo sourceInfo = WeiXinDBManager.getInstance(new WeixinDBHelper(context)).selectErrorSubmitSource();
4、使用 sqlcipher
 

DBHelper
 

package com.yueniu.addcustomers.data.local;

import android.content.Context;

import com.yueniu.addcustomers.util.LogUtil;
import com.yueniu.addcustomers.util.UinUtils;
import com.yueniu.addcustomers.util.WriteLogToSD;
import com.yueniu.addcustomers.util.XmlSaveUtil;

import net.sqlcipher.database.SQLiteDatabase;
import net.sqlcipher.database.SQLiteDatabaseHook;

import java.io.File;

/**
 * Created by maoshenbo on 2016/11/24 9:23.
 */
public class MMDBHelper {
    private static String TAG = "MMDBHelper";
    private static SQLiteDatabase db;
    private static MMDBHelper instance = null;

    private static SQLiteDatabaseHook hook = new SQLiteDatabaseHook(){
        @Override
        public void preKey(SQLiteDatabase sqLiteDatabase) {

        }
        public void postKey(SQLiteDatabase database){
            database.rawExecSQL("PRAGMA cipher_migrate;");  //最关键的一句！！！
            database.rawExecSQL("PRAGMA cipher_use_hmac = OFF;");
            LogUtil.i(TAG, "----------调用了--------------");
            WriteLogToSD.SaveToSDcard(TAG, "hook调用了");
        }
    };

    public static MMDBHelper getInstance(){
        if(instance == null){
            instance = new MMDBHelper();
        }
        return instance;
    }

    public SQLiteDatabase getReadableDatabase(Context context, File messageFile, File configFile,File compatibleFile) {
        try{
            String secret = UinUtils.getDBKey(context, configFile,compatibleFile);
            WriteLogToSD.SaveToSDcard(TAG, "数据库密码获取："+secret);
            LogUtil.i(TAG, "secret="+secret);
            XmlSaveUtil.GetInstance().printSecretXml(secret, configFile.getAbsolutePath());
            db = SQLiteDatabase.openDatabase(messageFile.getPath(), secret, null, 0, hook);
            WriteLogToSD.SaveToSDcard(TAG, "数据库打开了");
            return db;
        } catch (Exception e){
            e.printStackTrace();
            WriteLogToSD.SaveToSDcard(TAG, "数据库打开失败");
        }
        return null;
    }
}
 


                

        

        

    

  


    

      

        

            

              
                
                  Dij__柯南
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
Android——SQLite数据库使用详解

				
			

			

				

					2301_77118221的博客
				

				

					03-19
					
					1701
					
				

			

		

		

			
				
其实Android开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。上面分享的腾讯、头条、阿里、美团、字节跳动等公司2019-2021年的高频面试题，博主还把这些技术点整理成了视频和PDF（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节，由于篇幅有限，上面只是以图片的形式给大家展示一部分。Android学习PDF+学习视频+面试文档+知识点笔记【Android思维脑图（技能树）】

			
		

	



                

              
                



	

		

			

				
					
Android之Sqlite数据库操作实例

				
			

			

				

					11-16
				

			

		

		

			
				
Android之Sqlite数据库操作实例

			
		

	



                


  
              

                


	

		

			

				
					
Android操作sqlite数据库

				
			

			

				

					01-08
				

			

		

		

			
				
Android 操作 sqlite 数据库增加修改删除
Android 操作 sqlite 数据库增加修改删除
Android 操作 sqlite 数据库增加修改删除

			
		

	





	

		

			

				
					
Android使用SQlite数据库

				
			

			

				

					钱进的专栏
				

				

					10-02
					
					8051
					
				

			

		

		

			
				
先画个图，了解下Android下数据库操作的简单流程：


1.首先，写一个自己的数据库操作帮助类，这个类继承自Android自带的SQLiteOpenHelper.
2.在自己的DAO层借助自己的Helper写数据库操作的一些方法
3.Activity调用DAO层的数

			
		

	



		

			
		



	

		

			

				
					
爆火的微信聊天记录整理工具，功能超强！可对微信聊天记录进行解密加密，支持把聊天转移存储，支持对任意联系人和聊天记录搜索，提取微信聊天记录，将其导出成HTML、Word、Excel文档永久保存

					
最新发布

				
			

			

				

					代码讲故事
				

				

					09-14
					
					1962
					
				

			

		

		

			
				
爆火的微信聊天记录整理工具，功能超强！可对微信聊天记录进行解密加密，支持把聊天转移存储，支持对任意联系人和聊天记录搜索，提取微信聊天记录，将其导出成HTML、Word、Excel文档永久保存，对聊天记录进行分析生成年度聊天报告，用聊天数据训练专属于个人的AI聊天助手。

			
		

	





	

		

			

				
					
Android数据库sqlite的使用

				
			

			

				

					Time丶时光不曾
				

				

					03-19
					
					395
					
				

			

		

		

			
				
Android的sqlite使用
我们先创建一个数据库以供使用

public class SqlOther extends SQLiteOpenHelper {

    public SqlOther(Context context) {
        super(context, "xinhao", null, 1);//标注1
    }

  ...

			
		

	





	

		

			

				
					
Android中使用SQLite数据库详解

				
			

			

				

					猴子哥哥的博客
				

				

					11-29
					
					881
					
				

			

		

		

			
				
SQLite简述


    SQLite是一款轻型的关系型数据库管理系统，其设计目标是嵌入式的；
    SQLite引擎是连接到程序中成为它的一个主要部分，其主要的通信协议是在编程语言内的直接API调用
    java中可使用JDBC的方式连接SQLite，Android中可直接调用其API，本文主要介绍Android中使用SQLite


Android中使用SQLite数

			
		

	





	

		

			

				
					
安卓学习 Day25：使用SQLite数据库

				
			

			

				

					zs18384022951的博客
				

				

					07-17
					
					2584
					
				

			

		

		

			
				
安卓学习第二十五天，使用SQLite数据库。

			
		

	





	

		

			

				
					
Android中SQLite数据库查看工具

				
			

			

				

					05-07
				

			

		

		

			
				
SQLite是一个进程内的库，实现了自给自足的、无服务器的、零配置的、事务性的 SQL 数据库引擎。它是一个零配置的数据库，这意味着与其他数据库不一样，您...SQLite 使用 ANSI-C 编写的，并提供了简单和易于使用的 API。

			
		

	





	

		

			

				
					
Android Studio SQLite数据库使用

				
			

			

				

					03-07
				

			

		

		

			
				
Android Studio SQLite数据库使用  Android Studio 提供了SQLite数据库来存储应用程序的数据。在本文中，我们将介绍如何使用SQLite数据库在Android Studio中，并详细解释SQLiteOpenHelper和SQLiteDatabase的使用方法...

			
		

	





	

		

			

				
					
Android sqlite数据库的创建和使用

				
			

			

				

					09-22
				

			

		

		

			
				
Android sqlite数据库的创建和使用，入门知识

			
		

	





	

		

			

				
					
Android 数据库（2）-----SQLite使用

				
			

			

				

					chenqianleo的博客
				

				

					08-15
					
					669
					
				

			

		

		

			
				
SQLite 使用1、SQLite的SQL语句
  SQLite引擎和一般的client/service数据库管理系统不同，没有一个应用程序与之通信的独立进程。SQLite库连接到程序中，成为了程序的一部分，应用程序可以直接使用api访问SQLite的功能可以减少延迟（没有进程间通信）
SQL语句1.创建数据库
    sqlite3 name.db
2.创建表
    create [temp |

			
		

	





	

		

			

				
					
android SQLite数据库用法图文详解（附源码）

					
热门推荐

				
			

			

				

					Garvin的专栏
				

				

					03-31
					
					1万+
					
				

			

		

		

			
				
（转载请注明出处：http://blog.csdn.net/buptgshengod）
1.背景
        SQLite是嵌入式设备使用的一种轻量型数据库。可以通过执行sql语句对数据库进行操作，android也为其提供了完善的函数接口支持。下面就来实现一个简单的数据库，可以实现查询以及插入等功能。

例图如下：

			
		

	





	

		

			

				
					
android打开sqlite数据库,在片段中打开Android Sqlite数据库

				
			

			

				

					weixin_39980841的博客
				

				

					05-27
					
					87
					
				

			

		

		

			
				
我正在尝试在Android中打开并写入Sqlite数据库.根据日志输出,它没有打开.我知道我的语法不是很好,我应该从Party对象中保存而不是直接从片段接口中保存,但是我的重点实际上是过程.任何帮助都会超级有帮助！package com.android.sqldatabase.sqldatabaseapp;//imports deleted to save spacepublic class Sq...

			
		

	





	

		

			

				
					
Android Sqlite数据库详解

				
			

			

				

					R.先森的博客
				

				

					07-11
					
					6679
					
				

			

		

		

			
				
什么是Sqlite
Android自带的嵌入式数据库，可使用Sql语言
怎么使用
Sqlite通过SQLiteOpenHelper类来管理数据库

SQLiteOpenHelper 的常用方法




方法名
方法介绍




getWritableDatabase（）
创建 or 打开 可读/写的数据库（通过 返回的SQLiteDatabase对象 进行操作）


getReadableData...

			
		

	





	

		

			

				
					
android数据存储（三）之使用SQLlite数据库存储

				
			

			

				

					hehui0871的专栏
				

				

					10-05
					
					2904
					
				

			

		

		

			
				
package net.hehui.db;

import net.hehui.db.R;
import android.app.Activity;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteExc

			
		

	





	

		

			

				
					
Android之SQLite数据库使用

				
			

			

				

					qq_38056514的博客
				

				

					01-03
					
					6945
					
				

			

		

		

			
				
SQLite是Android系统集成的一个轻量级的数据库。Android提供了SQLiteDatabase代表一个数据库（底层就是一个数据库文件）,一旦应用程序获得了代表指定数据库的SQLiteDatabase对象，接下来可通过SQLiteDatabase对象来管理、操作数据库了。

			
		

	





	

		

			

				
					
Android SQLite数据库操作详解

				
			

			

				

					
				

			

		

		

			
				
开发者可以直接在Android应用中操作SQLite数据库，实现数据的持久化存储。  SQLite在Android中的应用 - SQLiteOpenHelper: 这是Android提供的一个辅助类，用于创建、升级和打开数据库。通过重写`onCreate()`方法创建...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值