Android程序中读取使用已有的SQLite数据库

本文详细介绍了在Android应用中如何使用SQLite数据库进行文件路径管理、权限申请、资源复制及数据库初始化、创建、访问等关键步骤。同时,提供了一种复制数据库到Android设备本地的方法,包括创建空数据库、检查数据库是否存在并进行复制操作。最后,展示了如何通过继承SQLiteOpenHelper类实现数据库管理,包括创建数据库、检查数据库、复制数据库和打开数据库等功能。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

方法一:

先在 Manifest 里添加权限

<span style="font-size:12px;"><uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.MOUNT_UNMOUNT_FILESYSTEMS" /></span>
第一步先判断在指定的路劲是否存在,不存在就创建。第二步将android的资源下的数据库复制到指定路径下面。第三步就是根据指定路径打开或者创建数据库,然后得到操作数据库的对象,得到操作数据库的对象了,自然就可以对数据库中的表进行增删改查等操作了。
<span style="font-size:12px;">SQLiteDatabase db;
    private final String DATABASE_PATH = android.os.Environment
            .getExternalStorageDirectory().getAbsolutePath() + "/vote";
    private String DATABASE_FILENAME = "db_vote.db";


// 初始化数据库
    private SQLiteDatabase openDatabase() {
        try {
            String databaseFilename = DATABASE_PATH + "/" + DATABASE_FILENAME;
            File dir = new File(DATABASE_PATH);
            if (!dir.exists())
                dir.mkdir();
            if (!(new File(databaseFilename)).exists()) {
                InputStream is = getResources().openRawResource(R.raw.db_vote);
                FileOutputStream fos = new FileOutputStream(databaseFilename);
                byte[] buffer = new byte[8192];
                int count = 0;
                while ((count = is.read(buffer)) > 0) {
                    fos.write(buffer, 0, count);
                }
                fos.close();
                is.close();
            }
            db = SQLiteDatabase.openOrCreateDatabase(databaseFilename, null);
            return db;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }</span>
方法二:
1. 准备SQLite database文件

    假设你已经创建了一个sqlite数据库,我们需要对其进行一些修改。

   (译者注:这里原文是推荐了一个SQLite数据库管理软件,这个我觉得可以随自己的喜好,最Windows下面有多款可视化的SQlite数据库管理软件,可以方便的读取,编辑数据库,例如我用的是sqlitestudio

打开数据库,添加一个新的table “android_metadata",插入一行数据,具体的SQL如下:

<span style="font-size:12px;">    CREATE TABLE "android_metadata" ("locale" TEXT DEFAULT 'en_US')  
      
    INSERT INTO "android_metadata" VALUES ('en_US')  </span>
(译者注:上面两行是表明需要进行的操作,具体可以直接在sqlitesstudio中完成)

    然后你需要对你数据表格的primary id 列重命名为 “_id”,这样Adroid会知道怎么对id列进行绑定,你可以很容易的在SQlite数据库管理软件中进行列编辑。

    这两步之后,你的sqlite数据库文件就准备好了。

  (这里我保留了id列,即没有对其进行重命名,测试证明也是没有问题的)

2. 在你的Android程序中复制,打开以及访问数据库

    现在把你上一步准备好的数据库文件放在“assets”文件夹下面,然后通过继承 SQLiteOpenHelper类来创建一个Database Helper类,

你的DataBaseHelper类大致可以如下:

    <span style="font-size:12px;">public class DataBaseHelper extends SQLiteOpenHelper{  
       
        //The Android's default system path of your application database.  
        private static String DB_PATH = "/data/data/YOUR_PACKAGE/databases/";  
       
        private static String DB_NAME = "myDBName";  
       
        private SQLiteDatabase myDataBase;   
       
        private final Context myContext;  
       
        /** 
         * Constructor 
         * Takes and keeps a reference of the passed context in order to access to the application assets and resources. 
         * @param context 
         */  
        public DataBaseHelper(Context context) {  
       
            super(context, DB_NAME, null, 1);  
            this.myContext = context;  
        }     
       
      /** 
         * Creates a empty database on the system and rewrites it with your own database. 
         * */  
        public void createDataBase() throws IOException{  
       
            boolean dbExist = checkDataBase();  
       
            if(dbExist){  
                //do nothing - database already exist  
            }else{  
       
                //By calling this method and empty database will be created into the default system path  
                   //of your application so we are gonna be able to overwrite that database with our database.  
                this.getReadableDatabase();  
       
                try {  
       
                    copyDataBase();  
       
                } catch (IOException e) {  
       
                    throw new Error("Error copying database");  
       
                }  
            }  
       
        }  
       
        /** 
         * Check if the database already exist to avoid re-copying the file each time you open the application. 
         * @return true if it exists, false if it doesn't 
         */  
        private boolean checkDataBase(){  
       
            SQLiteDatabase checkDB = null;  
       
            try{  
                String myPath = DB_PATH + DB_NAME;  
                checkDB = SQLiteDatabase.openDatabase(myPath, null, SQLiteDatabase.OPEN_READONLY);  
       
            }catch(SQLiteException e){  
       
                //database does't exist yet.  
       
            }  
       
            if(checkDB != null){  
       
                checkDB.close();  
       
            }  
       
            return checkDB != null ? true : false;  
        }  
       
        /** 
         * Copies your database from your local assets-folder to the just created empty database in the 
         * system folder, from where it can be accessed and handled. 
         * This is done by transfering bytestream. 
         * */  
        private void copyDataBase() throws IOException{  
       
            //Open your local db as the input stream  
            InputStream myInput = myContext.getAssets().open(DB_NAME);  
       
            // Path to the just created empty db  
            String outFileName = DB_PATH + DB_NAME;  
       
            //Open the empty db as the output stream  
            OutputStream myOutput = new FileOutputStream(outFileName);  
       
            //transfer bytes from the inputfile to the outputfile  
            byte[] buffer = new byte[1024];  
            int length;  
            while ((length = myInput.read(buffer))>0){  
                myOutput.write(buffer, 0, length);  
            }  
       
            //Close the streams  
            myOutput.flush();  
            myOutput.close();  
            myInput.close();  
       
        }  
       
        public void openDataBase() throws SQLException{  
       
            //Open the database  
            String myPath = DB_PATH + DB_NAME;  
            myDataBase = SQLiteDatabase.openDatabase(myPath, null, SQLiteDatabase.OPEN_READONLY);  
       
        }  
       
        @Override  
        public synchronized void close() {  
       
                if(myDataBase != null)  
                    myDataBase.close();  
       
                super.close();  
       
        }  
       
        @Override  
        public void onCreate(SQLiteDatabase db) {  
       
        }  
       
        @Override  
        public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {  
       
        }  
       
            // Add your public helper methods to access and get content from the database.  
           // You could return cursors by doing "return myDataBase.query(....)" so it'd be easy  
           // to you to create adapters for your views.  
       
    }  </span>

就这样。

    现在你可以创建一个新的DataBaseHelper实例,然后调用createDataBase(),然后再调用openDataBase()方法,记住修改DB_PATH字符串中“YOUR_PACKAGE”为你真正的package名称(也就是说com.examplename.myapp)

以下是示范代码:

   <span style="font-size:12px;"> ...  
      
           DataBaseHelper myDbHelper = new DataBaseHelper();  
           myDbHelper = new DataBaseHelper(this);  
      
           try {  
      
            myDbHelper.createDataBase();  
      
        } catch (IOException ioe) {  
      
            throw new Error("Unable to create database");  
      
        }  
      
        try {  
      
            myDbHelper.openDataBase();  
      
        }catch(SQLException sqle){  
      
            throw sqle;  
      
        }  
      
           ...  </span>





<think>我们正在处理用户的问题:如何在Android Studio项目中集成和使用现有的SQLite数据库文件。 根据引用[1]和引用[2],我们知道Android Studio内置了SQLite数据库,并且有相关的使用方法。 但是用户的需求是使用已有SQLite数据库文件(即一个已经创建好的.db文件),而不是在应用中创建新的数据库。 步骤: 1. 准备已有SQLite数据库文件(例如:mydatabase.db),并确保它包含所需的表和数据。 2. 将数据库文件放入Android项目的assets目录中(如果没有assets目录,则创建:app/src/main/assets)。 3. 在应用启动时,将该数据库文件复制到应用的数据库目录(/data/data/<package_name>/databases/)中,因为Android系统只能访问该目录下的数据库文件。 4. 创建SQLiteOpenHelper的子类,并在其中实现数据库的复制(如果数据库不存在)和打开操作。 5. 通过这个Helper类来获取可读或可写的数据库对象,从而进行查询等操作。 注意:在复制数据库时,需要检查目标目录是否存在,如果不存在则创建;同时,如果数据库已经存在,则不需要重复复制(除非需要更新数据库,但更新数据库需要更复杂的处理,如版本管理)。 下面我们逐步说明: 步骤1:将数据库文件放入assets目录 - 在项目的app/src/main/目录下,创建assets文件夹(如果不存在)。 - 将你的数据库文件(例如:mydatabase.db)放入该文件夹中。 步骤2:创建DatabaseHelper类 - 这个类继承自SQLiteOpenHelper,并重写onCreate和onUpgrade方法。 - 在构造方法中,指定数据库名称和版本号。 - 在onCreate方法中,我们不需要创建表,因为数据库已经存在,但需要复制数据库。但是注意,onCreate只会在数据库不存在时被调用,所以我们可以在此时复制数据库。 - 另外,我们也可以将复制数据库的操作放在构造方法中(在数据库不存在时复制),但更常见的做法是在第一次尝试打开数据库时进行复制。 步骤3:实现数据库复制方法 - 在DatabaseHelper类中,编写一个方法用于从assets目录复制数据库到设备数据库目录。 步骤4:在需要的时候使用DatabaseHelper获取数据库实例,然后进行查询操作。 下面是一个示例代码: 首先,在AndroidManifest.xml中确保有写入外部存储的权限(如果需要,在Android 6.0以上需要动态申请): <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" /> 注意:从Android 10(API 29)开始,应用默认只能访问自己的外部存储目录,所以通常不需要这个权限也可以操作自己的数据库目录。因此,如果只操作应用内部存储,可能不需要这个权限。 但是,我们复制数据库到内部存储的数据库目录(/data/data/<package>/databases)不需要外部存储权限。 然后,创建DatabaseHelper类: ```java import android.content.Context; import android.database.sqlite.SQLiteDatabase; import android.database.sqlite.SQLiteOpenHelper; import android.database.SQLException; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; public class DatabaseHelper extends SQLiteOpenHelper { // 数据库名称 private static String DB_NAME = "mydatabase.db"; // 数据库版本,如果已有数据库的版本需要更新,可以在这里增加版本号,并在onUpgrade中处理 private static final int DB_VERSION = 1; // 数据库在设备中的完整路径 private static String DB_PATH = ""; private Context mContext; private SQLiteDatabase mDatabase; public DatabaseHelper(Context context) { super(context, DB_NAME, null, DB_VERSION); // 在Android 4.2及以上,可以使用context.getApplicationInfo().dataDir获取数据目录 DB_PATH = context.getApplicationInfo().dataDir + "/databases/"; this.mContext = context; } // 此方法会在数据库不存在的时候被调用,所以我们在这里复制数据库 @Override public void onCreate(SQLiteDatabase db) { // 这里不需要创建表,因为我们从assets复制 // 但是我们需要确保数据库文件存在,所以调用复制方法 try { copyDatabase(); } catch (IOException e) { throw new RuntimeException("Error copying database", e); } } @Override public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { // 当数据库版本升级时,这里可以处理升级逻辑 // 例如:备份旧数据库,复制新的数据库文件等 } // 创建数据库,如果数据库已经存在,则直接打开,否则复制 private void copyDatabase() throws IOException { // 检查数据库是否已经存在 if (checkDatabase()) { return; } // 如果不存在,则先创建目录 this.getReadableDatabase(); // 这会调用onCreate,但为了避免递归,我们不在onCreate中调用copyDatabase,所以这里直接调用复制 try { // 复制assets中的数据库文件到应用数据库目录 InputStream inputStream = mContext.getAssets().open(DB_NAME); String outFileName = DB_PATH + DB_NAME; OutputStream outputStream = new FileOutputStream(outFileName); byte[] buffer = new byte[1024]; int length; while ((length = inputStream.read(buffer)) > 0) { outputStream.write(buffer, 0, length); } outputStream.flush(); outputStream.close(); inputStream.close(); } catch (IOException e) { throw new RuntimeException("Error copying database", e); } } // 检查数据库是否已经存在 private boolean checkDatabase() { SQLiteDatabase checkDB = null; try { String path = DB_PATH + DB_NAME; checkDB = SQLiteDatabase.openDatabase(path, null, SQLiteDatabase.OPEN_READONLY); } catch (SQLException e) { // 数据库不存在 } if (checkDB != null) { checkDB.close(); } return checkDB != null; } // 打开数据库,如果数据库没有复制,则先复制 public void openDatabase() throws SQLException { String path = DB_PATH + DB_NAME; mDatabase = SQLiteDatabase.openDatabase(path, null, SQLiteDatabase.OPEN_READWRITE); } @Override public synchronized void close() { if (mDatabase != null) { mDatabase.close(); } super.close(); } } ``` 步骤4:在Activity中使用: ```java public class MainActivity extends AppCompatActivity { private DatabaseHelper dbHelper; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); dbHelper = new DatabaseHelper(this); try { // 打开数据库(如果数据库不存在,会在构造方法中调用onCreate,然后复制数据库dbHelper.openDatabase(); } catch (SQLException e) { e.printStackTrace(); } // 现在可以通过dbHelper获取数据库对象,然后进行查询 SQLiteDatabase db = dbHelper.getWritableDatabase(); // 或者getReadableDatabase() // 执行查询操作... // 例如:Cursor cursor = db.rawQuery("SELECT * FROM my_table", null); } @Override protected void onDestroy() { super.onDestroy(); dbHelper.close(); } } ``` 注意:上面的代码中,我们在DatabaseHelper的构造方法中并没有立即复制数据库,而是在onCreate中调用了复制。但是,由于在创建DatabaseHelper时,会调用getReadableDatabase()或getWritableDatabase(),这会触发onCreate(如果数据库不存在)。因此,我们实际上在第一次打开数据库时复制了数据库。 但是,上面的代码在onCreate中调用了copyDatabase,而copyDatabase中又调用了checkDatabase,如果数据库不存在,则进行复制。这样确保了数据库只复制一次。 另外,我们提供了openDatabase方法,用于打开数据库连接(在DatabaseHelper中已经通过getReadableDatabase()或getWritableDatabase()打开了,所以这里其实可以不用)。实际上,我们通常直接使用DatabaseHelper的getWritableDatabase()方法,它会返回一个可写的数据库对象,并且如果数据库不存在,会触发onCreate(从而复制数据库)。 因此,我们可以简化DatabaseHelper,去掉openDatabase方法,直接在需要的时候调用getWritableDatabase()。 修改后的DatabaseHelper的onCreate方法: ```java @Override public void onCreate(SQLiteDatabase db) { // 这里我们不需要创建表,因为数据库是从assets复制的 // 但是,由于数据库文件还没有复制,所以我们需要先复制 // 注意:此时数据库已经创建(一个空数据库),所以我们需要关闭它,然后复制我们的数据库文件,再重新打开 // 因此,我们不在onCreate中复制,而是在getWritableDatabase之前检查并复制 // 实际上,我们不在onCreate中复制,而是采用另一种方式:在构造方法后,调用getWritableDatabase之前,先复制数据库(如果不存在) // 所以,我们可以不在onCreate中做任何事,而是单独写一个方法,在创建Helper后调用 } ``` 因此,更常见的做法是在DatabaseHelper中提供一个方法用于检查并复制数据库,然后在创建Helper后调用该方法。或者,我们可以在getWritableDatabase()之前,确保数据库已经复制。 我们调整一下策略: 1. 在DatabaseHelper的构造方法中,检查数据库是否存在,如果不存在则复制(注意:此时还没有调用getWritableDatabase,所以不会触发onCreate)。 2. 但是,复制数据库需要数据库文件,所以我们要在复制前创建好数据库目录。 修改后的DatabaseHelper: ```java public class DatabaseHelper extends SQLiteOpenHelper { // ... 其他同上 public DatabaseHelper(Context context) { super(context, DB_NAME, null, DB_VERSION); DB_PATH = context.getApplicationInfo().dataDir + "/databases/"; this.mContext = context; // 确保数据库目录存在 File dbDir = new File(DB_PATH); if (!dbDir.exists()) { dbDir.mkdirs(); } // 检查并复制数据库 if (!checkDatabase()) { try { copyDatabase(); } catch (IOException e) { throw new RuntimeException("Error copying database", e); } } } @Override public void onCreate(SQLiteDatabase db) { // 这里什么都不做,因为数据库已经由复制操作完成 } @Override public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { // 升级数据库 } private boolean checkDatabase() { // ...同上 } private void copyDatabase() throws IOException { // 打开assets中的数据库文件流 InputStream inputStream = mContext.getAssets().open(DB_NAME); // 目标文件路径 String outFileName = DB_PATH + DB_NAME; OutputStream outputStream = new FileOutputStream(outFileName); // 复制文件 byte[] buffer = new byte[1024]; int length; while ((length = inputStream.read(buffer)) > 0) { outputStream.write(buffer, 0, length); } outputStream.flush(); outputStream.close(); inputStream.close(); } // 打开数据库,这里我们直接使用父类的方法 } ``` 然后在Activity中: ```java dbHelper = new DatabaseHelper(this); // 此时数据库已经复制(如果不存在) SQLiteDatabase db = dbHelper.getWritableDatabase(); // 现在可以正常使用 ``` 这样,在创建DatabaseHelper时,如果数据库文件不存在,就会复制。然后调用getWritableDatabase()时,会打开这个数据库(不会触发onCreate,因为数据库已经存在)。 注意:如果数据库已经存在,但版本号低于当前设置的版本号,会触发onUpgrade方法,所以需要在onUpgrade中处理数据库升级。 关于数据库升级:如果已有数据库文件,并且需要更新,那么我们可以将新版本的数据库文件放在assets中,然后在onUpgrade中删除旧数据库,再复制新的数据库文件。但是,这会导致用户数据丢失。因此,更常见的做法是使用SQL脚本来更新数据库结构(例如:执行ALTER TABLE语句),而不是替换整个数据库文件。这需要根据业务需求来处理。 以上就是在Android Studio中使用已有SQLite数据库文件的方法。 相关问题: 1. 如何更新已经存在的SQLite数据库文件(当应用升级时)? 2. 在复制数据库时,如果数据库较大,如何避免ANR(应用无响应)? 3. 如何加密SQLite数据库以保证数据安全?</think>### 在Android Studio中集成和使用现有SQLite数据库文件 #### 步骤1:准备数据库文件 1. 准备已有SQLite数据库文件(如`mydatabase.db`) 2. 在项目的`app/src/main/`目录下创建`assets`文件夹(若不存在) 3. 将数据库文件放入`assets`文件夹中 #### 步骤2:创建数据库辅助类 ```java import android.content.Context; import android.database.sqlite.SQLiteDatabase; import android.database.sqlite.SQLiteOpenHelper; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; public class DatabaseHelper extends SQLiteOpenHelper { private static final String DB_NAME = "mydatabase.db"; private static final int DB_VERSION = 1; private final Context context; public DatabaseHelper(Context context) { super(context, DB_NAME, null, DB_VERSION); this.context = context; } @Override public void onCreate(SQLiteDatabase db) { // 数据库已存在,无需创建 } @Override public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { // 数据库升级逻辑 } public void createDatabase() throws IOException { if (!checkDatabase()) { this.getReadableDatabase(); // 创建空数据库 copyDatabase(); } } private boolean checkDatabase() { return context.getDatabasePath(DB_NAME).exists(); } private void copyDatabase() throws IOException { try (InputStream input = context.getAssets().open(DB_NAME); OutputStream output = new FileOutputStream(context.getDatabasePath(DB_NAME))) { byte[] buffer = new byte[1024]; int length; while ((length = input.read(buffer)) > 0) { output.write(buffer, 0, length); } output.flush(); } } } ``` #### 步骤3:初始化数据库(在Activity中) ```java public class MainActivity extends AppCompatActivity { private SQLiteDatabase database; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); DatabaseHelper dbHelper = new DatabaseHelper(this); try { dbHelper.createDatabase(); // 复制数据库 database = dbHelper.getReadableDatabase(); } catch (IOException e) { throw new RuntimeException("数据库复制失败", e); } } } ``` #### 步骤4:执行数据库操作 ```java // 查询示例 public List<User> getUsers() { List<User> users = new ArrayList<>(); Cursor cursor = database.rawQuery("SELECT * FROM users", null); if (cursor.moveToFirst()) { do { User user = new User(); user.setId(cursor.getInt(0)); user.setName(cursor.getString(1)); users.add(user); } while (cursor.moveToNext()); } cursor.close(); return users; } // 插入示例 public void addUser(User user) { ContentValues values = new ContentValues(); values.put("name", user.getName()); database.insert("users", null, values); } ``` #### 关键注意事项: 1. **数据库位置**:复制后数据库位于`/data/data/<包名>/databases/mydatabase.db` 2. **首次运行**:只在首次启动时复制,避免重复覆盖 3. **主线程限制**:大数据操作需在子线程执行,避免ANR 4. **数据库版本**:若修改数据库结构需增加版本号并处理`onUpgrade()` 5. **文件大小**:大于1MB的数据库需分段复制[^1] #### 查看数据库内容: 1. 使用Android Studio的**Device File Explorer** 2. 路径:`/data/data/<包名>/databases/` 3. 导出.db文件后用SQLite浏览器查看[^2]
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值