基於Android如何實現將數據庫保存到SD卡

有時候為了需要，會將數據庫保存到外部存儲或者SD卡中（對於這種情況可以通過加密數據來避免數據被破解），比如一個應用支持多個數據，每個數據都需要有一個對應的數據庫，並且數據庫中的信息量特別大時，這顯然更應該將數據庫保存在外部存儲或者SD卡中，因為RAM的大小是有限的；其次在寫某些測試程序時將數據庫保存在SD卡更方便查看數據庫中的內容。

Android通過SQLiteOpenHelper創建數據庫時默認是將數據庫保存在'/data/data/應用程序名/databases'目錄下的，只需要在繼承SQLiteOpenHelper類的構造函數中傳入數據庫名稱就可以了，但如果將數據庫保存到指定的路徑下面，都需要通過重寫繼承SQLiteOpenHelper類的構造函數中的context，因為：在閱讀SQLiteOpenHelper.java的源碼時會發現：創建數據庫都是通過Context的openOrCreateDatabase方法實現的，如果我們需要在指定的路徑下創建數據庫，就需要寫一個類繼承Context，並復寫其openOrCreateDatabase方法，在openOrCreateDatabase方法中指定數據庫存儲的路徑即可，下面為類SQLiteOpenHelper中getWritableDatabase和getReadableDatabase方法的源碼，SQLiteOpenHelper就是通過這兩個方法來創建數據庫的。

/**
  * Create and/or open a database that will be used for reading and writing.
  * The first time this is called, the database will be opened and
  * {@link #onCreate}, {@link #onUpgrade} and/or {@link #onOpen} will be
  * called.
  *
  * <p>Once opened successfully, the database is cached, so you can
  * call this method every time you need to write to the database.
  * (Make sure to call {@link #close} when you no longer need the database.)
  * Errors such as bad permissions or a full disk may cause this method
  * to fail, but future attempts may succeed if the problem is fixed.</p>
  *
  * <p class="caution">Database upgrade may take a long time, you
  * should not call this method from the application main thread, including
  * from {@link android.content.ContentProvider#onCreate ContentProvider.onCreate()}.
  *
  * @throws SQLiteException if the database cannot be opened for writing
  * @return a read/write database object valid until {@link #close} is called
  */
 public synchronized SQLiteDatabase getWritableDatabase() {
  if (mDatabase != null) {
   if (!mDatabase.isOpen()) {
    // darn! the user closed the database by calling mDatabase.close()
    mDatabase = null;
   } else if (!mDatabase.isReadOnly()) {
    return mDatabase; // The database is already open for business
   }
  }
  if (mIsInitializing) {
   throw new IllegalStateException("getWritableDatabase called recursively");
  }
  // If we have a read-only database open, someone could be using it
  // (though they shouldn't), which would cause a lock to be held on
  // the file, and our attempts to open the database read-write would
  // fail waiting for the file lock. To prevent that, we acquire the
  // lock on the read-only database, which shuts out other users.
  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, mErrorHandler);
   }
   int version = db.getVersion();
   if (version != mNewVersion) {
    db.beginTransaction();
    try {
     if (version == 0) {
      onCreate(db);
     } else {
      if (version > mNewVersion) {
       onDowngrade(db, version, mNewVersion);
      } 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();
   }
  }
 }
 /**
  * Create and/or open a database. This will be the same object returned by
  * {@link #getWritableDatabase} unless some problem, such as a full disk,
  * requires the database to be opened read-only. In that case, a read-only
  * database object will be returned. If the problem is fixed, a future call
  * to {@link #getWritableDatabase} may succeed, in which case the read-only
  * database object will be closed and the read/write object will be returned
  * in the future.
  *
  * <p class="caution">Like {@link #getWritableDatabase}, this method may
  * take a long time to return, so you should not call it from the
  * application main thread, including from
  * {@link android.content.ContentProvider#onCreate ContentProvider.onCreate()}.
  *
  * @throws SQLiteException if the database cannot be opened
  * @return a database object valid until {@link #getWritableDatabase}
  * or {@link #close} is called.
  */
 public synchronized SQLiteDatabase getReadableDatabase() {
  if (mDatabase != null) {
   if (!mDatabase.isOpen()) {
    // darn! the user closed the database by calling mDatabase.close()
    mDatabase = null;
   } else {
    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!
   Log.e(TAG, "Couldn't open " + mName + " for writing (will try read-only):", e);
  }
  SQLiteDatabase db = null;
  try {
   mIsInitializing = true;
   String path = mContext.getDatabasePath(mName).getPath();
   db = SQLiteDatabase.openDatabase(path, mFactory, SQLiteDatabase.OPEN_READONLY,
     mErrorHandler);
   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();
  }
 }

通過上面的分析可以寫出一個自定義的Context類，該類繼承Context即可，但由於Context中有除了openOrCreateDatabase方法以外的其它抽象函數，所以建議使用非抽象類ContextWrapper，該類繼承自Context，自定義的DatabaseContext類源碼如下：

public class DatabaseContext extends ContextWrapper {
 public DatabaseContext(Context context){
  super( context );
 }
 /**
  * 獲得數據庫路徑，如果不存在，則創建對象對象
  * @param name
  * @param mode
  * @param factory
  */
 @Override
 public File getDatabasePath(String name) {
  //判斷是否存在sd卡
  boolean sdExist = android.os.Environment.MEDIA_MOUNTED.equals(android.os.Environment.getExternalStorageState());
  if(!sdExist){//如果不存在,
   return null;
  }else{//如果存在
   //獲取sd卡路徑
   String dbDir= FileUtils.getFlashBPath();
   dbDir += "DB";//數據庫所在目錄
   String dbPath = dbDir+"/"+name;//數據庫路徑
   //判斷目錄是否存在，不存在則創建該目錄
   File dirFile = new File(dbDir);
   if(!dirFile.exists()){
    dirFile.mkdirs();
   }
   //數據庫文件是否創建成功
   boolean isFileCreateSuccess = false; 
   //判斷文件是否存在，不存在則創建該文件
   File dbFile = new File(dbPath);
   if(!dbFile.exists()){
    try {   
     isFileCreateSuccess = dbFile.createNewFile();//創建文件
    } catch (IOException e) {
     e.printStackTrace();
    }
   }else{
    isFileCreateSuccess = true;
   }
   //返回數據庫文件對象
   if(isFileCreateSuccess){
    return dbFile;
   }else{
    return null;
   }
  }
 }
 /**
  * 重載這個方法，是用來打開SD卡上的數據庫的，android 2.3及以下會調用這個方法。
  * 
  * @param name
  * @param mode
  * @param factory
  */
 @Override
 public SQLiteDatabase openOrCreateDatabase(String name, int mode, SQLiteDatabase.CursorFactory factory) {
  SQLiteDatabase result = SQLiteDatabase.openOrCreateDatabase(getDatabasePath(name), null);
  return result;
 }
 /**
  * Android 4.0會調用此方法獲取數據庫。
  * 
  * @see android.content.ContextWrapper#openOrCreateDatabase(java.lang.String, int, 
  *   android.database.sqlite.SQLiteDatabase.CursorFactory,
  *   android.database.DatabaseErrorHandler)
  * @param name
  * @param mode
  * @param factory
  * @param errorHandler
  */
 @Override
 public SQLiteDatabase openOrCreateDatabase(String name, int mode, CursorFactory factory, DatabaseErrorHandler errorHandler) {
  SQLiteDatabase result = SQLiteDatabase.openOrCreateDatabase(getDatabasePath(name), null);
  return result;
 }
}

在繼承SQLiteOpenHelper的子類的構造函數中，用DatabaseContext的實例替代context即可：

DatabaseContext dbContext = new DatabaseContext(context);
super(dbContext, mDatabaseName, null, VERSION);

基於Android如何實現將數據庫保存到SD卡的全部內容就給大家介紹這麼多，同時也非常感謝大家一直以來對本站網站的支持，謝謝。