Android软件开发之制作第三方数据库与读取文件中数据库详解

雨松MOMO原创文章如转载，请注明：转载至我的独立域名博客雨松MOMO程序研究院，原文地址:http://www.xuanyusong.com/archives/199

好久都没有更新Android开发系列博文了，不知道大伙还能都记得我这个老朋友，嘿嘿。其实这段时间Android的开发我也一直都没有闲着，Android + IOS + Unity 的游戏与软件开发MOMO都在同时进行，给力的生活还是继续这儿。希望过段时间有机会可以尝试制作一些WP7下的游戏或软件的开发。

        Android软件开发中为什么要制作第三方数据库？在程序中获取数据的方式无非就是两种：本地获取，服务器获取。如果项目中的数据非常庞大，并且又不能使用联网获取数据的方式，那么就需要采取制作第三方数据库的方式。我用一个比较实际的例子向大家说明这一点，最近我制作了一个来电归属地查询的小DEMO，产品的需求是对方打过来电话后能再屏幕中现实对方手机号码的归属地。Android提供了联网获取归属地的方式，但是我没有采取这样的方式获取号码归属地。因为联网获取号码归属地时间实在无法控制，有可能用户已经接通电话数据才获取到，那么来电归属地的意义就不存在了。并且联网获取数据还必需是在有网络的情况下，所以限制太多了，所以我放弃的联网获取手机号码归属地的方法。

         接着我在网络中找了一份07年手机号码归属地的数据库原始资源。它是以TXT形式包含中国所有省份与城市的号码归属地规则，如下图所示，打开上海所在的归属地文件后。发现归属的规则是截取手机号码前6位判断手机号码所在的归属地。归属地数据库的原始资源包括移动号码与联通号码，加起来一共有61个文本文件。我们需要编写程序这些数据需要全部写入数据库中，然后将生成的数据库文件放入需要查询的新工程中。这么做的原因是归属地数据库的数据量比较大，如果在查询的工程中写入数据库的话至少也要20分钟。这样会造成用户安装完软件后，第一个电话打进来时有可能你的数据库还没写完，用户体验大打折扣。所以我们需要在第三方程序中将这个庞大的数据库先制作出来，然后在放入软件中，最后直接操作这个数据库即可。

07年的数据确实有点老，但是本篇博文的重点不是探讨手机号码归属地。我最终的涉及思路是将.db文件放置在服务器中，服务器端来维护这个db文件，用户首次安装时从服务器下载这个数据库文件，说的有点远了 呵呵。下面学习如何将归属地数据库中庞大的原始数据写入数据库当中，首先需要制作生成数据库的程序。如下图所示，本程序的是方法为点击“开始读取资源写入数据库”按钮后，程序将循环开始在本地读取所有原始资源，截取出需要的数值后在写入归属地数据库当中。

上图对应的Activity是GenerateDBActivity，代码如下所示：

[java]  view plain copy

1. import java.io.BufferedReader;  
2. import java.io.IOException;  
3. import java.io.InputStream;  
4. import java.io.InputStreamReader;  
5. import java.io.UnsupportedEncodingException;  
6.   
7.   
8. import android.app.Activity;  
9. import android.content.res.Resources;  
10. import android.content.res.Resources.NotFoundException;  
11.   
12. import android.os.Bundle;  
13. import android.os.Handler;  
14. import android.os.Message;  
15. import android.util.Log;  
16. import android.view.View;  
17. import android.view.View.OnClickListener;  
18. import android.widget.Button;  
19. import android.widget.TextView;  
20. import android.widget.Toast;  
21.   
22. public class GenerateDBActivity extends Activity  
23. {  
24.   
25.     //DB对象  
26.     public DBHelper m_db = null;  
27.     //按钮对象  
28.     public Button button = null;  
29.     //文本对象  
30.     public TextView textNumber = null;  
31.     public TextView textCity = null;  
32.     public TextView textLocation = null;  
33.       
34.     //接收线程中传递的数值，用于刷新UI  
35.     Handler handler = new Handler() {  
36.         //注解3  
37.         @Override  
38.         public void handleMessage(Message msg) {  
39.               
40.             Bundle bundle = msg.getData();  
41.             //获取号码、城市、省级  
42.             String number = bundle.getString("number");  
43.             String city = bundle.getString("city");  
44.             String location = bundle.getString("location");  
45.             //更新UI  
46.             textNumber.setText(number);  
47.             textCity.setText(city);  
48.             textLocation.setText(location);  
49.                 
50.             super.handleMessage(msg);  
51.         }  
52.     };    
53.       
54.       
55.     @Override  
56.     public void onCreate(Bundle savedInstanceState)  
57.     {  
58.         super.onCreate(savedInstanceState);  
59.         setContentView(R.layout.main);  
60.   
61.         // 获取DBHelper对象  
62.         m_db = DBHelper.getInstance(this);  
63.           
64.         //获取按钮对象  
65.         button = (Button)this.findViewById(R.id.button);  
66.         button.setText("开始读取资源写入数据库");  
67.         //获取文本对象  
68.         textNumber = (TextView)this.findViewById(R.id.number);  
69.         textCity = (TextView)this.findViewById(R.id.city);  
70.         textLocation = (TextView)this.findViewById(R.id.location);  
71.           
72.           
73.         //开始读取资源  
74.         button.setOnClickListener(new OnClickListener()  
75.         {  
76.               
77.             @Override  
78.             public void onClick(View v)  
79.             {  
80.                 //注解1  
81.                 //启动线程开始读取资源并写入数据库当中  
82.                 new Thread()   
83.                 {  
84.                     @Override  
85.                     public void run()   
86.                     {  
87.                         int count = DBHelper.LOCATIONS.length;    
88.                           
89.                         for(int i =0; i < count; i++)  
90.                         {  
91.                             loadLocationFile(i);  
92.                         }  
93.                       
94.                     }  
95.                 }.start();  
96.                   
97.             }  
98.         });   
99.     }  
100.   
101.     private void loadLocationFile(int resourceID)  
102.     {  
103.         //注解2  
104.         Resources res = this.getResources();  
105.         InputStream in = null;  
106.         BufferedReader br = null;  
107.   
108.         try  
109.         {  
110.             in = res.openRawResource(R.raw.location_a0 + resourceID);  
111.             String str;  
112.             br = new BufferedReader(new InputStreamReader(in, "GBK"));  
113.             while ((str = br.readLine()) != null)  
114.             {  
115.                 //手机号码特征值为前7位  
116.                 String number = str.substring(0, 6);  
117.                 //手机号码归属地从第24位开始到最后  
118.                 String city = str.substring(24, str.length());  
119.                   
120.                 //将数据写入数据库当中  
121.                 m_db.insert(DBHelper.TABLE_NAME,   
122.                             new String[] { DBHelper.NUMBER, DBHelper.CITY, DBHelper.LOCATION },   
123.                             new String[]{ number, city, DBHelper.LOCATIONS[resourceID] });  
124.                   
125.                 Message msg = new Message();  
126.                 Bundle bundle = new Bundle();  
127.                 bundle.putString("number", "手机号码特征数据：" + number);  
128.                 bundle.putString("city", "手机号归属地城市：" + city);  
129.                 bundle.putString("location", "手机号码省级运营商：" + DBHelper.LOCATIONS[resourceID]);  
130.                 msg.setData(bundle);  
131.                 handler.sendMessage(msg);  
132.                   
133.                 Log.v("xuanyusong", "手机号码特征数据：" + number + " 手机号归属地城市：" + city + " 手机号码省级运营商：" + DBHelper.LOCATIONS[resourceID]);  
134.             }  
135.         } catch (NotFoundException e)  
136.         {  
137.             Toast.makeText(this, "文本文件不存在", 100).show();  
138.             e.printStackTrace();  
139.         } catch (UnsupportedEncodingException e)  
140.         {  
141.             Toast.makeText(this, "文本编码出现异常", 100).show();  
142.             e.printStackTrace();  
143.         } catch (IOException e)  
144.         {  
145.             Toast.makeText(this, "文件读取错误", 100).show();  
146.             e.printStackTrace();  
147.         } finally  
148.         {  
149.             try  
150.             {  
151.                 if (in != null)  
152.                 {  
153.                     in.close();  
154.                 }  
155.                 if (br != null)  
156.                 {  
157.                     br.close();  
158.                 }  
159.             } catch (IOException e)  
160.             {  
161.                 e.printStackTrace();  
162.             }  
163.   
164.         }  
165.     }  
166.   
167. }  

注解1：在窗口中用户点击“读取写入数据库”按钮后，程序将开启一个线程来读取资源，而且代码必需写在线程中读取，因为数据量比较大，主线程中读取会出现ANR的情况。DBHelper.LOCATIONS.Length表示原始数据资源文件的数量，这里使用循环将读取所有原始资源文件。

注解2：loadLocationFile()方法开始读取本地原始资源，原始资源全部放置在res/raw下，使用openRawResource()方法取得每一个原始文件的流对象。然后在while循环中调用br.readLine()方法逐行读取文本对象中的数据，数据读取完毕后将它们写入数据库当中。因为这里是线程，所以需要刷新UI时就得使用Handler了。

注解3：数据库中每插入一条数据库使用handler发来一条消息，在这里获取该消息附带的参数，然后刷新UI将数据现实在屏幕中。

数据库的创建与插入数据的方法写在 DBHelper类当中，代码如下所示：

[java]  view plain copy

1. package com.m15.cn;  
2.   
3.   
4. import android.content.ContentValues;  
5. import android.content.Context;  
6. import android.database.sqlite.SQLiteDatabase;  
7. import android.database.sqlite.SQLiteOpenHelper;  
8.   
9. public class DBHelper extends SQLiteOpenHelper  
10. {  
11.   
12.     public static DBHelper mInstance = null;  
13.   
14.     /** 数据库名称 **/  
15.     public static final String DATABASE_NAME = "location.db";  
16.   
17.     /** 数据库版本号 **/  
18.     private static final int DATABASE_VERSION = 1;  
19.   
20.     /** DB对象 **/  
21.     SQLiteDatabase mDb = null;  
22.   
23.     Context mContext = null;  
24.   
25.     // 归属地  
26.     public final static String TABLE_NAME = "location_date";  
27.     public final static String ID = "_id";  
28.     public final static String NUMBER = "number";  
29.     public final static String LOCATION = "location";  
30.     public final static String CITY = "city";  
31.   
32.     // 索引ID  
33.     public final static int ID_INDEX = 0;  
34.     public final static int NUMBER_INDEX = 1;  
35.     public final static int LOCATION_INDEX = 2;  
36.     public final static int CITY_INDEX = 3;  
37.   
38.     /** 数据库SQL语句 创建归属地表 **/  
39.     public static final String NAME_TABLE_CREATE = "create table location_date(" + "_id INTEGER PRIMARY KEY AUTOINCREMENT," + "number TEXT NOT NULL," + "city TEXT NOT NULL,"  
40.             + "location TEXT NOT NULL);";  
41.   
42.     public final static String[] LOCATIONS =  
43.     { "上海移动", "上海联通", "云南移动", "云南联通", "内蒙古移动", "内蒙古联通", "北京移动", "北京联通", "吉林移动", "吉林联通", "四川移动", "四川联通", "天津移动", "天津联通", "宁夏移动", "宁夏联通", "安徽移动", "安徽联通", "山东移动", "山东联通", "山西移动", "山西联通", "广东移动", "广东联通",  
44.             "广西移动", "广西联通", "新疆移动", "新疆联通", "江苏移动", "江苏联通", "江西移动", "江西联通", "河北移动", "河北联通", "河南移动", "河南联通", "浙江移动", "浙江联通", "海南移动", "海南联通", "湖北移动", "湖北联通", "湖南移动", "湖南联通", "甘肃移动", "甘肃联通", "福建移动",  
45.             "福建联通", "西藏移动", "西藏联通", "贵州移动", "贵州联通", "辽宁移动", "辽宁联通", "重庆移动", "重庆联通", "陕西移动", "陕西联通", "青海移动", "青海联通", "黑龙江移动", "黑龙江联通" };  
46.   
47.     /** 单例模式 **/  
48.     public static synchronized DBHelper getInstance(Context context)  
49.     {  
50.         if (mInstance == null)  
51.         {  
52.             mInstance = new DBHelper(context);  
53.         }  
54.         return mInstance;  
55.     }  
56.   
57.     public DBHelper(Context context)  
58.     {  
59.         super(context, DATABASE_NAME, null, DATABASE_VERSION);  
60.         // 得到数据库对象  
61.         mDb = getReadableDatabase();  
62.         mContext = context;  
63.     }  
64.   
65.     @Override  
66.     public void onCreate(SQLiteDatabase db)  
67.     {  
68.         //创建数据库  
69.         db.execSQL(NAME_TABLE_CREATE);  
70.     }  
71.   
72.     @Override  
73.     public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion)  
74.     {  
75.   
76.     }  
77.   
78.     /** 
79.      * 插入一条数据 
80.      *  
81.      * @param key 
82.      * @param date 
83.      */  
84.     public void insert(String tablename, String key[], String date[])  
85.     {  
86.         ContentValues values = new ContentValues();  
87.         for (int i = 0; i < key.length; i++)  
88.         {  
89.             values.put(key[i], date[i]);  
90.         }  
91.         mDb.insert(tablename, null, values);  
92.     }  
93.   
94. }  

数据库写入完毕后，然后将生成的数据库从程序中拷贝至本地。如下图所示，将本例程序的location.db文件拷贝至电脑中。

然后使用数据库查看软件，来看一看我们生成的数据库。因为我这里使用的是mac在做开发，所以和以前写用的数据库查看软件有点不一样。如下图所示，本地数据已经写入到数据库当中 , 下面说一下字段的含义：_id为升序具有唯一性 ， number 表示号码的前6位字段，city表示号码归属地的城市，location：表示省级的运营商归属地。那么到这一步我们的第三方数据库文件就已经制作完毕。如果有朋友问能不能使用非Android程序生成的数据库，那么我建议最好不要用。或者你将系统生成的表android_metadata与sqlite_sequence表添加进你的数据库试一试，因为这个数据库一定要与Android生成出来的数据库结构一样。否则在部分Android手机上无法打开它db文件的对象。

        接着创建一个新android工程，用于我们查询数据库。首先将上面工程中生成的归属地数据库文件location.db拷贝至新工程的raw文件夹中。在如下代码中开始载入数据库中的内容。

[java]  view plain copy

1. import java.io.File;  
2. import java.io.FileOutputStream;  
3. import java.io.InputStream;  
4.   
5. import android.app.Activity;  
6. import android.content.Context;  
7. import android.database.Cursor;  
8. import android.database.sqlite.SQLiteDatabase;  
9. import android.os.Bundle;  
10. import android.view.View;  
11. import android.view.View.OnClickListener;  
12. import android.widget.Button;  
13. import android.widget.EditText;  
14. import android.widget.TextView;  
15. import android.widget.Toast;  
16.   
17. public class GetInfoActivity extends Activity  
18. {  
19.       
20.     //文件的路径  
21.     public final static String URL = "/data/data/cn.location.xys/files";  
22.     //数据库文件  
23.     public final static String DB_FILE_NAME = "location.db";  
24.     // 归属地  
25.     public final static String TABLE_NAME = "location_date";  
26.     // 索引ID  
27.     public final static int ID_INDEX = 0;  
28.     public final static int NUMBER_INDEX = 1;  
29.     public final static int LOCATION_INDEX = 2;  
30.     public final static int CITY_INDEX = 3;  
31.   
32.     EditText editText = null;  
33.     Button button = null;  
34.     TextView textView = null;  
35.     SQLiteDatabase db = null;  
36.   
37.     @Override  
38.     protected void onCreate(Bundle savedInstanceState)  
39.     {  
40.   
41.         super.onCreate(savedInstanceState);  
42.   
43.         setContentView(R.layout.getinfo);  
44.         //首先将DB文件拷贝至程序内存当中  
45.         //注解1  
46.         if (copyDB())  
47.         {  
48.             //得到数据库文件  
49.             File file = new File(URL, DB_FILE_NAME);  
50.             db = SQLiteDatabase.openOrCreateDatabase(file, null);  
51.   
52.             editText = (EditText) this.findViewById(R.id.edit);  
53.             textView = (TextView) this.findViewById(R.id.location);  
54.   
55.             button = (Button) this.findViewById(R.id.button);  
56.             button.setOnClickListener(new OnClickListener()  
57.             {  
58.   
59.                 public void onClick(View v)  
60.                 {  
61.                     String editStr = editText.getText().toString();  
62.                     if (editStr.length() == 11)  
63.                     {  
64.                         //输入手机号码  
65.                         Cursor cursor = db.query("location_date", null, "number=?", new String[]{ editStr.substring(0, 6) }, null, null, null);  
66.   
67.                         if (cursor != null && cursor.moveToFirst())  
68.                         {  
69.                             //获取号码省级与市级归属地  
70.                             String text = cursor.getString(LOCATION_INDEX) + cursor.getString(CITY_INDEX);  
71.                             textView.setText(text);  
72.                         }  
73.                         else  
74.                         {  
75.                             Toast.makeText(getApplicationContext(), "未能在数据库中查询到您的手机号码", Toast.LENGTH_SHORT).show();  
76.                         }  
77.                     } else  
78.                     {  
79.                         Toast.makeText(getApplicationContext(), "手机号码为11位，重新输入", Toast.LENGTH_SHORT).show();  
80.                     }  
81.   
82.                 }  
83.             });  
84.         }  
85.     }  
86.   
87.     // 将raw文件中的数据库文件拷贝至手机中的程序内存当中  
88.     public boolean copyDB()  
89.     {  
90.   
91.         try  
92.         {  
93.             // 判断程序内存中是否有拷贝后的文件  
94.             if (!(new File(URL)).exists())  
95.             {  
96.                 InputStream is = getResources().openRawResource(R.raw.location);  
97.                 FileOutputStream fos = this.openFileOutput(DB_FILE_NAME, Context.MODE_WORLD_READABLE);  
98.                 // 一次拷贝的缓冲大小1M  
99.                 byte[] buffer = new byte[1024 * 1024];  
100.                 int count = 0;  
101.                 // 循环拷贝数据库文件  
102.                 while ((count = is.read(buffer)) > 0)  
103.                 {  
104.                     fos.write(buffer, 0, count);  
105.                 }  
106.   
107.                 fos.close();  
108.                 is.close();  
109.             }  
110.             return true;  
111.         } catch (Exception e)  
112.         {  
113.             e.printStackTrace();  
114.             return false;  
115.         }  
116.     }  
117.   
118. }  

注解1：首先将raw文件夹中的数据库文件拷贝至程序内存当中，接着通过拷贝后的路径获取数据库文件的对象。有了数据库对象那么增、删、改、查的操作都可以执行啦。最后的效果图如下所示，输入手机号码后点击查询，下方将现实手机号码的归属地信息。

最后还是老规矩每篇文章都会附带源代码，最后如果你还是觉得我写的不够详细 看的不够爽 不要紧我把源代码的下载地址贴出来 欢迎大家一起讨论学习雨松MOMO希望可以和大家一起进步。

下载地址：http://www.xuanyusong.com/archives/199

（内容包括数据库生成程序与数据库查询程序）