欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  移动技术

Android中SQLite 使用方法详解

程序员文章站 2022-06-11 09:33:15
android中sqlite 使用方法详解 现在的主流移动设备像android、iphone等都使用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”的数据库文件,如图:

Android中SQLite 使用方法详解

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

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的项目,结构如下:

Android中SQLite 使用方法详解

其中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中SQLite 使用方法详解

Android中SQLite 使用方法详解

感谢阅读,希望能帮助到大家,谢谢大家对本站的支持!