Android數據存儲五種方式總結

本文介紹Android平台進行數據存儲的五大方式,分別如下:   

    1 使用SharedPreferences存儲數據

    2 文件存儲數據      

    3 SQLite數據庫存儲數據

    4 使用ContentProvider存儲數據

    5 網絡存儲數據

下面詳細講解這五種方式的特點

第一種： 使用SharedPreferences存儲數據

    適用范圍：保存少量的數據，且這些數據的格式非常簡單：字符串型、基本類型的值。比如應用程序的各種配置信息（如是否打開音效、是否使用震動效果、小游戲的玩家積分等），解鎖口 令密碼等

    核心原理：保存基於XML文件存儲的key-value鍵值對數據，通常用來存儲一些簡單的配置信息。通過DDMS的File Explorer面板，展開文件瀏覽樹,很明顯SharedPreferences數據總是存儲在/data/data/<package name>/shared_prefs目錄下。SharedPreferences對象本身只能獲取數據而不支持存儲和修改,存儲修改是通過SharedPreferences.edit()獲取的內部接口Editor對象實現。 SharedPreferences本身是一 個接口，程序無法直接創建SharedPreferences實例，只能通過Context提供的getSharedPreferences(String name, int mode)方法來獲取SharedPreferences實例，該方法中name表示要操作的xml文件名，第二個參數具體如下：

                 Context.MODE_PRIVATE: 指定該SharedPreferences數據只能被本應用程序讀、寫。

                 Context.MODE_WORLD_READABLE:  指定該SharedPreferences數據能被其他應用程序讀，但不能寫。

                 Context.MODE_WORLD_WRITEABLE:  指定該SharedPreferences數據能被其他應用程序讀，寫

Editor有如下主要重要方法：

                 SharedPreferences.Editor clear():清空SharedPreferences里所有數據

                 SharedPreferences.Editor putXxx(String key , xxx value): 向SharedPreferences存入指定key對應的數據，其中xxx 可以是boolean,float,int等各種基本類型據

                 SharedPreferences.Editor remove(): 刪除SharedPreferences中指定key對應的數據項

                 boolean commit(): 當Editor編輯完成后，使用該方法提交修改

    實際案例：運行界面如下

                       

這里只提供了兩個按鈕和一個輸入文本框，布局簡單，故在此不給出界面布局文件了,程序核心代碼如下：         

class ViewOcl implements View.OnClickListener{ @Override public void onClick(View v) { switch(v.getId()){ case R.id.btnSet: //步驟1：獲取輸入值 String code = txtCode.getText().toString().trim(); //步驟2-1：創建一個SharedPreferences.Editor接口對象，lock表示要寫入的XML文件名，MODE_WORLD_WRITEABLE寫操作 SharedPreferences.Editor editor = getSharedPreferences("lock", MODE_WORLD_WRITEABLE).edit(); //步驟2-2：將獲取過來的值放入文件 editor.putString("code", code); //步驟3：提交  editor.commit(); Toast.makeText(getApplicationContext(), "口令設置成功", Toast.LENGTH_LONG).show(); break; case R.id.btnGet: //步驟1：創建一個SharedPreferences接口對象 SharedPreferences read = getSharedPreferences("lock", MODE_WORLD_READABLE); //步驟2：獲取文件中的值 String value = read.getString("code", ""); Toast.makeText(getApplicationContext(), "口令為："+value, Toast.LENGTH_LONG).show(); break; } } }

讀寫其他應用的SharedPreferences: 步驟如下

                1、在創建SharedPreferences時，指定MODE_WORLD_READABLE模式，表明該SharedPreferences數據可以被其他程序讀取

                2、創建其他應用程序對應的Context:

                    Context pvCount = createPackageContext("com.tony.app", Context.CONTEXT_IGNORE_SECURITY);這里的com.tony.app就是其他程序的包名

                3、使用其他程序的Context獲取對應的SharedPreferences

                    SharedPreferences read = pvCount.getSharedPreferences("lock", Context.MODE_WORLD_READABLE);

                4、如果是寫入數據，使用Editor接口即可，所有其他操作均和前面一致。

SharedPreferences對象與SQLite數據庫相比，免去了創建數據庫，創建表，寫SQL語句等諸多操作，相對而言更加方便，簡潔。 但是SharedPreferences也有其自身缺陷，比如其職能存儲boolean，int，float，long和String五種簡單的數據類 型，比如其無法進行條件查詢等。所以不論SharedPreferences的數據存儲操作是如何簡單，它也只能是存儲方式的一種補充，而無法完全替代如 SQLite數據庫這樣的其他數據存儲方式。

 

第二種： 文件存儲數據

 核心原理: Context提供了兩個方法來打開數據文件里的文件IO流 FileInputStream openFileInput(String name); FileOutputStream(String name , int mode),這兩個方法第一個參數 用於指定文件名，第二個參數指定打開文件的模式。具體有以下值可選：

             MODE_PRIVATE：為默認操作模式，代表該文件是私有數據，只能被應用本身訪問，在該模式下，寫入的內容會覆蓋原文件的內容，如果想把新寫入的內容追加到原文件中。可   以使用Context.MODE_APPEND

             MODE_APPEND：模式會檢查文件是否存在，存在就往文件追加內容，否則就創建新文件。

             MODE_WORLD_READABLE：表示當前文件可以被其他應用讀取；

             MODE_WORLD_WRITEABLE：表示當前文件可以被其他應用寫入。

 除此之外，Context還提供了如下幾個重要的方法：

             getDir(String name , int mode):在應用程序的數據文件夾下獲取或者創建name對應的子目錄

             File getFilesDir():獲取該應用程序的數據文件夾得絕對路徑

             String[] fileList():返回該應用數據文件夾的全部文件               

實際案例：界面沿用上圖

             核心代碼如下：

public String read() { try { FileInputStream inStream = this.openFileInput("message.txt"); byte[] buffer = new byte[1024]; int hasRead = 0; StringBuilder sb = new StringBuilder(); while ((hasRead = inStream.read(buffer)) != -1) { sb.append(new String(buffer, 0, hasRead)); } inStream.close(); return sb.toString(); } catch (Exception e) { e.printStackTrace(); } return null; } public void write(String msg){ // 步驟1：獲取輸入值 if(msg == null) return; try { // 步驟2:創建一個FileOutputStream對象,MODE_APPEND追加模式 FileOutputStream fos = openFileOutput("message.txt", MODE_APPEND); // 步驟3：將獲取過來的值放入文件  fos.write(msg.getBytes()); // 步驟4：關閉數據流  fos.close(); } catch (Exception e) { e.printStackTrace(); } }

openFileOutput()方法的第一參數用於指定文件名稱，不能包含路徑分隔符“/” ，如果文件不存在，Android 會自動創建它。創建的文件保存在/data/data/<package name>/files目錄，如： /data/data/cn.tony.app/files/message.txt，

 下面講解某些特殊文件讀寫需要注意的地方:

讀寫sdcard上的文件

其中讀寫步驟按如下進行:

1、調用Environment的getExternalStorageState()方法判斷手機上是否插了sd卡,且應用程序具有讀寫SD卡的權限，如下代碼將返回true

Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)

2、調用Environment.getExternalStorageDirectory()方法來獲取外部存儲器，也就是SD卡的目錄,或者使用"/mnt/sdcard/"目錄

3、使用IO流操作SD卡上的文件 

注意點：手機應該已插入SD卡，對於模擬器而言，可通過mksdcard命令來創建虛擬存儲卡

           必須在AndroidManifest.xml上配置讀寫SD卡的權限

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

案例代碼：

// 文件寫操作函數 private void write(String content) { if (Environment.getExternalStorageState().equals( Environment.MEDIA_MOUNTED)) { // 如果sdcard存在 File file = new File(Environment.getExternalStorageDirectory() .toString() + File.separator + DIR + File.separator + FILENAME); // 定義File類對象 if (!file.getParentFile().exists()) { // 父文件夾不存在 file.getParentFile().mkdirs(); // 創建文件夾  } PrintStream out = null; // 打印流對象用於輸出 try { out = new PrintStream(new FileOutputStream(file, true)); // 追加文件  out.println(content); } catch (Exception e) { e.printStackTrace(); } finally { if (out != null) { out.close(); // 關閉打印流  } } } else { // SDCard不存在，使用Toast提示用戶 Toast.makeText(this, "保存失敗，SD卡不存在！", Toast.LENGTH_LONG).show(); } } // 文件讀操作函數 private String read() { if (Environment.getExternalStorageState().equals( Environment.MEDIA_MOUNTED)) { // 如果sdcard存在 File file = new File(Environment.getExternalStorageDirectory() .toString() + File.separator + DIR + File.separator + FILENAME); // 定義File類對象 if (!file.getParentFile().exists()) { // 父文件夾不存在 file.getParentFile().mkdirs(); // 創建文件夾  } Scanner scan = null; // 掃描輸入 StringBuilder sb = new StringBuilder(); try { scan = new Scanner(new FileInputStream(file)); // 實例化Scanner while (scan.hasNext()) { // 循環讀取 sb.append(scan.next() + "\n"); // 設置文本  } return sb.toString(); } catch (Exception e) { e.printStackTrace(); } finally { if (scan != null) { scan.close(); // 關閉打印流  } } } else { // SDCard不存在，使用Toast提示用戶 Toast.makeText(this, "讀取失敗，SD卡不存在！", Toast.LENGTH_LONG).show(); } return null; }

 第三種：SQLite存儲數據

SQLite是輕量級嵌入式數據庫引擎，它支持 SQL 語言，並且只利用很少的內存就有很好的性能。現在的主流移動設備像Android、iPhone等都使用SQLite作為復雜數據的存儲引擎，在我們為移 動設備開發應用程序時，也許就要使用到SQLite來存儲我們大量的數據，所以我們就需要掌握移動設備上的SQLite開發技巧

SQLiteDatabase類為我們提供了很多種方法，上面的代碼中基本上囊括了大部分的數據庫操作；對於添加、更新和刪除來說，我們都可以使用

1 db.executeSQL(String sql); 2 db.executeSQL(String sql, Object[] bindArgs);//sql語句中使用占位符，然后第二個參數是實際的參數集 

除了統一的形式之外，他們還有各自的操作方法：

1 db.insert(String table, String nullColumnHack, ContentValues values); 2 db.update(String table, Contentvalues values, String whereClause, String whereArgs); 3 db.delete(String table, String whereClause, String whereArgs);

以上三個方法的第一個參數都是表示要操作的表名；insert中的第二個參數表示如果插入的數據每一列都為空的話，需要指定此行中某一列的名稱，系 統將此列設置為NULL，不至於出現錯誤；insert中的第三個參數是ContentValues類型的變量，是鍵值對組成的Map，key代表列 名，value代表該列要插入的值；update的第二個參數也很類似，只不過它是更新該字段key為最新的value值，第三個參數 whereClause表示WHERE表達式，比如“age > ? and age < ?”等，最后的whereArgs參數是占位符的實際參數值；delete方法的參數也是一樣

下面給出demo

數據的添加

1.使用insert方法

1 ContentValues cv = new ContentValues();//實例化一個ContentValues用來裝載待插入的數據 2 cv.put("title","you are beautiful");//添加title 3 cv.put("weather","sun"); //添加weather 4 cv.put("context","xxxx"); //添加context 5 String publish = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss") 6 .format(new Date()); 7 cv.put("publish ",publish); //添加publish 8 db.insert("diary",null,cv);//執行插入操作

2.使用execSQL方式來實現

String sql = "insert into user(username,password) values ('Jack Johnson','iLovePopMuisc');//插入操作的SQL語句
db.execSQL(sql);//執行SQL語句

數據的刪除

同樣有2種方式可以實現

String whereClause = "username=?";//刪除的條件 String[] whereArgs = {"Jack Johnson"};//刪除的條件參數 db.delete("user",whereClause,whereArgs);//執行刪除

使用execSQL方式的實現

String sql = "delete from user where username='Jack Johnson'";//刪除操作的SQL語句 db.execSQL(sql);//執行刪除操作

數據修改

同上，仍是2種方式

ContentValues cv = new ContentValues();//實例化ContentValues cv.put("password","iHatePopMusic");//添加要更改的字段及內容 String whereClause = "username=?";//修改條件 String[] whereArgs = {"Jack Johnson"};//修改條件的參數 db.update("user",cv,whereClause,whereArgs);//執行修改

使用execSQL方式的實現

String sql = "update user set password = 'iHatePopMusic' where username='Jack Johnson'";//修改的SQL語句 db.execSQL(sql);//執行修改

數據查詢

下面來說說查詢操作。查詢操作相對於上面的幾種操作要復雜些，因為我們經常要面對着各種各樣的查詢條件，所以系統也考慮到這種復雜性，為我們提供了較為豐富的查詢形式：

1 db.rawQuery(String sql, String[] selectionArgs); 2 db.query(String table, String[] columns, String selection, String[] selectionArgs, String groupBy, String having, String orderBy); 3 db.query(String table, String[] columns, String selection, String[] selectionArgs, String groupBy, String having, String orderBy, String limit); 4 db.query(String distinct, String table, String[] columns, String selection, String[] selectionArgs, String groupBy, String having, String orderBy, String limit); 

上面幾種都是常用的查詢方法，第一種最為簡單，將所有的SQL語句都組織到一個字符串中，使用占位符代替實際參數，selectionArgs就是占位符實際參數集；

各參數說明：

• table：表名稱
• colums：表示要查詢的列所有名稱集
• selection：表示WHERE之后的條件語句，可以使用占位符
• selectionArgs：條件語句的參數數組
• groupBy：指定分組的列名
• having：指定分組條件,配合groupBy使用
• orderBy：y指定排序的列名
• limit：指定分頁參數
• distinct：指定“true”或“false”表示要不要過濾重復值
• Cursor：返回值，相當於結果集ResultSet

最后，他們同時返回一個Cursor對象，代表數據集的游標，有點類似於JavaSE中的ResultSet。下面是Cursor對象的常用方法：

 1 c.move(int offset); //以當前位置為參考,移動到指定行  2 c.moveToFirst(); //移動到第一行  3 c.moveToLast(); //移動到最后一行  4 c.moveToPosition(int position); //移動到指定行  5 c.moveToPrevious(); //移動到前一行  6 c.moveToNext(); //移動到下一行  7 c.isFirst(); //是否指向第一條  8 c.isLast(); //是否指向最后一條  9 c.isBeforeFirst(); //是否指向第一條之前 10 c.isAfterLast(); //是否指向最后一條之后 11 c.isNull(int columnIndex); //指定列是否為空(列基數為0) 12 c.isClosed(); //游標是否已關閉 13 c.getCount(); //總數據項數 14 c.getPosition(); //返回當前游標所指向的行數 15 c.getColumnIndex(String columnName);//返回某列名對應的列索引值 16 c.getString(int columnIndex); //返回當前行指定列的值 

實現代碼

String[] params =  {12345,123456};
Cursor cursor = db.query("user",columns,"ID=?",params,null,null,null);//查詢並獲得游標 if(cursor.moveToFirst()){//判斷游標是否為空 for(int i=0;i<cursor.getCount();i++){ cursor.move(i);//移動到指定記錄 String username = cursor.getString(cursor.getColumnIndex("username"); String password = cursor.getString(cursor.getColumnIndex("password")); } }

通過rawQuery實現的帶參數查詢

Cursor result=db.rawQuery("SELECT ID, name, inventory FROM mytable");
//Cursor c = db.rawQuery("s name, inventory FROM mytable where ID=?",new Stirng[]{"123456"}); result.moveToFirst(); while (!result.isAfterLast()) { int id=result.getInt(0); String name=result.getString(1); int inventory=result.getInt(2); // do something useful with these  result.moveToNext(); } result.close();

 

在上面的代碼示例中，已經用到了這幾個常用方法中的一些，關於更多的信息，大家可以參考官方文檔中的說明。

最后當我們完成了對數據庫的操作后，記得調用SQLiteDatabase的close()方法釋放數據庫連接，否則容易出現SQLiteException。

上面就是SQLite的基本應用，但在實際開發中，為了能夠更好的管理和維護數據庫，我們會封裝一個繼承自SQLiteOpenHelper類的數據庫操作類，然后以這個類為基礎，再封裝我們的業務邏輯方法。

這里直接使用案例講解：下面是案例demo的界面

SQLiteOpenHelper類介紹

SQLiteOpenHelper是SQLiteDatabase的一個幫助類，用來管理數據庫的創建和版本的更新。一般是建立一個類繼承它，並實現它的onCreate和onUpgrade方法。

方法名	方法描述
SQLiteOpenHelper(Context context,String name,SQLiteDatabase.CursorFactory factory,int version)	構造方法，其中 context 程序上下文環境 即：XXXActivity.this; name :數據庫名字; factory:游標工廠，默認為null,即為使用默認工廠; version 數據庫版本號
onCreate(SQLiteDatabase db)	創建數據庫時調用
onUpgrade(SQLiteDatabase db,int oldVersion , int newVersion)	版本更新時調用
getReadableDatabase()	創建或打開一個只讀數據庫
getWritableDatabase()	創建或打開一個讀寫數據庫

首先創建數據庫類

 1 import android.content.Context;  2 import android.database.sqlite.SQLiteDatabase;  3 import android.database.sqlite.SQLiteDatabase.CursorFactory;  4 import android.database.sqlite.SQLiteOpenHelper;  5  6 public class SqliteDBHelper extends SQLiteOpenHelper {  7  8 // 步驟1：設置常數參量  9 private static final String DATABASE_NAME = "diary_db"; 10 private static final int VERSION = 1; 11 private static final String TABLE_NAME = "diary"; 12 13 // 步驟2：重載構造方法 14 public SqliteDBHelper(Context context) { 15 super(context, DATABASE_NAME, null, VERSION); 16  } 17 18 /* 19  * 參數介紹：context 程序上下文環境 即：XXXActivity.this 20  * name 數據庫名字 21  * factory 接收數據，一般情況為null 22  * version 數據庫版本號 23 */ 24 public SqliteDBHelper(Context context, String name, CursorFactory factory, 25 int version) { 26 super(context, name, factory, version); 27  } 28 //數據庫第一次被創建時，onCreate()會被調用 29  @Override 30 public void onCreate(SQLiteDatabase db) { 31 // 步驟3：數據庫表的創建 32 String strSQL = "create table " 33 + TABLE_NAME 34 + "(tid integer primary key autoincrement,title varchar(20),weather varchar(10),context text,publish date)"; 35 //步驟4：使用參數db,創建對象 36  db.execSQL(strSQL); 37  } 38 //數據庫版本變化時，會調用onUpgrade() 39  @Override 40 public void onUpgrade(SQLiteDatabase arg0, int arg1, int arg2) { 41 42  } 43 }

正如上面所述，數據庫第一次創建時onCreate方法會被調用，我們可以執行創建表的語句，當系統發現版本變化之后，會調用onUpgrade方法，我們可以執行修改表結構等語句。

 我們需要一個Dao，來封裝我們所有的業務方法，代碼如下：

 1 import android.content.Context;  2 import android.database.Cursor;  3 import android.database.sqlite.SQLiteDatabase;  4  5 import com.chinasoft.dbhelper.SqliteDBHelper;  6  7 public class DiaryDao {  8  9 private SqliteDBHelper sqliteDBHelper; 10 private SQLiteDatabase db; 11 12 // 重寫構造方法 13 public DiaryDao(Context context) { 14 this.sqliteDBHelper = new SqliteDBHelper(context); 15 db = sqliteDBHelper.getWritableDatabase(); 16  } 17 18 // 讀操作 19 public String execQuery(final String strSQL) { 20 try { 21 System.out.println("strSQL>" + strSQL); 22 // Cursor相當於JDBC中的ResultSet 23 Cursor cursor = db.rawQuery(strSQL, null); 24 // 始終讓cursor指向數據庫表的第1行記錄 25  cursor.moveToFirst(); 26 // 定義一個StringBuffer的對象，用於動態拼接字符串 27 StringBuffer sb = new StringBuffer(); 28 // 循環游標，如果不是最后一項記錄 29 while (!cursor.isAfterLast()) { 30 sb.append(cursor.getInt(0) + "/" + cursor.getString(1) + "/" 31 + cursor.getString(2) + "/" + cursor.getString(3) + "/" 32 + cursor.getString(4)+"#"); 33 //cursor游標移動 34  cursor.moveToNext(); 35  } 36  db.close(); 37 return sb.deleteCharAt(sb.length()-1).toString(); 38 } catch (RuntimeException e) { 39  e.printStackTrace(); 40 return null; 41  } 42 43  } 44 45 // 寫操作 46 public boolean execOther(final String strSQL) { 47 db.beginTransaction(); //開始事務 48 try { 49 System.out.println("strSQL" + strSQL); 50  db.execSQL(strSQL); 51 db.setTransactionSuccessful(); //設置事務成功完成 52  db.close(); 53 return true; 54 } catch (RuntimeException e) { 55  e.printStackTrace(); 56 return false; 57 }finally { 58 db.endTransaction(); //結束事務 59  } 60 61  } 62 }

我們在Dao構造方法中實例化sqliteDBHelper並獲取一個SQLiteDatabase對象，作為整個應用的數據庫實例；在增刪改信息時，我們采用了事務處理，確保數據完整性；最后要注意釋放數據庫資源db.close()，這一個步驟在我們整個應用關閉時執行，這個環節容易被忘記，所以朋友們要注意。

我們獲取數據庫實例時使用了getWritableDatabase()方法，也許朋友們會有疑問，在getWritableDatabase()和getReadableDatabase()中，你為什么選擇前者作為整個應用的數據庫實例呢？在這里我想和大家着重分析一下這一點。

我們來看一下SQLiteOpenHelper中的getReadableDatabase()方法：

 1 public synchronized SQLiteDatabase getReadableDatabase() {  2 if (mDatabase != null && mDatabase.isOpen()) {  3 // 如果發現mDatabase不為空並且已經打開則直接返回  4 return mDatabase;  5  }  6  7 if (mIsInitializing) {  8 // 如果正在初始化則拋出異常  9 throw new IllegalStateException("getReadableDatabase called recursively"); 10  } 11 12 // 開始實例化數據庫mDatabase 13 14 try { 15 // 注意這里是調用了getWritableDatabase()方法 16 return getWritableDatabase(); 17 } catch (SQLiteException e) { 18 if (mName == null) 19 throw e; // Can't open a temp database read-only! 20 Log.e(TAG, "Couldn't open " + mName + " for writing (will try read-only):", e); 21  } 22 23 // 如果無法以可讀寫模式打開數據庫 則以只讀方式打開 24 25 SQLiteDatabase db = null; 26 try { 27 mIsInitializing = true; 28 String path = mContext.getDatabasePath(mName).getPath();// 獲取數據庫路徑 29 // 以只讀方式打開數據庫 30 db = SQLiteDatabase.openDatabase(path, mFactory, SQLiteDatabase.OPEN_READONLY); 31 if (db.getVersion() != mNewVersion) { 32 throw new SQLiteException("Can't upgrade read-only database from version " + db.getVersion() + " to " 33 + mNewVersion + ": " + path); 34  } 35 36  onOpen(db); 37 Log.w(TAG, "Opened " + mName + " in read-only mode"); 38 mDatabase = db;// 為mDatabase指定新打開的數據庫 39 return mDatabase;// 返回打開的數據庫 40 } finally { 41 mIsInitializing = false; 42 if (db != null && db != mDatabase) 43  db.close(); 44  } 45 }

在getReadableDatabase()方法中，首先判斷是否已存在數據庫實例並且是打開狀態，如果是，則直接返回該實例，否則試圖獲取一個可讀寫模式的數據庫實例，如果遇到磁盤空間已滿等情況獲取失敗的話，再以只讀模式打開數據庫，獲取數據庫實例並返回，然后為mDatabase賦值為最新打開的數據庫實例。既然有可能調用到getWritableDatabase()方法，我們就要看一下了：

public synchronized SQLiteDatabase getWritableDatabase() { if (mDatabase != null && mDatabase.isOpen() && !mDatabase.isReadOnly()) { // 如果mDatabase不為空已打開並且不是只讀模式 則返回該實例 return mDatabase; } 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; // 如果mDatabase不為空則加鎖 阻止其他的操作 if (mDatabase != null) mDatabase.lock(); try { mIsInitializing = true; if (mName == null) { db = SQLiteDatabase.create(null); } else { // 打開或創建數據庫 db = mContext.openOrCreateDatabase(mName, 0, mFactory); } // 獲取數據庫版本(如果剛創建的數據庫,版本為0) int version = db.getVersion(); // 比較版本(我們代碼中的版本mNewVersion為1) if (version != mNewVersion) { db.beginTransaction();// 開始事務 try { if (version == 0) { // 執行我們的onCreate方法  onCreate(db); } else { // 如果我們應用升級了mNewVersion為2,而原版本為1則執行onUpgrade方法  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) { // 如果mDatabase有值則先關閉 try { mDatabase.close(); } catch (Exception e) { } mDatabase.unlock();// 解鎖  } mDatabase = db;// 賦值給mDatabase } else { // 打開失敗的情況：解鎖、關閉 if (mDatabase != null) mDatabase.unlock(); if (db != null) db.close(); } } }

大家可以看到，幾個關鍵步驟是，首先判斷mDatabase如果不為空已打開並不是只讀模式則直接返回，否則如果mDatabase不為空則加鎖，然后開始打開或創建數據庫，比較版本，根據版本號來調用相應的方法，為數據庫設置新版本號，最后釋放舊的不為空的mDatabase並解鎖，把新打開的數據庫實例賦予mDatabase，並返回最新實例。

看完上面的過程之后，大家或許就清楚了許多，如果不是在遇到磁盤空間已滿等情況，getReadableDatabase()一般都會返回和getWritableDatabase()一樣的數據庫實例，所以我們在DBManager構造方法中使用getWritableDatabase()獲取整個應用所使用的數據庫實例是可行的。當然如果你真的擔心這種情況會發生，那么你可以先用getWritableDatabase()獲取數據實例，如果遇到異常，再試圖用getReadableDatabase()獲取實例，當然這個時候你獲取的實例只能讀不能寫了

最后，讓我們看一下如何使用這些數據操作方法來顯示數據,界面核心邏輯代碼:

public class SQLiteActivity extends Activity { public DiaryDao diaryDao; //因為getWritableDatabase內部調用了mContext.openOrCreateDatabase(mName, 0, mFactory); //所以要確保context已初始化,我們可以把實例化Dao的步驟放在Activity的onCreate里  @Override protected void onCreate(Bundle savedInstanceState) { diaryDao = new DiaryDao(SQLiteActivity.this); initDatabase(); } class ViewOcl implements View.OnClickListener { @Override public void onClick(View v) { String strSQL; boolean flag; String message; switch (v.getId()) { case R.id.btnAdd: String title = txtTitle.getText().toString().trim(); String weather = txtWeather.getText().toString().trim();; String context = txtContext.getText().toString().trim();; String publish = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss") .format(new Date()); // 動態組件SQL語句 strSQL = "insert into diary values(null,'" + title + "','" + weather + "','" + context + "','" + publish + "')"; flag = diaryDao.execOther(strSQL); //返回信息 message = flag?"添加成功":"添加失敗"; Toast.makeText(getApplicationContext(), message, Toast.LENGTH_LONG).show(); break; case R.id.btnDelete: strSQL = "delete from diary where tid = 1"; flag = diaryDao.execOther(strSQL); //返回信息 message = flag?"刪除成功":"刪除失敗"; Toast.makeText(getApplicationContext(), message, Toast.LENGTH_LONG).show(); break; case R.id.btnQuery: strSQL = "select * from diary order by publish desc"; String data = diaryDao.execQuery(strSQL); Toast.makeText(getApplicationContext(), data, Toast.LENGTH_LONG).show(); break; case R.id.btnUpdate: strSQL = "update diary set title = '測試標題1-1' where tid = 1"; flag = diaryDao.execOther(strSQL); //返回信息 message = flag?"更新成功":"更新失敗"; Toast.makeText(getApplicationContext(), message, Toast.LENGTH_LONG).show(); break; } } } private void initDatabase() { // 創建數據庫對象 SqliteDBHelper sqliteDBHelper = new SqliteDBHelper(SQLiteActivity.this); sqliteDBHelper.getWritableDatabase(); System.out.println("數據庫創建成功"); } }

 

Android sqlite3數據庫管理工具

Android SDK的tools目錄下提供了一個sqlite3.exe工具，這是一個簡單的sqlite數據庫管理工具。開發者可以方便的使用其對sqlite數據庫進行命令行的操作。

程序運行生成的*.db文件一般位於"/data/data/項目名(包括所處包名)/databases/*.db"，因此要對數據庫文件進行操作需要先找到數據庫文件：

1、進入shell 命令

adb shell

2、找到數據庫文件

#cd data/data
#ls                --列出所有項目
#cd project_name   --進入所需項目名
#cd databases    
#ls                --列出現寸的數據庫文件

3、進入數據庫

#sqlite3 test_db   --進入所需數據庫

會出現類似如下字樣：

SQLite version 3.6.22
Enter ".help" for instructions
Enter SQL statements terminated with a ";"
sqlite>

至此，可對數據庫進行sql操作。

4、sqlite常用命令

>.databases        --產看當前數據庫
>.tables           --查看當前數據庫中的表
>.help             --sqlite3幫助
>.schema            --各個表的生成語句

 

第四種： 使用ContentProvider存儲數據

Android這個系統和其他的操作系統還不太一樣，我們需要記住的是，數據在Android當中是私有的，當然這些數據包括文件數據和數據庫數據 以及一些其他類型的數據。那這個時候有讀者就會提出問題，難道兩個程序之間就沒有辦法對於數據進行交換？Android這么優秀的系統不會讓這種情況發生 的。解決這個問題主要靠ContentProvider。一個Content Provider類實現了一組標准的方法接口，從而能夠讓其他的應用保存或讀取此Content Provider的各種數據類型。也就是說，一個程序可以通過實現一個Content Provider的抽象接口將自己的數據暴露出去。外界根本看不到，也不用看到這個應用暴露的數據在應用當中是如何存儲的，或者是用數據庫存儲還是用文件 存儲，還是通過網上獲得，這些一切都不重要，重要的是外界可以通過這一套標准及統一的接口和程序里的數據打交道，可以讀取程序的數據，也可以刪除程序的數 據，當然，中間也會涉及一些權限的問題。

一個程序可以通過實現一個ContentProvider的抽象接口將自己的數據完全暴露出去，而且ContentProviders是以類似數據 庫中表的方式將數據暴露，也就是說ContentProvider就像一個“數據庫”。那么外界獲取其提供的數據，也就應該與從數據庫中獲取數據的操作基 本一樣，只不過是采用URI來表示外界需要訪問的“數據庫”。

Content Provider提供了一種多應用間數據共享的方式，比如：聯系人信息可以被多個應用程序訪問。

Content Provider是個實現了一組用於提供其他應用程序存取數據的標准方法的類。 應用程序可以在Content Provider中執行如下操作: 查詢數據 修改數據 添加數據 刪除數據

標准的Content Provider: Android提供了一些已經在系統中實現的標准Content Provider，比如聯系人信息，圖片庫等等，你可以用這些Content Provider來訪問設備上存儲的聯系人信息，圖片等等。

查詢記錄:  

在Content Provider中使用的查詢字符串有別於標准的SQL查詢。很多諸如select, add, delete, modify等操作我們都使用一種特殊的URI來進行，這種URI由3個部分組成， “content://”, 代表數據的路徑，和一個可選的標識數據的ID。

以下是一些示例URI:

content://media/internal/images 這個URI將返回設備上存儲的所有圖片

content://contacts/people/ 這個URI將返回設備上的所有聯系人信息

content://contacts/people/45 這個URI返回單個結果（聯系人信息中ID為45的聯系人記錄）

盡管這種查詢字符串格式很常見，但是它看起來還是有點令人迷惑。為此，Android提供一系列的幫助類（在android.provider包下），里面包含了很多以類變量形式給出的查詢字符串，這種方式更容易讓我們理解一點，參見下例:

MediaStore.Images.Media.INTERNAL_CONTENT_URI Contacts.People.CONTENT_URI

因此，如上面content://contacts/people/45這個URI就可以寫成如下形式：

Uri person = ContentUris.withAppendedId(People.CONTENT_URI, 45);

然后執行數據查詢: Cursor cur = managedQuery(person, null, null, null);

這個查詢返回一個包含所有數據字段的游標，我們可以通過迭代這個游標來獲取所有的數據：

 

package com.wissen.testApp; 

public class ContentProviderDemo extends Activity { 

    @Override 

    public void onCreate(Bundle savedInstanceState) { 

        super.onCreate(savedInstanceState); 

        setContentView(R.layout.main); 

       displayRecords(); 

    } 

    private void displayRecords() { 

        //該數組中包含了所有要返回的字段 

     String columns[] = new String[] { People.NAME, People.NUMBER }; 

       Uri mContacts = People.CONTENT_URI; 

       Cursor cur = managedQuery( 

           mContacts, 

          columns,  // 要返回的數據字段 

       null,          // WHERE子句 

       null,         // WHERE 子句的參數 

       null         // Order-by子句 

     ); 

       if (cur.moveToFirst()) { 

           String name = null; 

           String phoneNo = null; 

           do { 

              // 獲取字段的值 

         name = cur.getString(cur.getColumnIndex(People.NAME)); 

             phoneNo = cur.getString(cur.getColumnIndex(People.NUMBER)); 

             Toast.makeText(this, name + ” ” + phoneNo, Toast.LENGTH_LONG).show(); 

          } while (cur.moveToNext()); 

       } 

    } 

}

上例示范了一個如何依次讀取聯系人信息表中的指定數據列name和number。

修改記錄:  

我們可以使用ContentResolver.update()方法來修改數據，我們來寫一個修改數據的方法:

 

private void updateRecord(int recNo, String name) { 

         Uri uri = ContentUris.withAppendedId(People.CONTENT_URI, recNo); 

         ContentValues values = new ContentValues(); 

         values.put(People.NAME, name); 

         getContentResolver().update(uri, values, null, null); 

    }

現在你可以調用上面的方法來更新指定記錄： updateRecord(10, ”XYZ”); //更改第10條記錄的name字段值為“XYZ”

添加記錄:

要增加記錄，我們可以調用ContentResolver.insert()方法，該方法接受一個要增加的記錄的目標URI，以及一個包含了新記錄值的Map對象，調用后的返回值是新記錄的URI，包含記錄號。

上面的例子中我們都是基於聯系人信息簿這個標准的Content Provider，現在我們繼續來創建一個insertRecord() 方法以對聯系人信息簿中進行數據的添加：

 

private void insertRecords(String name, String phoneNo) { 

    ContentValues values = new ContentValues(); 

    values.put(People.NAME, name); 

    Uri uri = getContentResolver().insert(People.CONTENT_URI, values); 

    Log.d(”ANDROID”, uri.toString()); 

    Uri numberUri = Uri.withAppendedPath(uri, People.Phones.CONTENT_DIRECTORY); 

    values.clear(); 

    values.put(Contacts.Phones.TYPE, People.Phones.TYPE_MOBILE); 

    values.put(People.NUMBER, phoneNo); 

    getContentResolver().insert(numberUri, values); 

}

這樣我們就可以調用insertRecords(name, phoneNo)的方式來向聯系人信息簿中添加聯系人姓名和電話號碼。

刪除記錄:

Content Provider中的getContextResolver.delete()方法可以用來刪除記錄。

下面的記錄用來刪除設備上所有的聯系人信息：

 

private void deleteRecords() {  

 Uri uri = People.CONTENT_URI;  

 getContentResolver().delete(uri, null, null);  

    }

你也可以指定WHERE條件語句來刪除特定的記錄：

getContentResolver().delete(uri, “NAME=” + “‘XYZ XYZ’”, null);

這將會刪除name為‘XYZ XYZ’的記錄。

創建Content Provider:  

至此我們已經知道如何使用Content Provider了，現在讓我們來看下如何自己創建一個Content Provider。

要創建我們自己的Content Provider的話，我們需要遵循以下幾步：

1. 創建一個繼承了ContentProvider父類的類

2. 定義一個名為CONTENT_URI，並且是public static final的Uri類型的類變量，你必須為其指定一個唯一的字符串值，最好的方案是以類的全名稱，

如: public static final Uri CONTENT_URI = Uri.parse( “content://com.google.android.MyContentProvider”);

3. 創建你的數據存儲系統。大多數Content Provider使用Android文件系統或SQLite數據庫來保持數據，但是你也可以以任何你想要的方式來存儲。

4. 定義你要返回給客戶端的數據列名。如果你正在使用Android數據庫，則數據列的使用方式就和你以往所熟悉的其他數據庫一樣。但是，你必須為其定義一個叫_id的列，它用來表示每條記錄的唯一性。

5. 如果你要存儲字節型數據，比如位圖文件等，那保存該數據的數據列其實是一個表示實際保存文件的URI字符串，客戶端通過它來讀取對應的文件數據，處理這種 數據類型的Content Provider需要實現一個名為_data的字段，_data字段列出了該文件在Android文件系統上的精確路徑。這個字段不僅是供客戶端使用，而 且也可以供ContentResolver使用。客戶端可以調用ContentResolver.openOutputStream()方法來處理該 URI指向的文件資源，如果是ContentResolver本身的話，由於其持有的權限比客戶端要高，所以它能直接訪問該數據文件。

6. 聲明public static String型的變量，用於指定要從游標處返回的數據列。

7. 查詢返回一個Cursor類型的對象。所有執行寫操作的方法如insert(), update() 以及delete()都將被監聽。我們可以通過使用ContentResover().notifyChange()方法來通知監聽器關於數據更新的信息。

8. 在AndroidMenifest.xml中使用標簽來設置Content Provider。

9. 如果你要處理的數據類型是一種比較新的類型，你就必須先定義一個新的MIME類型，以供ContentProvider.geType(url)來返回。

MIME類型有兩種形式:

一種是為指定的單個記錄的，還有一種是為多條記錄的。這里給出一種常用的格式： vnd.android.cursor.item/vnd.yourcompanyname.contenttype （單個記錄的MIME類型） 比如, 一個請求列車信息的URI如content://com.example.transportationprovider/trains/122 可能就會返回typevnd.android.cursor.item/vnd.example.rail這樣一個MIME類型。

vnd.android.cursor.dir/vnd.yourcompanyname.contenttype （多個記錄的MIME類型） 比如, 一個請求所有列車信息的URI如content://com.example.transportationprovider/trains 可能就會返回vnd.android.cursor.dir/vnd.example.rail這樣一個MIME 類型。

下列代碼將創建一個Content Provider，它僅僅是存儲用戶名稱並顯示所有的用戶名稱（使用 SQLLite數據庫存儲這些數據）：

 

package com.wissen.testApp; 

public class MyUsers { 

    public static final String AUTHORITY  = “com.wissen.MyContentProvider”; 

    // BaseColumn類中已經包含了 _id字段 

   public static final class User implements BaseColumns { 

        public static final Uri CONTENT_URI  = Uri.parse(”content://com.wissen.MyContentProvider”); 

        // 表數據列 

     public static final String  USER_NAME  = “USER_NAME”; 

    } 

}

上面的類中定義了Content Provider的CONTENT_URI，以及數據列。下面我們將定義基於上面的類來定義實際的Content Provider類：

 

package com.wissen.testApp.android; 

public class MyContentProvider extends ContentProvider { 

    private SQLiteDatabase     sqlDB; 

    private DatabaseHelper    dbHelper; 

    private static final String  DATABASE_NAME     = “Users.db”; 

    private static final int        DATABASE_VERSION         = 1; 

    private static final String TABLE_NAME   = “User”; 

    private static final String TAG = “MyContentProvider”; 

    private static class DatabaseHelper extends SQLiteOpenHelper { 

        DatabaseHelper(Context context) { 

            super(context, DATABASE_NAME, null, DATABASE_VERSION); 

        } 

        @Override 

        public void onCreate(SQLiteDatabase db) { 

            //創建用於存儲數據的表 

        db.execSQL(”Create table ” + TABLE_NAME + “( _id INTEGER PRIMARY KEY AUTOINCREMENT, USER_NAME TEXT);”); 

        } 

        @Override 

        public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { 

            db.execSQL(”DROP TABLE IF EXISTS ” + TABLE_NAME); 

            onCreate(db); 

        } 

    } 

    @Override 

    public int delete(Uri uri, String s, String[] as) { 

        return 0; 

    } 

    @Override 

    public String getType(Uri uri) { 

        return null; 

    } 

    @Override 

    public Uri insert(Uri uri, ContentValues contentvalues) { 

        sqlDB = dbHelper.getWritableDatabase(); 

        long rowId = sqlDB.insert(TABLE_NAME, “”, contentvalues); 

        if (rowId > 0) { 

            Uri rowUri = ContentUris.appendId(MyUsers.User.CONTENT_URI.buildUpon(), rowId).build(); 

            getContext().getContentResolver().notifyChange(rowUri, null); 

            return rowUri; 

        } 

        throw new SQLException(”Failed to insert row into ” + uri); 

    } 

    @Override 

    public boolean onCreate() { 

        dbHelper = new DatabaseHelper(getContext()); 

        return (dbHelper == null) ? false : true; 

    } 

    @Override 

    public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) { 

        SQLiteQueryBuilder qb = new SQLiteQueryBuilder(); 

        SQLiteDatabase db = dbHelper.getReadableDatabase(); 

        qb.setTables(TABLE_NAME); 

        Cursor c = qb.query(db, projection, selection, null, null, null, sortOrder); 

        c.setNotificationUri(getContext().getContentResolver(), uri); 

        return c; 

    } 

    @Override 

    public int update(Uri uri, ContentValues contentvalues, String s, String[] as) { 

        return 0; 

    } 

}

一個名為MyContentProvider的Content Provider創建完成了，它用於從Sqlite數據庫中添加和讀取記錄。

Content Provider的入口需要在AndroidManifest.xml中配置:

之后，讓我們來使用這個定義好的Content Provider:

 

package com.wissen.testApp; 

public class MyContentDemo extends Activity { 

    @Override 

    protected void onCreate(Bundle savedInstanceState) { 

        super.onCreate(savedInstanceState); 

        insertRecord(”MyUser”); 

        displayRecords(); 

    } 

    private void insertRecord(String userName) { 

        ContentValues values = new ContentValues(); 

        values.put(MyUsers.User.USER_NAME, userName); 

        getContentResolver().insert(MyUsers.User.CONTENT_URI, values); 

    } 

    private void displayRecords() { 

        String columns[] = new String[] { MyUsers.User._ID, MyUsers.User.USER_NAME }; 

        Uri myUri = MyUsers.User.CONTENT_URI; 

        Cursor cur = managedQuery(myUri, columns,null, null, null ); 

        if (cur.moveToFirst()) { 

            String id = null; 

            String userName = null; 

            do { 

                id = cur.getString(cur.getColumnIndex(MyUsers.User._ID)); 

                userName = cur.getString(cur.getColumnIndex(MyUsers.User.USER_NAME)); 

                Toast.makeText(this, id + ” ” + userName, Toast.LENGTH_LONG).show(); 

           } while (cur.moveToNext()); 

       } 

    } 

}

上面的類將先向數據庫中添加一條用戶數據，然后顯示數據庫中所有的用戶數據。

第五種： 網絡存儲數據

前面介紹的幾種存儲都是將數據存儲在本地設備上，除此之外，還有一種存儲（獲取）數據的方式，通過網絡來實現數據的存儲和獲取。

我們可以調用WebService返回的數據或是解析HTTP協議實現網絡數據交互。

具體需要熟悉java.net.*，Android.net.*這兩個包的內容，在這就不贅述了，請大家參閱相關文檔。

下面是一個通過地區名稱查詢該地區的天氣預報，以POST發送的方式發送請求到webservicex.net站點，訪問WebService.webservicex.net站點上提供查詢天氣預報的服務。

代碼如下：

 

package com.android.weather;  

import java.util.ArrayList; 

import java.util.List; 

import org.apache.http.HttpResponse; 

import org.apache.http.NameValuePair; 

import org.apache.http.client.entity.UrlEncodedFormEntity; 

import org.apache.http.client.methods.HttpPost; 

import org.apache.http.impl.client.DefaultHttpClient; 

import org.apache.http.message.BasicNameValuePair; 

import org.apache.http.protocol.HTTP; 

import org.apache.http.util.EntityUtils; 

import android.app.Activity; 

import android.os.Bundle; 

public class MyAndroidWeatherActivity extends Activity { 

    //定義需要獲取的內容來源地址 

    private static final String SERVER_URL =  

        "http://www.webservicex.net/WeatherForecast.asmx/GetWeatherByPlaceName";  

    /** Called when the activity is first created. */ 

    @Override 

    public void onCreate(Bundle savedInstanceState) { 

        super.onCreate(savedInstanceState); 

        setContentView(R.layout.main); 

        HttpPost request = new HttpPost(SERVER_URL); //根據內容來源地址創建一個Http請求 

        // 添加一個變量  

        List<NameValuePair> params = new ArrayList<NameValuePair>();  

        // 設置一個地區名稱 

        params.add(new BasicNameValuePair("PlaceName", "NewYork"));  //添加必須的參數 

        try {  

            //設置參數的編碼 

            request.setEntity(new UrlEncodedFormEntity(params, HTTP.UTF_8));  

            //發送請求並獲取反饋 

            HttpResponse httpResponse = new DefaultHttpClient().execute(request); 

            // 解析返回的內容 

            if(httpResponse.getStatusLine().getStatusCode() != 404){  

               String result = EntityUtils.toString(httpResponse.getEntity());  

               System.out.println(result); 

            } 

        } catch (Exception e) { 

            e.printStackTrace(); 

       }  

    }

別忘記了在配置文件中設置訪問網絡權限：

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