Android 使用存放在存assets文件夹下的SQLite数据库

因为这次的项目需要自带数据，所以就就把数据都放到一个SQLite的数据库文件中了，之后把该文件放到了assets文件夹下面。一开始打算每次都从assets文件夹下面把该文件夹拷贝到手机的SD卡或者手机自身的存储上之后再使用，后来考虑到每次都拷贝的话效率不高，并且如果涉及到对数据库的修改操作的话拷贝之后数据就被恢复了。

因此就写了该封装，该封装只是在第一次使用数据库文件的时候把该文件夹拷贝到手机的/data/data/应用程序报名/database文件夹下，之后就直接从这个地方使用了。并且它允许你直接通过assets文件夹下的数据库名称来获取SQLiteDatabase对象，这样就极大的方便了你对数据库的使用。

1. package com.jemsn.database;
2. import java.io.File;
3. import java.io.FileOutputStream;
4. import java.io.InputStream;
5. import java.io.OutputStream;
6. import java.util.HashMap;
7. import java.util.Map;
8. import android.content.Context;
9. import android.content.SharedPreferences;
10. import android.content.res.AssetManager;
11. import android.database.sqlite.SQLiteDatabase;
12. import android.util.Log;
13. /**
14. * This is a Assets Database Manager
15. * Use it, you can use a assets database file in you application
16. * It will copy the database file to "/data/data/[your application package name]/database" when you first time you use it
17. * Then you can get a SQLiteDatabase object by the assets database file
18. * @author RobinTang
19. * @time 2012-09-20
20. *
21. *
22. * How to use:
23. * 1. Initialize AssetsDatabaseManager
24. * 2. Get AssetsDatabaseManager
25. * 3. Get a SQLiteDatabase object through database file
26. * 4. Use this database object
27. *
28. * Using example:
29. * AssetsDatabaseManager.initManager(getApplication()); // this method is only need call one time
30. * AssetsDatabaseManager mg = AssetsDatabaseManager.getManager();   // get a AssetsDatabaseManager object
31. * SQLiteDatabase db1 = mg.getDatabase("db1.db");   // get SQLiteDatabase object, db1.db is a file in assets folder
32. * db1.???  // every operate by you want
33. * Of cause, you can use AssetsDatabaseManager.getManager().getDatabase("xx") to get a database when you need use a database
34. */
35. public class AssetsDatabaseManager {
36. private static String tag = "AssetsDatabase"; // for LogCat
37. private static String databasepath = "/data/data/%s/database"; // %s is packageName
38. // A mapping from assets database file to SQLiteDatabase object
39. private Map<String, SQLiteDatabase> databases = new HashMap<String, SQLiteDatabase>();
40. // Context of application
41. private Context context = null;
42. // Singleton Pattern
43. private static AssetsDatabaseManager mInstance = null;
44. /**
45. * Initialize AssetsDatabaseManager
46. * @param context, context of application
47. */
48. public static void initManager(Context context){
49. if(mInstance == null){
50. mInstance = new AssetsDatabaseManager(context);
51. }
52. }
53. /**
54. * Get a AssetsDatabaseManager object
55. * @return, if success return a AssetsDatabaseManager object, else return null
56. */
57. public static AssetsDatabaseManager getManager(){
58. return mInstance;
59. }
60. private AssetsDatabaseManager(Context context){
61. this.context = context;
62. }
63. /**
64. * Get a assets database, if this database is opened this method is only return a copy of the opened database
65. * @param dbfile, the assets file which will be opened for a database
66. * @return, if success it return a SQLiteDatabase object else return null
67. */
68. public SQLiteDatabase getDatabase(String dbfile) {
69. if(databases.get(dbfile) != null){
70. Log.i(tag, String.format("Return a database copy of %s", dbfile));
71. return (SQLiteDatabase) databases.get(dbfile);
72. }
73. if(context==null)
74. return null;
75. Log.i(tag, String.format("Create database %s", dbfile));
76. String spath = getDatabaseFilepath();
77. String sfile = getDatabaseFile(dbfile);
78. File file = new File(sfile);
79. SharedPreferences dbs = context.getSharedPreferences(AssetsDatabaseManager.class.toString(), 0);
80. boolean flag = dbs.getBoolean(dbfile, false); // Get Database file flag, if true means this database file was copied and valid
81. if(!flag || !file.exists()){
82. file = new File(spath);
83. if(!file.exists() && !file.mkdirs()){
84. Log.i(tag, "Create \""+spath+"\" fail!");
85. return null;
86. }
87. if(!copyAssetsToFilesystem(dbfile, sfile)){
88. Log.i(tag, String.format("Copy %s to %s fail!", dbfile, sfile));
89. return null;
90. }
91. dbs.edit().putBoolean(dbfile, true).commit();
92. }
93. SQLiteDatabase db = SQLiteDatabase.openDatabase(sfile, null, SQLiteDatabase.NO_LOCALIZED_COLLATORS);
94. if(db != null){
95. databases.put(dbfile, db);
96. }
97. return db;
98. }
99. private String getDatabaseFilepath(){
100. return String.format(databasepath, context.getApplicationInfo().packageName);
101. }
102. private String getDatabaseFile(String dbfile){
103. return getDatabaseFilepath()+"/"+dbfile;
104. }
105. private boolean copyAssetsToFilesystem(String assetsSrc, String des){
106. Log.i(tag, "Copy "+assetsSrc+" to "+des);
107. InputStream istream = null;
108. OutputStream ostream = null;
109. try{
110. AssetManager am = context.getAssets();
111. istream = am.open(assetsSrc);
112. ostream = new FileOutputStream(des);
113. byte[] buffer = new byte[1024];
114. int length;
115. while ((length = istream.read(buffer))>0){
116. ostream.write(buffer, 0, length);
117. }
118. istream.close();
119. ostream.close();
120. }
121. catch(Exception e){
122. e.printStackTrace();
123. try{
124. if(istream!=null)
125. istream.close();
126. if(ostream!=null)
127. ostream.close();
128. }
129. catch(Exception ee){
130. ee.printStackTrace();
131. }
132. return false;
133. }
134. return true;
135. }
136. /**
137. * Close assets database
138. * @param dbfile, the assets file which will be closed soon
139. * @return, the status of this operating
140. */
141. public boolean closeDatabase(String dbfile){
142. if(databases.get(dbfile) != null){
143. SQLiteDatabase db = (SQLiteDatabase) databases.get(dbfile);
144. db.close();
145. databases.remove(dbfile);
146. return true;
147. }
148. return false;
149. }
150. /**
151. * Close all assets database
152. */
153. static public void closeAllDatabase(){
154. Log.i(tag, "closeAllDatabase");
155. if(mInstance != null){
156. for(int i=0; i<mInstance.databases.size(); ++i){
157. if(mInstance.databases.get(i)!=null){
158. mInstance.databases.get(i).close();
159. }
160. }
161. mInstance.databases.clear();
162. }
163. }
164. }

使用的过程也很简单，应用程序开始的时候初始化一下，之后就可以在任意地方获取管理器在通过assets文件夹下的数据库文件名直接获取SQLiteDatabase对象，之后对数据库的操作就完全看你了。。。

简单的使用例子：

1. // 初始化，只需要调用一次
2. AssetsDatabaseManager.initManager(getApplication());
3. // 获取管理对象，因为数据库需要通过管理对象才能够获取
4. AssetsDatabaseManager mg = AssetsDatabaseManager.getManager();
5. // 通过管理对象获取数据库
6. SQLiteDatabase db1 = mg.getDatabase("db1.db");
7. // 对数据库进行操作
8. db1.execSQL("insert into tb([ID],[content]) values(null, 'db1');");

需要注意的是获取数据库对象的时候是区分数据库文件名的大小写的。