SQLite实现基本的增删改查功能


还是向之前一样，先介绍功能，再介绍所用知识点，然后贴下代码。

 一，SQLite简介：
SQLite，是一款轻型的数据库，是遵守ACID(原子性、一致性、隔离性、持久性)的关联式数据库管理系统，多用于嵌入式开发中。
  SQLite的数据类型：Typelessness(无类型), 可以保存任何类型的数据到你所想要保存的任何表的任何列中. 但它又支持常见的类型比如: NULL, VARCHAR, TEXT, INTEGER, BLOB, CLOB...等. 唯一的例外：integer primary key 此字段只能存储64位整数，数据库的主键只能为"_id",设为primary key时，会自增，从1开始，不需要再加auto_increment关键字

  在Android系统，提供了一个SQLiteOpenHelper抽象类，该类用于对数据库版本进行管理.数据库帮助类，用户创建和管理数据库，该类中常用的方法:
     onCreate     数据库创建时执行(第一次连接获取数据库对象时执行)，初始化一些表；
     onUpgrade     数据库更新时执行(版本号改变时执行)，在执行添加表，删除表，修改表时可以在此方法中操作
     onOpen          数据库每次打开时执行(每次打开数据库时调用，在 onCreate，onUpgrade方法之后)

数据库操作工具：
SQLiteHelper,SQLiteExpert，SQLite3
 
数据库一般操作步骤：
1，加载驱动；
2，连接数据库；
3，操作数据库
但是在android中，前两步骤省略了，andorid帮我做了
 
在第一次连接数据库用SQLiteOpenHelper调用getReaderDatabase()方法时创建数据库
 
为防止SQL注入，尽量不要把字符串拼接SQL
 
数据库存放路径：
/data/data/程序包名/databases/数据库名.db 下
 
数据库操作注意事项：
1，判断数据库是否打开，isOpen();
2，数据库使用完之后要关闭 close();
3, 查询方法：rawQuery();
4,插入方法：execSQL()
 
在android中，操作数据库有两种方式:
1，直接写SQL语句；
2，使用API提供的方法进行增删改查，相当于hibernate中的HQL；
 
数据库事务操作：
// 开启事务
 db.beginTransaction();

 // 标记事务成功
 db.setTransactionSuccessful();

 // 停止事务
 db.endTransaction();
 
使用事务会加快执行速度
 
Cursor结果集的特点：
1，默认指定-1
moveToNext()
Cursor使用完之后需要关闭close()，不然会一直保存在内存中，出现内存溢出。
 
sqlite3的使用
命令：
1，adb shell   通过adb可以轻松的执行Linux Shell命令
2， cd   /data/data/packageName/databases    进入databases 目录 
3，sqlite3 test.db     进入sqlite3,操作test数据库
 
.tables :列出数据库中所有的表
exit:退出sqlite操作模式
 
二，主要功能：
　　1，实现对student表的增删改查功能；
 
三，主要知识点：
　　1，SQLiteOpenHelper抽象类的使用
　　2，Cursor的使用；
　　3，事务的使用；
四，工程目录结构截图：
五，代码展示：
　　1，实体类Student.java
public class Student {
    private int id;
    private String name;
    private int age;
    private String info;
    
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    
    public String getInfo() {
        return info;
    }

    public void setInfo(String info) {
        this.info = info;
    }
    public Student(int id, String name, int age, String info) {
        super();
        this.id = id;
        this.name = name;
        this.age = age;
        this.info = info;
    }
    
    public Student() {
        super();
    }
    @Override
    public String toString() {
        return "Student [id=" + id + ", name=" + name + ", age=" + age + "]";
    }
}
View Code

　　2，DBHelper.java,继承SQLiteOpenHelper类

/**
 * 能够更好的管理和维护数据库，我们会封装一个继承自SQLiteOpenHelper类的数据库操作类，
 * 然后以这个类为基础，再封装我们的业务逻辑方法。
 * @author wk
 *
 */
public class DBHelper  extends SQLiteOpenHelper {

    public static final String DB_NAME = "test.db";
    public static final int VERSION = 1;
    
    public DBHelper(Context context) {
         //CursorFactory设置为null,使用默认值  
        super(context, DB_NAME, null, VERSION);
    }

     //数据库第一次被创建时onCreate会被调用  
    @Override
    public void onCreate(SQLiteDatabase db) {
        // TODO Auto-generated method stub
         db.execSQL("CREATE TABLE IF NOT EXISTS student" +  
                    "(_id INTEGER PRIMARY KEY , name VARCHAR, age INTEGER, info TEXT)");
    }

    //如果DATABASE_VERSION值被改为2,系统发现现有数据库版本不同,即会调用onUpgrade
    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        // TODO Auto-generated method stub
    //    if(oldVersion ==1&&newVersion ==2){
    //        db.execSQL("alter table student add sex integer");
    //    }
    }

}
View Code

　　3，数据库管理类DBManager，实现增删改查功能

public class DBManager {
    private DBHelper helper = null;
    private SQLiteDatabase database ;
    public DBManager(Context context) {
        this.helper = new DBHelper(context);
        //因为getWritableDatabase内部调用了mContext.openOrCreateDatabase(mName, 0, mFactory);  
        //所以要确保context已初始化,我们可以把实例化DBManager的步骤放在Activity的onCreate里  
        database = helper.getWritableDatabase();
    }
    
    /**
     * 插入操作
     * 在添加student信息时，我们采用了事务处理，确保数据完整性；
     * @param student
     */
    public boolean insert(Student student){
        boolean flag = false;
        //开启事务
        database.beginTransaction();
        try {
            if(database.isOpen()){
                database.execSQL("insert into student(name,age,info) values(?,?,?)",new Object[]{student.getName(),student.getAge(),student.getInfo()} );
                //标记事务成功，如果没执行这句话，则自动回滚
                database.setTransactionSuccessful();
            }
            flag = true;
            
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        }finally{
            //关闭事务
            database.endTransaction();
        }
        return flag;
    }
    /**
     * 删除操作
     * @param studentId
     */
    public boolean delete(int studentId){
        boolean flag = false;
        try {
            if(database.isOpen()){
                database.execSQL("delete from student where _id = ?",new Object[]{studentId});
            }
            flag = true;
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        }
        
        return flag;
    }
    
    /**
     * 更新操作
     * @param id
     * @param name
     * @return
     */
    public boolean update(int id,String name){
        boolean flag = false;
        try {
            
            if(database.isOpen()){
                database.execSQL("update student set name = ? where _id = ?",new Object[]{name,id});
                database.close();
            }
            flag = true;
            
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        }
        
        return flag;
    }
    /**
     * 根据id查询学生信息
     * @param id
     * @return
     */
    public Student queryById(int id){
        Student student = null;
        try {
            
            if(database.isOpen()){
                Cursor cursor = database.rawQuery("select _id,name,age,info from student where _id = ?", new String[]{String.valueOf(id)});
                if(cursor!=null && cursor.getCount()>0){
                    if(cursor.moveToFirst()){
                        int _id =cursor.getInt(0);
                        String name = cursor.getString(1);
                        int age = cursor.getInt(2);
                        String info = cursor.getString(3);
                        student = new Student(_id,name,age,info);
                    }
                }
                cursor.close();
            }
            return student;
            
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
            return null;
        }
        
    }
    /**
     * 查询所有的学生信息
     * @return
     */
    public List<Student> queryAllStudent(){
        List<Student> studentList = null;
        try {
            if(database.isOpen()){
                studentList = new ArrayList<Student>();
                Cursor cursor = database.rawQuery("select _id,name,age,info from student",null);
                while (cursor.moveToNext()){
                    
                    int _id =cursor.getInt(cursor.getColumnIndex("_id"));
                    String name = cursor.getString(cursor.getColumnIndex("name"));
                    int age = cursor.getInt(cursor.getColumnIndex("age"));
                    String info = cursor.getString(cursor.getColumnIndex("info"));
                    Student student = new Student(_id,name,age,info);
                    studentList.add(student);
                }
            }
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        }
        
        return studentList;
    }
    
    public void closeDB() {
        //释放数据库连接，否则容易出现SQLiteException
        if(database.isOpen()){
            database.close();
        }
    }
}
View Code

　　4，测试类DatabaseTest，继承AndroidTestCase

public class DatabaseTest extends AndroidTestCase {

    public static final String TAG = DatabaseTest.class.getSimpleName();
    
    private DBManager dao ;
    
    public void testInsert(){
        Student student = new Student();
        student.setName("冠希");
        student.setAge(30);
        student.setInfo("hhe");
        dao = new DBManager(getContext());
        boolean flag = dao.insert(student);
        Assert.assertEquals(true, flag);
    }
    public void testDelete(){
        
        dao = new DBManager(getContext());
        boolean flag = dao.delete(1);
        Assert.assertEquals(true, flag);
    }
    public void testUpdate(){
        dao = new DBManager(getContext());
        boolean flag = dao.update(1, "凤姐");
        Assert.assertEquals(true, flag);
    }
    
    public void testQueryAll(){
        
        dao = new DBManager(getContext());
        List<Student> studentList= dao.queryAllStudent();
        for (int i = 0; i < studentList.size(); i++) {
            Log.i(TAG, studentList.get(i).toString());
        }
    }
    
    
    
    public void testQueryId(){
        
        dao = new DBManager(getContext());
        Student student= dao.queryById(2);
        
        Log.i(TAG, student.toString());
        
    }
    
    
}
View Code

最后为了JUnit单元测试,需要在AndroidManifest.xml文件中配置一下信息:

    在manifest节点下:
    <instrumentation
        android:name="android.test.InstrumentationTestRunner"
        android:targetPackage="com.example.sqlitedemo" />

    在application节点下配置下面信息:
    <uses-library android:name="android.test.runner" />
 
好了，通过以上步骤基本可以实现单表的增删改查功能了