Android SQLite数据库—getWritableDatabase()和getReadableDatabase()区别

本章节讲述getWritableDatabase()和getReadableDatabase()区别

Android使用getWritableDatabase()和getReadableDatabase()方法都可以获取一个用于操作数据库的SQLiteDatabase实例。(getReadableDatabase()方法中会调用getWritableDatabase()方法)

其中getWritableDatabase() 方法以读写方式打开数据库，一旦数据库的磁盘空间满了，数据库就只能读而不能写，倘若使用的是getWritableDatabase() 方法就会出错。

getReadableDatabase()方法则是先以读写方式打开数据库，如果数据库的磁盘空间满了，就会打开失败，当打开失败后会继续尝试以只读方式打开数据库。如果该问题成功解决，则只读数据库对象就会关闭，然后返回一个可读写的数据库对象。

getWritableDatabase源码

public synchronized SQLiteDatabase getWritableDatabase() {  

        if (mDatabase != null && mDatabase.isOpen() && !mDatabase.isReadOnly()) {  

            return mDatabase;  // The database is already open for business 

        }  

        if (mIsInitializing) {  

            throw new IllegalStateException("getWritableDatabase called recursively");  

        }  

     boolean success = false;  

        SQLiteDatabase db = null;  

        if (mDatabase != null) mDatabase.lock();  

        try {  

            mIsInitializing = true;  

            if (mName == null) {  

                db = SQLiteDatabase.create(null);  

            } else {  

                db = mContext.openOrCreateDatabase(mName, 0, mFactory); 

            }  

            int version = db.getVersion();  

            if (version != mNewVersion) {  

                db.beginTransaction();  

                try {  

                    if (version == 0) {  

                        onCreate(db);  

                    } else {  

                        onUpgrade(db, version, mNewVersion);  

                    }  

                    db.setVersion(mNewVersion);  

                    db.setTransactionSuccessful();  

                } finally {  

                    db.endTransaction();  

                }  

            }  

            onOpen(db);  

            success = true;  

            return db;  

        } finally {  

            mIsInitializing = false;  

            if (success) {  

                if (mDatabase != null) {  

                    try { mDatabase.close(); } catch (Exception e) { }  

                    mDatabase.unlock();  

                }  

                mDatabase = db;  

            } else {  

                if (mDatabase != null) mDatabase.unlock();  

                if (db != null) db.close();  

            }  

        }  

}  

getReadableDatabase源码

 public synchronized SQLiteDatabase getReadableDatabase() {  

       if (mDatabase != null && mDatabase.isOpen()) {  

         return mDatabase;  // The database is already open for business

        }  

        if (mIsInitializing) {  

            throw new IllegalStateException("getReadableDatabase called recursively");  

        }  

  

        try {  

            return getWritableDatabase();  

        } catch (SQLiteException e) {  

            if (mName == null) throw e;  // Can't open a temp database read-only!  

        }  

  

       SQLiteDatabase db = null;  

        try {  

            mIsInitializing = true;  

            String path = mContext.getDatabasePath(mName).getPath();  

            db = SQLiteDatabase.openDatabase(path, mFactory, SQLiteDatabase.OPEN_READONLY);  

            if (db.getVersion() != mNewVersion) {  

                throw new SQLiteException("Can't upgrade read-only database from version " +  

                        db.getVersion() + " to " + mNewVersion + ": " + path);

            }  

  

            onOpen(db);  

            Log.w(TAG, "Opened " + mName + " in read-only mode");  

            mDatabase = db;  

            return mDatabase;  

        } finally {  

            mIsInitializing = false;  

            if (db != null && db != mDatabase) db.close();  

        }  

}