Android中的数据存储

泡在网上的日子 / 文 发表于2014-12-04 15:34 次阅读 存储

Android中的数据存储主要分为三种基本方法:

  1.利用shared preferences存储一些轻量级的键值对数据。

  2.传统文件系统。

  3.利用SQLite的数据库管理系统。

  对SharedPreferences对象和SQLite数据库,它们的数据仅对创建它们的应用是可访问的。

  (比如,MODE_WORLD_READABLEMODE_WORLD_WRITEABLE现在(since API 17)已经被标记为deprecated)。

  换句话说,它们不是共享的,如果需要在不同的应用之间共享数据,需要建立content provider,本文对这部分内容不作介绍。

  本文基本是官方文档翻译,原文请见文后链接。


本文目录

一.利用shared preferences存储键值对

  1.获得SharedPreferences的Handle

  2.向Shared Preferences写数据

  3.从Shared Preferences读取数据

二.存储文件

  选择内部或外部存储

  获取外部存储设备的权限

  向内部存储存文件

  向外部存储存储文件

  查询剩余空间

  删除文件

三.在SQL数据库中存储文件

  定义一个构架和契约Define a Schema and Contract

  用SQL Helper创建一个数据库

  向数据库中存入数据

  从数据库中读取数据

  删除数据库中的信息

  更新数据库


一、利用shared preferences存储键值对

SharedPreferences 提供了一种存储键值对的方法,可以用于存储原生数据类型(boolean, float, int, long, String)

这些数据在用户工作阶段一直被保持,即便应用被关闭也还是保持。所以可以用来保存一些数据,比如用户设定的字体,背景,用户名等,在下一次打开应用时,不用重新设定这些数据。


    1. 获得SharedPreferences的Handle

获得SharedPreferences对象可以使用下面两种方法:

getSharedPreferences()这是 Context 中的方法,可以通过第一个参数指定你需要获得的文件名。

getPreferences()这是 Activity 中的方法,获取Activity中默认的shared preference文件,这个文件是Activity私有的,所以不需要指定名字。


    2.向Shared Preferences写数据

  向Shared Preferences写数据,首先需要调用edit()方法创建一个 SharedPreferences.Editor对象,然后调用这个对象的putXXX()方法存储键值对,键都是String类型,值是XXX所对应的数据类型(boolean, float, int, long, String, String集合)。

  最后需要调用commit() 方法把改变从Editor对象转移到SharedPreferences对象。


    3.从Shared Preferences读取数据

  读取数据时需要调用SharedPreferences对象的getXXX()方法,来获得给定键(第一个参数)对应的值,如果给定键不存在,则会返回给定的默认值(第二个参数)。


二、存储文件

Android文件系统和其他平台上的类似,使用File APIs可以读写文件。

这部分内容需要你已经了解了Linux文件系统的基础,并且也了解了java.io包中的标准文件输入输出APIs。

(1)选择内部或外部存储

  所有的Android设备都有两块文件存储区域:内部和外部存储。

  内部存一般指设备自带的非易失性存储器外部存储可拆卸的存储介质,比如微型的SD卡。

  一些设备把永久的存储区域分为"internal"和"external"的分区,所以即便没有可拆卸的存储介质,这些设备永远都有两种存储区域,并且不管外部存储区到底是可拆卸的还是内置的,APIs的行为是一致的。

  内部存储:

  永远可用。

  存储在内部存储区域的数据默认情况下只对你的app可用。无论是用户或者是其他app都不能访问你的数据。

  当用户卸载你的app时,系统会自动移除app在内部存储上的所有文件。

  外部存储:

  不一定一直可以访问,因为用户可以拆卸外部存储设备。

  存储在外部存储的文件是全局可读的,没有访问限制,不受你的控制。可以和其他apps分享数据,用户使用电脑也可以访问在外部存储中的文件。

  当用户卸载你的app时,只有当你把文件存储在以getExternalFilesDir().获得的路径下时,系统才会帮你自动移除。

  注意:默认情况下app是安装在内存上的,可以通过在manifest中指定android:installLocation 属性来安排app的安装位置。具体见App Install Location.

(2)获取外部存储设备的权限

  为了向外部存储中写入数据,需要在manifest中指定权限 WRITE_EXTERNAL_STORAGE

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

  注意:现在所有的app都可以读取外部存储中的数据,而不需要特殊的权限说明。

  但是,这点在新版本的更新中有可能会改变,如果你的应用需要读取外部存储中的数据而不需要写数据,应该声明READ_EXTERNAL_STORAGE 权限。

  为了保证应用能够持续工作,应该现在开始就加入读取权限:

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

   然而,如果你的应用包含了WRITE_EXTERNAL_STORAGE 权限,它隐式地包含了读取权限。

(3)向内部存储存文件

   向内部存储存文件时,可以通过下面两个方法获取合适的路径,返回值是一个File对象。

  getFilesDir()返回一个File,表示的是app的应用文件在内部存储的绝对路径。

  getCacheDir()返回一个File,表示的是app的缓存文件在内部存储的绝对路径。

 在如上路径中创建一个新文件,可以利用File() 的构造方法。将上面两个方法获得的File对象作为参数传入,如:

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

  另外,也可以调用openFileOutput()来获取FileOutputStream ,然后向你的内部目录写入数据,如下:

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中提取了文件名,然后利用该文件名创建了一个文件存储在应用的内部缓存路径下:

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;
}

  注意:

  你应用的内部存储路径是由应用的包名指定的,在Android文件系统上的一个特定位置。

  技术上来说,如果你把文件的模式设置为可读的,其他应用是可以读取你的内部文件的,但是,另外的应用需要知道你的应用的包名和文件的名字。

  如果不明确指明,其他应用是不可浏览你的内部文件路径的,也不拥有读取和写入的权限。

  所以,只要你对内部存储上的文件使用MODE_PRIVATE,它们对其他应用来说就是不可用的。

(4)向外部存储存储文件

  因为外部存储很有可能不可用,所以每次使用前都需要检查可用性。

  通过getExternalStorageState()方法可以查询外部存储状态,如果返回状态为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;
}

尽管外部存储可以被用户和其他app修改,仍然有两种类型的文件你可以选择:

Public files

  这些文件对用户和其他应用都是可用的。当用户卸载应用时,这些文件对用户仍然是可用的。比如,应用拍摄的照片文件或者是下载的文件。

Private files

  属于你应用的文件,应当在应用被卸载的时候同时被删除。

  尽管从技术上来说,这些文件可以被用户和其他文件访问,因为它们是存储在外部存储介质上的,但是它们在你的应用外部并不提供什么实际价值。当用户卸载应用时,系统会删除外部存储上应用私有路径下的所有文件。

  比如,应用下载的一些额外的资源或者临时的媒体文件。


存储公有文件,首先用getExternalStoragePublicDirectory()获得路径,这个方法需要一个参数指明文件类型,比如 DIRECTORY_MUSICDIRECTORY_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;
}

如果想要创建私有文件,利用getExternalFilesDir() 方法获得路径,并且传递给它一个名字指明路径类型。

  每一个用这种方法创建的路径都会被加在一个父目录中,这个目录包装了你的应用的所有外部文件,当你卸载应用时,系统会删除它们。

  比如,下面的方法为相册创建了一个路径:

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。这样会返回你的应用在外部存储上私有路径的根目录。

  要记住getExternalFilesDir()在一个卸载应用时系统要删除的目录中创建目录如果你的文件在应用删除之后仍需要保存,你应该使用getExternalStoragePublicDirectory()

  无论使用哪种方法,比较重要的一点是,要使用API提供的路径名常量,如DIRECTORY_PICTURES等。这些路径名保证了文件会被系统正确处理。

(5)查询剩余空间

  如果你提前知道你要存储多少数据,你可以实现查询是否有足够的存储空间,而不必引起一个IOException

  通过调用getFreeSpace()getTotalSpace()方法,你可以获取当前的空闲空间和当前卷的总空间。

  但是,系统并不保证你可以存储的容量和getFreeSpace() 方法获取的字节数一样多,如果该方法返回的容量要比你实际存储的数据大小多几个MB,或者存储后系统的填满程度小于90%,那么很可能是可以安全处理的。否则,可能就存储不下了。

  并没有要求你必须先检查剩余空间再存储文件,你可以把存储的语句写入一个try块中,然后catch IOException。在你并不知道文件多大时你需要这么做。

(6)删除文件

  在你不需要文件时你需要将其删除。

  最直接的方法:获得文件引用然后调用delete() 方法:

myFile.delete();

 如果文件存储在内部存储上,可以请求 Context 去定位和删除文件,通过调用deleteFile():

myContext.deleteFile(fileName);

 注意,当用户卸载你的app时,Android系统删除如下:

  所有在内部存储上的文件。

  所有用getExternalFilesDir()存储在外部存储上的文件。

  然而,你需要定期手工地删除利用getCacheDir() 创建的所有缓存文件。并且,需要定期清除所有不再需要的文件。



三、在SQL数据库中存储文件

  对于重复或结构性强的数据来说,把它们存储在数据库中是一种理想的做法。

  Android系统上你将会用到的数据库相关的APIs都在这个包中:android.database.sqlite

(1)定义一个构架和契约Define a Schema and Contract

  SQL数据库中的主要原则之一就是构架(schema):一个关于这个数据库是如何组织的一个正式的声明。

  构架反映在创建SQL数据库的语句中。

  你可能会发现创建一个同伴类(companion class)很有用,同伴类同时被称作合约类(contract class),其中明确规定了你的构架的布局,以一种系统且自说明的方式。


  一个合约类(contract class)是一个常量的容器,这些常量定义了URI,表的名字,列的名字。

  合约类允许你在同一个包的其他类中使用这些名字常量。

  这就允许了你在一个地方改变列名,而同时把它传播到代码的其他地方去。

  组织合约类的一个好方法是:把对于你的整个数据库来说是全局的那些定义放在类的根级上;然后对于每一个表(table)创建一个内部类,列举其列。


  注意:通过实现BaseColumns 接口,你的内部类要继承一个基本的关键字域叫做_ID,一些Android的类比如cursor adaptors将需要它。

它不是必须的,但是它能帮助你的数据库更和谐地和Android framework工作


  比如,下面这个代码段定义了表名和列名:

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";
    ...
}

  为了阻止不小心实例化合约类,给它一个私有的空构造函数:

// Prevents the FeedReaderContract class from being instantiated.
private FeedReaderContract() {}

(2)用SQL Helper创建一个数据库

  一旦你定义好了你的数据库看起来什么样,你就应该实现一些方法,用来创建和维护数据库和数据表。

  下面是创建和删除表的一些典型的语句:

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;

  就好像你存储文件到设备的内部存储上一样,Android在你应用相关的私有磁盘空间上存储你的数据库数据。

  你的数据是安全的,因为默认情况下其他应用无法访问这块区域。

SQLiteOpenHelper 类提供了一些有用的APIs,当你使用这个类来获取数据库的引用时,系统仅在需要时执行可能长时间的操作:创建和更新数据库,而不是在应用启动的时候执行。

  你需要做的仅仅是调用getWritableDatabase()getReadableDatabase()方法。

  注意:因为它们是长时间运行的,所以请确保你在背景线程中调用:

getWritableDatabase()getReadableDatabase()

  比如用 AsyncTaskIntentService


  为了使用SQLiteOpenHelper,创建一个子类,然后覆盖这三个回调函数:

onCreate(), onUpgrade()onOpen()

  你也可以实现 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);
    }
}

  要访问你的数据库,需要先实例化你的SQLiteOpenHelper的子类。

FeedReaderDbHelper mDbHelper = new FeedReaderDbHelper(getContext());

(3)向数据库中存入数据

  想数据库中插入数据:通过向  insert()方法中传入一个ContentValues对象实现。

// 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()方法接收的第一个参数是表的名字,第二个参数是列的名字:可以通过这个参数设定一个列名,如果ContentValues是空值,这样这个列就会插入NULL;如果第二个参数是null,那么如果ContentValues是空值将不会被插入表中。

(4)从数据库中读取数据

  从数据库中读取,是通过query()方法,向它传递你的选择标准和你想要的列。

  这个方法结合了insert()update()方法的元素,只不过它的列的表指定了你想取出的数据,而不是插入的数据。

  查询结果是由一个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方法,你必须指定你想要的列的索引,你可以通过 getColumnIndex()getColumnIndexOrThrow()方法来获得索引。

  比如:

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

(5)删除数据库中的信息

  要删除表中的行,你需要提供一定的选择标准来确定要删除的行。

  数据库API提供了一种机制,用于创建选择标准,防止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, selection, selectionArgs);

(6)更新数据库

  当你需要修改你的数据库中值的一个子集时,运用update()方法。

  更新数据表结合了insert()方法中的content values语义和delete()方法中的where语义。

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);


参考资料

  《Beginning Android 4 Application Development》Chapter6:Data Persistence

  Android官方文档:Training:Saving Data

http://developer.android.com/training/basics/data-storage/index.html

  API Guides: Storage Options

http://developer.android.com/guide/topics/data/data-storage.html


收藏 赞 (0) 踩 (0)
上一篇:使用WindowManager实现Android悬浮窗
WindowManager介绍 通过Context.getSystemService(Context.WINDOW_SERVICE)可以获得 WindowManager对象。 每一个WindowManager对象都和一个特定的 Display 绑定。 想要获取一个不同的display的WindowManager,可以用 createDisplayContext(Display)来获取那
下一篇:DL插件开发笔记
DL的插件和宿主有三种开发模式,我们这里讨论的是DL插件和宿主程序完全独立的开发模式,至于其余两种,可以到官网了解。 CodeBox客户端就是一个宿主程序,开发插件的同学可以完全不去管宿主是如何开发的。这篇文章也是专门讨论插件的开发。 DL插件开发其实非