android sqlite数据库封装 实现crud

android常用的数据保存方式有文件、sharepreferences、数据库、网络、contentprovider集中方式。

文件存储方式，经常使用在缓存整个页面数据，比如电子书内容、html数据等。

sharepreferrences存储方式，实质也就是xml文件存储的封装，常用于存储配置参数数据。当然也可以用文件存储+Properties来存储参数数据。

网络，就是将数据存储在网络空间上。

contentprovider主要作用是统一数据存储方式，实现数据共享，以后有机会仔细分析下。

数据库的方式，常用在存储一系列的结构复杂的数据，轻量级的数据库SQlit使用起来还是比较简单，但是总想能像hibernate似的框架可以进行下封装，实现orm并且可以实现简单的rcud。这里就介绍下一个分装过程，源码下载在后面。

一、封装数据库的类结构

 

结构比较简单：BaseBean.java--实体类的基类

DBConfig.java---数据库的参数，包括数据库名、要创建的表列表、数据库版本等

IssContentProvider.java--继承了ContentProvider，定义了数据库的初始化和操作

DBFactory--数据库工厂类

Table.java----定义Table的annotation

TableColumn.java--定义表的列的annotation和属性

TableUtil.java--书库操作工具类，主要是获得表和根据标签拼装sql语句

二、封装数据库的使用过程

由于封装后的数据库使用比较简单，就跟配置好hibernate之后使用似的，所以咱们先看下咱们使用，不理解的地方，等分析了整个实现过程后就行清晰了。

1、要实现orm，肯定要定义带标签的实体类，当然是继承BaseBean类。

2、要将数据库参数传递给DBConfig，并初始化。

3、数据库操作类，通过contentprovideder实现crud。

用例子看下
1，定义实体类

1. public class SmartDownloadBean extends BaseBean<SmartDownloadBean> {
2. @TableColumn(type = TableColumn.Types.TEXT, isIndex = true, isNotNull = true)
3. public String downpath;
4. @TableColumn(type = TableColumn.Types.INTEGER)
5. public int threadid;
6. @TableColumn(type = TableColumn.Types.INTEGER)
7. public int downlength;
8. @Override
9. public SmartDownloadBean parseJSON(JSONObject jsonObj) {
10. return null;
11. }
12. @Override
13. public JSONObject toJSON() {
14. // TODO Auto-generated method stub
15. return null;
16. }
17. @Override
18. public SmartDownloadBean cursorToBean(Cursor cursor) {
19. this.downpath = cursor.getString(cursor.getColumnIndex("downpath"));
20. this.threadid = cursor.getInt(cursor.getColumnIndex("threadid"));
21. this.downlength = cursor.getInt(cursor.getColumnIndex("downlength"));
22. return this;
23. }
24. @Override
25. public ContentValues beanToValues() {
26. ContentValues values = new ContentValues();
27. if (!TextUtils.isEmpty(downpath)) {
28. values.put("downpath", downpath);
29. }
30. if (!TextUtils.isEmpty(threadid+"")) {
31. values.put("threadid", threadid);
32. }
33. if (!TextUtils.isEmpty(downlength+"")) {
34. values.put("downlength", downlength);
35. }
36. return values;
37. }
38. }

实体类通过标签，定义了对应表的列名、及列的属性

2、定义要创建的表、数据名等参数

1. /**
2. * 数据库配置
3. **/
4. public class SssProvider extends IssContentProvider {
5. @Override
6. public void init() {
7. // 数据库相关参数设置
8. DBConfig config = new DBConfig.Builder()
9. .addTatble(SmartDownloadBean.class)
10. .setName("sss.db").setVersion(2)
11. .setAuthority("com.sss").build();
12. IssDBFactory.init(getContext(), config);
13. }
14. }

要定义都个表的话，再addTatble(Bean.class)即可。

3、调用数据库的工具类

1. /**
2. * 操作数据库的utils
3. *
4. * @author dllik 2013-11-23
5. */
6. public class DBUtils {
7. public static Uri URI_SMARTDOWNLOAD = IssContentProvider.buildUri(SmartDownloadBean.class);
8. /**
9. * 获取每条线程已经下载的文件长度
10. *
11. * @param context
12. * @param downpath
13. * @return
14. */
15. public static Map<Integer, Integer> querySmartDownData(Context context, String downpath) {
16. ContentResolver mResolver = context.getContentResolver();
17. Cursor cursor = mResolver.query(URI_SMARTDOWNLOAD, null, "downpath=?", new String[] {
18. downpath
19. }, null);
20. Map<Integer, Integer> data = new HashMap<Integer, Integer>();
21. while (cursor.moveToNext()) {
22. SmartDownloadBean bean = new SmartDownloadBean();
23. bean.cursorToBean(cursor);
24. data.put(bean.threadid, bean.downlength);
25. }
26. cursor.close();
27. return data;
28. }
29. /**
30. * 保存每条线程已经下载的文件长度
31. *
32. * @param context
33. * @param path
34. * @param map
35. */
36. public static void insertSmartDown(Context context, String path, Map<Integer, Integer> map) {
37. ContentResolver mResolver = context.getContentResolver();
38. for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
39. SmartDownloadBean bean = new SmartDownloadBean();
40. bean.downpath = path;
41. bean.downlength = entry.getValue();
42. bean.threadid = entry.getKey();
43. mResolver.insert(URI_SMARTDOWNLOAD, bean.beanToValues());
44. }
45. }
46. /**
47. * 实时更新每条线程已经下载的文件长度
48. *
49. * @param context
50. * @param path
51. * @param map
52. */
53. public static void updateSmartDown(Context context, String path, Map<Integer, Integer> map) {
54. ContentResolver mResolver = context.getContentResolver();
55. for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
56. SmartDownloadBean bean = new SmartDownloadBean();
57. bean.downpath = path;
58. bean.downlength = entry.getValue();
59. bean.threadid = entry.getKey();
60. mResolver.update(URI_SMARTDOWNLOAD, bean.beanToValues(), "downpath=? and threadid=?",
61. new String[] {
62. bean.downpath, bean.threadid + ""
63. });
64. }
65. }
66. /**
67. * 当文件下载完成后，删除对应的下载记录
68. *
69. * @param context
70. * @param path
71. */
72. public static void deleteSmartDown(Context context, String path) {
73. ContentResolver mResolver = context.getContentResolver();
74. mResolver.delete(URI_SMARTDOWNLOAD, "downpath=?", new String[] {
75. path
76. });
77. }
78. }

三、数据库的封装过程

看下实体类的基类

1. public abstract class BaseBean<T> implements Serializable {
2. private static final long serialVersionUID = -804757173578073135L;
3. @TableColumn(type = TableColumn.Types.INTEGER, isPrimary = true)
4. public static final String _ID = "_id";
5. /**
6. * 将json对象转化为Bean实例
7. *
8. * @param jsonObj
9. * @return
10. */
11. public abstract T parseJSON(JSONObject jsonObj);
12. /**
13. * 将Bean实例转化为json对象
14. *
15. * @return
16. */
17. public abstract JSONObject toJSON();
18. /**
19. * 将数据库的cursor转化为Bean实例（如果对象涉及在数据库存取，需实现此方法）
20. *
21. * @param cursor
22. * @return
23. */
24. public abstract T cursorToBean(Cursor cursor);
25. /**
26. * 将Bean实例转化为一个ContentValues实例，供存入数据库使用（如果对象涉及在数据库存取，需实现此方法）
27. *
28. * @return
29. */
30. public abstract ContentValues beanToValues();
31. @SuppressWarnings("unchecked")
32. public T parseJSON(Gson gson, String json) {
33. return (T) gson.fromJson(json, this.getClass());
34. }
35. public ContentValues toValues() {
36. ContentValues values = new ContentValues();
37. try {
38. Class<?> c = getClass();
39. Field[] fields = c.getFields();
40. for (Field f : fields) {
41. f.setAccessible(true);
42. final TableColumn tableColumnAnnotation = f.getAnnotation(TableColumn.class);
43. if (tableColumnAnnotation != null) {
44. if (tableColumnAnnotation.type() == TableColumn.Types.INTEGER) {
45. values.put(f.getName(), f.getInt(this));
46. } else if (tableColumnAnnotation.type() == TableColumn.Types.BLOB) {
47. values.put(f.getName(), (byte[]) f.get(this));
48. } else if (tableColumnAnnotation.type() == TableColumn.Types.TEXT) {
49. values.put(f.getName(), f.get(this).toString());
50. } else {
51. values.put(f.getName(), f.get(this).toString());
52. }
53. }
54. }
55. } catch (IllegalArgumentException e) {
56. e.printStackTrace();
57. } catch (IllegalAccessException e) {
58. e.printStackTrace();
59. }
60. return values;
61. }
62. }

说明几点：1、用到了泛型，因为定义的数据实体类有多个

2、实现序列化，实体类数据通过Intent进行传递

3、定义了一个主键id

数据库参数类

1. public class DBConfig {
2. final ArrayList<Class<? extends BaseBean<?>>> tableList;
3. final String dbName;
4. final int dbVersion;
5. final String authority;
6. final ArrayList<String> tableNameList;
7. private DBConfig(final Builder builder) {
8. tableList = builder.tableList;
9. dbName = builder.dbName;
10. dbVersion = builder.dbVersion;
11. authority = builder.authority;
12. tableNameList =  new ArrayList<String>();
13. for(Class<? extends BaseBean<?>> c:tableList){
14. String name = TableUtil.getTableName(c);
15. tableNameList.add(name);
16. }
17. }
18. public static class Builder {
19. private ArrayList<Class<? extends BaseBean<?>>> tableList;
20. private String dbName;
21. private int dbVersion;
22. private String authority = "com.iss.mobile";
23. public Builder() {
24. tableList = new ArrayList<Class<? extends BaseBean<?>>>();
25. }
26. public Builder setName(String name) {
27. dbName = name;
28. return this;
29. }
30. public Builder setVersion(int version) {
31. dbVersion = version;
32. return this;
33. }
34. public Builder addTatble(Class<? extends BaseBean<?>> table) {
35. tableList.add(table);
36. return this;
37. }
38. public Builder setAuthority(String authority){
39. this.authority = authority;
40. return this;
41. }
42. public DBConfig build(){
43. return new DBConfig(this);
44. }
45. }
46. }

通过该类，来设置数据库的参数，在初始化数据库的时候用到。

内容提供者类，初始化和操作数据库

1. public abstract class IssContentProvider extends ContentProvider {
2. public static String CONTENT_TYPE = "vnd.android.cursor.dir/iss.db";
3. protected SQLiteDatabase mDB;
4. public static String AUTHORITY = "com.iss.mobile";
5. @Override
6. public boolean onCreate() {
7. init();
8. IssDBFactory issDBFactory = IssDBFactory.getInstance();
9. DBConfig config = IssDBFactory.getInstance().getDBConfig();
10. if (config == null) {
11. throw new RuntimeException("db factory not init");
12. }
13. AUTHORITY = config.authority;
14. CONTENT_TYPE = "vnd.android.cursor.dir/" + config.dbName;
15. mDB = issDBFactory.open();
16. return true;
17. }
18. public abstract void init();
19. public static final String SCHEME = "content";
20. @Override
21. public Uri insert(Uri uri, ContentValues values) {
22. String tableName = getTableName(uri);
23. long result = mDB.insert(tableName, null, values);
24. if (result != -1) {
25. getContext().getContentResolver().notifyChange(uri, null);
26. }
27. return buildResultUri(tableName, result);
28. }
29. @Override
30. public int bulkInsert(Uri uri, ContentValues[] values) {
31. mDB.beginTransaction();
32. String tableName = getTableName(uri);
33. for(ContentValues value:values){
34. mDB.insert(tableName, null, value);
35. }
36. mDB.setTransactionSuccessful();
37. mDB.endTransaction();
38. return values.length;
39. }
40. @Override
41. public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs,
42. String sortOrder) {
43. String tableName = getTableName(uri);
44. return mDB.query(tableName, projection, selection, selectionArgs, null, null, sortOrder);
45. }
46. @Override
47. public String getType(Uri uri) {
48. return CONTENT_TYPE;
49. }
50. @Override
51. public int delete(Uri uri, String selection, String[] selectionArgs) {
52. String tableName = getTableName(uri);
53. int result = mDB.delete(tableName, selection, selectionArgs);
54. if (result != 0) {
55. getContext().getContentResolver().notifyChange(uri, null);
56. }
57. return result;
58. }
59. @Override
60. public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
61. String tableName = getTableName(uri);
62. int result = mDB.update(tableName, values, selection, selectionArgs);
63. if (result != 0) {
64. getContext().getContentResolver().notifyChange(uri, null);
65. }
66. return result;
67. }
68. private Uri buildResultUri(String tableName, long result) {
69. final Uri.Builder builder = new Uri.Builder();
70. DBConfig config = IssDBFactory.getInstance().getDBConfig();
71. if (config == null) {
72. throw new RuntimeException("db factory not init");
73. }
74. builder.scheme(SCHEME);
75. builder.authority(config.authority);
76. builder.path(tableName);
77. builder.appendPath(String.valueOf(result));
78. return builder.build();
79. }
80. private String getTableName(Uri uri) {
81. DBConfig config = IssDBFactory.getInstance().getDBConfig();
82. if (config == null) {
83. throw new RuntimeException("db factory not init");
84. }
85. String path = uri.getLastPathSegment();
86. if (!config.tableNameList.contains(path)) {
87. throw new IllegalArgumentException("Unknown URI " + uri);
88. }
89. return path;
90. }
91. public static Uri buildUri(String path, String id) {
92. final Uri.Builder builder = new Uri.Builder();
93. DBConfig config = IssDBFactory.getInstance().getDBConfig();
94. if (config == null) {
95. throw new RuntimeException("db factory not init");
96. }
97. builder.scheme(SCHEME);
98. builder.authority(config.authority);
99. builder.path(path);
100. builder.appendPath(id);
101. return builder.build();
102. }
103. public static Uri buildUri(String path) {
104. final Uri.Builder builder = new Uri.Builder();
105. DBConfig config = IssDBFactory.getInstance().getDBConfig();
106. if (config == null) {
107. throw new RuntimeException("db factory not init");
108. }
109. builder.scheme(SCHEME);
110. builder.authority(config.authority);
111. builder.path(path);
112. return builder.build();
113. }
114. public static Uri buildUri(Class<? extends BaseBean<?>> c) {
115. final String tableName = TableUtil.getTableName(c);
116. return buildUri(tableName);
117. }
118. }

该内容提供者在创建的时候，先执行init()(将要数据库的参数设置好，再将参数传递给工厂类)，工厂类根据参数创建数据库mDB = issDBFactory.open();
数据库工厂类：

1. public class IssDBFactory {
2. private static final String TAG = IssDBFactory.class.getSimpleName();
3. private DBConfig mConfig;
4. private SQLiteDatabase mSQLiteDB;
5. private IssDBOpenHelper mDBOpenHelper;
6. private final Context mContext;
7. private static IssDBFactory instance ;
8. private IssDBFactory(Context context) {
9. mContext = context;
10. }
11. public static void init(Context context,DBConfig dbConfig){
12. if(instance==null){
13. instance = new IssDBFactory(context.getApplicationContext());
14. instance.setDBConfig(dbConfig);
15. }
16. }
17. public static IssDBFactory getInstance(){
18. return instance;
19. }
20. public void setDBConfig(DBConfig dbConfig){
21. mConfig = dbConfig;
22. }
23. public DBConfig getDBConfig(){
24. return mConfig;
25. }
26. public SQLiteDatabase open() {
27. if(mSQLiteDB==null){
28. mDBOpenHelper = new IssDBOpenHelper(mContext, mConfig.dbName, null, mConfig.dbVersion);
29. mSQLiteDB = mDBOpenHelper.getWritableDatabase();
30. }
31. return mSQLiteDB;
32. }
33. public void close() {
34. if(mDBOpenHelper!=null){
35. mDBOpenHelper.close();
36. }
37. }
38. public void beginTransaction() {
39. if(mSQLiteDB==null){
40. mSQLiteDB.beginTransaction();
41. }
42. }
43. public void endTransaction() {
44. if (mSQLiteDB==null&&mSQLiteDB.inTransaction()) {
45. mSQLiteDB.endTransaction();
46. }
47. }
48. public void setTransactionSuccessful() {
49. if (mSQLiteDB==null){
50. mSQLiteDB.setTransactionSuccessful();
51. }
52. }
53. private final class IssDBOpenHelper extends SQLiteOpenHelper {
54. public IssDBOpenHelper(Context context, String name, CursorFactory factory, int version) {
55. super(context, name, factory, version);
56. }
57. @Override
58. public void onCreate(SQLiteDatabase db) {
59. for (Class<? extends BaseBean<?>> table : mConfig.tableList) {
60. try {
61. for (String statment : TableUtil.getCreateStatments(table)) {
62. Log.d(TAG, statment);
63. db.execSQL(statment);
64. }
65. } catch (Throwable e) {
66. Log.e(TAG, "Can't create table " + table.getSimpleName());
67. }
68. }
69. /**
70. * 初始化数据
71. */
72. // initData();
73. }
74. @Override
75. public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
76. Log.d(TAG, "onUpgrade: " + oldVersion + " >> " + newVersion);
77. for (Class<? extends BaseBean<?>> table : mConfig.tableList) {
78. try {
79. db.execSQL("DROP TABLE IF EXISTS " + TableUtil.getTableName(table));
80. } catch (Throwable e) {
81. Log.e(TAG, "Can't create table " + table.getSimpleName());
82. }
83. }
84. onCreate(db);
85. }
86. }
87. public void cleanTable(String tableName, int maxSize, int batchSize) {
88. Cursor cursor = mSQLiteDB.rawQuery("select count(_id) from " + tableName, null);
89. if (cursor.getCount() != 0 && cursor.moveToFirst() && !cursor.isAfterLast()) {
90. if (cursor.getInt(0) >= maxSize) {
91. int deleteSize = maxSize - batchSize;
92. mSQLiteDB.execSQL("delete from " + tableName + " where _id in (" + "select _id from " + tableName
93. + " order by _id " + "  limit " + deleteSize + " )");
94. }
95. }
96. cursor.close();
97. }

看到这用过数据库的就比较清晰了，用到了SQLiteOpenHelper是以内部类的形式实现的，在oncreat里创建了表，在onupgrade里实现了更新表。

其中用到TableUtil.getCreateStatments(table），

数据库工具类：

1. public class TableUtil {
2. public static String getTableName(Class<? extends BaseBean<?>> c) {
3. String name = null;
4. Table tableNameAnnotation = c.getAnnotation(Table.class);
5. if (tableNameAnnotation != null) {
6. name = tableNameAnnotation.name();
7. }
8. if (TextUtils.isEmpty(name)) {
9. name = c.getSimpleName();
10. }
11. return name;
12. }
13. /**
14. * 拼装sql用的建表语句以及索引语句
15. *
16. * @param c
17. * @return
18. */
19. public final static List<String> getCreateStatments(Class<? extends BaseBean<?>> c) {
20. final List<String> createStatments = new ArrayList<String>();
21. final List<String> indexStatments = new ArrayList<String>();
22. final StringBuilder builder = new StringBuilder();
23. final String tableName = getTableName(c);
24. builder.append("CREATE TABLE ");
25. builder.append(tableName);
26. builder.append(" (");
27. int columnNum = 0;
28. for (final Field f : c.getFields()) {
29. f.setAccessible(true);
30. final TableColumn tableColumnAnnotation = f.getAnnotation(TableColumn.class);
31. if (tableColumnAnnotation != null) {
32. columnNum++;
33. String columnName = f.getName();
34. builder.append(columnName);
35. builder.append(" ");
36. if (tableColumnAnnotation.type() == TableColumn.Types.INTEGER) {
37. builder.append(" INTEGER");
38. } else if (tableColumnAnnotation.type() == TableColumn.Types.BLOB) {
39. builder.append(" BLOB");
40. } else if (tableColumnAnnotation.type() == TableColumn.Types.TEXT) {
41. builder.append(" TEXT");
42. } else {
43. builder.append(" DATETIME");
44. }
45. if (tableColumnAnnotation.isPrimary()) {
46. builder.append(" PRIMARY KEY");
47. } else {
48. if (tableColumnAnnotation.isNotNull()) {
49. builder.append(" NOT NULL");
50. }
51. if (tableColumnAnnotation.isUnique()) {
52. builder.append(" UNIQUE");
53. }
54. }
55. if (tableColumnAnnotation.isIndex()) {
56. indexStatments.add("CREATE INDEX idx_" + columnName + "_" + tableName + " ON "
57. + tableName + "(" + columnName + ");");
58. }
59. builder.append(", ");
60. }
61. }
62. builder.setLength(builder.length() - 2); // remove last ','
63. builder.append(");");
64. if (columnNum > 0) {
65. createStatments.add(builder.toString());
66. createStatments.addAll(indexStatments);
67. }
68. return createStatments;
69. }
70. }

就两个方法，获取表名，在更新表的时候用到，拼装sql在创建表时候用到。
最后两个标签类：

1. @Retention(RetentionPolicy.RUNTIME)
2. public @interface Table {
3. String name();
4. }

1. @Retention(RetentionPolicy.RUNTIME)
2. public @interface TableColumn {
3. public enum Types {
4. INTEGER, TEXT, BLOB, DATETIME
5. }
6. Types type() default Types.TEXT;
7. boolean isPrimary() default false;
8. boolean isIndex() default false;
9. boolean isNotNull() default false;
10. boolean isUnique() default false;
11. }

思路比较简单，就是注意先标签、过滤器、内容提供者的使用就行了。

最后是封装包代码，使用过程没有加，自己加入吧：http://download.csdn.net/detail/xiangxue336/7001299