android数据存储之Sqlite（二）

SQLite学习笔记

前言：上一章我们介绍了sqlite的一些基本知识以及在dos命令下对sqlite进行的增删改查的操作，这一章我们将在android项目中实际来操作sqlite。

1、 SQLiteDatabase的介绍

Android提供了创建和是用SQLite数据库的API。SQLiteDatabase代表一个数据库对象，提供了操作数据库的一些方法。在 Android的SDK目录下有sqlite3工具，我们可以利用它创建数据库、创建表和执行一些SQL语句。下面是SQLiteDatabase的常用方法：

方法名称	方法描述
openOrCreateDatabase(String path,SQLiteDatabase.CursorFactory factory)	打开或创建数据库
insert(String table,String nullColumnHack,ContentValues values)	添加一条记录
delete(String table,String whereClause,String[] whereArgs)	删除一条记录
query(String table,String[] columns,String selection,String[] selectionArgs,String groupBy,String having,String orderBy)	查询一条记录
update(String table,ContentValues values,String whereClause,String[] whereArgs)	修改记录
execSQL(String sql)	执行一条SQL语句
close()	关闭数据库

2、SQLiteOpenHelper

　　该类是SQLiteDatabase一个辅助类。这个类主要生成一 个数据库，并对数据库的版本进行管理。当在程序当中调用这个类的方法getWritableDatabase()或者 getReadableDatabase()方法的时候，如果当时没有数据，那么Android系统就会自动生成一个数据库。 SQLiteOpenHelper 是一个抽象类，我们通常需要继承它，并且实现里面的3个函数：

1.onCreate（SQLiteDatabase）

在数据库第一次生成的时候会调用这个方法，也就是说，只有在创建数据库的时候才会调用，当然也有一些其它的情况，一般我们在这个方法里边生成数据库表。

2.  onUpgrade（SQLiteDatabase，int，int）

当数据库需要升级的时候，Android系统会主动的调用这个方法。一般我们在这个方法里边删除数据表，并建立新的数据表，当然是否还需要做其他的操作，完全取决于应用的需求。

3.  onOpen（SQLiteDatabase）：

这是当打开数据库时的回调函数，一般在程序中不是很常使用。

写了这么多，改改用实际例子来说明上面的内容了。下面这个操作数据库的实例实现了创建数据库，创建表以及数据库的增删改查的操作。

3、 实例一，利用execSQL()和rawQuery()方法来实现sqlite数据库的增删改查

程序中需要用到的模型层Student：

package com.demo.sqlite.model;

public class Student {

    private int sid;
    private String sname;
    private short age;

    public Student(int sid, String sname, short age) {
        super();
        this.sid = sid;
        this.sname = sname;
        this.age = age;
    }

    public Student() {
        super();
    }

    public int getSid() {
        return sid;
    }

    public void setSid(int sid) {
        this.sid = sid;
    }

    public String getSname() {
        return sname;
    }

    public void setSname(String sname) {
        this.sname = sname;
    }

    public short getAge() {
        return age;
    }

    public void setAge(short age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "sid:" + sid + ",sname:" + sname + ",age:" + age;
    }
}

（1）     编写一个类继承自SQLiteOpenHelper　

package com.demo.sqlite.dao;

import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import android.util.Log;

//sqlite中文社区：http://www.sqlite.com.cn/POPlist.asp?classid=5
public class DBOpenHelper extends SQLiteOpenHelper {

    // 数据库的版本
    private static final int VERSION = 1;
    // 数据库的名称
    private static final String DBNAME = "data.db";
    // 数据表名
    private static final String TABLE_NAME = "t_student";

    public DBOpenHelper(Context context) {
        super(context, DBNAME, null, VERSION);
    }

    // 数据第一次创建的时候执行
    @Override
    public void onCreate(SQLiteDatabase db) {
        // 创建数据库表
        // db.execSQL("create table t_student(sid integer,sname varchar(20),age integer)");
        db.execSQL("create table " + TABLE_NAME
                + " (sid integer,sname varchar(20),age integer)");

    }

    // 更新版本，更新数据（数据的备份）
    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        Log.i("StudentDaoTest", "Upgrade");
        String tempstudent = "temp_student";
        // 修改t_student表为temp_student
        db.execSQL("alter table " + TABLE_NAME + " rename to " + tempstudent);
        // 创建t_student表
        db.execSQL("create table " + TABLE_NAME
                + " (sid integer,sname varchar(20),age integer,sex varchar(4))");
        // 查询temp_student表中的数据并插入到t_student表中
        String sql = "insert into " + TABLE_NAME
                + " (sid,sname,age,sex) select sid,sname,age,'男' from " + tempstudent;
        db.execSQL(sql);
    }
}

（2）     业务逻辑层StudentDao的编写

package com.demo.sqlite.dao;

import java.util.ArrayList;
import java.util.List;

import com.demo.sqlite.model.Student;

import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;

public class StudentDao {

    private DBOpenHelper helper;
    private SQLiteDatabase db;

    public StudentDao(Context context) {
        helper = new DBOpenHelper(context);
    }

    /**
     * 添加学生信息
     * @param stu
     */
    public void add(Student stu) {
        db = helper.getWritableDatabase();
        db.execSQL("insert into t_student(sid,sname,age) values(?,?,?)",
                new Object[] { stu.getSid(), stu.getSname(), stu.getAge() });
    }

    /**
     * 更新学生信息
     * @param stu
     */
    public void update(Student stu) {
        db = helper.getWritableDatabase();
        db.execSQL("update t_student set sname = ? ,age = ? where sid = ? ",
                new Object[] {stu.getSname(), stu.getAge() ,stu.getSid()});
    }

    /**
     * 根据sid查询学生信息
     * @param sid
     * @return
     */
    public Student findStudentById(int sid) {
        db = helper.getWritableDatabase();
        Cursor cursor = db.rawQuery(
                "select sid,sname,age from t_student where sid = ? ",
                new String[] { String.valueOf(sid) });
        if (cursor.moveToNext()) {
            return new Student(cursor.getInt(cursor.getColumnIndex("sid")),
                    cursor.getString(cursor.getColumnIndex("sname")),
                    cursor.getShort(cursor.getColumnIndex("age")));
        }
        return null;
    }

    /**
     * 根据sid删除学生信息
     * @param sid
     */
    public void delete(Integer... sids) {
        if (sids.length > 0) {
            StringBuffer sb = new StringBuffer();
            for (int i = 0; i < sids.length; i++) {
                sb.append("?").append(",");
            }
            sb.deleteCharAt(sb.length() - 1);
            db = helper.getWritableDatabase();
            db.execSQL("delete from t_student where sid in (" + sb + ")",
                    (Object[]) sids);
        }
    }

    /**
     * 查找学生信息
     * @param start    起始位置
     * @param count    学生数量
     * @return
     */
    public List<Student> getStudent(int start,int count){
        List<Student> students = new ArrayList<Student>();
        db = helper.getWritableDatabase();
        Cursor cursor = db.rawQuery("select sid,sname,age from t_student limit ?,? ",new String[]{String.valueOf(start),String.valueOf(count)});
        while(cursor.moveToNext()){
            students.add(new Student(cursor.getInt(cursor.getColumnIndex("sid")), cursor.getString(cursor.getColumnIndex("sname")), cursor.getShort(cursor.getColumnIndex("age"))));
        }
        return students;
    }

    /**
     * 获取学生数量
     * @return
     */
    public long getCount(){
        db = helper.getWritableDatabase();
        Cursor cursor = db.rawQuery("select count(sid) from t_student",null);
        if(cursor.moveToNext()){
            return cursor.getLong(0);
        }
        return 0;
    }
}

（3）  为了更快速的检测我们写的代码的正确性，我这里就不在使用Activity来展示并实行功能了，而是直接采用单元测试，这样更方便

　　  3-1）编写测试代码，在与src同级下建立一个test资源文件夹，接着建一个和android项目包名一致的包，我这里是com.demo.sqlite.activity，然后编写一个类继承AndroidTestCase，测试代码如下：

package com.demo.sqlite.activity;

import java.util.List;

import com.demo.sqlite.dao.StudentDao;
import com.demo.sqlite.model.Student;

import android.test.AndroidTestCase;
import android.util.Log;

/**
 * 单元测试
 * @author yinbenyang
 *
 */
public class StudentDaoTest extends AndroidTestCase {

    //日志输出
    private static final String TAG = "StudentDaoTest";

    //测试添加方法
    public void testAdd(){
        StudentDao sdao = new StudentDao(this.getContext());
        Student stu = new Student(1,"zhangsan",(short)23);
        sdao.add(stu);
        Log.i(TAG, "添加学生成功");
    }

    //测试修改方法
    public void testUpdate(){
        StudentDao sdao = new StudentDao(this.getContext());
        Student stu = sdao.findStudentById(1);
        stu.setSname("lisi");
        sdao.update(stu);
        Log.i(TAG, "修改学生信息成功");
    }

    //测试根据id查找学生方法
    public void testFindStudentById(){
        StudentDao sdao = new StudentDao(this.getContext());
        Student stu = sdao.findStudentById(1);
        if(stu == null){
            Log.i(TAG, "not find");
        }else{
            Log.i(TAG, stu.toString());
        }
    }

    //测试删除方法
    public void testDelete(){
        StudentDao sdao = new StudentDao(this.getContext());
        sdao.delete(1,2);
        Log.i(TAG, "删除成功");
    }

    //测试获取总人数的方法
    public void testGetCount(){
        StudentDao sdao = new StudentDao(this.getContext());
        long count = sdao.getCount();
        Log.i(TAG, count+"");
    }

    //测试分页方法
    public void testGetStudent(){
        StudentDao sdao = new StudentDao(this.getContext());
        List<Student> lists = sdao.getStudent(0, 1);
        for (Student s : lists) {
            Log.i(TAG, s.toString());
        }
    }
}

　　3-2）在android的AndroidManifest.xml文件中进行单元测试的配置：

　　<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    　　package="com.demo.sqlite.activity"
    　　android:versionCode="1"
    　　android:versionName="1.0" >

<uses-sdk
        android:minSdkVersion="15"
        android:targetSdkVersion="15" />

<application
        android:allowBackup="true"
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme" >
        <uses-library android:name="android.test.runner" />
    </application>

<instrumentation
        android:name="android.test.InstrumentationTestRunner"
        android:targetPackage="com.demo.sqlite.activity"
        android:label="Test My App" >
    </instrumentation>
</manifest>

------------------------------------------------------------------分割线-----------------------------------------------------------------------------------------

实例二，利用SqliteDatabase自带的insert(),delete(),update(),query()进行增删改查的操作

（1）编写一个类继承自SQLiteOpenHelper，同上，不在赘述

（2）业务逻辑层StudentDao2的编写：

package com.demo.sqlite.dao;

import java.util.ArrayList;
import java.util.List;

import com.demo.sqlite.model.Student;

import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;

public class StudentDao2 {

    private DBOpenHelper helper;
    private SQLiteDatabase db;

    public StudentDao2(Context context) {
        helper = new DBOpenHelper(context);
    }

    /**
     * 添加学生信息
     * @param stu
     */
    public void add(Student stu) {
        db = helper.getWritableDatabase();
        ContentValues values = new ContentValues();
        values.put("sid", stu.getSid());
        values.put("sname", stu.getSname());
        values.put("age", stu.getAge());
        /**
         * 第一个参数：String table：插入数据的数据表名
         * 第二个参数：String nullColumnHack：当values参数为空或者里面没有内容的时候，insert是会失败的（不允许插入空行）,
         *         为了防止这种情况，我们指定一个列名，如果发现要插入的行为空行时，就会将你设定的列名的值设为null，然后在向数据库表中插入，
         *         例如当values为空时，实际上sql语句变成了：insert into t_student(sid) values(null);
         * 第三个参数：ContentValues values：一个ContentValues对象，类似于map
         */
        db.insert("t_student", "sid", values);
    }

    /**
     * 更新学生信息
     * @param stu
     */
    public void update(Student stu) {
        db = helper.getWritableDatabase();
        ContentValues values = new ContentValues();
        values.put("sname", stu.getSname());
        values.put("age", stu.getAge());
        db.update("t_student", values, " sid = ? ", new String[]{String.valueOf(stu.getSid())});
    }

    /**
     * 根据sid查询学生信息
     * @param sid
     * @return
     */
    public Student findStudentById(int sid) {
        db = helper.getWritableDatabase();
        Cursor cursor =  db.query("t_student", new String[]{"sid","sname","age"},"sid = ? " ,new String[]{String.valueOf(sid)},"","","");
        if(cursor.moveToNext()){
            //这里使用0,1,2是根据各自在t_student表中的位置来定位的，也可以使用cursor.getInt(cursor.getColumnIndex("sid"))
            return new Student(cursor.getInt(0), cursor.getString(1),cursor.getShort(2));
        }
        return null;
    }

    /**
     * 根据sid删除学生信息
     * @param sid
     */
    public void delete(Integer... sids) {
        if (sids.length > 0) {
            StringBuffer sb = new StringBuffer();
            String[] strSid = new String[sids.length];
            for (int i = 0; i < sids.length; i++) {
                sb.append("?").append(",");
                strSid[i] = String.valueOf(sids[i]);
            }
            sb.deleteCharAt(sb.length() - 1);
            db = helper.getWritableDatabase();
            db.delete("t_student", "sid in("+sb+")", strSid);
        }
    }

    /**
     * 查找学生信息
     * @param start    起始位置
     * @param count    学生数量
     * @return
     */
    public List<Student> getStudent(int start,int count){
        List<Student> students = new ArrayList<Student>();
        db = helper.getWritableDatabase();
        /** query()方法中各参数的说明
         *  ①table:表名称
                  ②columns:列名称数组
            ③selection:条件字句，相当于where
            ④selectionArgs:条件字句，参数数组
            ⑤groupBy:分组列
            ⑥having:分组条件
            ⑦orderBy:排序列
            ⑧limit:分页查询限制
         */
        Cursor cursor = db.query("t_student", new String[]{"sid","sname","age"}, null, null, null, null, "sid desc",start+","+count);
        while(cursor.moveToNext()){
            students.add(new Student(cursor.getInt(0), cursor.getString(1), cursor.getShort(2)));
        }
        return students;
    }

    /**
     * 获取学生数量
     * @return
     */
    public long getCount(){
        db = helper.getWritableDatabase();
        Cursor cursor = db.query("t_student", new String[]{"count(*)"}, null, null, null, null, null);
        if(cursor.moveToNext()){
            return cursor.getLong(0);
        }
        return 0;
    }
}

（3） 单元测试类的编写，和上面第一种实例的差不多，就是将StudentDao换成StudentDao2，此处不在赘述。

4、 运行测试

　　（1）测试添加方法testAdd(),点击项目名-->test-->包名-->StudentDaoTest-->testAdd(),右键run as，选择Android JUnit Test，如图

aaarticlea/png;base64,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" alt="" width="793" height="263" />

接着我们在测试查询的结果，如图：

aaarticlea/png;base64,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" alt="" width="781" height="293" />

生成的data.db存放在data/data/项目包名/dataases/data.db中。可以通过ddms视图看到，也可以在dos下使用命令来查看：

aaarticlea/png;base64,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*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" alt="" width="514" height="284" />aaarticlea/png;base64,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*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" alt="" width="496" height="286" />

（2）在上面的DBOpenHelper 这个类里面有一个onUpgrade()方法，这个是用来更新数据库版本的操作的，当数据库版本有改变时，将会执行这个方法，例如现在将DBOpenHelper 里面的VERSION改为2，在运行测试testFindStudentById()方法会出现什么情况呢？如下图：

aaarticlea/png;base64,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" alt="" width="604" height="235" />

这时我们看到onUpgrade里面的log日志打印出来了，并且执行了里面的操作【向t_student表中添加一个sex字段，实现的思路是：先将t_student表重命名为temp_student，然后重新创建一个带有sex字段的表，接着查询出temp_student表中的数据并插入到t_student表中，也就是说此时的data.db中有两张表：t_student和temp_student，t_student表中有四个四段，而temp_studnet表中只有三个字段】，使用命令来查看效果：

aaarticlea/png;base64,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" alt="" width="878" height="212" />

源码下载：SqliteDemo.zip