android sqlite数据库增删改查

需要测试环境,启动模拟器 不需要对模拟器进行操作 只用junit就能完成本次的练习
一、编写sqlite的助手类 继承SQLiteOpenHelper类 因为父类没有空的构造器 所有要创建
   public DBOpenHelp(Context context, CursorFactory factory, int version) {} 构造器
在创建一个 public DBOpenHelp(Context context) {}构造器 方便调用 下面助手类源码

[java]  view plain copy

1. package com.itcast.service;  
2.   
3. import android.content.Context;  
4. import android.database.sqlite.SQLiteDatabase;  
5. import android.database.sqlite.SQLiteDatabase.CursorFactory;  
6. import android.database.sqlite.SQLiteOpenHelper;  
7.   
8. /** 
9.  * 实现了SQLiteOpenHelper的助手类 
10.  *  
11.  * @author Administrator 
12.  *  
13.  */  
14. public class DBOpenHelp extends SQLiteOpenHelper {  
15.     private static final String DATABASENAME = "itcast.db";// 数据库名称  
16.     private static final int DATABASEVERSION = 1;// 数据库版本  
17.     
18.     public DBOpenHelp(Context context) {  
19.         /** 
20.          * 1<br> 
21.          * 2数据库名称<br> 
22.          * 3游标工厂 一般都不需要 默认就行 null为默认<br> 
23.          * 4数据库版本号<br> 
24.          */  
25.         super(context, DATABASENAME, null, DATABASEVERSION);  
26.     }  
27.   
28.     @Override  
29.     /** 
30.      * 该方法只调用一次 就是在数据库被创建的时候<br> 
31.      * 可以完成数据库表的创建<br> 
32.      * 可以通过擦参数SQLiteDatabase的对象 执行sql语句 
33.      */  
34.     public void onCreate(SQLiteDatabase db) {  
35.         /** 
36.          * mysql有5个数据对象可存储 INTEGER TEXT(字符串文本) NULL REAL(浮点数字) BLOB(二进制对象)<br> 
37.          * 但也可以存储其他的数据类型 比如 varchar(n) char(n) decimal(p,s)等数据类型 
38.          * 只不过在保存的时候会转成对应的5中数据类型<br> 
39.          * sqlite 最大特点就是可以把各种数据类型保存到字段中 而不用关心数据库声明字段的类型 
40.          * 比如可以再integer类型存放字符串或者在字符类型中存放日期<br> 
41.          * 但有一种是例外 定义为integer primary key的字段 只能64为整数 当向这种字段保存其他类型数据时 会产生错误<br> 
42.          * sqlite 在创建表( create table )的时候会忽略字段后跟的数据类型 以及 他的长度 所以sqlite数据库中创建的表 
43.          * 是忽略字段类型 和长度的 除了上面说到的integer primary key<br> 
44.          */  
45.         db.execSQL("create table person(id integer primary key autoincrement,name varchar(20))");// 执行有更新行为的sql,比如创建,修改,删除  
46.     }  
47.   
48.     @Override  
49.     /** 
50.      * 更新数据库版本的时候调用 可以对数据表结构调整 基本信息添加等 
51.      */  
52.     public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {  
53.         db.execSQL("drop table if exists person ");// 真正项目中需要考虑数据的重要性 尽量少对数据库做删除  
54.         onCreate(db);  
55.     }  
56.   
57. }  

二、编写增删改查的业务类 android可用资源少 所以不建议面向接口编程 尽量少用接口 接口也只是为了代码的耦合 在android不存在多少代码的耦合 所以不需要 这也是android大多用内部类的一个原因 下面增删改查的业务类代码及注释

[java]  view plain copy

1. package com.itcast.service;  
2.   
3. import java.util.ArrayList;  
4. import java.util.List;  
5.   
6. import android.content.Context;  
7. import android.database.Cursor;  
8. import android.database.sqlite.SQLiteDatabase;  
9.   
10. import com.itcast.model.Person;  
11.   
12. public class PersonService {  
13.     private DBOpenHelp dbOpenHelp;  
14.   
15.     public PersonService(Context context) {  
16.         this.dbOpenHelp = new DBOpenHelp(context);  
17.     }  
18.   
19.     /** 
20.      * 添加一个person 
21.      *  
22.      * @param person 
23.      */  
24.     public void savePerson(Person person) {  
25.         // getWritableDatabase()如果磁盘空间满了,就只能以读的方式打开数据库,所以在磁盘空间满了的状态下调用该方法会出错  
26.         SQLiteDatabase db = dbOpenHelp.getWritableDatabase();// 可读可写的方式打开数据库,如果要对数据进行增删改操作,调用该方法的到数据库操作实例  
27.         // getReadableDatabase 该方法是先调用getWritableDatabase 如果磁盘空间满了  
28.         // 调用getWritableDatabase方法会出错 之后就会调用另一开以只读的方法打开数据库  
29.         dbOpenHelp.getReadableDatabase();// 以读的形式打开数据库,如果只对数据进行,就调用该方法  
30.         db.execSQL("insert into person(name) values(?)", new Object[] { person.getName() });// 后面的数组用来填充前面的占位符  
31.     }  
32.   
33.     /** 
34.      * 更新person对象 
35.      *  
36.      * @param person 
37.      */  
38.     public void updatePerson(Person person) {  
39.         SQLiteDatabase db = dbOpenHelp.getWritableDatabase();// getWritableDatabase,getReadableDatabase调用后先检测数据库版本号  
40.                                                                 // 如果跟上次不一样,就会调用@DBOpenHelp@onUpgrade()  
41.         db.execSQL("update person set name=? where id=?", new Object[] { person.getName(), person.getId() });  
42.     }  
43.   
44.     /** 
45.      * 删除一个person对象 
46.      *  
47.      * @param personId 
48.      */  
49.     public void deletePerson(Integer personId) {  
50.         SQLiteDatabase db = dbOpenHelp.getWritableDatabase();  
51.         db.execSQL("delete from person where id=?", new Object[] { personId.toString() });  
52.     }  
53.   
54.     /** 
55.      * 查询一个person 
56.      *  
57.      * @param personId 
58.      * @return 
59.      */  
60.     public Person findPerson(Integer personId) {  
61.         SQLiteDatabase db = dbOpenHelp.getReadableDatabase();// 如果磁盘空间没满的话,该对象与上面的对象是相等的,如果满了,该方法会调用另一只读方法,那么他们就不相等了  
62.         Cursor cursor = db.rawQuery("select * from person where id=?", new String[] { personId.toString() });  
63.         if (cursor.moveToFirst()) {  
64.             Person person = new Person();  
65.             person.setId(cursor.getInt(cursor.getColumnIndex("id")));  
66.             person.setName(cursor.getString(cursor.getColumnIndex("name")));  
67.             return person;  
68.         }  
69.         return null;  
70.     }  
71.   
72.     /** 
73.      * 查询分页 
74.      *  
75.      * @param offSet 
76.      *            忽略开始的多少条数据 
77.      * @param maxResult 
78.      *            查询的记录数 
79.      * @return 
80.      */  
81.     public List<Person> findPersonForPage(int offset, int maxResult) {  
82.         List<Person> persons = new ArrayList<Person>();  
83.         SQLiteDatabase db = dbOpenHelp.getReadableDatabase();  
84.         Cursor cursor = db.rawQuery("select * from person limit?,?", new String[] { String.valueOf(offset), String.valueOf(maxResult) });  
85.         while (cursor.moveToNext()) {  
86.             Person person = new Person();  
87.             person.setId(cursor.getInt(cursor.getColumnIndex("id")));  
88.             person.setName(cursor.getString(cursor.getColumnIndex("name")));  
89.             persons.add(person);  
90.         }  
91.         cursor.close();  
92.         return persons;  
93.     }  
94.   
95.     /** 
96.      * 查询person表的总记录数 
97.      *  
98.      * @return 
99.      */  
100.     public Long countPerson() {  
101.         SQLiteDatabase db = dbOpenHelp.getReadableDatabase();  
102.         Cursor cursor = db.rawQuery("select count(*) from person", null);  
103.         cursor.moveToFirst();// 一定要将光标移动到第一行 因为光标刚开始处于第一条记录的顶部  
104.                                 // moveToFirst可以判断光标是否可以移到下一行并且移到下一行  
105.         return cursor.getLong(0);  
106.     }  
107. }  

三、测试类;需要测试环境 上面有连接

[java]  view plain copy

1. package com.itcast.db;  
2.   
3. import java.util.List;  
4.   
5. import android.test.AndroidTestCase;  
6. import android.util.Log;  
7.   
8. import com.itcast.model.Person;  
9. import com.itcast.service.DBOpenHelp;  
10. import com.itcast.service.PersonService;  
11.   
12. public class PersonServiceTest extends AndroidTestCase {  
13.     private static final String TAG = "PersonServiceTest";  
14.   
15.     public void testCreateDataBase() throws Throwable {  
16.         DBOpenHelp dbHelp = new DBOpenHelp(getContext());  
17.         dbHelp.getWritableDatabase();  
18.     }  
19.   
20.     public void testSavePerson() throws Throwable {  
21.         PersonService personService = new PersonService(getContext());  
22.         Person person = new Person("张三");  
23.         Person person2 = new Person("李四");  
24.         Person person3 = new Person("王五");  
25.         Person person4 = new Person("赵六");  
26.         Person person5 = new Person("黑七");  
27.         Person person6 = new Person("马二");  
28.         personService.savePerson(person);  
29.         personService.savePerson(person2);  
30.         personService.savePerson(person3);  
31.         personService.savePerson(person4);  
32.         personService.savePerson(person5);  
33.         personService.savePerson(person6);  
34.   
35.     }  
36.   
37.     public void testUpdatePerson() throws Throwable {  
38.         Person person = new Person();  
39.         person.setId(1);  
40.         person.setName("xxx");  
41.         PersonService personService = new PersonService(getContext());  
42.         personService.updatePerson(person);  
43.     }  
44.   
45.     public void testDeletePerson() throws Throwable {  
46.         PersonService personService = new PersonService(getContext());  
47.         personService.deletePerson(1);  
48.     }  
49.   
50.     public void testFindPerson() throws Throwable {  
51.         PersonService personService = new PersonService(getContext());  
52.         Person person = personService.findPerson(1);  
53.         Log.i(TAG, person.toString());  
54.     }  
55.   
56.     public void testFindPersonForPage() throws Throwable {  
57.         PersonService personService = new PersonService(getContext());  
58.         List<Person> persons = personService.findPersonForPage(1, 3);  
59.         for (Person person : persons) {  
60.             Log.i(TAG, person.toString());  
61.         }  
62.     }  
63.   
64.     public void testCountPerson() throws Throwable {  
65.         PersonService personService = new PersonService(getContext());  
66.         Long n = personService.countPerson();  
67.         Log.i(TAG, n+"");  
68.     }  
69. }  

四、另一种业务类的写法,这种写法一是为了不熟悉sql,而是如果开发过程中有第三方提供数据或者API符合下面的语句条件 可用下面的增删改查业务的方法实现对数据库的操作 一般情况下不建议下面着用 因为下面的语句都是自己有构造的sql语句 但从性能上说就没有上面的业务类高 为不同的需求 下面贴出源码

[java]  view plain copy

1. package com.itcast.service;  
2.   
3. import java.util.ArrayList;  
4. import java.util.List;  
5.   
6. import android.content.ContentValues;  
7. import android.content.Context;  
8. import android.database.Cursor;  
9. import android.database.sqlite.SQLiteDatabase;  
10.   
11. import com.itcast.model.Person;  
12.   
13. public class OtherPersonService {  
14.     private DBOpenHelp dbOpenHelp;  
15.   
16.     public OtherPersonService(Context context) {  
17.         this.dbOpenHelp = new DBOpenHelp(context);  
18.     }  
19.   
20.     /** 
21.      * 添加一个person 
22.      *  
23.      * @param person 
24.      */  
25.     public void savePerson(Person person) {  
26.         SQLiteDatabase db = dbOpenHelp.getWritableDatabase();  
27.         ContentValues values = new ContentValues();  
28.         values.put("name", person.getName());  
29.         db.insert("person", null, values);// 该方法自己构造sql语句 所以性能比execSQL  
30.         // 参数2表示;如果参数3为空的话,参数2将作为insert语句的字段名插入一个null值,除了主键 其他都为空值  
31.         // 例如 db.insert("person", "name", null);  
32.         // 等价于 insert into person(name) values(null);  
33.   
34.     }  
35.   
36.     /** 
37.      * 更新person对象 
38.      *  
39.      * @param person 
40.      */  
41.     public void updatePerson(Person person) {  
42.         SQLiteDatabase db = dbOpenHelp.getWritableDatabase();  
43.         ContentValues values = new ContentValues();  
44.         values.put("name", person.getName());  
45.         /** 
46.          * 1:表名<br> 
47.          * 2:要修改的字段和值放在一个类似map的集合里 字段做key<br> 
48.          * 3:sql语句中的条件语句 不带where 值可用占位符表示<br> 
49.          * 4:数组,存放前面的占位符的值 
50.          */  
51.         db.update("person", values, "id=?", new String[] { String.valueOf(person.getId()) });// 该方法构造了自己又构造了sql语句  
52.         // 上面语句等价于 db.execSQL("update person set name=? where id=?", new  
53.         // Object[] {  
54.         // person.getName(), person.getId() });  
55.     }  
56.   
57.     /** 
58.      * 删除一个person对象 
59.      *  
60.      * @param personId 
61.      */  
62.     public void deletePerson(Integer personId) {  
63.         SQLiteDatabase db = dbOpenHelp.getWritableDatabase();  
64.         db.delete("person", "id=?", new String[] { personId.toString() });  
65.         // 上面语句等价于 db.execSQL("delete from person where id=?", new Object[] {  
66.         // personId.toString() });  
67.     }  
68.   
69.     /** 
70.      * 查询一个person 
71.      *  
72.      * @param personId 
73.      * @return 
74.      */  
75.     public Person findPerson(Integer personId) {  
76.         SQLiteDatabase db = dbOpenHelp.getReadableDatabase();// 如果磁盘空间没满的话,该对象与上面的对象是相等的,如果满了,  
77.                                                                 // 该方法会调用另一只读方法,那么他们就不相等了  
78.         /** 
79.          * 1:表名<br> 
80.          * 2:查找表列名的组合 是一个字符串数组 如果为null的话 则表示全部<br> 
81.          * 3:查询的条件,可用占位符<br> 
82.          * 4:是参数3中占位符的值<br> 
83.          * 5:分组依据<br> 
84.          * 6:分组筛选语句<br> 
85.          * 7:排序语句 
86.          */  
87.         Cursor cursor = db.query("person", new String[] { "id", "name" }, "id=?", new String[] { personId.toString() }, null, null, null);  
88.         // 上面语句等价于 Cursor cursor =  
89.         // db.rawQuery("select * from person where id=?", new  
90.         // String[] { personId.toString() });  
91.         if (cursor.moveToFirst()) {  
92.             Person person = new Person();  
93.             person.setId(cursor.getInt(cursor.getColumnIndex("id")));  
94.             person.setName(cursor.getString(cursor.getColumnIndex("name")));  
95.             return person;  
96.         }  
97.         return null;  
98.     }  
99.   
100.     /** 
101.      * 查询分页 
102.      *  
103.      * @param offSet 
104.      *            忽略开始的多少条数据 
105.      * @param maxResult 
106.      *            查询的记录数 
107.      * @return 
108.      */  
109.     public List<Person> findPersonForPage(int offset, int maxResult) {  
110.         List<Person> persons = new ArrayList<Person>();  
111.         SQLiteDatabase db = dbOpenHelp.getReadableDatabase();  
112.         /** 
113.          * 1:表名<br> 
114.          * 2:查找表列名的组合 是一个字符串数组 如果为null的话 则表示全部<br> 
115.          * 3:查询的条件,可用占位符<br> 
116.          * 4:是参数3中占位符的值<br> 
117.          * 5:分组依据<br> 
118.          * 6:分组筛选语句<br> 
119.          * 7:排序语句<br> 
120.          * 8:分页语句 传入类似 2,5的字符串<br> 
121.          */  
122.         Cursor cursor = db.query("person", null, null, null, null, null, null, offset + "," + maxResult);  
123.         // 上面语句等价于 Cursor cursor = db.rawQuery("select * from person limit?,?",  
124.         // new  
125.         // String[] { String.valueOf(offset), String.valueOf(maxResult) });  
126.         while (cursor.moveToNext()) {  
127.             Person person = new Person();  
128.             person.setId(cursor.getInt(cursor.getColumnIndex("id")));  
129.             person.setName(cursor.getString(cursor.getColumnIndex("name")));  
130.             persons.add(person);  
131.         }  
132.         cursor.close();  
133.         return persons;  
134.     }  
135.   
136.     /** 
137.      * 查询person表的总记录数 
138.      *  
139.      * @return 
140.      */  
141.     public Long countPerson() {  
142.         SQLiteDatabase db = dbOpenHelp.getReadableDatabase();  
143.         Cursor cursor = db.query("person", new String[] { "count(*)" }, null, null, null, null, null);  
144.         // 上面语句等价于 Cursor cursor = db.rawQuery("select count(*) from person",  
145.         // null);  
146.         cursor.moveToFirst();// 一定要将光标移动到第一行 因为光标刚开始处于第一条记录的顶部  
147.                                 // moveToFirst可以判断光标是否可以移到下一行并且移到下一行  
148.         return cursor.getLong(0);  
149.     }  
150. }