[Android]如何导入已有的外部数据库

我们平时见到的android数据库操作一般都是在程序开始时创建一个空的数据库,然后再进行相关操作。如果我们需要使用一个已有数据的数据库怎么办呢?
我 们都知道android系统下数据库应该存放在 /data/data/com.*.*(package name)/ 目录下,所以我们需要做的是把已有的数据库传入那个目录下。操作方法是用FileInputStream读取原数据库,再用 FileOutputStream把读取到的东西写入到那个目录。
操作方法:1. 把原数据库包括在项目源码的 res/raw 目录下,然后建立一个DBManager类,代码如下:

   
   
   
   
  1. package com.android.ImportDatabase; 
  2.   
  3. import java.io.File; 
  4. import java.io.FileNotFoundException; 
  5. import java.io.FileOutputStream; 
  6. import java.io.IOException; 
  7. import java.io.InputStream; 
  8.   
  9. import android.content.Context; 
  10. import android.database.sqlite.SQLiteDatabase; 
  11. import android.os.Environment; 
  12. import android.util.Log; 
  13.   
  14. public class DBManager { 
  15.     private final int BUFFER_SIZE = 400000
  16.     public static final String DB_NAME = "countries.db"//保存的数据库文件名 
  17.     public static final String PACKAGE_NAME = "com.android.ImportDatabase"
  18.     public static final String DB_PATH = "/data" 
  19.             + Environment.getDataDirectory().getAbsolutePath() + "/" 
  20.             + PACKAGE_NAME;  //在手机里存放数据库的位置 
  21.   
  22.     private SQLiteDatabase database; 
  23.     private Context context; 
  24.   
  25.     DBManager(Context context) { 
  26.         this.context = context; 
  27.     } 
  28.   
  29.     public void openDatabase() { 
  30.         this.database = this.openDatabase(DB_PATH + "/" + DB_NAME); 
  31.     } 
  32.   
  33.     private SQLiteDatabase openDatabase(String dbfile) { 
  34.         try { 
  35.             if (!(new File(dbfile).exists())) {  //判断数据库文件是否存在,若不存在则执行导入,否则直接打开数据库 
  36.                 InputStream is = this.context.getResources().openRawResource( 
  37.                         R.raw.countries); //欲导入的数据库 
  38.                 FileOutputStream fos = new FileOutputStream(dbfile); 
  39.                 byte[] buffer = new byte[BUFFER_SIZE]; 
  40.                 int count = 0
  41.                 while ((count = is.read(buffer)) > 0) { 
  42.                     fos.write(buffer, 0, count); 
  43.                 } 
  44.                 fos.close(); 
  45.                 is.close(); 
  46.             } 
  47.             SQLiteDatabase db = SQLiteDatabase.openOrCreateDatabase(dbfile, 
  48.                     null); 
  49.             return db; 
  50.         } catch (FileNotFoundException e) { 
  51.             Log.e("Database""File not found"); 
  52.             e.printStackTrace(); 
  53.         } catch (IOException e) { 
  54.             Log.e("Database""IO exception"); 
  55.             e.printStackTrace(); 
  56.         } 
  57.         return null
  58.     } 
  59. //do something else here<br>
  60.  public void closeDatabase() {
             this .database.close();
         }
    }
    然后在程序的首个Activity中示例化一个DBManager对象,然后对其执行openDatabase方法就可以完成导入了,可以把一些要 对数据库进行的操作写在DBManager类里,然后通过DBManager类的对象调用;也可以在完成导入之后通过一个SQliteDatabase类 的对象打开数据库,并执行操作。

我的做法是 在程序的首个Activity中导入数据库:

   
   
   
   
  1. package com.android.ImportDatabase;  
  2.    
  3. import android.app.Activity;  
  4. import android.content.Intent;  
  5. import android.os.Bundle;  
  6.    
  7. public class RootView extends Activity {  
  8.    
  9.     public DBManager dbHelper;  
  10.    @Override 
  11.     public void onCreate(Bundle savedInstanceState) { 
  12.   
  13.         super.onCreate(savedInstanceState); 
  14.         setContentView(R.layout.main); 
  15.   
  16.         dbHelper = new DBManager(this); 
  17.         dbHelper.openDatabase(); 
  18.         dbHelper.closeDatabase(); 
  19.   
  20.     } 
  21. }
  22.  
此时在DDMS中可以查看到,外部数据库已经成功导入

在需要使用数据库的类里:

   
   
   
   
  1. package com.android.ImportDatabase; 
  2.   
  3. import java.util.ArrayList; 
  4. import android.app.Activity; 
  5. import android.database.Cursor; 
  6. import android.database.sqlite.SQLiteDatabase; 
  7. import android.os.Bundle; 
  8.   
  9. public class TaxiActivity extends Activity { 
  10.   
  11.     private SQLiteDatabase database; 
  12.         ArrayList<CityClass> CITY; 
  13.   
  14.     @Override 
  15.     public void onCreate(Bundle savedInstanceState) { 
  16.   
  17.         super.onCreate(savedInstanceState); 
  18.         setContentView(R.layout.main); 
  19.           
  20.         database = SQLiteDatabase.openOrCreateDatabase(DBManager.DB_PATH + "/" + DBManager.DB_NAME, null); 
  21.   
  22.         CITY = getCity(); 
  23.           
  24.         // do something with CITY 
  25.   
  26.         database.close(); 
  27.     } 
  28.   
  29.     private ArrayList<CityClass> getCity() { 
  30.           
  31.         Cursor cur = database.rawQuery("SELECT city.id_city, city.name FROM taxi, city WHERE city.id_city = taxi.id_city GROUP BY city.id_city"null); 
  32.           
  33.         if (cur != null) { 
  34.             int NUM_CITY = cur.getCount(); 
  35.             ArrayList<CityClass> taxicity = new ArrayList<CityClass>(NUM_CITY); 
  36.             if (cur.moveToFirst()) { 
  37.                 do { 
  38.                     String name = cur.getString(cur.getColumnIndex("name")); 
  39.                     int id = cur.getInt(cur.getColumnIndex("id_city")); 
  40.                     CityClass city = new CityClass(""0); 
  41.                     System.out.println(name);  //额外添加一句,把select到的信息输出到Logcat 
  42.                     city.city_name = name; 
  43.                     city.city_id = id; 
  44.                     taxicity.add(city); 
  45.                 } while (cur.moveToNext()); 
  46.             } 
  47.             return taxicity; 
  48.         } else { 
  49.             return null
  50.         } 
  51.     } 
  52. }
查看输出的结果:

如果导入的数据库大小有问题,或使用InputStream读取出错了,请看此贴 [iPhone/Android] 导入程序的数据库大小与原数据库大小不一致怎么办?

 

你可能感兴趣的:(数据库,android)