10) 十分鍾學會android--app數據保存三種方式

雖然可以在onPause()時保存一些信息以免用戶的使用進度被丟失，但大多數Android app仍然是需執行保存數據的動作。大多數較好的apps都需要保存用戶的設置信息，而且有一些apps必須維護大量的文件信息與DB信息。本章節將介紹Android中主要的數據存儲方法，包括：

• 保存到Preferences

  學習使用Shared Preferences文件以Key-Value的方式保存簡要的信息。

• 保存到文件

  學習保存基本的文件。

• 保存到數據庫

  學習使用SQLite數據庫讀寫數據。

保存到Preference

當有一個相對較小的key-value集合需要保存時，可以使用SharedPreferences APIs。 SharedPreferences 對象指向一個保存key-value pairs的文件，並為讀寫他們提供了簡單的方法。每個 SharedPreferences 文件均由framework管理，其既可以是私有的，也可以是共享的。 這節課會演示如何使用 SharedPreferences APIs 來存儲與檢索簡單的數據。

Note： SharedPreferences APIs 僅僅提供了讀寫key-value對的功能，請不要與Preference APIs相混淆。后者可以幫助我們建立一個設置用戶配置的頁面（盡管它實際上是使用SharedPreferences 來實現保存用戶配置的)。更多關於Preference APIs的信息，請參考Settings 指南。

獲取SharedPreference

我們可以通過以下兩種方法之一創建或者訪問shared preference 文件:

• getSharedPreferences() — 如果需要多個通過名稱參數來區分的shared preference文件, 名稱可以通過第一個參數來指定。可在app中通過任何一個Context 執行該方法。
• getPreferences() — 當activity僅需要一個shared preference文件時。因為該方法會檢索activity下默認的shared preference文件，並不需要提供文件名稱。

例：下面的示例在一個 Fragment 中被執行，它以private模式訪問名為 R.string.preference_file_key 的shared preference文件。這種情況下，該文件僅能被我們的app訪問。

Context context = getActivity();
SharedPreferences sharedPref = context.getSharedPreferences(
        getString(R.string.preference_file_key), Context.MODE_PRIVATE);

 

應以與app相關的方式為shared preference文件命名，該名稱應唯一。如本例中可將其命名為 "com.example.myapp.PREFERENCE_FILE_KEY" 。

當然，當activity僅需要一個shared preference文件時，我們可以使用getPreferences()方法：

SharedPreferences sharedPref = getActivity().getPreferences(Context.MODE_PRIVATE);

Caution: 如果創建了一個MODE_WORLD_READABLE或者MODE_WORLD_WRITEABLE 模式的shared preference文件，則其他任何app均可通過文件名訪問該文件。

寫Shared Preference

為了寫shared preferences文件，需要通過執行edit()創建一個 SharedPreferences.Editor。

通過類似putInt()與putString()等方法傳遞keys與values，接着通過commit() 提交改變.

SharedPreferences sharedPref = getActivity().getPreferences(Context.MODE_PRIVATE);
SharedPreferences.Editor editor = sharedPref.edit();
editor.putInt(getString(R.string.saved_high_score), newHighScore);
editor.commit();

 

讀Shared Preference

為了從shared preference中讀取數據，可以通過類似於 getInt() 及 getString()等方法來讀取。在那些方法里面傳遞我們想要獲取的value對應的key，並提供一個默認的value作為查找的key不存在時函數的返回值。如下：

SharedPreferences sharedPref = getActivity().getPreferences(Context.MODE_PRIVATE);
int defaultValue = getResources().getInteger(R.string.saved_high_score_default);
long highScore = sharedPref.getInt(getString(R.string.saved_high_score), default);

 

保存到文件

Android使用與其他平台類似的基於磁盤的文件系統(disk-based file systems)。本課程將描述如何在Android文件系統上使用 File 的讀寫APIs對Andorid的file system進行讀寫。

File 對象非常適合於流式順序數據的讀寫。如圖片文件或是網絡中交換的數據等。

本課程將會演示如何在app中執行基本的文件相關操作。假定讀者已對linux的文件系統及java.io中標准的I/O APIs有一定認識。

存儲在內部還是外部

所有的Android設備均有兩個文件存儲區域："internal" 與 "external" 。 這兩個名稱來自於早先的Android系統，當時大多設備都內置了不可變的內存（internal storage)及一個類似於SD card（external storage）這樣的可卸載的存儲部件。之后有一些設備將"internal" 與 "external" 都做成了不可卸載的內置存儲，雖然如此，但是這一整塊還是從邏輯上有被划分為"internal"與"external"的。只是現在不再以是否可卸載進行區分了。 下面列出了兩者的區別：

• Internal storage:

  • 總是可用的
  • 這里的文件默認只能被我們的app所訪問。
  • 當用戶卸載app的時候，系統會把internal內該app相關的文件都清除干凈。
  • Internal是我們在想確保不被用戶與其他app所訪問的最佳存儲區域。

• External storage:

  • 並不總是可用的，因為用戶有時會通過USB存儲模式掛載外部存儲器，當取下掛載的這部分后，就無法對其進行訪問了。
  • 是大家都可以訪問的，因此保存在這里的文件可能被其他程序訪問。
  • 當用戶卸載我們的app時，系統僅僅會刪除external根目錄（getExternalFilesDir()）下的相關文件。
  • External是在不需要嚴格的訪問權限並且希望這些文件能夠被其他app所共享或者是允許用戶通過電腦訪問時的最佳存儲區域。

Tip: 盡管app是默認被安裝到internal storage的，我們還是可以通過在程序的manifest文件中聲明android:installLocation 屬性來指定程序安裝到external storage。當某個程序的安裝文件很大且用戶的external storage空間大於internal storage時，用戶會傾向於將該程序安裝到external storage。更多安裝信息見App Install Location。

獲取External存儲的權限

為了寫數據到external storage, 必須在你manifest文件中請求WRITE_EXTERNAL_STORAGE權限：

<manifest ...> <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" /> ... </manifest> 

Caution:目前，所有的apps都可以在不指定某個專門的權限下做讀external storage的動作。但這在以后的安卓版本中會有所改變。如果我們的app只需要讀的權限(不是寫), 那么將需要聲明 READ_EXTERNAL_STORAGE 權限。為了確保app能持續地正常工作，我們現在在編寫程序時就需要聲明讀權限。

<manifest ...> <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" /> ... </manifest> 

但是，如果我們的程序有聲明WRITE_EXTERNAL_STORAGE 權限，那么就默認有了讀的權限。

對於internal storage，我們不需要聲明任何權限，因為程序默認就有讀寫程序目錄下的文件的權限。

保存到Internal Storage

當保存文件到internal storage時，可以通過執行下面兩個方法之一來獲取合適的目錄作為 FILE 的對象：

• getFilesDir() : 返回一個File，代表了我們app的internal目錄。
• getCacheDir() : 返回一個File，代表了我們app的internal緩存目錄。請確保這個目錄下的文件能夠在一旦不再需要的時候馬上被刪除，並對其大小進行合理限制，例如1MB 。系統的內部存儲空間不夠時，會自行選擇刪除緩存文件。

可以使用File() 構造器在那些目錄下創建一個新的文件，如下：

File file = new File(context.getFilesDir(), filename); 

同樣，也可以執行openFileOutput() 獲取一個 FileOutputStream 用於寫文件到internal目錄。如下：

String filename = "myfile";
String string = "Hello world!";
FileOutputStream outputStream;

try {
  outputStream = openFileOutput(filename, Context.MODE_PRIVATE);
  outputStream.write(string.getBytes());
  outputStream.close();
} catch (Exception e) {
  e.printStackTrace();
}

 

如果需要緩存一些文件，可以使用createTempFile()。例如：下面的方法從URL中抽取了一個文件名，然后再在程序的internal緩存目錄下創建了一個以這個文件名命名的文件。

 public File getTempFile(Context context, String url) {
    File file;
    try {
        String fileName = Uri.parse(url).getLastPathSegment();
        file = File.createTempFile(fileName, null, context.getCacheDir());
    catch (IOException e) {
        // Error while creating file
    }
    return file;
}

 

Note: 我們的app的internal storage 目錄以app的包名作為標識存放在Android文件系統的特定目錄下[data/data/com.example.xx]。 從技術上講，如果文件被設置為可讀的，那么其他app就可以讀取該internal文件。然而，其他app需要知道包名與文件名。若沒有設置為可讀或者可寫，其他app是沒有辦法讀寫的。因此我們只要使用了MODE_PRIVATE ，那么這些文件就不可能被其他app所訪問。

保存文件到External Storage

因為external storage可能是不可用的，比如遇到SD卡被拔出等情況時。因此在訪問之前應對其可用性進行檢查。我們可以通過執行 getExternalStorageState()來查詢external storage的狀態。若返回狀態為MEDIA_MOUNTED, 則可以讀寫。示例如下：

 /* Checks if external storage is available for read and write */
public boolean isExternalStorageWritable() {
    String state = Environment.getExternalStorageState();
    if (Environment.MEDIA_MOUNTED.equals(state)) {
        return true;
    }
    return false;
}

/* Checks if external storage is available to at least read */
public boolean isExternalStorageReadable() {
    String state = Environment.getExternalStorageState();
    if (Environment.MEDIA_MOUNTED.equals(state) ||
        Environment.MEDIA_MOUNTED_READ_ONLY.equals(state)) {
        return true;
    }
    return false;
}

 

盡管external storage對於用戶與其他app是可修改的，我們可能會保存下面兩種類型的文件。

• Public files :這些文件對與用戶與其他app來說是public的，當用戶卸載我們的app時，這些文件應該保留。例如，那些被我們的app拍攝的圖片或者下載的文件。
• Private files: 這些文件完全被我們的app所私有，它們應該在app被卸載時刪除。盡管由於存儲在external storage，那些文件從技術上而言可以被用戶與其他app所訪問，但實際上那些文件對於其他app沒有任何意義。因此，當用戶卸載我們的app時，系統會刪除其下的private目錄。例如，那些被我們的app下載的緩存文件。

想要將文件以public形式保存在external storage中，請使用getExternalStoragePublicDirectory()方法來獲取一個 File 對象，該對象表示存儲在external storage的目錄。這個方法會需要帶有一個特定的參數來指定這些public的文件類型，以便於與其他public文件進行分類。參數類型包括DIRECTORY_MUSIC 或者 DIRECTORY_PICTURES. 如下:

public File getAlbumStorageDir(String albumName) {
    // Get the directory for the user's public pictures directory.
    File file = new File(Environment.getExternalStoragePublicDirectory(
            Environment.DIRECTORY_PICTURES), albumName);
    if (!file.mkdirs()) {
        Log.e(LOG_TAG, "Directory not created");
    }
    return file;
}

 

想要將文件以private形式保存在external storage中，可以通過執行getExternalFilesDir() 來獲取相應的目錄，並且傳遞一個指示文件類型的參數。每一個以這種方式創建的目錄都會被添加到external storage封裝我們app目錄下的參數文件夾下（如下則是albumName）。這下面的文件會在用戶卸載我們的app時被系統刪除。如下示例：

public File getAlbumStorageDir(Context context, String albumName) {
    // Get the directory for the app's private pictures directory.
    File file = new File(context.getExternalFilesDir(
            Environment.DIRECTORY_PICTURES), albumName);
    if (!file.mkdirs()) {
        Log.e(LOG_TAG, "Directory not created");
    }
    return file;
}

 

如果剛開始的時候，沒有預定義的子目錄存放我們的文件，可以在 getExternalFilesDir()方法中傳遞null. 它會返回app在external storage下的private的根目錄。

請記住，getExternalFilesDir() 方法會創建的目錄會在app被卸載時被系統刪除。如果我們的文件想在app被刪除時仍然保留，請使用getExternalStoragePublicDirectory().

無論是使用 getExternalStoragePublicDirectory() 來存儲可以共享的文件，還是使用 getExternalFilesDir() 來儲存那些對於我們的app來說是私有的文件，有一點很重要，那就是要使用那些類似DIRECTORY_PICTURES 的API的常量。那些目錄類型參數可以確保那些文件被系統正確的對待。例如，那些以DIRECTORY_RINGTONES 類型保存的文件就會被系統的media scanner認為是ringtone而不是音樂。

查詢剩余空間

如果事先知道想要保存的文件大小，可以通過執行getFreeSpace() or getTotalSpace() 來判斷是否有足夠的空間來保存文件，從而避免發生IOException。那些方法提供了當前可用的空間還有存儲系統的總容量。

然而，系統並不能保證可以寫入通過getFreeSpace()查詢到的容量文件， 如果查詢的剩余容量比我們的文件大小多幾MB，或者說文件系統使用率還不足90%，這樣則可以繼續進行寫的操作，否則最好不要寫進去。

Note：並沒有強制要求在寫文件之前去檢查剩余容量。我們可以嘗試先做寫的動作，然后通過捕獲 IOException 。這種做法僅適合於事先並不知道想要寫的文件的確切大小。例如，如果在把PNG圖片轉換成JPEG之前，我們並不知道最終生成的圖片大小是多少。

刪除文件

在不需要使用某些文件的時候應刪除它。刪除文件最直接的方法是直接執行文件的delete()方法。

myFile.delete();

如果文件是保存在internal storage，我們可以通過Context來訪問並通過執行deleteFile()進行刪除

myContext.deleteFile(fileName);

Note: 當用戶卸載我們的app時，android系統會刪除以下文件：

• 所有保存到internal storage的文件。
• 所有使用getExternalFilesDir()方式保存在external storage的文件。

然而，通常來說，我們應該手動刪除所有通過 getCacheDir() 方式創建的緩存文件，以及那些不會再用到的文件。

 

保存到數據庫

對於重復或者結構化的數據（如聯系人信息）等保存到DB是個不錯的主意。本課假定讀者已經熟悉SQL數據庫的常用操作。在Android上可能會使用到的APIs，可以從android.database.sqlite包中找到。

定義Schema與Contract

SQL中一個重要的概念是schema：一種DB結構的正式聲明，用於表示database的組成結構。schema是從創建DB的SQL語句中生成的。我們會發現創建一個伴隨類（companion class）是很有益的，這個類稱為合約類（contract class）,它用一種系統化並且自動生成文檔的方式，顯示指定了schema樣式。

Contract Clsss是一些常量的容器。它定義了例如URIs，表名，列名等。這個contract類允許在同一個包下與其他類使用同樣的常量。 它讓我們只需要在一個地方修改列名，然后這個列名就可以自動傳遞給整個code。

組織contract類的一個好方法是在類的根層級定義一些全局變量，然后為每一個table來創建內部類。

Note：通過實現 BaseColumns 的接口，內部類可以繼承到一個名為_ID的主鍵，這個對於Android里面的一些類似cursor adaptor類是很有必要的。這么做不是必須的，但這樣能夠使得我們的DB與Android的framework能夠很好的相容。

例如，下面的例子定義了表名與該表的列名：

public final class FeedReaderContract {
    // To prevent someone from accidentally instantiating the contract class,
    // give it an empty constructor.
    public FeedReaderContract() {}

    /* Inner class that defines the table contents */
    public static abstract class FeedEntry implements BaseColumns {
        public static final String TABLE_NAME = "entry";
        public static final String COLUMN_NAME_ENTRY_ID = "entryid";
        public static final String COLUMN_NAME_TITLE = "title";
        public static final String COLUMN_NAME_SUBTITLE = "subtitle";
        ...
    }
}

 

使用SQL Helper創建DB

定義好了的DB的結構之后，就應該實現那些創建與維護db和table的方法。下面是一些典型的創建與刪除table的語句。

private static final String TEXT_TYPE = " TEXT";
private static final String COMMA_SEP = ",";
private static final String SQL_CREATE_ENTRIES =
    "CREATE TABLE " + FeedReaderContract.FeedEntry.TABLE_NAME + " (" +
    FeedReaderContract.FeedEntry._ID + " INTEGER PRIMARY KEY," +
    FeedReaderContract.FeedEntry.COLUMN_NAME_ENTRY_ID + TEXT_TYPE + COMMA_SEP +
    FeedReaderContract.FeedEntry.COLUMN_NAME_TITLE + TEXT_TYPE + COMMA_SEP +
    ... // Any other options for the CREATE command
    " )";

private static final String SQL_DELETE_ENTRIES =
    "DROP TABLE IF EXISTS " + TABLE_NAME_ENTRIES;

 

類似於保存文件到設備的internal storage ，Android會將db保存到程序的private的空間。我們的數據是受保護的，因為那些區域默認是私有的，不可被其他程序所訪問。

在SQLiteOpenHelper類中有一些很有用的APIs。當使用這個類來做一些與db有關的操作時，系統會對那些有可能比較耗時的操作（例如創建與更新等）在真正需要的時候才去執行，而不是在app剛啟動的時候就去做那些動作。我們所需要做的僅僅是執行getWritableDatabase()或者getReadableDatabase().

Note：因為那些操作可能是很耗時的，請確保在background thread（AsyncTask or IntentService）里面去執行 getWritableDatabase() 或者 getReadableDatabase() 。

為了使用 SQLiteOpenHelper, 需要創建一個子類並重寫onCreate(), onUpgrade()與onOpen()等callback方法。也許還需要實現onDowngrade(), 但這並不是必需的。

例如，下面是一個實現了SQLiteOpenHelper 類的例子：

public class FeedReaderDbHelper extends SQLiteOpenHelper {
    // If you change the database schema, you must increment the database version.
    public static final int DATABASE_VERSION = 1;
    public static final String DATABASE_NAME = "FeedReader.db";

    public FeedReaderDbHelper(Context context) {
        super(context, DATABASE_NAME, null, DATABASE_VERSION);
    }
    public void onCreate(SQLiteDatabase db) {
        db.execSQL(SQL_CREATE_ENTRIES);
    }
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        // This database is only a cache for online data, so its upgrade policy is
        // to simply to discard the data and start over
        db.execSQL(SQL_DELETE_ENTRIES);
        onCreate(db);
    }
    public void onDowngrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        onUpgrade(db, oldVersion, newVersion);
    }
}

 

為了訪問我們的db，需要實例化 SQLiteOpenHelper的子類：

FeedReaderDbHelper mDbHelper = new FeedReaderDbHelper(getContext()); 

添加信息到DB

通過傳遞一個 ContentValues 對象到insert()方法：

// Gets the data repository in write mode
SQLiteDatabase db = mDbHelper.getWritableDatabase();

// Create a new map of values, where column names are the keys
ContentValues values = new ContentValues();
values.put(FeedReaderContract.FeedEntry.COLUMN_NAME_ENTRY_ID, id);
values.put(FeedReaderContract.FeedEntry.COLUMN_NAME_TITLE, title);
values.put(FeedReaderContract.FeedEntry.COLUMN_NAME_CONTENT, content);

// Insert the new row, returning the primary key value of the new row
long newRowId;
newRowId = db.insert(
         FeedReaderContract.FeedEntry.TABLE_NAME,
         FeedReaderContract.FeedEntry.COLUMN_NAME_NULLABLE,
         values);

 

insert()方法的第一個參數是table名，第二個參數會使得系統自動對那些ContentValues 沒有提供數據的列填充數據為null，如果第二個參數傳遞的是null，那么系統則不會對那些沒有提供數據的列進行填充。

從DB中讀取信息

為了從DB中讀取數據，需要使用query()方法，傳遞需要查詢的條件。查詢后會返回一個 Cursor 對象。

SQLiteDatabase db = mDbHelper.getReadableDatabase();

// Define a projection that specifies which columns from the database
// you will actually use after this query.
String[] projection = {
    FeedReaderContract.FeedEntry._ID,
    FeedReaderContract.FeedEntry.COLUMN_NAME_TITLE,
    FeedReaderContract.FeedEntry.COLUMN_NAME_UPDATED,
    ...
    };

// How you want the results sorted in the resulting Cursor
String sortOrder =
    FeedReaderContract.FeedEntry.COLUMN_NAME_UPDATED + " DESC";

Cursor c = db.query(
    FeedReaderContract.FeedEntry.TABLE_NAME,  // The table to query
    projection,                               // The columns to return
    selection,                                // The columns for the WHERE clause
    selectionArgs,                            // The values for the WHERE clause
    null,                                     // don't group the rows
    null,                                     // don't filter by row groups
    sortOrder                                 // The sort order
    );

 

要查詢在cursor中的行，使用cursor的其中一個move方法，但必須在讀取值之前調用。一般來說應該先調用moveToFirst()函數，將讀取位置置於結果集最開始的位置。對每一行，我們可以使用cursor的其中一個get方法如getString()或getLong()獲取列的值。對於每一個get方法必須傳遞想要獲取的列的索引位置(index position)，索引位置可以通過調用getColumnIndex()或getColumnIndexOrThrow()獲得。

下面演示如何從course對象中讀取數據信息：

cursor.moveToFirst();
long itemId = cursor.getLong(
    cursor.getColumnIndexOrThrow(FeedReaderContract.FeedEntry._ID)
);

 

刪除DB中的信息

和查詢信息一樣，刪除數據同樣需要提供一些刪除標准。DB的API提供了一個防止SQL注入的機制來創建查詢與刪除標准。

SQL Injection：(隨着B/S模式應用開發的發展，使用這種模式編寫應用程序的程序員也越來越多。但由於程序員的水平及經驗也參差不齊，相當大一部分程序員在編寫代碼時沒有對用戶輸入數據的合法性進行判斷，使應用程序存在安全隱患。用戶可以提交一段數據庫查詢代碼，根據程序返回的結果，獲得某些他想得知的數據，這就是所謂的SQL Injection，即SQL注入)

該機制把查詢語句划分為選項條件與選項參數兩部分。條件定義了查詢的列的特征，參數用於測試是否符合前面的條款。由於處理的結果不同於通常的SQL語句，這樣可以避免SQL注入問題。

// Define 'where' part of query.
String selection = FeedReaderContract.FeedEntry.COLUMN_NAME_ENTRY_ID + " LIKE ?";
// Specify arguments in placeholder order.
String[] selelectionArgs = { String.valueOf(rowId) };
// Issue SQL statement.
db.delete(table_name, mySelection, selectionArgs);

 

更新數據

當需要修改DB中的某些數據時，使用 update() 方法。

update結合了插入與刪除的語法。

SQLiteDatabase db = mDbHelper.getReadableDatabase();

// New value for one column
ContentValues values = new ContentValues();
values.put(FeedReaderContract.FeedEntry.COLUMN_NAME_TITLE, title);

// Which row to update, based on the ID
String selection = FeedReaderContract.FeedEntry.COLUMN_NAME_ENTRY_ID + " LIKE ?";
String[] selectionArgs = { String.valueOf(rowId) };

int count = db.update(
    FeedReaderDbHelper.FeedEntry.TABLE_NAME,
    values,
    selection,
    selectionArgs);