SQLite是D.Richard Hipp用C语言编写的开源嵌入式数据库引擎。它支持大多数的SQL92标准,并且可以在所有主要的操作系统上运行。
SQLite由以下几个部分组成:SQL编译器、内核、后端以及附件。SQLite通过利用虚拟机和虚拟数据库引擎(VDBE),是调试、修改和扩展SQLite的内核变得更加方便。所有SQL语句都被编译成易读的、可以在SQLite虚拟机中执行的程序集。SQLite的整体结构图如下:
袖珍型的SQLite竟然可以支持高达2TB大小的数据库,每个数据库都是以单个文件的形式存在,这些数据都是以B-Tree的数据结构形式存储在磁盘上。
在事务处理方面,SQLite通过数据库级上的独占性和共享锁来实现独立事务处理。这意味着多个进程可以在同一时间从同一数据库读取数据,但只有一个可以写入数据。在某个进程或线程想数据库执行写操作之前,必须获得独占锁。在获得独占锁之后,其他的读或写操作将不会再发生。
SQLite采用动态数据类型,当某个值插入到数据库时,SQLite将会检查它的类型,如果该类型与关联的列不匹配,SQLite则会尝试将该值转换成该列的类型,如果不能转换,则该值将作为本身的类型存储,SQLite称这为“弱类型”。但有一个特例,如果是INTEGER PRIMARY KEY,则其他类型不会被转换,会报一个“datatype missmatch”的错误。
概括来讲,SQLite支持NULL、INTEGER、REAL、TEXT和BLOB数据类型,分别代表空值、整型值、浮点值、字符串文本、二进制对象。
在操作之前,朋友们要先下载SQLite数据库,官方的下载页面是http://sqlite.org/download.html,我是在Windows下试验,所以我选择了Precompiled Binaries For Windows下面的sqlite-shell-win32-x86和sqlite-analyzer-win32-x86的zip包,前者是SQLite数据库引擎,后者是SQLite数据库分析器,主要用于分析数据库的状态等信息,大家也可以根据自己的情况去下载。下载完成后分别解压,得到两个可执行文件,如图:
这两个文件可以根据自己的喜好放置在指定的位置,我将其放在D盘根目录下。下面我们就来一步一步操作SQLite:
创建数据库:
1. D:\>sqlite3 test.db
2. SQLite version 3.7.7.1 2011-06-28 17:39:05
3. Enter ".help" for instructions
4. Enter SQL statements terminated with a ";"
5. sqlite> .databases
6. seq name file
7.
8. -------------------------------------------------------------------------
9.
10. 0 main D:\test.db
11.
12. sqlite>
我们执行了sqlite3命令,参数就是数据库的名称,如果该数据库已存在,则使用,如果不存在,则新建一个,这里我们简单的在当前位置创建了test.db,你也可以在任何存在的并且可写的目录下创建自己的数据库。(如果对于SQLite的命令不太熟悉,可以执行“.help”命令列出所有的命令清单进行查看)。
创建表:
1. sqlite> CREATE TABLE person (id INTEGER PRIMARY KEY AUTOINCREMENT, name VARCHAR(20), age SMALLINT);
2. sqlite> .tables
3. person
4. sqlite> .schema person
5. CREATE TABLE person (id INTEGER PRIMARY KEY AUTOINCREMENT, name VARCHAR(20), age SMALLINT);
6. sqlite>
在我们创建表之后,可以用“.tables”命令去查看已有的表,用“.schema”命令去查看表的结构,如果后面没有表名做参数,则将会输出所有表的建表语句。
插入数据:
1. sqlite> INSERT INTO person VALUES (NULL, 'john', 30);
2. sqlite> SELECT * FROM person;
3. 1|john|30
从.sql文件导入数据:
1. sqlite> .read test.sql
2. sqlite> SELECT * FROM person;
3. 1|john|30
4. 2|david|35
5. 3|henry|40
6. sqlite>
分析数据库使用状态:
1. D:\>sqlite3_analyzer test.db
2. /** Disk-Space Utilization Report For test.db
3.
4. Page size in bytes.................... 1024
5. Pages in the whole file (measured).... 4
6. Pages in the whole file (calculated).. 4
7. Pages that store data................. 4 100.0%
8. Pages on the freelist (per header).... 0 0.0%
9. Pages on the freelist (calculated).... 0 0.0%
10. Pages of auto-vacuum overhead......... 0 0.0%
11. Number of tables in the database...... 4
12. Number of indices..................... 0
13. Number of named indices............... 0
14. Automatically generated indices....... 0
15. Size of the file in bytes............. 4096
16. Bytes of user payload stored.......... 39 0.95%
17. ...
备份数据库:
备份 SQLite 数据库有两种方法。如果数据库正在使用中,则应从命令行界面使用 .dump 命令。这样可以创建一个包含必要命令和数据的文件,从而重新创建数据库。.dump 命令也可以用于备份数据库表。
1. sqlite> .dump
2. PRAGMA foreign_keys=OFF;
3. BEGIN TRANSACTION;
4. CREATE TABLE person (id INTEGER PRIMARY KEY AUTOINCREMENT, name VARCHAR(20), age SMALLINT);
5. INSERT INTO "person" VALUES(1,'john',30);
6. INSERT INTO "person" VALUES(2,'david',35);
7. INSERT INTO "person" VALUES(3,'henry',40);
8. DELETE FROM sqlite_sequence;
9. INSERT INTO "sqlite_sequence" VALUES('person',3);
10. COMMIT;
11. sqlite> .output dump.sql
12. sqlite> .dump
13. sqlite>
我们可以指定输出的目标为一个文件,然后再使用命令时,输出信息就会写入指定的文件,如果想恢复为标准输出,可以这样设定:
1. sqlite> .output stdout
2. sqlite> .dump
3. PRAGMA foreign_keys=OFF;
4. BEGIN TRANSACTION;
5. CREATE TABLE person (id INTEGER PRIMARY KEY AUTOINCREMENT, name VARCHAR(20), age SMALLINT);
6. INSERT INTO "person" VALUES(1,'john',30);
7. INSERT INTO "person" VALUES(2,'david',35);
8. INSERT INTO "person" VALUES(3,'henry',40);
9. DELETE FROM sqlite_sequence;
10. INSERT INTO "sqlite_sequence" VALUES('person',3);
11. COMMIT;
12. sqlite>
如果数据库没有处于使用状态,则可以直接将数据库文件复制到安全位置。
最后,我们可以使用“.quit”或“.exit”退出SQLite。
管理工具:
现在网络上的SQLite管理工具很多,我向大家推荐一款好用的工具:SQLite Expert。
在Java中使用SQLite:
我们要想在Java中使用SQLite,需要下载SQLite相关驱动,推荐大家到http://www.xerial.org/trac/Xerial/wiki/SQLiteJDBC页面去下载最新的驱动包,现在最新版本是sqlite-jdbc-3.7.2.jar,体积有点大,因为它包含了Linux、Mac、Windows的本地类库,如图:
下载了驱动之后,我们新建一个项目,名为sqlite:
在上图中,我们引入sqlite驱动包到类路径下,然后建立一个db的文件夹,用于放置数据库文件。最后我们看一下Test.java代码:
1. package com.scott.sqlite;
2. import java.sql.Connection;
3. import java.sql.DriverManager;
4. import java.sql.ResultSet;
5. import java.sql.Statement;
6.
7. public class Test {
8. public static void main(String[] args) throws Exception {
9. Class.forName("org.sqlite.JDBC");
10. Connection conn = DriverManager.getConnection("jdbc:sqlite:db/test.db");
11. Statement stmt = conn.createStatement();
12.
13. stmt.executeUpdate("DROP TABLE IF EXISTS person");
14. stmt.executeUpdate("CREATE TABLE person(id INTEGER, name STRING)");
15. stmt.executeUpdate("INSERT INTO person VALUES(1, 'john')");
16. stmt.executeUpdate("INSERT INTO person VALUES(2, 'david')");
17. stmt.executeUpdate("INSERT INTO person VALUES(3, 'henry')");
18. ResultSet rs = stmt.executeQuery("SELECT * FROM person");
19. while (rs.next()) {
20. System.out.println("id=>" + rs.getInt("id") + ", name=>" + rs.getString("name"));
21. }
22. stmt.close();
23. conn.close();
24. }
25. }
执行Test.java文件,结果如下:
这个时候,在我们的db目录下,就生成了一个test.db的文件:
SQLite使用须知:
目前没有可用于 SQLite 的网络服务器。从应用程序运行位于其他计算机上的 SQLite 的惟一方法是从网络共享运行。这样会导致一些问题,像 UNIX® 和 Windows® 网络共享都存在文件锁定问题。还有由于与访问网络共享相关的延迟而带来的性能下降问题。
SQLite 只提供数据库级的锁定。
SQLite 没有用户帐户概念,而是根据文件系统确定所有数据库的权限。
结束语:
由于资源占用少、性能良好和零管理成本,嵌入式数据库有了它的用武之地,像Android、iPhone都有内置的SQLite数据库供开发人员使用,它的易用性可以加快应用程序的开发,并使得复杂的数据存储变得轻松了许多。
Android中SQLite应用详解
现在的主流移动设备像Android、iPhone等都使用SQLite作为复杂数据的存储引擎,在我们为移动设备开发应用程序时,也许就要使用到SQLite来存储我们大量的数据,所以我们就需要掌握移动设备上的SQLite开发技巧。对于Android平台来说,系统内置了丰富的API来供开发人员操作SQLite,我们可以轻松的完成对数据的存取。
下面就向大家介绍一下SQLite常用的操作方法,为了方便,我将代码写在了Activity的onCreate中:
1. @Override
2. protected void onCreate(Bundle savedInstanceState) {
3. super.onCreate(savedInstanceState);
4.
5. //打开或创建test.db数据库
6. SQLiteDatabase db = openOrCreateDatabase("test.db", Context.MODE_PRIVATE, null);
7. db.execSQL("DROP TABLE IF EXISTS person");
8. //创建person表
9. db.execSQL("CREATE TABLE person (_id INTEGER PRIMARY KEY AUTOINCREMENT, name VARCHAR, age SMALLINT)");
10. Person person = new Person();
11. person.name = "john";
12. person.age = 30;
13. //插入数据
14. db.execSQL("INSERT INTO person VALUES (NULL, ?, ?)", new Object[]{person.name, person.age});
15.
16. person.name = "david";
17. person.age = 33;
18. //ContentValues以键值对的形式存放数据
19. ContentValues cv = new ContentValues();
20. cv.put("name", person.name);
21. cv.put("age", person.age);
22. //插入ContentValues中的数据
23. db.insert("person", null, cv);
24.
25. cv = new ContentValues();
26. cv.put("age", 35);
27. //更新数据
28. db.update("person", cv, "name = ?", new String[]{"john"});
29.
30. Cursor c = db.rawQuery("SELECT * FROM person WHERE age >= ?", new String[]{"33"});
31. while (c.moveToNext()) {
32. int _id = c.getInt(c.getColumnIndex("_id"));
33. String name = c.getString(c.getColumnIndex("name"));
34. int age = c.getInt(c.getColumnIndex("age"));
35. Log.i("db", "_id=>" + _id + ", name=>" + name + ", age=>" + age);
36. }
37. c.close();
38.
39. //删除数据
40. db.delete("person", "age < ?", new String[]{"35"});
41.
42. //关闭当前数据库
43. db.close();
44.
45. //删除test.db数据库
46. // deleteDatabase("test.db");
47. }
在执行完上面的代码后,系统就会在/data/data/[PACKAGE_NAME]/databases目录下生成一个“test.db”的数据库文件,如图:
上面的代码中基本上囊括了大部分的数据库操作;对于添加、更新和删除来说,我们都可以使用
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方法的参数也是一样。
下面来说说查询操作。查询操作相对于上面的几种操作要复杂些,因为我们经常要面对着各种各样的查询条件,所以系统也考虑到这种复杂性,为我们提供了较为丰富的查询形式:
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就是占位符实际参数集;下面的几种参数都很类似,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对象的常用方法:
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); //返回当前行指定列的值
在上面的代码示例中,已经用到了这几个常用方法中的一些,关于更多的信息,大家可以参考官方文档中的说明。
最后当我们完成了对数据库的操作后,记得调用SQLiteDatabase的close()方法释放数据库连接,否则容易出现SQLiteException。
上面就是SQLite的基本应用,但在实际开发中,为了能够更好的管理和维护数据库,我们会封装一个继承自SQLiteOpenHelper类的数据库操作类,然后以这个类为基础,再封装我们的业务逻辑方法。
下面,我们就以一个实例来讲解具体的用法,我们新建一个名为db的项目,结构如下:
其中DBHelper继承了SQLiteOpenHelper,作为维护和管理数据库的基类,DBManager是建立在DBHelper之上,封装了常用的业务方法,Person是我们的person表对应的JavaBean,MainActivity就是我们显示的界面。
下面我们先来看一下DBHelper:
1. package com.scott.db;
2.
3. import android.content.Context;
4. import android.database.sqlite.SQLiteDatabase;
5. import android.database.sqlite.SQLiteOpenHelper;
6.
7. public class DBHelper extends SQLiteOpenHelper {
8.
9. private static final String DATABASE_NAME = "test.db";
10. private static final int DATABASE_VERSION = 1;
11.
12. public DBHelper(Context context) {
13. //CursorFactory设置为null,使用默认值
14. super(context, DATABASE_NAME, null, DATABASE_VERSION);
15. }
16.
17. //数据库第一次被创建时onCreate会被调用
18. @Override
19. public void onCreate(SQLiteDatabase db) {
20. db.execSQL("CREATE TABLE IF NOT EXISTS person" +
21. "(_id INTEGER PRIMARY KEY AUTOINCREMENT, name VARCHAR, age INTEGER, info TEXT)");
22. }
23.
24. //如果DATABASE_VERSION值被改为2,系统发现现有数据库版本不同,即会调用onUpgrade
25. @Override
26. public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
27. db.execSQL("ALTER TABLE person ADD COLUMN other STRING");
28. }
29. }
正如上面所述,数据库第一次创建时onCreate方法会被调用,我们可以执行创建表的语句,当系统发现版本变化之后,会调用onUpgrade方法,我们可以执行修改表结构等语句。
为了方便我们面向对象的使用数据,我们建一个Person类,对应person表中的字段,如下:
1. package com.scott.db;
2.
3. public class Person {
4. public int _id;
5. public String name;
6. public int age;
7. public String info;
8.
9. public Person() {
10. }
11.
12. public Person(String name, int age, String info) {
13. this.name = name;
14. this.age = age;
15. this.info = info;
16. }
17. }
然后,我们需要一个DBManager,来封装我们所有的业务方法,代码如下:
1. package com.scott.db;
2.
3. import java.util.ArrayList;
4. import java.util.List;
5.
6. import android.content.ContentValues;
7. import android.content.Context;
8. import android.database.Cursor;
9. import android.database.sqlite.SQLiteDatabase;
10.
11. public class DBManager {
12. private DBHelper helper;
13. private SQLiteDatabase db;
14.
15. public DBManager(Context context) {
16. helper = new DBHelper(context);
17. //因为getWritableDatabase内部调用了mContext.openOrCreateDatabase(mName, 0, mFactory);
18. //所以要确保context已初始化,我们可以把实例化DBManager的步骤放在Activity的onCreate里
19. db = helper.getWritableDatabase();
20. }
21.
22. /**
23. * add persons
24. * @param persons
25. */
26. public void add(List<Person> persons) {
27. db.beginTransaction(); //开始事务
28. try {
29. for (Person person : persons) {
30. db.execSQL("INSERT INTO person VALUES(null, ?, ?, ?)", new Object[]{person.name, person.age, person.info});
31. }
32. db.setTransactionSuccessful(); //设置事务成功完成
33. } finally {
34. db.endTransaction(); //结束事务
35. }
36. }
37.
38. /**
39. * update person's age
40. * @param person
41. */
42. public void updateAge(Person person) {
43. ContentValues cv = new ContentValues();
44. cv.put("age", person.age);
45. db.update("person", cv, "name = ?", new String[]{person.name});
46. }
47.
48. /**
49. * delete old person
50. * @param person
51. */
52. public void deleteOldPerson(Person person) {
53. db.delete("person", "age >= ?", new String[]{String.valueOf(person.age)});
54. }
55.
56. /**
57. * query all persons, return list
58. * @return List<Person>
59. */
60. public List<Person> query() {
61. ArrayList<Person> persons = new ArrayList<Person>();
62. Cursor c = queryTheCursor();
63. while (c.moveToNext()) {
64. Person person = new Person();
65. person._id = c.getInt(c.getColumnIndex("_id"));
66. person.name = c.getString(c.getColumnIndex("name"));
67. person.age = c.getInt(c.getColumnIndex("age"));
68. person.info = c.getString(c.getColumnIndex("info"));
69. persons.add(person);
70. }
71. c.close();
72. return persons;
73. }
74.
75. /**
76. * query all persons, return cursor
77. * @return Cursor
78. */
79. public Cursor queryTheCursor() {
80. Cursor c = db.rawQuery("SELECT * FROM person", null);
81. return c;
82. }
83.
84. /**
85. * close database
86. */
87. public void closeDB() {
88. db.close();
89. }
90. }
我们在DBManager构造方法中实例化DBHelper并获取一个SQLiteDatabase对象,作为整个应用的数据库实例;在添加多个Person信息时,我们采用了事务处理,确保数据完整性;最后我们提供了一个closeDB方法,释放数据库资源,这一个步骤在我们整个应用关闭时执行,这个环节容易被忘记,所以朋友们要注意。
我们获取数据库实例时使用了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()方法,我们就要看一下了:
1. public synchronized SQLiteDatabase getWritableDatabase() {
2. if (mDatabase != null && mDatabase.isOpen() && !mDatabase.isReadOnly()) {
3. // 如果mDatabase不为空已打开并且不是只读模式 则返回该实例
4. return mDatabase;
5. }
6.
7. if (mIsInitializing) {
8. throw new IllegalStateException("getWritableDatabase called recursively");
9. }
10.
11. // If we have a read-only database open, someone could be using it
12. // (though they shouldn't), which would cause a lock to be held on
13. // the file, and our attempts to open the database read-write would
14. // fail waiting for the file lock. To prevent that, we acquire the
15. // lock on the read-only database, which shuts out other users.
16.
17. boolean success = false;
18. SQLiteDatabase db = null;
19. // 如果mDatabase不为空则加锁 阻止其他的操作
20. if (mDatabase != null)
21. mDatabase.lock();
22. try {
23. mIsInitializing = true;
24. if (mName == null) {
25. db = SQLiteDatabase.create(null);
26. } else {
27. // 打开或创建数据库
28. db = mContext.openOrCreateDatabase(mName, 0, mFactory);
29. }
30. // 获取数据库版本(如果刚创建的数据库,版本为0)
31. int version = db.getVersion();
32. // 比较版本(我们代码中的版本mNewVersion为1)
33. if (version != mNewVersion) {
34. db.beginTransaction();// 开始事务
35. try {
36. if (version == 0) {
37. // 执行我们的onCreate方法
38. onCreate(db);
39. } else {
40. // 如果我们应用升级了mNewVersion为2,而原版本为1则执行onUpgrade方法
41. onUpgrade(db, version, mNewVersion);
42. }
43. db.setVersion(mNewVersion);// 设置最新版本
44. db.setTransactionSuccessful();// 设置事务成功
45. } finally {
46. db.endTransaction();// 结束事务
47. }
48. }
49.
50. onOpen(db);
51. success = true;
52. return db;// 返回可读写模式的数据库实例
53. } finally {
54. mIsInitializing = false;
55. if (success) {
56. // 打开成功
57. if (mDatabase != null) {
58. // 如果mDatabase有值则先关闭
59. try {
60. mDatabase.close();
61. } catch (Exception e) {
62. }
63. mDatabase.unlock();// 解锁
64. }
65. mDatabase = db;// 赋值给mDatabase
66. } else {
67. // 打开失败的情况:解锁、关闭
68. if (mDatabase != null)
69. mDatabase.unlock();
70. if (db != null)
71. db.close();
72. }
73. }
74. }
大家可以看到,几个关键步骤是,首先判断mDatabase如果不为空已打开并不是只读模式则直接返回,否则如果mDatabase不为空则加锁,然后开始打开或创建数据库,比较版本,根据版本号来调用相应的方法,为数据库设置新版本号,最后释放旧的不为空的mDatabase并解锁,把新打开的数据库实例赋予mDatabase,并返回最新实例。
看完上面的过程之后,大家或许就清楚了许多,如果不是在遇到磁盘空间已满等情况,getReadableDatabase()一般都会返回和getWritableDatabase()一样的数据库实例,所以我们在DBManager构造方法中使用getWritableDatabase()获取整个应用所使用的数据库实例是可行的。当然如果你真的担心这种情况会发生,那么你可以先用getWritableDatabase()获取数据实例,如果遇到异常,再试图用getReadableDatabase()获取实例,当然这个时候你获取的实例只能读不能写了。
最后,让我们看一下如何使用这些数据操作方法来显示数据,下面是MainActivity.java的布局文件和代码:
1. <?xml version="1.0" encoding="utf-8"?>
2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
3. android:orientation="vertical"
4. android:layout_width="fill_parent"
5. android:layout_height="fill_parent">
6. <Button
7. android:layout_width="fill_parent"
8. android:layout_height="wrap_content"
9. android:text="add"
10. android:onClick="add"/>
11. <Button
12. android:layout_width="fill_parent"
13. android:layout_height="wrap_content"
14. android:text="update"
15. android:onClick="update"/>
16. <Button
17. android:layout_width="fill_parent"
18. android:layout_height="wrap_content"
19. android:text="delete"
20. android:onClick="delete"/>
21. <Button
22. android:layout_width="fill_parent"
23. android:layout_height="wrap_content"
24. android:text="query"
25. android:onClick="query"/>
26. <Button
27. android:layout_width="fill_parent"
28. android:layout_height="wrap_content"
29. android:text="queryTheCursor"
30. android:onClick="queryTheCursor"/>
31. <ListView
32. android:id="@+id/listView"
33. android:layout_width="fill_parent"
34. android:layout_height="wrap_content"/>
35. </LinearLayout>
1. package com.scott.db;
2.
3. import java.util.ArrayList;
4. import java.util.HashMap;
5. import java.util.List;
6. import java.util.Map;
7.
8. import android.app.Activity;
9. import android.database.Cursor;
10. import android.database.CursorWrapper;
11. import android.os.Bundle;
12. import android.view.View;
13. import android.widget.ListView;
14. import android.widget.SimpleAdapter;
15. import android.widget.SimpleCursorAdapter;
16.
17.
18. public class MainActivity extends Activity {
19.
20. private DBManager mgr;
21. private ListView listView;
22.
23. @Override
24. public void onCreate(Bundle savedInstanceState) {
25. super.onCreate(savedInstanceState);
26. setContentView(R.layout.main);
27. listView = (ListView) findViewById(R.id.listView);
28. //初始化DBManager
29. mgr = new DBManager(this);
30. }
31.
32. @Override
33. protected void onDestroy() {
34. super.onDestroy();
35. //应用的最后一个Activity关闭时应释放DB
36. mgr.closeDB();
37. }
38.
39. public void add(View view) {
40. ArrayList<Person> persons = new ArrayList<Person>();
41.
42. Person person1 = new Person("Ella", 22, "lively girl");
43. Person person2 = new Person("Jenny", 22, "beautiful girl");
44. Person person3 = new Person("Jessica", 23, "sexy girl");
45. Person person4 = new Person("Kelly", 23, "hot baby");
46. Person person5 = new Person("Jane", 25, "a pretty woman");
47.
48. persons.add(person1);
49. persons.add(person2);
50. persons.add(person3);
51. persons.add(person4);
52. persons.add(person5);
53.
54. mgr.add(persons);
55. }
56.
57. public void update(View view) {
58. Person person = new Person();
59. person.name = "Jane";
60. person.age = 30;
61. mgr.updateAge(person);
62. }
63.
64. public void delete(View view) {
65. Person person = new Person();
66. person.age = 30;
67. mgr.deleteOldPerson(person);
68. }
69.
70. public void query(View view) {
71. List<Person> persons = mgr.query();
72. ArrayList<Map<String, String>> list = new ArrayList<Map<String, String>>();
73. for (Person person : persons) {
74. HashMap<String, String> map = new HashMap<String, String>();
75. map.put("name", person.name);
76. map.put("info", person.age + " years old, " + person.info);
77. list.add(map);
78. }
79. SimpleAdapter adapter = new SimpleAdapter(this, list, android.R.layout.simple_list_item_2,
80. new String[]{"name", "info"}, new int[]{android.R.id.text1, android.R.id.text2});
81. listView.setAdapter(adapter);
82. }
83.
84. public void queryTheCursor(View view) {
85. Cursor c = mgr.queryTheCursor();
86. startManagingCursor(c); //托付给activity根据自己的生命周期去管理Cursor的生命周期
87. CursorWrapper cursorWrapper = new CursorWrapper(c) {
88. @Override
89. public String getString(int columnIndex) {
90. //将简介前加上年龄
91. if (getColumnName(columnIndex).equals("info")) {
92. int age = getInt(getColumnIndex("age"));
93. return age + " years old, " + super.getString(columnIndex);
94. }
95. return super.getString(columnIndex);
96. }
97. };
98. //确保查询结果中有"_id"列
99. SimpleCursorAdapter adapter = new SimpleCursorAdapter(this, android.R.layout.simple_list_item_2,
100. cursorWrapper, new String[]{"name", "info"}, new int[]{android.R.id.text1, android.R.id.text2});
101. ListView listView = (ListView) findViewById(R.id.listView);
102. listView.setAdapter(adapter);
103. }
104. }
这里需要注意的是SimpleCursorAdapter的应用,当我们使用这个适配器时,我们必须先得到一个Cursor对象,这里面有几个问题:如何管理Cursor的生命周期,如果包装Cursor,Cursor结果集都需要注意什么。
如果手动去管理Cursor的话会非常的麻烦,还有一定的风险,处理不当的话运行期间就会出现异常,幸好Activity为我们提供了startManagingCursor(Cursor cursor)方法,它会根据Activity的生命周期去管理当前的Cursor对象,下面是该方法的说明:
1. /**
2. * This method allows the activity to take care of managing the given
3. * {@link Cursor}'s lifecycle for you based on the activity's lifecycle.
4. * That is, when the activity is stopped it will automatically call
5. * {@link Cursor#deactivate} on the given Cursor, and when it is later restarted
6. * it will call {@link Cursor#requery} for you. When the activity is
7. * destroyed, all managed Cursors will be closed automatically.
8. *
9. * @param c The Cursor to be managed.
10. *
11. * @see #managedQuery(android.net.Uri , String[], String, String[], String)
12. * @see #stopManagingCursor
13. */
文中提到,startManagingCursor方法会根据Activity的生命周期去管理当前的Cursor对象的生命周期,就是说当Activity停止时他会自动调用Cursor的deactivate方法,禁用游标,当Activity重新回到屏幕时它会调用Cursor的requery方法再次查询,当Activity摧毁时,被管理的Cursor都会自动关闭释放。
如何包装Cursor:我们会使用到CursorWrapper对象去包装我们的Cursor对象,实现我们需要的数据转换工作,这个CursorWrapper实际上是实现了Cursor接口。我们查询获取到的Cursor其实是Cursor的引用,而系统实际返回给我们的必然是Cursor接口的一个实现类的对象实例,我们用CursorWrapper包装这个实例,然后再使用SimpleCursorAdapter将结果显示到列表上。
Cursor结果集需要注意些什么:一个最需要注意的是,在我们的结果集中必须要包含一个“_id”的列,否则SimpleCursorAdapter就会翻脸不认人,为什么一定要这样呢?因为这源于SQLite的规范,主键以“_id”为标准。解决办法有三:第一,建表时根据规范去做;第二,查询时用别名,例如:SELECT id AS _id FROM person;第三,在CursorWrapper里做文章:
1. CursorWrapper cursorWrapper = new CursorWrapper(c) {
2. @Override
3. public int getColumnIndexOrThrow(String columnName) throws IllegalArgumentException {
4. if (columnName.equals("_id")) {
5. return super.getColumnIndex("id");
6. }
7. return super.getColumnIndexOrThrow(columnName);
8. }
9. };
如果试图从CursorWrapper里获取“_id”对应的列索引,我们就返回查询结果里“id”对应的列索引即可。
最后我们来看一下结果如何: