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”对应的列索引即可。
最后我们来看一下结果如何：

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