使用Greendao出现SQLiteConstraintException: UNIQUE constraint failed引发的一系列问题记录

完整的错误信息：

io.reactivex.exceptions.OnErrorNotImplementedException:The exception was not handled due to missing onError handler in the subscribe() method call. Further reading: https://github.com/ReactiveX/RxJava/wiki/Error-Handling | android.database.sqlite.SQLiteConstraintException: UNIQUE constraint failed: DBFRIENDS_ENTITY.USER_ID (Sqlite code 2067 SQLITE_CONSTRAINT_UNIQUE), (OS error - 0:Success)

使用场景

Greendao使用场景是对好友资料进行本地数据库存储，由于某些鸡肋需求，我们并未对好友上限做限制，同时也需要对好友进行字母分组排序，在数据量较大情况下，会出现接口请求慢，UI卡顿的问题。

解决该问题时引发的新问题

针对此问题，我们在新版本上加入了异步加载，使用了RxJava2，由于没有处理onError，出现了上述错误中的The exception was not handled due to missing onError handler in the subscribe() method call

Observable.create((ObservableOnSubscribe>) emitter -> {
    //这里只是对好友数据进行本地数据库存储
     FriendDaoOpe.deleteAllData();
     ...
     FriendDaoOpe.insertListData(mList);
} .subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subcribe()

完整错误：

03-26 10:02:14.271 12283 12283 W System.err: io.reactivex.exceptions.OnErrorNotImplementedException: The exception was not handled due to missing onError handler in the subscribe() method call. Further reading: https://github.com/ReactiveX/RxJava/wiki/Error-Handling | android.database.sqlite.SQLiteConstraintException: UNIQUE constraint failed: DBFRIENDS_ENTITY.USER_ID (Sqlite code 2067 SQLITE_CONSTRAINT_UNIQUE), (OS error - 0:Success)
6203-26 10:02:14.272 12283 12283 W System.err: at io.reactivex.internal.functions.FunctionsOnErrorMissingConsumer.accept(Functions.java:701)
6403-26 10:02:14.272 12283 12283 W System.err: at io.reactivex.internal.observers.LambdaObserver.onError(LambdaObserver.java:77)
6503-26 10:02:14.272 12283 12283 W System.err: at io.reactivex.internal.operators.observable.ObservableObserveOnObserveOnObserver.drainNormal(ObservableObserveOn.java:172)
6703-26 10:02:14.272 12283 12283 W System.err: at io.reactivex.internal.operators.observable.ObservableObserveOnScheduledRunnable.run(HandlerScheduler.java:124)

Rxjava相关错误分析解决

我们可以看到警告信息中OnErrorMissingConsumer.accept(Functions.java:701)及subscribe()源码中看出The RxJavaPlugins.onSubscribe hook returned a null Observer

那么我们就需要如此调用：

.subscribe(new Consumer>() {
            @Override
            public void accept(List contactSections) throws Exception {
                
            }
        })

针对OnErrorNotImplementedException错误，https://github.com/ReactiveX/RxJava/wiki/Error-Handling 有相关解答：这表明Observable试图调用其观察者的onError()方法，但是不存在这样的方法。

要么保证Observable不会出现错误，要么就在onError中处理相关。

至此，Rx相关的问题处理完成。

SQLite相关错误分析解决

接下来分析android.database.sqlite.SQLiteConstraintException: UNIQUE constraint failed: DBFRIENDS_ENTITY.USER_ID (Sqlite code 2067 SQLITE_CONSTRAINT_UNIQUE), (OS error - 0:Success 错误。

重要信息：UNIQUE constraint failed

出现这个问题主要有俩种可能：

定义的字段为 NOT NULL 而在插入/修改时对应的字段为NULL
定义的字段为UNIQUE , 而在插入/修改时对应字段的值已存在

先展示我的表中字段定义DBFriendsEntity

@Entity()
public class DBFriendsEntity {
    @Id(autoincrement = true)
    private Long id;
    @Unique
    private String user_id;
    private String user_name;
    private String head_img;
    private String friend_remark;
    ...
}

其中id为主键，必须是Long类型添加注解@Id(autoincrement = true)实现自增长

user_id 添加注解@Unique 约束该字段不能出现重复的值

上述中我们提到了Unique，还有Primary key （主键）简述下二者特征： PRIMARY KEY 主键：

SQLite中每个表最多可以有一个Primary key，且不能为NULL

Unique 唯一约束：

定义了UNIQUE约束的字段值不可以重复，可以为NULL。一个表中多个字段可以存在多个UNIQUE

关于PRIMARY KEY 和 UNIQUE更多相关信息可以阅读SQLite中的介绍。

通过上面的简单分析 user_id后台肯定不会返回空的，只有一种情况就是重复插入了同一条数据。至于为何会出现这种情况，初步分析是因为多个线程中同时对数据表进行了操作导致（好友的资料更新/删除/添加都会对表进行操作）

之前多条数据的插入方法：

 DaoHelper.getInstance(NimHelper.getContext())
                .getWriteDaoSession().getDBFriendsEntityDao().insertInTx(list);

暂时没有发现其他原因，那么将插入方法insertInTx() 改为insertOrReplaceInTx() ，意为如果存在则替换

相同单条数据的插入也由insert()改为insertOrReplace()

 /**
     * @desc 添加单条数据至数据库
     **/
    public static void insertData(DBFriendsEntity friendsEntity) {
        DaoHelper.getInstance(NimHelper.getContext())
                .getWriteDaoSession().getDBFriendsEntityDao().insert(friendsEntity);
    }

    /**
     * 添加数据至数据库，如果存在，将原来的数据覆盖
     *
     * @param student
     */
    public static void insertOrReplace(DBFriendsEntity student) {
        DaoHelper.getInstance(NimHelper.getContext())
                .getWriteDaoSession().getDBFriendsEntityDao().insertOrReplace(student);
    }
    
        /**
     * 将数据实体列表数据添加到数据库
     *
     * @param list
     */
    public static void insertListData(List list) {
        if (null == list || list.isEmpty()) {
            return;
        }
        DaoHelper.getInstance(NimHelper.getContext())
                .getWriteDaoSession().getDBFriendsEntityDao().insertInTx(list);
    }

    /**
     * 将数据实体列表数据添加到数据库
     * 如果存在则替换
     *
     * @param list
     */
    public static void insertOrReplaceListData(List list) {
        if (null == list || list.isEmpty()) {
            return;
        }
        DaoHelper.getInstance(NimHelper.getContext())
                .getWriteDaoSession().getDBFriendsEntityDao().insertOrReplaceInTx(list);
    }

至此，上述俩个问题“大概率已经解决了”,但是还是没有找到复现路径，本质上没有得到解决，后续更新此文章...

其他问题

在上述问题解决后，对好友排序和数据库相关操作做了一些优化。

关于数据库加密问题：

项目中用到的并非重要数据，并没有加密，刚开始用的时候知道会报出提示加密的警告错误，但是没作处理。

现在呢，见不得红于是加入了数据库加密。

GreenDao可以通过SQLCipher来进行加密处理，SQLCipher最新版本4.3.0

引入：

implementation 'net.zetetic:android-database-sqlcipher:4.3.0'
implementation "androidx.sqlite:sqlite:2.0.1"

DaoSession获取方式：

openHelper.getEncryptedWritableDb("*****")  //加密写法 参数为数据库密码
SQLiteDatabase db = openHelper.getWritableDatabase(); //不加密的写法

遇到一个问题：

Couldn't open nim_friend.db for writing (will try read-only):
    net.sqlcipher.database.SQLiteException: file is not a database: , while compiling: select count(*) from sqlite_master

google之后定位到问题：之前版本数据库是未加密的，对未加密数据库解密时错误了。所以需要对旧的数据库进行加密在查询。

public class dbencrypt {
    public static dbencrypt dbencrypt;
    private boolean isopen = true;
 
    public static dbencrypt getinstences() {
        if (dbencrypt == null) {
            synchronized (dbencrypt.class) {
                if (dbencrypt == null) {
                    dbencrypt = new dbencrypt();
                }
            }
        }
        return dbencrypt;
    }
 
    /**
     * 如果有旧表 先加密数据库
     *
     * @param context
     * @param passphrase
     */
    public void encrypt(context context, string passphrase) {
        file file = new file("/data/data/" + context.getpackagename() + "/databases/db_name");
        if (file.exists()) {
            if (isopen) {
                try {
                    file newfile = file.createtempfile("sqlcipherutils", "tmp", context.getcachedir());
 
                    net.sqlcipher.database.sqlitedatabase db = net.sqlcipher.database.sqlitedatabase.opendatabase(
                            file.getabsolutepath(), "", null, sqlitedatabase.open_readwrite);
 
                    db.rawexecsql(string.format("attach database '%s' as encrypted key '%s';",
                            newfile.getabsolutepath(), passphrase));
                    db.rawexecsql("select sqlcipher_export('encrypted')");
                    db.rawexecsql("detach database encrypted;");
 
                    int version = db.getversion();
                    db.close();
 
                    db = net.sqlcipher.database.sqlitedatabase.opendatabase(newfile.getabsolutepath(),
                            passphrase, null,
                            sqlitedatabase.open_readwrite);
 
                    db.setversion(version);
                    db.close();
                    file.delete();
                    newfile.renameto(file);
                    isopen = false;
                } catch (exception e) {
                    isopen = false;
                }
            }
        }
    }
}

特此记录，后期更新。