上次我向大家介紹了SQLite的基本資訊和使用過程，相信朋友們對SQLite已經有所瞭解了，那今天呢，我就和大家分享一下在Android中如何使用SQLite。

現在的主流移動裝置像Android、iPhone等都使用SQLite作為複雜資料的儲存引擎，在我們為移動裝置開發應用程式時，也許就要使用到SQLite來儲存我們大量的資料，所以我們就需要掌握移動裝置上的SQLite開發技巧。對於Android平臺來說，系統內建了豐富的API來供開發人員操作SQLite，我們可以輕鬆的完成對資料的存取。

下面就向大家介紹一下SQLite常用的操作方法，為了方便，我將程式碼寫在了Activity的onCreate中：

[java] view plaincopyprint?

1. @Override
2. protectedvoid onCreate(Bundle savedInstanceState) {  
3. super.onCreate(savedInstanceState);  
4. //開啟或建立test.db資料庫
5.         SQLiteDatabase db = openOrCreateDatabase("test.db", Context.MODE_PRIVATE, null);  
6.         db.execSQL("DROP TABLE IF EXISTS person");  
7. //建立person表
8.         db.execSQL("CREATE TABLE person (_id INTEGER PRIMARY KEY AUTOINCREMENT, name VARCHAR, age SMALLINT)");  
9.         Person person = new Person();  
10.         person.name = "john";  
11.         person.age = 30;  
12. //插入資料
13.         db.execSQL("INSERT INTO person VALUES (NULL, ?, ?)", new Object[]{person.name, person.age});  
14.         person.name = "david";  
15.         person.age = 33;  
16. //ContentValues以鍵值對的形式存放資料
17.         ContentValues cv = new ContentValues();  
18.         cv.put("name", person.name);  
19.         cv.put("age", person.age);  
20. //插入ContentValues中的資料
21.         db.insert("person", null, cv);  
22.         cv = new ContentValues();  
23.         cv.put("age", 35);  
24. //更新資料
25.         db.update("person", cv, "name = ?", new String[]{"john"});  
26.         Cursor c = db.rawQuery("SELECT * FROM person WHERE age >= ?", new String[]{"33"});  
27. while (c.moveToNext()) {  
28. int _id = c.getInt(c.getColumnIndex("_id"));  
29.             String name = c.getString(c.getColumnIndex("name"));  
30. int age = c.getInt(c.getColumnIndex("age"));  
31.             Log.i("db", "_id=>" + _id + ", name=>" + name + ", age=>" + age);  
32.         }  
33.         c.close();  
34. //刪除資料
35.         db.delete("person", "age < ?", new String[]{"35"});  
36. //關閉當前資料庫
37.         db.close();  
38. //刪除test.db資料庫
39. //      deleteDatabase("test.db");
40.     }  

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		
		//開啟或建立test.db資料庫
		SQLiteDatabase db = openOrCreateDatabase("test.db", Context.MODE_PRIVATE, null);
		db.execSQL("DROP TABLE IF EXISTS person");
		//建立person表
		db.execSQL("CREATE TABLE person (_id INTEGER PRIMARY KEY AUTOINCREMENT, name VARCHAR, age SMALLINT)");
		Person person = new Person();
		person.name = "john";
		person.age = 30;
		//插入資料
		db.execSQL("INSERT INTO person VALUES (NULL, ?, ?)", new Object[]{person.name, person.age});
		
		person.name = "david";
		person.age = 33;
		//ContentValues以鍵值對的形式存放資料
		ContentValues cv = new ContentValues();
		cv.put("name", person.name);
		cv.put("age", person.age);
		//插入ContentValues中的資料
		db.insert("person", null, cv);
		
		cv = new ContentValues();
		cv.put("age", 35);
		//更新資料
		db.update("person", cv, "name = ?", new String[]{"john"});
		
		Cursor c = db.rawQuery("SELECT * FROM person WHERE age >= ?", new String[]{"33"});
		while (c.moveToNext()) {
			int _id = c.getInt(c.getColumnIndex("_id"));
			String name = c.getString(c.getColumnIndex("name"));
			int age = c.getInt(c.getColumnIndex("age"));
			Log.i("db", "_id=>" + _id + ", name=>" + name + ", age=>" + age);
		}
		c.close();
		
		//刪除資料
		db.delete("person", "age < ?", new String[]{"35"});
		
		//關閉當前資料庫
		db.close();
		
		//刪除test.db資料庫
//		deleteDatabase("test.db");
	}

在執行完上面的程式碼後，系統就會在/data/data/[PACKAGE_NAME]/databases目錄下生成一個“test.db”的資料庫檔案，如圖：

上面的程式碼中基本上囊括了大部分的資料庫操作；對於新增、更新和刪除來說，我們都可以使用

[java] view plaincopyprint?

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

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

除了統一的形式之外，他們還有各自的操作方法： [java] view plaincopyprint?

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

db.insert(String table, String nullColumnHack, ContentValues values);
db.update(String table, Contentvalues values, String whereClause, String whereArgs);
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方法的引數也是一樣。

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

[java] view plaincopyprint?

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

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

上面幾種都是常用的查詢方法，第一種最為簡單，將所有的SQL語句都組織到一個字串中，使用佔位符代替實際引數，selectionArgs就是佔位符實際引數集；下面的幾種引數都很類似，columns表示要查詢的列所有名稱集，selection表示WHERE之後的條件語句，可以使用佔位符，groupBy指定分組的列名，having指定分組條件，配合groupBy使用，orderBy指定排序的列名，limit指定分頁引數，distinct可以指定“true”或“false”表示要不要過濾重複值。需要注意的是，selection、groupBy、having、orderBy、limit這幾個引數中不包括“WHERE”、“GROUP BY”、“HAVING”、“ORDER BY”、“LIMIT”等SQL關鍵字。
最後，他們同時返回一個Cursor物件，代表資料集的遊標，有點類似於JavaSE中的ResultSet。

下面是Cursor物件的常用方法：

[java] view plaincopyprint?

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);   //返回當前行指定列的值

c.move(int offset);	//以當前位置為參考,移動到指定行
c.moveToFirst();	//移動到第一行
c.moveToLast();		//移動到最後一行
c.moveToPosition(int position);	//移動到指定行
c.moveToPrevious();	//移動到前一行
c.moveToNext();		//移動到下一行
c.isFirst();		//是否指向第一條
c.isLast();		//是否指向最後一條
c.isBeforeFirst();	//是否指向第一條之前
c.isAfterLast();	//是否指向最後一條之後
c.isNull(int columnIndex);	//指定列是否為空(列基數為0)
c.isClosed();		//遊標是否已關閉
c.getCount();		//總資料項數
c.getPosition();	//返回當前遊標所指向的行數
c.getColumnIndex(String columnName);//返回某列名對應的列索引值
c.getString(int columnIndex);	//返回當前行指定列的值

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

最後當我們完成了對資料庫的操作後，記得呼叫SQLiteDatabase的close()方法釋放資料庫連線，否則容易出現SQLiteException。

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

下面，我們就以一個例項來講解具體的用法，我們新建一個名為db的專案，結構如下：

其中DBHelper繼承了SQLiteOpenHelper，作為維護和管理資料庫的基類，DBManager是建立在DBHelper之上，封裝了常用的業務方法，Person是我們的person表對應的JavaBean，MainActivity就是我們顯示的介面。

下面我們先來看一下DBHelper：

[java] view plaincopyprint?

1. package com.scott.db;  
2. import android.content.Context;  
3. import android.database.sqlite.SQLiteDatabase;  
4. import android.database.sqlite.SQLiteOpenHelper;  
5. publicclass DBHelper extends SQLiteOpenHelper {  
6. privatestaticfinal String DATABASE_NAME = "test.db";  
7. privatestaticfinalint DATABASE_VERSION = 1;  
8. public DBHelper(Context context) {  
9. //CursorFactory設定為null,使用預設值
10. super(context, DATABASE_NAME, null, DATABASE_VERSION);  
11.     }  
12. //資料庫第一次被建立時onCreate會被呼叫
13. @Override
14. publicvoid onCreate(SQLiteDatabase db) {  
15.         db.execSQL("CREATE TABLE IF NOT EXISTS person" +  
16. "(_id INTEGER PRIMARY KEY AUTOINCREMENT, name VARCHAR, age INTEGER, info TEXT)");  
17.     }  
18. //如果DATABASE_VERSION值被改為2,系統發現現有資料庫版本不同,即會呼叫onUpgrade
19. @Override
20. publicvoid onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {  
21.         db.execSQL("ALTER TABLE person ADD COLUMN other STRING");  
22.     }  
23. }  

package com.scott.db;

import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;

public class DBHelper extends SQLiteOpenHelper {

	private static final String DATABASE_NAME = "test.db";
	private static final int DATABASE_VERSION = 1;
	
	public DBHelper(Context context) {
		//CursorFactory設定為null,使用預設值
		super(context, DATABASE_NAME, null, DATABASE_VERSION);
	}

	//資料庫第一次被建立時onCreate會被呼叫
	@Override
	public void onCreate(SQLiteDatabase db) {
		db.execSQL("CREATE TABLE IF NOT EXISTS person" +
				"(_id INTEGER PRIMARY KEY AUTOINCREMENT, name VARCHAR, age INTEGER, info TEXT)");
	}

	//如果DATABASE_VERSION值被改為2,系統發現現有資料庫版本不同,即會呼叫onUpgrade
	@Override
	public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
		db.execSQL("ALTER TABLE person ADD COLUMN other STRING");
	}
}

正如上面所述，資料庫第一次建立時onCreate方法會被呼叫，我們可以執行建立表的語句，當系統發現版本變化之後，會呼叫onUpgrade方法，我們可以執行修改表結構等語句。

為了方便我們面向物件的使用資料，我們建一個Person類，對應person表中的欄位，如下：

[java] view plaincopyprint?

1. package com.scott.db;  
2. publicclass Person {  
3. publicint _id;  
4. public String name;  
5. publicint age;  
6. public String info;  
7. public Person() {  
8.     }  
9. public Person(String name, int age, String info) {  
10. this.name = name;  
11. this.age = age;  
12. this.info = info;  
13.     }  
14. }  

package com.scott.db;

public class Person {
	public int _id;
	public String name;
	public int age;
	public String info;
	
	public Person() {
	}
	
	public Person(String name, int age, String info) {
		this.name = name;
		this.age = age;
		this.info = info;
	}
}

然後，我們需要一個DBManager，來封裝我們所有的業務方法，程式碼如下： [java] view plaincopyprint?

1. package com.scott.db;  
2. import java.util.ArrayList;  
3. import java.util.List;  
4. import android.content.ContentValues;  
5. import android.content.Context;  
6. import android.database.Cursor;  
7. import android.database.sqlite.SQLiteDatabase;  
8. publicclass DBManager {  
9. private DBHelper helper;  
10. private SQLiteDatabase db;  
11. public DBManager(Context context) {  
12.         helper = new DBHelper(context);  
13. //因為getWritableDatabase內部呼叫了mContext.openOrCreateDatabase(mName, 0, mFactory);
14. //所以要確保context已初始化,我們可以把例項化DBManager的步驟放在Activity的onCreate裡
15.         db = helper.getWritableDatabase();  
16.     }  
17. /** 
18.      * add persons 
19.      * @param persons 
20.      */
21. publicvoid add(List<Person> persons) {  
22.         db.beginTransaction();  //開始事務
23. try {  
24. for (Person person : persons) {  
25.                 db.execSQL("INSERT INTO person VALUES(null, ?, ?, ?)", new Object[]{person.name, person.age, person.info});  
26.             }  
27.             db.setTransactionSuccessful();  //設定事務成功完成
28.         } finally {  
29.             db.endTransaction();    //結束事務
30.         }  
31.     }  
32. /** 
33.      * update person's age 
34.      * @param person 
35.      */
36. publicvoid updateAge(Person person) {  
37.         ContentValues cv = new ContentValues();  
38.         cv.put("age", person.age);  
39.         db.update("person", cv, "name = ?", new String[]{person.name});  
40.     }  
41. /** 
42.      * delete old person 
43.      * @param person 
44.      */
45. publicvoid deleteOldPerson(Person person) {  
46.         db.delete("person", "age >= ?", new String[]{String.valueOf(person.age)});  
47.     }  
48. /** 
49.      * query all persons, return list 
50.      * @return List<Person> 
51.      */
52. public List<Person> query() {  
53.         ArrayList<Person> persons = new ArrayList<Person>();  
54.         Cursor c = queryTheCursor();  
55. while (c.moveToNext()) {  
56.             Person person = new Person();  
57.             person._id = c.getInt(c.getColumnIndex("_id"));  
58.             person.name = c.getString(c.getColumnIndex("name"));  
59.             person.age = c.getInt(c.getColumnIndex("age"));  
60.             person.info = c.getString(c.getColumnIndex("info"));  
61.             persons.add(person);  
62.         }  
63.         c.close();  
64. return persons;  
65.     }  
66. /** 
67.      * query all persons, return cursor 
68.      * @return  Cursor 
69.      */
70. public Cursor queryTheCursor() {  
71.         Cursor c = db.rawQuery("SELECT * FROM person", null);  
72. return c;  
73.     }  
74. /** 
75.      * close database 
76.      */
77. publicvoid closeDB() {  
78.         db.close();  
79.     }  
80. }  

package com.scott.db;

import java.util.ArrayList;
import java.util.List;

import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;

public class DBManager {
	private DBHelper helper;
	private SQLiteDatabase db;
	
	public DBManager(Context context) {
		helper = new DBHelper(context);
		//因為getWritableDatabase內部呼叫了mContext.openOrCreateDatabase(mName, 0, mFactory);
		//所以要確保context已初始化,我們可以把例項化DBManager的步驟放在Activity的onCreate裡
		db = helper.getWritableDatabase();
	}
	
	/**
	 * add persons
	 * @param persons
	 */
	public void add(List<Person> persons) {
        db.beginTransaction();	//開始事務
        try {
        	for (Person person : persons) {
        		db.execSQL("INSERT INTO person VALUES(null, ?, ?, ?)", new Object[]{person.name, person.age, person.info});
        	}
        	db.setTransactionSuccessful();	//設定事務成功完成
        } finally {
        	db.endTransaction();	//結束事務
        }
	}
	
	/**
	 * update person's age
	 * @param person
	 */
	public void updateAge(Person person) {
		ContentValues cv = new ContentValues();
		cv.put("age", person.age);
		db.update("person", cv, "name = ?", new String[]{person.name});
	}
	
	/**
	 * delete old person
	 * @param person
	 */
	public void deleteOldPerson(Person person) {
		db.delete("person", "age >= ?", new String[]{String.valueOf(person.age)});
	}
	
	/**
	 * query all persons, return list
	 * @return List<Person>
	 */
	public List<Person> query() {
		ArrayList<Person> persons = new ArrayList<Person>();
		Cursor c = queryTheCursor();
        while (c.moveToNext()) {
        	Person person = new Person();
        	person._id = c.getInt(c.getColumnIndex("_id"));
        	person.name = c.getString(c.getColumnIndex("name"));
        	person.age = c.getInt(c.getColumnIndex("age"));
        	person.info = c.getString(c.getColumnIndex("info"));
        	persons.add(person);
        }
        c.close();
        return persons;
	}
	
	/**
	 * query all persons, return cursor
	 * @return	Cursor
	 */
	public Cursor queryTheCursor() {
        Cursor c = db.rawQuery("SELECT * FROM person", null);
        return c;
	}
	
	/**
	 * close database
	 */
	public void closeDB() {
		db.close();
	}
}

我們在DBManager構造方法中例項化DBHelper並獲取一個SQLiteDatabase物件，作為整個應用的資料庫例項；在新增多個Person資訊時，我們採用了事務處理，確保資料完整性；最後我們提供了一個closeDB方法，釋放資料庫資源，這一個步驟在我們整個應用關閉時執行，這個環節容易被忘記，所以朋友們要注意。

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

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

[java] view plaincopyprint?

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

	public synchronized SQLiteDatabase getReadableDatabase() {
		if (mDatabase != null && mDatabase.isOpen()) {
			// 如果發現mDatabase不為空並且已經開啟則直接返回
			return mDatabase;
		}

		if (mIsInitializing) {
			// 如果正在初始化則丟擲異常
			throw new IllegalStateException("getReadableDatabase called recursively");
		}

		// 開始例項化資料庫mDatabase

		try {
			// 注意這裡是呼叫了getWritableDatabase()方法
			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);
			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;// 為mDatabase指定新開啟的資料庫
			return mDatabase;// 返回開啟的資料庫
		} finally {
			mIsInitializing = false;
			if (db != null && db != mDatabase)
				db.close();
		}
	}

在getReadableDatabase()方法中，首先判斷是否已存在資料庫例項並且是開啟狀態，如果是，則直接返回該例項，否則試圖獲取一個可讀寫模式的資料庫例項，如果遇到磁碟空間已滿等情況獲取失敗的話，再以只讀模式開啟資料庫，獲取資料庫例項並返回，然後為mDatabase賦值為最新開啟的資料庫例項。既然有可能呼叫到getWritableDatabase()方法，我們就要看一下了： [java] view plaincopyprint?

1. publicsynchronized SQLiteDatabase getWritableDatabase() {  
2. if (mDatabase != null && mDatabase.isOpen() && !mDatabase.isReadOnly()) {  
3. // 如果mDatabase不為空已開啟並且不是隻讀模式 則返回該例項
4. return mDatabase;  
5.     }  
6. if (mIsInitializing) {  
7. thrownew IllegalStateException("getWritableDatabase called recursively");  
8.     }  
9. // If we have a read-only database open, someone could be using it
10. // (though they shouldn't), which would cause a lock to be held on
11. // the file, and our attempts to open the database read-write would
12. // fail waiting for the file lock. To prevent that, we acquire the
13. // lock on the read-only database, which shuts out other users.
14. boolean success = false;  
15.     SQLiteDatabase db = null;  
16. // 如果mDatabase不為空則加鎖 阻止其他的操作
17. if (mDatabase != null)  
18.         mDatabase.lock();  
19. try {  
20.         mIsInitializing = true;  
21. if (mName == null) {  
22.             db = SQLiteDatabase.create(null);  
23.         } else {  
24. // 開啟或建立資料庫
25.             db = mContext.openOrCreateDatabase(mName, 0, mFactory);  
26.         }  
27. // 獲取資料庫版本(如果剛建立的資料庫,版本為0)
28. int version = db.getVersion();  
29. // 比較版本(我們程式碼中的版本mNewVersion為1)
30. if (version != mNewVersion) {  
31.             db.beginTransaction();// 開始事務
32. try {  
33. if (version == 0) {  
34. // 執行我們的onCreate方法
35.                     onCreate(db);  
36.                 } else {  
37. // 如果我們應用升級了mNewVersion為2,而原版本為1則執行onUpgrade方法
38.                     onUpgrade(db, version, mNewVersion);  
39.                 }  
40.                 db.setVersion(mNewVersion);// 設定最新版本
41.                 db.setTransactionSuccessful();// 設定事務成功
42.             } finally {  
43.                 db.endTransaction();// 結束事務
44.             }  
45.         }  
46.         onOpen(db);  
47.         success = true;  
48. return db;// 返回可讀寫模式的資料庫例項
49.     } finally {  
50.         mIsInitializing = false;  
51. if (success) {  
52. // 開啟成功
53. if (mDatabase != null) {  
54. // 如果mDatabase有值則先關閉
55. try {  
56.                     mDatabase.close();  
57.                 } catch (Exception e) {  
58.                 }  
59.                 mDatabase.unlock();// 解鎖
60.             }  
61.             mDatabase = db;// 賦值給mDatabase
62.         } else {  
63. // 開啟失敗的情況：解鎖、關閉
64. if (mDatabase != null)  
65.                 mDatabase.unlock();  
66. 相關推薦

    Android sqlite應用詳解（轉自大牛SCOTT)

    上次我向大家介紹了SQLite的基本資訊和使用過程，相信朋友們對SQLite已經有所瞭解了，那今天呢，我就和大家分享一下在Android中如何使用SQLite。 現在的主流移動裝置像Android、iPhone等都使用SQLite作為複雜資料的儲存引擎，在我們為移動裝置開發

    Android中SQLite應用詳解

    上次我向大家介紹了SQLite的基本資訊和使用過程，相信朋友們對SQLite已經有所瞭解了，那今天呢，我就和大家分享一下在Android中如何使用SQLite。 現在的主流移動裝置像Android、iPhone等都使用SQLite作為複雜資料的儲存引擎，在我們為移動裝置開發

    FTS資料庫優化（Android）原理與應用詳解（1）

    在Android的官方開發文件上，有建議在使用文字類的資料庫全文搜尋（full-text search）時，使用FTS優化查詢速度。有關FTS的介紹文章不多，本文調研整理一下有關知識，供在Android上使用FTS之前參考。 1.什麼是FTS？ FTS，即full te

    Linux的SOCKET編程詳解（轉）

    readv lose 服務 網絡字節序 返回值 quest avi 取數 key Linux的SOCKET編程詳解 1. 網絡中進程之間如何通信 進 程通信的概念最初來源於單機系統。由於每個進程都在自己的地址範圍內運行，為保證兩個相互通信的進 程之間既互不幹擾又

    綜合運用: C++11 多線程下生產者消費者模型詳解（轉）

    並發 rep 生產 我會 交流 模型 操作 const ref 生產者消費者問題是多線程並發中一個非常經典的問題，相信學過操作系統課程的同學都清楚這個問題的根源。本文將就四種情況分析並介紹生產者和消費者問題，它們分別是：單生產者-單消費者模型，單生產者-多消費者模型，多生產

    C/C++中作用域詳解（轉）

    防止 局部作用域 gist 文件中 方式 為什麽不使用 形式參數 lan archive 作用域規則告訴我們一個變量的有效範圍，它在哪兒創建，在哪兒銷毀（也就是說超出了作用域）。變量的有效作用域從它的定義點開始，到和定義變量之前最鄰近的開括號配對的第一個閉括號。也就是說，作

    C# ListView用法詳解（轉）

    分組 創建 cti 排列 checkbox 定義 com 程序 erl 一、ListView類 1、常用的基本屬性： （1）FullRowSelect：設置是否行選擇模式。(默認為false) 提示：只有在Details視圖該屬性才有

    C++ 智能指針詳解（轉）

    include 復雜 測試類 信息 思想 編譯 應該 其他 eas C++ 智能指針詳解 一、簡介 由於 C++ 語言沒有自動內存回收機制，程序員每次 new 出來的內存都要手動 delete。程序員忘記 delete，流程太復雜，最終導致沒有 delete，異常導致程

    解析xml的4種方法詳解（轉）

    項目 目標 源碼 更多 news 大量 優秀 大型 頻繁 http://blog.csdn.net/jzhf2012/article/details/8532873 1. 介紹 1）DOM(JAXP Crimson解析器) DOM是用與平臺和語言無關的方式表

    css動畫-animation各個屬性詳解（轉）

    yellow range 空隙 定義 tro content bin ora .com CSS3的animation很容易就能實現各種酷炫的動畫，雖然看到別人的成果圖會覺得很難，但是如果掌握好各種動畫屬性，做好酷炫吊炸天的動畫都不在話下，好，切入正題。 一、動畫屬性：

    epoll使用詳解（轉）

    supports weak 第一次 sets processes windows 監聽事件 atoi 變化 epoll - I/O event notification facility在linux的網絡編程中，很長的時間都在使用select來做事件觸發。在linux新的內

    Understand:高效代碼靜態分析神器詳解（轉）

    none 前段時間 兩個 箭頭 ++ 開發 obj 結構 導入 之前用Windows系統，一直用source insight查看代碼非常方便，但是年前換到mac下面，雖說很多東西都方便了，但是卻沒有了靜態代碼分析工具，很幸運，前段時間找到一款比source insight軟

    回溯法實例詳解（轉）

    函數 枚舉 必須 using tool 有一個 發現 ads 問題 概念 回溯算法實際上一個類似枚舉的搜索嘗試過程，主要是在搜索嘗試過程中尋找問題的解，當發現已不滿足求解條件時，就“回溯”返回，嘗試別的路徑。 回溯法是一種選優搜索法，按選優條件向前搜索，以達

    深入探討Linux靜態庫與動態庫的詳解（轉）

    share 分享 命名 one .com 過程 程序 簡單介紹 mage 2.生成動態庫並使用 linux下編譯時通過 -shared 參數可以生成動態庫（.so）文件，如下 庫從本質上來說是一種可執行代碼的二進制格式，可以被載入內存中執行。庫分靜態庫和動態庫兩種。

    Spartan6芯片配置模式詳解（轉）

    roc gen bit png 寬度 con 讀取配置 3.2 多個 1. 配置概述　　Spartan6系列FPGA通過把應用程序數據導入芯片內部存儲器完成芯片的配置。Spart-6 FPGA可以自己從外部非易失性存儲器導入編程數據，或者通過外界的微處理器、DSP等對其進行

    log4j的配置詳解（轉）

    version let imp err pro 字符 bug rom 程序 轉自：http://blog.sina.com.cn/s/blog_5ed94d710101go3u.html 最近使用log4j寫log時候發現網上的寫的都是千篇一律，寫的好的嘛不

    KMP算法詳解（轉）

    不容易 浪費 成功 gif 字符串 重要 詳細 src text 網址http://www.cnblogs.com/tangzhengyue/p/4315393.html 網上有很多講解KMP算法的博客，我就不浪費時間再寫一份了。直接推薦一個當初我入門時看的博客吧：http

    Java技術——Java泛型詳解（轉）

    cal 5.1 try 既然 參數 top 兩種 泛型編程 編譯器 1．為什麽需要泛型轉載請註明出處：http://blog.csdn.net/seu_calvin/article/details/52230032泛型在Java中有很重要的地位，網上很多文章羅列各種理論，不

    中國剩余定理(孫子定理)詳解 （轉）

    col == 了解 turn 情況下 歐幾裏得算法 得到 輾轉相除法 人的 原文：https://www.cnblogs.com/freinds/p/6388992.html 問題：今有物不知其數，三三數之剩二，五五數之剩三，七七數之剩二。問物幾何？ 說明白一點就是

    python3多線程應用詳解（第一卷：線程的本質概念）

    本質 函數 解釋 style height auto 進行 mage pla 之前我用過多線程的方式執行了爬蟲程序，爬取了糗事百科的數據可以看到速率非常之快，就像正常一個人他要完一個漢堡，再吃喝一瓶水才能走，結果他邊吃漢堡邊喝水，速率一下加快了一樣。首先我們看看什麽是線程：