Android的数据持久化存储

Love The Way You Lie 2022-04-17 06:21 560阅读 0赞

**分享一下我老师大神的人工智能教程！零基础，通俗易懂！[http://blog.csdn.net/jiangjunshow][http_blog.csdn.net_jiangjunshow]**

**也欢迎大家转载本篇文章。分享知识，造福人民，实现我们中华民族伟大复兴！**

原文：  [http://developer.android.com/guide/topics/data/data-storage.html\#filesInternal][http_developer.android.com_guide_topics_data_data-storage.html_filesInternal]

**一、简介**

Android系统为我们提供了五种数据持久化存储的方式，以满足不同的需求。

他们分别是：

[Shared Preferences][]Store private primitive data in key-value pairs. [Internal Storage][http_developer.android.com_guide_topics_data_data-storage.html_filesInternal]Store private data on the device memory.把数据持久化存储到手机内部存储空间。他主要用于私有数据存储。 [External Storage][]Store public data on the shared external storage.把数据持久化存储到手机外部SD卡中。他主要用于非隐秘数据存储。 [SQLite Databases][]Store structured data in a private database. [Network Connection][]Store data on the web with your own network server.

Android provides a way for you to expose even your private data to other applications — with a  [content provider][content_provider] . A content provider is an optional component that exposes read/write access to your application data, subject to whatever restrictions you want to impose. For more information about using content providers, see the  [Content Providers][content_provider]  documentation.

Android系统中专门提供了 [Content Providers][content_provider]  这么一个组件来实现把你的应用程序的数据暴露给别的应用程序，这样别的应用程序也可以读写你的应用程序的数据。

**二、Shared Preferences**

The `SharedPreferences` class provides a general framework that allows you to save and retrieve persistent key-value pairs of primitive data types. You can use `SharedPreferences` to save any primitive data: booleans, floats, ints, longs, and strings. This data will persist across user sessions (even if your application is killed).

### User Preferences ###

Shared preferences are not strictly for saving "user preferences," such as what ringtone a user has chosen. If you're interested in creating user preferences for your application, see`PreferenceActivity`, which provides an Activity framework for you to create user preferences, which will be automatically persisted (using shared preferences).

To get a `SharedPreferences` object for your application, use one of two methods:

*  `getSharedPreferences()` - Use this if you need multiple preferences files identified by name, which you specify with the first parameter.
 *  `getPreferences()` - Use this if you need only one preferences file for your Activity. Because this will be the only preferences file for your Activity, you don't supply a name.

To write values:

1.  Call `edit()` to get a `SharedPreferences.Editor`.
2.  Add values with methods such as `putBoolean()` and `putString()`.
3.  Commit the new values with `commit()`

To read values, use `SharedPreferences` methods such as `getBoolean()` and `getString()`.

Here is an example that saves a preference for silent keypress mode in a calculator:

public  class  Calc  extends  Activity  \{

public  static  final  String  PREFS\_NAME  =  "MyPrefsFile" ;

@Override

protected  void  onCreate ( Bundle  state )\{

super . onCreate ( state );

.  .  .

/\* Restore preferences\*/

SharedPreferences  settings  =  getSharedPreferences ( PREFS\_NAME ,  0 );

boolean  silent  =  settings . getBoolean ( "silentMode" ,  false );

setSilent ( silent );

@Override

protected  void  onStop ()\{

super . onStop ();

/\* We need an Editor object to make preference changes.\*/

/\* All objects are from android.context.Context\*/

SharedPreferences  settings  =  getSharedPreferences ( PREFS\_NAME ,  0 );

SharedPreferences . Editor  editor  =  settings . edit ();

editor . putBoolean ( "silentMode" ,  mSilentMode );

/\* Commit the edits!\*/

editor . commit ();

关于SharedPreferences的更多内容请阅读《[SharedPreferences简介][SharedPreferences]》

**三、Internal Storage**

3.1、基本知识

You can save files directly on the device's internal storage. By default, files saved to the internal storage are private to your application and other applications cannot access them (nor can the user). When the user uninstalls your application, these files are removed.

To create and write a private file to the internal storage:

1.  Call `openFileOutput()` with the name of the file and the operating mode. This returns a`FileOutputStream`.
2.  Write to the file with `write()`.
3.  Close the stream with `close()`.

对于使用 Context对象的 [openFileOutput()][openFileOutput] 和 [openFileInput()][openFileInput] 来进行数据持久化存储的这种方式，你的数据文件将存储在内部存储空间的/data/data/你的应用程序的包名/files/目录下，无法指定更深一级的目录，而且默认是 Context.MODE\_PRIVATE模式，即 别的应用程序不能访问它。

示例1

String  FILENAME  =  "hello\_file" ;

String  string  =  "hello world!" ;

FileOutputStream  fos  =  openFileOutput ( FILENAME ,  Context . MODE\_PRIVATE );

fos . write ( string . getBytes ());

fos . close ();

`MODE_PRIVATE`  will create the file (or replace a file of the same name) and make it private to your application. Other modes available are:  `MODE_APPEND` ,  `MODE_WORLD_READABLE` , and  `MODE_WORLD_WRITEABLE` .

示例2

String  FILENAME  =  "hello\_file" ;

String  string  =  "hello world!" ;

FileOutputStream  fos  =  openFileOutput ( FILENAME ,   Context . MODE\_WORLD\_READABLE );

fos . write ( string . getBytes ());

fos . close ();

示例3

String  FILENAME  =  "hello\_file" ;

String  string  =  "hello world!" ;

FileOutputStream  fos  =  openFileOutput ( FILENAME ,  Context . MODE\_APPEND | Context . MODE\_WORLD\_READABLE) ;

fos . write ( string . getBytes ());

fos . close ();

**注意：**在很多手机上，虽然我们使用openFileOutput(FILENAME, Context.MODE\_WORLD\_READABLE)的方式来创建文件，而且使用ls -l看到该文件对别的应用程序来说其实已经有读的权限，但是别的应用程序实际上还是无法读取这些。这时我们需要在创建该文件的应用程序中对 [getFilesDir()][getFilesDir]目录执行"chmod 705"的操作来解决该问题。具体可以参照《 [Android中一些数据存储函数的封装][Android]》中的getInternalStorageDirectory()方法。

**3.2、Saving cache files**

If you'd like to cache some data, rather than store it persistently, you should use `getCacheDir()` to open a `File`that represents the internal directory where your application should save temporary cache files.

When the device is low on internal storage space, Android may delete these cache files to recover space. However, you should not rely on the system to clean up these files for you. You should always maintain the cache files yourself and stay within a reasonable limit of space consumed, such as 1MB. When the user uninstalls your application, these files are removed.

**3.3、Other useful methods**

`getFilesDir()`Gets the absolute path to the filesystem directory where your internal files are saved. `getDir()`Creates (or opens an existing) directory within your internal storage space. `deleteFile()`Deletes a file saved on the internal storage. `fileList()`Returns an array of files currently saved by your application.

**3.4、通过JAVA传统方式访问**

你也可以通过绝对路径以 JAVA传统方式访问内部存储空间。但是以这种方式创建的文件是对私有， 创建它的应用程序 对该文件是可读可写，但是 别的应用程序并不能直接访问它。 不是所有的 内部存储空间应用程序都可以访问，默认情况下只能访问“ /data/data/你的应用程序的包名”这个路径下的文件。

**实际1**

File  file  =  new  File ( "/data/data/" \+ getPackageName ()+ "/1.txt" );

Log . i ( TAG ,  "path:"  \+  file . getAbsolutePath ());

OutputStream  out  =  null ;

try  \{

out  =  new  BufferedOutputStream ( new  FileOutputStream ( file ));

out . write ( "Hello World" . getBytes ());

\}  catch  ( FileNotFoundException  e1 )  \{

e1 . printStackTrace ();

\}  catch  ( IOException  e )  \{

e . printStackTrace ();

\}  finally  \{

if  ( out  !=  null )  \{

try  \{

out . close ();

\}  catch  ( IOException  e )  \{

e . printStackTrace ();

运行结果

09-24 22:42:51.468: I/robin(24089): path:/data/data/com.lenovo.robin.test/1.txt

**四、External Storage**

**4.1、简介**

Every Android-compatible device supports a shared "external storage" that you can use to save files. This can be a removable storage media (such as an SD card) or an internal (non-removable) storage. Files saved to the external storage are world-readable and can be modified by the user when they enable USB mass storage to transfer files on a computer.

注意：保存在外部存储（SD卡）上的文件对所有的应用程序都是可读的，而保存在内部存储的文件默认对别的应用程序是不可访问的

Caution: External files can disappear if the user mounts the external storage on a computer or removes the media, and there's no security enforced upon files you save to the external storage. All applications can read and write files placed on the external storage and the user can remove them.

**4.2、Checking media availability**

Before you do any work with the external storage, you should always call  `getExternalStorageState()`  to check whether the media is available. The media might be mounted to a computer, missing, read-only, or in some other state. For example, here's how you can check the availability:

boolean  mExternalStorageAvailable  =  false ;

boolean  mExternalStorageWriteable  =  false ;

String  state  =  Environment . getExternalStorageState ();

if  ( Environment . MEDIA\_MOUNTED . equals ( state ))  \{

/\* We can read and write the media\*/

mExternalStorageAvailable  =  mExternalStorageWriteable  =  true ;

\}  else  if  ( Environment . MEDIA\_MOUNTED\_READ\_ONLY . equals ( state ))  \{

/\* We can only read the media\*/

mExternalStorageAvailable  =  true ;

mExternalStorageWriteable  =  false ;

\}  else  \{

/\* Something else is wrong. It may be one of many other states, but all we need\*/

/\*  to know is we can neither read nor write\*/

mExternalStorageAvailable  =  mExternalStorageWriteable  =  false ;

This example checks whether the external storage is available to read and write. The `getExternalStorageState()`  method returns other states that you might want to check, such as whether the media is being shared (connected to a computer), is missing entirely, has been removed badly, etc. You can use these to notify the user with more information when your application needs to access the media.

**4.3、Accessing files on external storage**

If you're using API Level 8 or greater, use `getExternalFilesDir()` to open a `File` that represents the external storage directory where you should save your files. This method takes a `type` parameter that specifies the type of subdirectory you want, such as `DIRECTORY_MUSIC` and `DIRECTORY_RINGTONES` (pass `null` to receive the root of your application's file directory). This method will create the appropriate directory if necessary. By specifying the type of directory, you ensure that the Android's media scanner will properly categorize your files in the system (for example, ringtones are identified as ringtones and not music). If the user uninstalls your application, this directory and all its contents will be deleted.

If you're using API Level 7 or lower, use `getExternalStorageDirectory()`, to open a `File` representing the root of the external storage. You should then write your data in the following directory:

/Android/data/<package_name>/files/

The `<package_name>` is your Java-style package name, such as "`com.example.android.app`". If the user's device is running API Level 8 or greater and they uninstall your application, this directory and all its contents will be deleted.

**4.4、Saving shared files**

f you want to save files that are not specific to your application and that should not be deleted when your application is uninstalled, save them to one of the public directories on the external storage. These directories lay at the root of the external storage, such as `Music/`, `Pictures/`, `Ringtones/`, and others.

In API Level 8 or greater, use`getExternalStoragePublicDirectory()`, passing it the type of public directory you want, such as `DIRECTORY_MUSIC`,`DIRECTORY_PICTURES`, `DIRECTORY_RINGTONES`, or others. This method will create the appropriate directory if necessary.

If you're using API Level 7 or lower, use`getExternalStorageDirectory()` to open a `File` that represents the root of the external storage, then save your shared files in one of the following directories:

*  `Music/` - Media scanner classifies all media found here as user music.
 *  `Podcasts/` - Media scanner classifies all media found here as a podcast.
 *  `Ringtones/ `\- Media scanner classifies all media found here as a ringtone.
 *  `Alarms/` - Media scanner classifies all media found here as an alarm sound.
 *  `Notifications/` - Media scanner classifies all media found here as a notification sound.
 *  `Pictures/` - All photos (excluding those taken with the camera).
 *  `Movies/` - All movies (excluding those taken with the camcorder).
 *  `Download/` - Miscellaneous downloads.

**4.5、Saving cache files**

f you're using API Level 8 or greater, use `getExternalCacheDir()` to open a `File` that represents the external storage directory where you should save cache files. If the user uninstalls your application, these files will be automatically deleted. However, during the life of your application, you should manage these cache files and remove those that aren't needed in order to preserve file space.

If you're using API Level 7 or lower, use `getExternalStorageDirectory()` to open a `File` that represents the root of the external storage, then write your cache data in the following directory:

/Android/data/<package_name>/cache/

The `<package_name>` is your Java-style package name, such as "`com.example.android.app`".

4.6、EMMC存储

很多手机现在都有EMMC存储（一般是2G），一些手机并没有挂载在getExternalStorageDirectory()这个节点上（该节点用于挂载外部sdcard了）.

而是挂载到如下"/mnt/emmc"的节点上，另外一些手机把 EMMC存储直接 挂载到了 getExternalStorageDirectory()这个节点上,而对于真正的外部sdcard挂载到了 "/mnt/sdcard2" 这个节点上。

因此当我们存储一个文件时首先应该存在 getExternalStorageDirectory()这个节点上，其次是 "/mnt/sdcard2" 这个节点上，再次是 "/mnt/emmc"，最后才是手机的内部存储(即“/data”区域）。 关于此一些封装请参照《 [Android中一些数据存储函数的封装》][Android]

**4.7、一些重要的函数**

Android中,关于外部存储的重要函数,请参考《 [Android中关于外部存储的一些重要函数][Android 1]》；关于内部存储的重要函数，请参考《 [Android中关于内部存储的一些重要函数][Android 2]》

**五、数据库存储**

Android provides full support for [SQLite][] databases. Any databases you create will be accessible by name to any class in the application, but not outside the application.

The recommended method to create a new SQLite database is to create a subclass of `SQLiteOpenHelper` and override the `onCreate()` method, in which you can execute a SQLite command to create tables in the database.

For example:

public  class  DictionaryOpenHelper  extends  SQLiteOpenHelper  \{       private  static  final  int  DATABASE\_VERSION  =  2 ;      private  static  final  String  DICTIONARY\_TABLE\_NAME  =  "dictionary" ;      private  static  final  String  DICTIONARY\_TABLE\_CREATE  =                  "CREATE TABLE "  \+  DICTIONARY\_TABLE\_NAME  \+  " ("  \+                 KEY\_WORD  \+  " TEXT, "  \+                 KEY\_DEFINITION  \+  " TEXT);" ;      DictionaryOpenHelper ( Context  context )  \{           super ( context ,  DATABASE\_NAME ,  null ,  DATABASE\_VERSION );      \}      @Override      public  void  onCreate ( SQLiteDatabase  db )  \{          db . execSQL ( DICTIONARY\_TABLE\_CREATE );      \} \}

You can then get an instance of your  `SQLiteOpenHelper` implementation using the constructor you've defined. To write to and read from the database, call  `getWritableDatabase()` and  `getReadableDatabase()`, respectively. These both return a  `SQLiteDatabase` object that represents the database and provides methods for SQLite operations.

Android does not impose any limitations beyond the standard SQLite concepts. We do recommend including an autoincrement value key field that can be used as a unique ID to quickly find a record. This is not required for private data, but if you implement a[content provider][content_provider], you must include a unique ID using the`BaseColumns._ID` constant.

You can execute SQLite queries using the `SQLiteDatabase``query()` methods, which accept various query parameters, such as the table to query, the projection, selection, columns, grouping, and others. For complex queries, such as those that require column aliases, you should use `SQLiteQueryBuilder`, which provides several convienent methods for building queries.

Every SQLite query will return a `Cursor` that points to all the rows found by the query. The `Cursor` is always the mechanism with which you can navigate results from a database query and read rows and columns.

For sample apps that demonstrate how to use SQLite databases in Android, see the [Note Pad][Note_Pad] and [Searchable Dictionary][] applications.

### Database debugging ###

The Android SDK includes a `sqlite3` database tool that allows you to browse table contents, run SQL commands, and perform other useful functions on SQLite databases. See [Examining sqlite3 databases from a remote shell][] to learn how to run this tool.

**六、网络存储**

You can use the network (when it's available) to store and retrieve data on your own web-based services. To do network operations, use classes in the following packages:

*  `java.net.*`
 *  `android.net.*`

**七、ACache存储**

ACache介绍：ACache类似于SharedPreferences，但是比SharedPreferences功能更加强大，SharedPreferences只能保存一些基本数据类型、Serializable、Bundle等数据。而Acache可以缓存如下数据：普通的字符串、JsonObject、JsonArray、Bitmap、Drawable、序列化的java对象，和 byte数据。主要特色：

*  1：轻，轻到只有一个JAVA文件。
 *  2：可配置，可以配置缓存路径，缓存大小，缓存数量等。
 *  3：可以设置缓存超时时间，缓存超时自动失效，并被删除。
 *  4：支持多进程。

应用场景：

*  1、替换SharePreference当做配置文件
 *  2、可以缓存网络请求数据，比如oschina的android客户端可以缓存http请求的新闻内容，缓存时间假设为1个小时，超时后自动失效，让客户端重新请求新的数据，减少客户端流量，同时减少服务器并发量。
 *  3、您来说...

下载链接： [https://github.com/yangfuhai/ASimpleCache][https_github.com_yangfuhai_ASimpleCache]

**八、DiskLruCache硬盘缓存**

Google又提供了一套硬盘缓存的解决方案：DiskLruCache(非Google官方编写，但获得官方认证)。

更多内容请参考《 [Android DiskLruCache完全解析，硬盘缓存的最佳方案][Android_DiskLruCache]》

结束

#### 给我老师的人工智能教程打call！[http://blog.csdn.net/jiangjunshow][http_blog.csdn.net_jiangjunshow] ####

![这里写图片描述][SouthEast]

[http_blog.csdn.net_jiangjunshow]: https://blog.csdn.net/jiangjunshow/article/details/77338485
[http_developer.android.com_guide_topics_data_data-storage.html_filesInternal]: http://developer.android.com/guide/topics/data/data-storage.html#filesInternal
[Shared Preferences]: http://developer.android.com/guide/topics/data/data-storage.html#pref
[External Storage]: http://developer.android.com/guide/topics/data/data-storage.html#filesExternal
[SQLite Databases]: http://developer.android.com/guide/topics/data/data-storage.html#db
[Network Connection]: http://developer.android.com/guide/topics/data/data-storage.html#netw
[content_provider]: http://developer.android.com/guide/topics/providers/content-providers.html
[SharedPreferences]: http://hubingforever.blog.163.com/blog/static/1710405792010516114033149/
[openFileOutput]: http://developer.android.com/reference/android/content/Context.html#openFileOutput%28java.lang.String,%20int%29
[openFileInput]: http://developer.android.com/reference/android/content/Context.html#openFileInput%28java.lang.String%29
[getFilesDir]: http://developer.android.com/reference/android/content/Context.html#getFilesDir%28%29
[Android]: http://hubingforever.blog.163.com/blog/static/17104057920129198236599/
[Android 1]: http://hubingforever.blog.163.com/blog/static/1710405792012816103948907/
[Android 2]: http://hubingforever.blog.163.com/blog/static/171040579201281895042802/
[SQLite]: http://www.sqlite.org/
[Note_Pad]: http://developer.android.com/resources/samples/NotePad/index.html
[Searchable Dictionary]: http://developer.android.com/resources/samples/SearchableDictionary/index.html
[Examining sqlite3 databases from a remote shell]: http://developer.android.com/tools/help/adb.html#sqlite
[https_github.com_yangfuhai_ASimpleCache]: https://github.com/yangfuhai/ASimpleCache
[Android_DiskLruCache]: http://blog.csdn.net/hudashi/article/details/51720614
[SouthEast]: /images/20220417/4ac44e600827467bb0dee5a7e8fca896.png