程序博客网 > windows手机恢复工具

Android中SQLite应用详解

来源：互联网 发布：windows手机恢复工具 编辑：程序博客网 时间：2024/06/11 21:18

原文地址：http://blog.csdn.net/liuhe688/article/details/6715983

上次我向大家介绍了SQLite的基本信息和使用过程，相信朋友们对SQLite已经有所了解了，那今天呢，我就和大家分享一下在Android中如何使用SQLite。

现在的主流移动设备像Android、iPhone等都使用SQLite作为复杂数据的存储引擎，在我们为移动设备开发应用程序时，也许就要使用到SQLite来存储我们大量的数据，所以我们就需要掌握移动设备上的SQLite开发技巧。对于Android平台来说，系统内置了丰富的API来供开发人员操作SQLite，我们可以轻松的完成对数据的存取。

下面就向大家介绍一下SQLite常用的操作方法，为了方便，我将代码写在了Activity的onCreate中：

[java] view plaincopy
  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”的数据库文件，如图：


上面的代码中基本上囊括了大部分的数据库操作；对于添加、更新和删除来说，我们都可以使用

[java] view plaincopy
  1. db.executeSQL(String sql);  
  2. db.executeSQL(String sql, Object[] bindArgs);//sql语句中使用占位符，然后第二个参数是实际的参数集  
除了统一的形式之外，他们还有各自的操作方法：
[java] view plaincopy
  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方法的参数也是一样。

下面来说说查询操作。查询操作相对于上面的几种操作要复杂些，因为我们经常要面对着各种各样的查询条件，所以系统也考虑到这种复杂性，为我们提供了较为丰富的查询形式：

[java] view plaincopy
  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”、“ORDERBY”、“LIMIT”等SQL关键字。
最后，他们同时返回一个Cursor对象，代表数据集的游标，有点类似于JavaSE中的ResultSet。

下面是Cursor对象的常用方法：

[java] view plaincopy
  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：

[java] view plaincopy
  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表中的字段，如下：

[java] view plaincopy
  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，来封装我们所有的业务方法，代码如下：
[java] view plaincopy
  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.     public void add(List persons) {  
  24.         db.beginTransaction();  //开始事务  
  25.         try {  
  26.             for (Person person : persons) {  
  27.                 db.execSQL("INSERT INTO person VALUES(null, ?, ?, ?)", new Object[]{person.name, person.age, person.info});  
  28.             }  
  29.             db.setTransactionSuccessful();  //设置事务成功完成  
  30.         } finally {  
  31.             db.endTransaction();    //结束事务  
  32.         }  
  33.     }  
  34.       
  35.       
  36.     public void 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.       
  43.     public void deleteOldPerson(Person person) {  
  44.         db.delete("person", "age >= ?", new String[]{String.valueOf(person.age)});  
  45.     }  
  46.       
  47.       
  48.     public List query() {  
  49.         ArrayList persons = new ArrayList();  
  50.         Cursor c = queryTheCursor();  
  51.         while (c.moveToNext()) {  
  52.             Person person = new Person();  
  53.             person._id = c.getInt(c.getColumnIndex("_id"));  
  54.             person.name = c.getString(c.getColumnIndex("name"));  
  55.             person.age = c.getInt(c.getColumnIndex("age"));  
  56.             person.info = c.getString(c.getColumnIndex("info"));  
  57.             persons.add(person);  
  58.         }  
  59.         c.close();  
  60.         return persons;  
  61.     }  
  62.       
  63.       
  64.     public Cursor queryTheCursor() {  
  65.         Cursor c = db.rawQuery("SELECT * FROM person", null);  
  66.         return c;  
  67.     }  
  68.       
  69.       
  70.     public void closeDB() {  
  71.         db.close();  
  72.     }  
  73. }  
我们在DBManager构造方法中实例化DBHelper并获取一个SQLiteDatabase对象，作为整个应用的数据库实例；在添加多个Person信息时，我们采用了事务处理，确保数据完整性；最后我们提供了一个closeDB方法，释放数据库资源，这一个步骤在我们整个应用关闭时执行，这个环节容易被忘记，所以朋友们要注意。

我们获取数据库实例时使用了getWritableDatabase()方法，也许朋友们会有疑问，在getWritableDatabase()和getReadableDatabase()中，你为什么选择前者作为整个应用的数据库实例呢？在这里我想和大家着重分析一下这一点。

我们来看一下SQLiteOpenHelper中的getReadableDatabase()方法：

[java] view plaincopy
  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()方法，我们就要看一下了：
[java] view plaincopy
  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的布局文件和代码：

[html] view plaincopy
0 0
windows手机恢复工具 windows手机恢复工具
原创粉丝点击
热门IT博客
python sql 防注入python sql 防注入
光环大数据光环大数据
java逆波兰式算法
java corba
点评淘宝店铺装修风格
magics软件
大数据带来的变革
win32 socket编程实例
李庄白肉 知乎
java web 极光推送
企业电话号码搜索软件
ldc1000中文数据手册
淘宝如何导出客户信息
celtx for mac 中文版
照片音乐视频制作软件
sift匹配算法 matlab
linux zip.gz解压
qq助手备份软件
p2p返利源码程序
犀牛软件模型
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 嵇的读音是什么 嵇字怎么读 道火不灭 嵇太康 嵇的拼音 嵇康 嵇康的读音 嵇康读音 嵇康简介 三国杀嵇康 嵇康广陵散 阮籍嵇康 嵇康之死 嵇康技能 嵇波 嵇绍 嵇绍怎么读 嵇芳 嵊泗 嵊 嵊怎么读 嵊泗怎么读 嵊泗岛 嵊山岛 嵊泗船票 嵊泗网 上海嵊泗 上海到嵊泗船票时刻表 上海到嵊泗 沈家湾到嵊泗时刻表 嵊泗拼音 嵊卅人才网 嵊泗枸杞嵊山岛青年旅社 嵊泗属于哪个市 嵊泗岛酒店 嵊泗南长涂沙滩 舟山到嵊泗船票时刻表 嵊泗菜园镇酒店 嵊泗枸杞岛 嵊泗家庭旅馆 嵊泗住宿 杭州到嵊泗二日游

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里