大家好,今天来介绍一下SQLite的相关知识,并结合Java实现对SQLite数据库的操作。
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数据库。
在操作之前,朋友们要先下载SQLite数据库,官方的下载页面是http://sqlite.org/download.html,我是在Windows下试验,所以我选择了Precompiled Binaries For Windows下面的sqlite-shell-win32-x86和sqlite-analyzer-win32-x86的zip包,前者是SQLite数据库引擎,后者是SQLite数据库分析器,主要用于分析数据库的状态等信息,大家也可以根据自己的情况去下载。下载完成后分别解压,得到两个可执行文件,如图:
这两个文件可以根据自己的喜好放置在指定的位置,我将其放在D盘根目录下。下面我们就来一步一步操作SQLite:
创建数据库:
- D:\>sqlite3 test.db
- SQLite version 3.7.7.1 2011-06-28 17:39:05
- Enter ".help" for instructions
- Enter SQL statements terminated with a ";"
- sqlite> .databases
- seq name file
-
-
-
- 0 main D:\test.db
-
- sqlite>
我们执行了sqlite3命令,参数就是数据库的名称,如果该数据库已存在,则使用,如果不存在,则新建一个,这里我们简单的在当前位置创建了test.db,你也可以在任何存在的并且可写的目录下创建自己的数据库。(如果对于SQLite的命令不太熟悉,可以执行“.help”命令列出所有的命令清单进行查看)。
创建表:
- sqlite> CREATE TABLE person (id INTEGER PRIMARY KEY AUTOINCREMENT, name VARCHAR(20), age SMALLINT);
- sqlite> .tables
- person
- sqlite> .schema person
- CREATE TABLE person (id INTEGER PRIMARY KEY AUTOINCREMENT, name VARCHAR(20), age SMALLINT);
- sqlite>
在我们创建表之后,可以用“.tables”命令去查看已有的表,用“.schema”命令去查看表的结构,如果后面没有表名做参数,则将会输出所有表的建表语句。
插入数据:
- sqlite> INSERT INTO person VALUES (NULL, 'john', 30);
- sqlite> SELECT * FROM person;
- 1|john|30
从.sql文件导入数据:
- sqlite> .read test.sql
- sqlite> SELECT * FROM person;
- 1|john|30
- 2|david|35
- 3|henry|40
- sqlite>
分析数据库使用状态:
- D:\>sqlite3_analyzer test.db
- /** Disk-Space Utilization Report For test.db
-
- Page size in bytes.................... 1024
- Pages in the whole file (measured).... 4
- Pages in the whole file (calculated).. 4
- Pages that store data................. 4 100.0%
- Pages on the freelist (per header).... 0 0.0%
- Pages on the freelist (calculated).... 0 0.0%
- Pages of auto-vacuum overhead......... 0 0.0%
- Number of tables in the database...... 4
- Number of indices..................... 0
- Number of named indices............... 0
- Automatically generated indices....... 0
- Size of the file in bytes............. 4096
- Bytes of user payload stored.......... 39 0.95%
- ...
备份数据库:
备份 SQLite 数据库有两种方法。如果数据库正在使用中,则应从命令行界面使用 .dump 命令。这样可以创建一个包含必要命令和数据的文件,从而重新创建数据库。.dump 命令也可以用于备份数据库表。
- sqlite> .dump
- PRAGMA foreign_keys=OFF;
- BEGIN TRANSACTION;
- CREATE TABLE person (id INTEGER PRIMARY KEY AUTOINCREMENT, name VARCHAR(20), age SMALLINT);
- INSERT INTO "person" VALUES(1,'john',30);
- INSERT INTO "person" VALUES(2,'david',35);
- INSERT INTO "person" VALUES(3,'henry',40);
- DELETE FROM sqlite_sequence;
- INSERT INTO "sqlite_sequence" VALUES('person',3);
- COMMIT;
- sqlite> .output dump.sql
- sqlite> .dump
- sqlite>
我们可以指定输出的目标为一个文件,然后再使用命令时,输出信息就会写入指定的文件,如果想恢复为标准输出,可以这样设定:- sqlite> .output stdout
- sqlite> .dump
- PRAGMA foreign_keys=OFF;
- BEGIN TRANSACTION;
- CREATE TABLE person (id INTEGER PRIMARY KEY AUTOINCREMENT, name VARCHAR(20), age SMALLINT);
- INSERT INTO "person" VALUES(1,'john',30);
- INSERT INTO "person" VALUES(2,'david',35);
- INSERT INTO "person" VALUES(3,'henry',40);
- DELETE FROM sqlite_sequence;
- INSERT INTO "sqlite_sequence" VALUES('person',3);
- COMMIT;
- 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代码:
- package com.scott.sqlite;
- import java.sql.Connection;
- import java.sql.DriverManager;
- import java.sql.ResultSet;
- import java.sql.Statement;
-
- public class Test {
- public static void main(String[] args) throws Exception {
- Class.forName("org.sqlite.JDBC");
- Connection conn = DriverManager.getConnection("jdbc:sqlite:db/test.db");
- Statement stmt = conn.createStatement();
-
- stmt.executeUpdate("DROP TABLE IF EXISTS person");
- stmt.executeUpdate("CREATE TABLE person(id INTEGER, name STRING)");
- stmt.executeUpdate("INSERT INTO person VALUES(1, 'john')");
- stmt.executeUpdate("INSERT INTO person VALUES(2, 'david')");
- stmt.executeUpdate("INSERT INTO person VALUES(3, 'henry')");
- ResultSet rs = stmt.executeQuery("SELECT * FROM person");
- while (rs.next()) {
- System.out.println("id=>" + rs.getInt("id") + ", name=>" + rs.getString("name"));
- }
- stmt.close();
- conn.close();
- }
- }
执行Test.java文件,结果如下:
这个时候,在我们的db目录下,就生成了一个test.db的文件:
SQLite使用须知:
目前没有可用于 SQLite 的网络服务器。从应用程序运行位于其他计算机上的 SQLite 的惟一方法是从网络共享运行。这样会导致一些问题,像 UNIX® 和 Windows® 网络共享都存在文件锁定问题。还有由于与访问网络共享相关的延迟而带来的性能下降问题。
SQLite 只提供数据库级的锁定。
SQLite 没有用户帐户概念,而是根据文件系统确定所有数据库的权限。
结束语:
由于资源占用少、性能良好和零管理成本,嵌入式数据库有了它的用武之地,像Android、iPhone都有内置的SQLite数据库供开发人员使用,它的易用性可以加快应用程序的开发,并使得复杂的数据存储变得轻松了许多。
上次我向大家介绍了SQLite的基本信息和使用过程,相信朋友们对SQLite已经有所了解了,那今天呢,我就和大家分享一下在Android中如何使用SQLite。
现在的主流移动设备像Android、iPhone等都使用SQLite作为复杂数据的存储引擎,在我们为移动设备开发应用程序时,也许就要使用到SQLite来存储我们大量的数据,所以我们就需要掌握移动设备上的SQLite开发技巧。对于Android平台来说,系统内置了丰富的API来供开发人员操作SQLite,我们可以轻松的完成对数据的存取。
下面就向大家介绍一下SQLite常用的操作方法,为了方便,我将代码写在了Activity的onCreate中:
- @Override
- protected void onCreate(Bundle savedInstanceState) {
- super.onCreate(savedInstanceState);
-
-
- SQLiteDatabase db = openOrCreateDatabase("test.db", Context.MODE_PRIVATE, null);
- db.execSQL("DROP TABLE IF EXISTS 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 cv = new ContentValues();
- cv.put("name", person.name);
- cv.put("age", person.age);
-
- 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();
-
-
-
- }
在执行完上面的代码后,系统就会在/data/data/[PACKAGE_NAME]/databases目录下生成一个“test.db”的数据库文件,如图:
上面的代码中基本上囊括了大部分的数据库操作;对于添加、更新和删除来说,我们都可以使用
- db.executeSQL(String sql);
- db.executeSQL(String sql, Object[] bindArgs);
除了统一的形式之外,他们还有各自的操作方法:- 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方法的参数也是一样。下面来说说查询操作。查询操作相对于上面的几种操作要复杂些,因为我们经常要面对着各种各样的查询条件,所以系统也考虑到这种复杂性,为我们提供了较为丰富的查询形式:
- 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对象的常用方法:
- 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);
- 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:
- 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) {
-
- super(context, DATABASE_NAME, null, DATABASE_VERSION);
- }
-
-
- @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)");
- }
-
-
- @Override
- public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
- db.execSQL("ALTER TABLE person ADD COLUMN other STRING");
- }
- }
正如上面所述,数据库第一次创建时onCreate方法会被调用,我们可以执行创建表的语句,当系统发现版本变化之后,会调用onUpgrade方法,我们可以执行修改表结构等语句。为了方便我们面向对象的使用数据,我们建一个Person类,对应person表中的字段,如下:
- 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,来封装我们所有的业务方法,代码如下:- 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);
-
-
- db = helper.getWritableDatabase();
- }
-
-
-
-
-
- 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();
- }
- }
-
-
-
-
-
- public void updateAge(Person person) {
- ContentValues cv = new ContentValues();
- cv.put("age", person.age);
- db.update("person", cv, "name = ?", new String[]{person.name});
- }
-
-
-
-
-
- public void deleteOldPerson(Person person) {
- db.delete("person", "age >= ?", new String[]{String.valueOf(person.age)});
- }
-
-
-
-
-
- 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;
- }
-
-
-
-
-
- public Cursor queryTheCursor() {
- Cursor c = db.rawQuery("SELECT * FROM person", null);
- return c;
- }
-
-
-
-
- public void closeDB() {
- db.close();
- }
- }
我们在DBManager构造方法中实例化DBHelper并获取一个SQLiteDatabase对象,作为整个应用的数据库实例;在添加多个Person信息时,我们采用了事务处理,确保数据完整性;最后我们提供了一个closeDB方法,释放数据库资源,这一个步骤在我们整个应用关闭时执行,这个环节容易被忘记,所以朋友们要注意。我们获取数据库实例时使用了getWritableDatabase()方法,也许朋友们会有疑问,在getWritableDatabase()和getReadableDatabase()中,你为什么选择前者作为整个应用的数据库实例呢?在这里我想和大家着重分析一下这一点。
我们来看一下SQLiteOpenHelper中的getReadableDatabase()方法:
- public synchronized SQLiteDatabase getReadableDatabase() {
- if (mDatabase != null && mDatabase.isOpen()) {
-
- return mDatabase;
- }
-
- if (mIsInitializing) {
-
- throw new IllegalStateException("getReadableDatabase called recursively");
- }
-
-
-
- try {
-
- return getWritableDatabase();
- } catch (SQLiteException e) {
- if (mName == null)
- throw e;
- 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;
- return mDatabase;
- } finally {
- mIsInitializing = false;
- if (db != null && db != mDatabase)
- db.close();
- }
- }
在getReadableDatabase()方法中,首先判断是否已存在数据库实例并且是打开状态,如果是,则直接返回该实例,否则试图获取一个可读写模式的数据库实例,如果遇到磁盘空间已满等情况获取失败的话,再以只读模式打开数据库,获取数据库实例并返回,然后为mDatabase赋值为最新打开的数据库实例。既然有可能调用到getWritableDatabase()方法,我们就要看一下了:- public synchronized SQLiteDatabase getWritableDatabase() {
- if (mDatabase != null && mDatabase.isOpen() && !mDatabase.isReadOnly()) {
-
- return mDatabase;
- }
-
- if (mIsInitializing) {
- throw new IllegalStateException("getWritableDatabase called recursively");
- }
-
-
-
-
-
-
-
- boolean success = false;
- SQLiteDatabase db = null;
-
- if (mDatabase != null)
- mDatabase.lock();
- try {
- mIsInitializing = true;
- if (mName == null) {
- db = SQLiteDatabase.create(null);
- } else {
-
- db = mContext.openOrCreateDatabase(mName, 0, mFactory);
- }
-
- int version = db.getVersion();
-
- if (version != mNewVersion) {
- db.beginTransaction();
- try {
- if (version == 0) {
-
- onCreate(db);
- } else {
-
- 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) {
-
- try {
- mDatabase.close();
- } catch (Exception e) {
- }
- mDatabase.unlock();
- }
- mDatabase = db;
- } else {
-
- if (mDatabase != null)
- mDatabase.unlock();
- if (db != null)
- db.close();
- }
- }
- }
大家可以看到,几个关键步骤是,首先判断mDatabase如果不为空已打开并不是只读模式则直接返回,否则如果mDatabase不为空则加锁,然后开始打开或创建数据库,比较版本,根据版本号来调用相应的方法,为数据库设置新版本号,最后释放旧的不为空的mDatabase并解锁,把新打开的数据库实例赋予mDatabase,并返回最新实例。看完上面的过程之后,大家或许就清楚了许多,如果不是在遇到磁盘空间已满等情况,getReadableDatabase()一般都会返回和getWritableDatabase()一样的数据库实例,所以我们在DBManager构造方法中使用getWritableDatabase()获取整个应用所使用的数据库实例是可行的。当然如果你真的担心这种情况会发生,那么你可以先用getWritableDatabase()获取数据实例,如果遇到异常,再试图用getReadableDatabase()获取实例,当然这个时候你获取的实例只能读不能写了。
最后,让我们看一下如何使用这些数据操作方法来显示数据,下面是MainActivity.Java的布局文件和代码:
- <?xml version="1.0" encoding="utf-8"?>
- <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
- android:orientation="vertical"
- android:layout_width="fill_parent"
- android:layout_height="fill_parent">
- <Button
- android:layout_width="fill_parent"
- android:layout_height="wrap_content"
- android:text="add"
- android:onClick="add"/>
- <Button
- android:layout_width="fill_parent"
- android:layout_height="wrap_content"
- android:text="update"
- android:onClick="update"/>
- <Button
- android:layout_width="fill_parent"
- android:layout_height="wrap_content"
- android:text="delete"
- android:onClick="delete"/>
- <Button
- android:layout_width="fill_parent"
- android:layout_height="wrap_content"
- android:text="query"
- android:onClick="query"/>
- <Button
- android:layout_width="fill_parent"
- android:layout_height="wrap_content"
- android:text="queryTheCursor"
- android:onClick="queryTheCursor"/>
- <ListView
- android:id="@+id/listView"
- android:layout_width="fill_parent"
- android:layout_height="wrap_content"/>
- </LinearLayout>
- package com.scott.db;
-
- import java.util.ArrayList;
- import java.util.HashMap;
- import java.util.List;
- import java.util.Map;
-
- import android.app.Activity;
- import android.database.Cursor;
- import android.database.CursorWrapper;
- import android.os.Bundle;
- import android.view.View;
- import android.widget.ListView;
- import android.widget.SimpleAdapter;
- import android.widget.SimpleCursorAdapter;
-
-
- public class MainActivity extends Activity {
-
- private DBManager mgr;
- private ListView listView;
-
- @Override
- public void onCreate(Bundle savedInstanceState) {
- super.onCreate(savedInstanceState);
- setContentView(R.layout.main);
- listView = (ListView) findViewById(R.id.listView);
-
- mgr = new DBManager(this);
- }
-
- @Override
- protected void onDestroy() {
- super.onDestroy();
-
- mgr.closeDB();
- }
-
- public void add(View view) {
- ArrayList<Person> persons = new ArrayList<Person>();
-
- Person person1 = new Person("Ella", 22, "lively girl");
- Person person2 = new Person("Jenny", 22, "beautiful girl");
- Person person3 = new Person("Jessica", 23, "sexy girl");
- Person person4 = new Person("Kelly", 23, "hot baby");
- Person person5 = new Person("Jane", 25, "a pretty woman");
-
- persons.add(person1);
- persons.add(person2);
- persons.add(person3);
- persons.add(person4);
- persons.add(person5);
-
- mgr.add(persons);
- }
-
- public void update(View view) {
- Person person = new Person();
- person.name = "Jane";
- person.age = 30;
- mgr.updateAge(person);
- }
-
- public void delete(View view) {
- Person person = new Person();
- person.age = 30;
- mgr.deleteOldPerson(person);
- }
-
- public void query(View view) {
- List<Person> persons = mgr.query();
- ArrayList<Map<String, String>> list = new ArrayList<Map<String, String>>();
- for (Person person : persons) {
- HashMap<String, String> map = new HashMap<String, String>();
- map.put("name", person.name);
- map.put("info", person.age + " years old, " + person.info);
- list.add(map);
- }
- SimpleAdapter adapter = new SimpleAdapter(this, list, android.R.layout.simple_list_item_2,
- new String[]{"name", "info"}, new int[]{android.R.id.text1, android.R.id.text2});
- listView.setAdapter(adapter);
- }
-
- public void queryTheCursor(View view) {
- Cursor c = mgr.queryTheCursor();
- startManagingCursor(c);
- CursorWrapper cursorWrapper = new CursorWrapper(c) {
- @Override
- public String getString(int columnIndex) {
-
- if (getColumnName(columnIndex).equals("info")) {
- int age = getInt(getColumnIndex("age"));
- return age + " years old, " + super.getString(columnIndex);
- }
- return super.getString(columnIndex);
- }
- };
-
- SimpleCursorAdapter adapter = new SimpleCursorAdapter(this, android.R.layout.simple_list_item_2,
- cursorWrapper, new String[]{"name", "info"}, new int[]{android.R.id.text1, android.R.id.text2});
- ListView listView = (ListView) findViewById(R.id.listView);
- listView.setAdapter(adapter);
- }
- }
这里需要注意的是SimpleCursorAdapter的应用,当我们使用这个适配器时,我们必须先得到一个Cursor对象,这里面有几个问题:如何管理Cursor的生命周期,如果包装Cursor,Cursor结果集都需要注意什么。如果手动去管理Cursor的话会非常的麻烦,还有一定的风险,处理不当的话运行期间就会出现异常,幸好Activity为我们提供了startManagingCursor(Cursor cursor)方法,它会根据Activity的生命周期去管理当前的Cursor对象,下面是该方法的说明:
文中提到,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里做文章:
- CursorWrapper cursorWrapper = new CursorWrapper(c) {
- @Override
- public int getColumnIndexOrThrow(String columnName) throws IllegalArgumentException {
- if (columnName.equals("_id")) {
- return super.getColumnIndex("id");
- }
- return super.getColumnIndexOrThrow(columnName);
- }
- };
如果试图从CursorWrapper里获取“_id”对应的列索引,我们就返回查询结果里“id”对应的列索引即可。最后我们来看一下结果如何:
0 0