Android中SQLite 使用方法详解
android中sqlite 使用方法详解
现在的主流移动设备像android、iphone等都使用sqlite作为复杂数据的存储引擎,在我们为移动设备开发应用程序时,也许就要使用到sqlite来存储我们大量的数据,所以我们就需要掌握移动设备上的sqlite开发技巧。对于android平台来说,系统内置了丰富的api来供开发人员操作sqlite,我们可以轻松的完成对数据的存取。
下面就向大家介绍一下sqlite常用的操作方法,为了方便,我将代码写在了activity的oncreate中:
@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”的数据库文件,如图:
上面的代码中基本上囊括了大部分的数据库操作;对于添加、更新和删除来说,我们都可以使用
db.executesql(string sql); db.executesql(string sql, object[] bindargs);//sql语句中使用占位符,然后第二个参数是实际的参数集
除了统一的形式之外,他们还有各自的操作方法:
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); //指定列是否为空(列基数为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:
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表中的字段,如下:
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); //因为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()方法:
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()方法,我们就要看一下了:
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()获取实例,当然这个时候你获取的实例只能读不能写了。
最后,让我们看一下如何使用这些数据操作方法来显示数据,下面是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); //初始化dbmanager mgr = new dbmanager(this); } @override protected void ondestroy() { super.ondestroy(); //应用的最后一个activity关闭时应释放db 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); //托付给activity根据自己的生命周期去管理cursor的生命周期 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); } }; //确保查询结果中有"_id"列 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对象,下面是该方法的说明:
/** * this method allows the activity to take care of managing the given * {@link cursor}'s lifecycle for you based on the activity's lifecycle. * that is, when the activity is stopped it will automatically call * {@link cursor#deactivate} on the given cursor, and when it is later restarted * it will call {@link cursor#requery} for you. when the activity is * destroyed, all managed cursors will be closed automatically. * * @param c the cursor to be managed. * * @see #managedquery(android.net.uri , string[], string, string[], string) * @see #stopmanagingcursor */
文中提到,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”对应的列索引即可。
最后我们来看一下结果如何:
感谢阅读,希望能帮助到大家,谢谢大家对本站的支持!
下一篇: Android音视频点/直播模块开发
推荐阅读