在Android Studio 3.0中附带数据库文件发布应用程序

对我来说，发布带有数据库文件的应用程序是个好主意。这样做的优点是不需要进行复杂的初始化，如果数据集很大，初始化有时会花费大量时间。

步骤1:准备数据库文件

准备好数据库文件。它可以是.db文件或.sqlite文件。如果您使用.sqlite文件，您所需要做的就是更改文件扩展名。步骤是一样的。

在本例中，我准备了一个名为testDB.db的文件。它有一个表和一些样本数据，像这样

步骤2:将文件导入到项目中

如果您还没有资产文件夹，请创建资产文件夹。然后将数据库文件复制并粘贴到此文件夹中

步骤3:复制文件到应用程序的数据文件夹

你需要将数据库文件复制到应用程序的数据文件夹中，以便与它进行进一步的交互。这是复制数据库文件的一次性操作(初始化)。如果多次调用此代码，data文件夹中的数据库文件将被assets文件夹中的数据库文件覆盖。当你想在未来的应用程序更新期间更新数据库时，这个覆盖过程是有用的。

注意，在应用程序更新期间，这个数据库文件不会在应用程序的数据文件夹中被更改。只有卸载才会删除它。

数据库文件需要复制到“/databases”文件夹下。打开设备文件资源管理器。输入data/data/<YourAppName>/ location。这是上面提到的应用程序的默认数据文件夹。默认情况下，数据库文件将放在该目录下的另一个名为databases的文件夹中

现在，复制文件的过程与Java所做的非常相似。使用下面的代码进行复制粘贴。这是起始代码。它还可以用于将来更新(通过覆盖)数据库文件。

//get context by calling "this" in activity or getActivity() in fragment
//call this if API level is lower than 17  String appDataPath = "/data/data/" + context.getPackageName() + "/databases/"
String appDataPath = context.getApplicationInfo().dataDir;

File dbFolder = new File(appDataPath + "/databases");//Make sure the /databases folder exists
dbFolder.mkdir();//This can be called multiple times.

File dbFilePath = new File(appDataPath + "/databases/testDB.db");

try {
    InputStream inputStream = context.getAssets().open("testDB.db");
    OutputStream outputStream = new FileOutputStream(dbFilePath);
    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){
    //handle
}

然后刷新文件夹以验证复制过程

步骤4:创建数据库打开帮助程序

为SQLiteOpenHelper创建一个子类，包括连接、关闭、路径等。我把它命名为DatabaseOpenHelper

import android.content.Context;
import android.database.SQLException;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;

public class DatabaseOpenHelper extends SQLiteOpenHelper {
    public static final String DB_NAME = "testDB.db";
    public static final String DB_SUB_PATH = "/databases/" + DB_NAME;
    private static String APP_DATA_PATH = "";
    private SQLiteDatabase dataBase;
    private final Context context;

    public DatabaseOpenHelper(Context context){
        super(context, DB_NAME, null, 1);
        APP_DATA_PATH = context.getApplicationInfo().dataDir;
        this.context = context;
    }

    public boolean openDataBase() throws SQLException{
        String mPath = APP_DATA_PATH + DB_SUB_PATH;
        //Note that this method assumes that the db file is already copied in place
        dataBase = SQLiteDatabase.openDatabase(mPath, null, SQLiteDatabase.OPEN_READWRITE);
        return dataBase != null;
    }

    @Override
    public synchronized void close(){
        if(dataBase != null) {dataBase.close();}
        super.close();
    }

    @Override
    public void onCreate(SQLiteDatabase db) {
    }

    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
    }
}

步骤5:创建与数据库交互的顶级类

这将是读取和写入数据库文件的类。还有一个示例查询，用于打印数据库中的值。

import android.content.Context;
import android.database.Cursor;
import android.database.SQLException;
import android.database.sqlite.SQLiteDatabase;
import android.util.Log;

public class Database {
    private final Context context;
    private SQLiteDatabase database;
    private DatabaseOpenHelper dbHelper;

    public Database(Context context){
        this.context = context;
        dbHelper = new DatabaseOpenHelper(context);
    }

    public Database open() throws SQLException
    {
        dbHelper.openDataBase();
        dbHelper.close();
        database = dbHelper.getReadableDatabase();
        return this;
    }

    public void close()
    {
        dbHelper.close();
    }

    public void test(){
        try{
            String query ="SELECT value FROM test1";
            Cursor cursor = database.rawQuery(query, null);
            if (cursor.moveToFirst()){
                do{
                    String value = cursor.getString(0);
                    Log.d("db", value);
                }while (cursor.moveToNext());
            }
            cursor.close();
        } catch (SQLException e) {
            //handle
        }
    }
}

步骤6:测试运行

通过运行以下代码行来测试代码。

Database db = new Database(context);
db.open();
db.test();
db.close();

按下跑步键，欢呼吧!

2017年11月，谷歌发布了房间持久性库。

从文档中可以看到:

Room持久库在SQLite上提供了一个抽象层 允许流畅的数据库访问，同时利用 SQLite。 该库可以帮助您在设备上创建应用程序数据的缓存 这个缓存，作为你的应用程序的单一 真实源，允许用户查看一致的密钥副本 应用程序中的信息，不管用户是否有 互联网连接。

当第一次创建或打开数据库时，Room数据库具有回调。可以使用create回调填充数据库。

Room.databaseBuilder(context.applicationContext,
        DataDatabase::class.java, "Sample.db")
        // prepopulate the database after onCreate was called
        .addCallback(object : Callback() {
            override fun onCreate(db: SupportSQLiteDatabase) {
                super.onCreate(db)
                // moving to a new thread
                ioThread {
                    getInstance(context).dataDao()
                                        .insert(PREPOPULATE_DATA)
                }
            }
        })
        .build()

这篇博文中的代码。

如果所需的数据不是很大(限制我不知道，将取决于很多东西)，你也可以从网站/网络应用下载数据(XML, JSON，无论什么)。接收到数据后，使用接收到的数据执行SQL语句，创建表并插入数据。

如果你的移动应用程序包含大量数据，稍后用更准确的数据或更改更新已安装的应用程序中的数据可能会更容易。

SQLiteAssetHelper库使得这个任务非常简单。

作为gradle依赖项添加它很容易(但Jar也可用于Ant/Eclipse)，它的文档可以在以下地址找到: https://github.com/jgilfelt/android-sqlite-asset-helper

注意:这个项目不再维护如上所述的Github链接。

如文档中所述:

Add the dependency to your module's gradle build file: dependencies { compile 'com.readystatesoftware.sqliteasset:sqliteassethelper:+' } Copy the database into the assets directory, in a subdirectory called assets/databases. For instance: assets/databases/my_database.db (Optionally, you may compress the database in a zip file such as assets/databases/my_database.zip. This isn't needed, since the APK is compressed as a whole already.) Create a class, for example: public class MyDatabase extends SQLiteAssetHelper { private static final String DATABASE_NAME = "my_database.db"; private static final int DATABASE_VERSION = 1; public MyDatabase(Context context) { super(context, DATABASE_NAME, null, DATABASE_VERSION); } }

从我所看到的，你应该是一个已经有表设置和数据的数据库。然而，如果你愿意(取决于你拥有的应用程序类型)，你可以允许“升级数据库选项”。然后你要做的就是下载最新的sqlite版本，获得在线托管的文本文件的最新Insert/Create语句，执行这些语句，并从旧的db进行数据传输到新的db。

我的解决方案既不使用任何第三方库，也不强迫您在SQLiteOpenHelper子类上调用自定义方法来在创建时初始化数据库。它还负责数据库升级。所有需要做的就是子类化SQLiteOpenHelper。

先决条件:

你希望与应用一起发布的数据库。它应该包含一个名为android_metadata的1x1表，其属性locale值为en_US，此外还有应用特有的表。

子类化SQLiteOpenHelper:

子类SQLiteOpenHelper。 在SQLiteOpenHelper子类中创建一个私有方法。此方法包含将数据库内容从“assets”文件夹中的数据库文件复制到在应用程序包上下文中创建的数据库的逻辑。 重写SQLiteOpenHelper的onCreate, onUpgrade和onOpen方法。

足够的说。下面是SQLiteOpenHelper子类:

public class PlanDetailsSQLiteOpenHelper extends SQLiteOpenHelper {
    private static final String TAG = "SQLiteOpenHelper";

    private final Context context;
    private static final int DATABASE_VERSION = 1;
    private static final String DATABASE_NAME = "my_custom_db";

    private boolean createDb = false, upgradeDb = false;

    public PlanDetailsSQLiteOpenHelper(Context context) {
        super(context, DATABASE_NAME, null, DATABASE_VERSION);
        this.context = context;
    }

    /**
     * Copy packaged database from assets folder to the database created in the
     * application package context.
     * 
     * @param db
     *            The target database in the application package context.
     */
    private void copyDatabaseFromAssets(SQLiteDatabase db) {
        Log.i(TAG, "copyDatabase");
        InputStream myInput = null;
        OutputStream myOutput = null;
        try {
            // Open db packaged as asset as the input stream
            myInput = context.getAssets().open("path/to/shipped/db/file");

            // Open the db in the application package context:
            myOutput = new FileOutputStream(db.getPath());

            // Transfer db file contents:
            byte[] buffer = new byte[1024];
            int length;
            while ((length = myInput.read(buffer)) > 0) {
                myOutput.write(buffer, 0, length);
            }
            myOutput.flush();

            // Set the version of the copied database to the current
            // version:
            SQLiteDatabase copiedDb = context.openOrCreateDatabase(
                DATABASE_NAME, 0, null);
            copiedDb.execSQL("PRAGMA user_version = " + DATABASE_VERSION);
            copiedDb.close();

        } catch (IOException e) {
            e.printStackTrace();
            throw new Error(TAG + " Error copying database");
        } finally {
            // Close the streams
            try {
                if (myOutput != null) {
                    myOutput.close();
                }
                if (myInput != null) {
                    myInput.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
                throw new Error(TAG + " Error closing streams");
            }
        }
    }

    @Override
    public void onCreate(SQLiteDatabase db) {
        Log.i(TAG, "onCreate db");
        createDb = true;
    }

    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        Log.i(TAG, "onUpgrade db");
        upgradeDb = true;
    }

    @Override
    public void onOpen(SQLiteDatabase db) {
        Log.i(TAG, "onOpen db");
        if (createDb) {// The db in the application package
            // context is being created.
            // So copy the contents from the db
            // file packaged in the assets
            // folder:
            createDb = false;
            copyDatabaseFromAssets(db);

        }
        if (upgradeDb) {// The db in the application package
            // context is being upgraded from a lower to a higher version.
            upgradeDb = false;
            // Your db upgrade logic here:
        }
    }
}

最后，要获得一个数据库连接，只需在SQLiteOpenHelper子类上调用getReadableDatabase()或getWritableDatabase()，它将负责创建一个db，如果数据库不存在，则从'assets'文件夹中的指定文件复制db内容。

简而言之，您可以使用SQLiteOpenHelper子类来访问资产文件夹中附带的db，就像您在onCreate()方法中使用SQL查询初始化数据库一样。