用数据库发送应用程序

如果您的应用程序需要一个数据库，并附带内置数据，那么运送该应用程序的最佳方式是什么？ 我是不是该：

1. 预先创buildSQLite数据库并将其包含在.apk ？

2. 在应用程序中包含SQL命令并让它创build数据库并在第一次使用时插入数据？

我看到的缺点是：

1. 可能的SQLite版本不匹配可能会导致问题，我目前不知道数据库应该去哪里以及如何访问它。

2. 在设备上创build和填充数据库可能需要很长时间。

有什么build议么？ 指出有关任何问题的文档将不胜感激。

Answer 1

我刚刚在ReignDesign博客中发现了一个在Android应用程序中使用自己的SQLite数据库的文章。 基本上你预先创build你的数据库，把它放在你的apk的资产目录中，首先使用复制到“/ data / data / YOUR_PACKAGE / databases /”目录。

Answer 2

有两种创build和更新数据库的选项。

一个是从外部创build一个数据库，然后将其放置在项目的assets文件夹中，然后从那里复制整个数据库。 如果数据库有很多表和其他组件，这会更快。 通过更改res / values / strings.xml文件中的数据库版本号来触发升级。 然后通过外部创build一个新的数据库来完成升级，用新的数据库replace资产文件夹中的旧数据库，以其他名称将旧数据库保存在内部存储器中，将新数据库从资产文件夹复制到内部存储器，将旧数据库（之前已重命名）的数据转换为新数据库，最后删除旧数据库。 你可以通过使用SQLitepipe理器FireFox插件来创build一个数据库来执行你的创buildsql语句。

另一种select是从一个sql文件内部创build一个数据库。 这不是那么快，但是如果数据库只有几张表，那么延迟对于用户可能是不明显的。 通过更改res / values / strings.xml文件中的数据库版本号来触发升级。 升级将通过处理升级sql文件来完成。 数据库中的数据将保持不变，除非其容器被删除，例如删除表格。

下面的例子演示了如何使用这两种方法。

这是一个示例create_database.sql文件。 它被放置在内部方法的项目的assets文件夹中，或者被复制到SQLite Manager的“Execute SQL”中，为外部方法创build数据库（注意：注意Android所需的表格的注释）。

 --Android requires a table named 'android_metadata' with a 'locale' column CREATE TABLE "android_metadata" ("locale" TEXT DEFAULT 'en_US'); INSERT INTO "android_metadata" VALUES ('en_US'); CREATE TABLE "kitchen_table"; CREATE TABLE "coffee_table"; CREATE TABLE "pool_table"; CREATE TABLE "dining_room_table"; CREATE TABLE "card_table"; 

这里是一个示例update_database.sql文件。 它被放置在内部方法的项目的assets文件夹中，或者被复制到SQLite Manager的“Execute SQL”中，为外部方法创build数据库（注意：所有这三种types的SQL注释都将被忽略通过本示例中包含的sqlparsing器）。

 --CREATE TABLE "kitchen_table"; This is one type of comment in sql. It is ignored by parseSql. /* * CREATE TABLE "coffee_table"; This is a second type of comment in sql. It is ignored by parseSql. */ { CREATE TABLE "pool_table"; This is a third type of comment in sql. It is ignored by parseSql. } /* CREATE TABLE "dining_room_table"; This is a second type of comment in sql. It is ignored by parseSql. */ { CREATE TABLE "card_table"; This is a third type of comment in sql. It is ignored by parseSql. } --DROP TABLE "picnic_table"; Uncomment this if picnic table was previously created and now is being replaced. CREATE TABLE "picnic_table" ("plates" TEXT); INSERT INTO "picnic_table" VALUES ('paper'); 

这是一个条目，添加到数据库版本号的/res/values/strings.xml文件中。

 <item type="string" name="databaseVersion" format="integer">1</item> 

这是一个访问数据库然后使用它的活动。 （ 注意：如果使用大量资源，可能需要在单独的线程中运行数据库代码。 ）

 package android.example; import android.app.Activity; import android.database.sqlite.SQLiteDatabase; import android.os.Bundle; /** * @author Danny Remington - MacroSolve * * Activity for demonstrating how to use a sqlite database. */ public class Database extends Activity { /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); DatabaseHelper myDbHelper; SQLiteDatabase myDb = null; myDbHelper = new DatabaseHelper(this); /* * Database must be initialized before it can be used. This will ensure * that the database exists and is the current version. */ myDbHelper.initializeDataBase(); try { // A reference to the database can be obtained after initialization. myDb = myDbHelper.getWritableDatabase(); /* * Place code to use database here. */ } catch (Exception ex) { ex.printStackTrace(); } finally { try { myDbHelper.close(); } catch (Exception ex) { ex.printStackTrace(); } finally { myDb.close(); } } } } 

这里是数据库帮助类，其中数据库是在必要时创build或更新的。 （注意：Android需要创build一个扩展SQLiteOpenHelper的类才能使用Sqlite数据库。）

 package android.example; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import android.content.Context; import android.database.sqlite.SQLiteDatabase; import android.database.sqlite.SQLiteOpenHelper; /** * @author Danny Remington - MacroSolve * * Helper class for sqlite database. */ public class DatabaseHelper extends SQLiteOpenHelper { /* * The Android's default system path of the application database in internal * storage. The package of the application is part of the path of the * directory. */ private static String DB_DIR = "/data/data/android.example/databases/"; private static String DB_NAME = "database.sqlite"; private static String DB_PATH = DB_DIR + DB_NAME; private static String OLD_DB_PATH = DB_DIR + "old_" + DB_NAME; private final Context myContext; private boolean createDatabase = false; private boolean upgradeDatabase = false; /** * 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, context.getResources().getInteger( R.string.databaseVersion)); myContext = context; // Get the path of the database that is based on the context. DB_PATH = myContext.getDatabasePath(DB_NAME).getAbsolutePath(); } /** * Upgrade the database in internal storage if it exists but is not current. * Create a new empty database in internal storage if it does not exist. */ public void initializeDataBase() { /* * Creates or updates the database in internal storage if it is needed * before opening the database. In all cases opening the database copies * the database in internal storage to the cache. */ getWritableDatabase(); if (createDatabase) { /* * If the database is created by the copy method, then the creation * code needs to go here. This method consists of copying the new * database from assets into internal storage and then caching it. */ try { /* * Write over the empty data that was created in internal * storage with the one in assets and then cache it. */ copyDataBase(); } catch (IOException e) { throw new Error("Error copying database"); } } else if (upgradeDatabase) { /* * If the database is upgraded by the copy and reload method, then * the upgrade code needs to go here. This method consists of * renaming the old database in internal storage, create an empty * new database in internal storage, copying the database from * assets to the new database in internal storage, caching the new * database from internal storage, loading the data from the old * database into the new database in the cache and then deleting the * old database from internal storage. */ try { FileHelper.copyFile(DB_PATH, OLD_DB_PATH); copyDataBase(); SQLiteDatabase old_db = SQLiteDatabase.openDatabase(OLD_DB_PATH, null, SQLiteDatabase.OPEN_READWRITE); SQLiteDatabase new_db = SQLiteDatabase.openDatabase(DB_PATH,null, SQLiteDatabase.OPEN_READWRITE); /* * Add code to load data into the new database from the old * database and then delete the old database from internal * storage after all data has been transferred. */ } catch (IOException e) { throw new Error("Error copying database"); } } } /** * 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 { /* * Close SQLiteOpenHelper so it will commit the created empty database * to internal storage. */ close(); /* * Open the database in the assets folder as the input stream. */ InputStream myInput = myContext.getAssets().open(DB_NAME); /* * Open the empty db in interal storage as the output stream. */ OutputStream myOutput = new FileOutputStream(DB_PATH); /* * Copy over the empty db in internal storage with the database in the * assets folder. */ FileHelper.copyFile(myInput, myOutput); /* * Access the copied database so SQLiteHelper will cache it and mark it * as created. */ getWritableDatabase().close(); } /* * This is where the creation of tables and the initial population of the * tables should happen, if a database is being created from scratch instead * of being copied from the application package assets. Copying a database * from the application package assets to internal storage inside this * method will result in a corrupted database. * <P> * NOTE: This method is normally only called when a database has not already * been created. When the database has been copied, then this method is * called the first time a reference to the database is retrieved after the * database is copied since the database last cached by SQLiteOpenHelper is * different than the database in internal storage. */ @Override public void onCreate(SQLiteDatabase db) { /* * Signal that a new database needs to be copied. The copy process must * be performed after the database in the cache has been closed causing * it to be committed to internal storage. Otherwise the database in * internal storage will not have the same creation timestamp as the one * in the cache causing the database in internal storage to be marked as * corrupted. */ createDatabase = true; /* * This will create by reading a sql file and executing the commands in * it. */ // try { // InputStream is = myContext.getResources().getAssets().open( // "create_database.sql"); // // String[] statements = FileHelper.parseSqlFile(is); // // for (String statement : statements) { // db.execSQL(statement); // } // } catch (Exception ex) { // ex.printStackTrace(); // } } /** * Called only if version number was changed and the database has already * been created. Copying a database from the application package assets to * the internal data system inside this method will result in a corrupted * database in the internal data system. */ @Override public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { /* * Signal that the database needs to be upgraded for the copy method of * creation. The copy process must be performed after the database has * been opened or the database will be corrupted. */ upgradeDatabase = true; /* * Code to update the database via execution of sql statements goes * here. */ /* * This will upgrade by reading a sql file and executing the commands in * it. */ // try { // InputStream is = myContext.getResources().getAssets().open( // "upgrade_database.sql"); // // String[] statements = FileHelper.parseSqlFile(is); // // for (String statement : statements) { // db.execSQL(statement); // } // } catch (Exception ex) { // ex.printStackTrace(); // } } /** * Called everytime the database is opened by getReadableDatabase or * getWritableDatabase. This is called after onCreate or onUpgrade is * called. */ @Override public void onOpen(SQLiteDatabase db) { super.onOpen(db); } /* * 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. */ } 

这是FileHelper类，它包含字节stream复制文件和parsingsql文件的方法。

 package android.example; import java.io.BufferedReader; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.FileReader; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.io.OutputStream; import java.io.Reader; import java.nio.channels.FileChannel; /** * @author Danny Remington - MacroSolve * * Helper class for common tasks using files. * */ public class FileHelper { /** * Creates the specified <i><b>toFile</b></i> that is a byte for byte a copy * of <i><b>fromFile</b></i>. If <i><b>toFile</b></i> already existed, then * it will be replaced with a copy of <i><b>fromFile</b></i>. The name and * path of <i><b>toFile</b></i> will be that of <i><b>toFile</b></i>. Both * <i><b>fromFile</b></i> and <i><b>toFile</b></i> will be closed by this * operation. * * @param fromFile * - InputStream for the file to copy from. * @param toFile * - InputStream for the file to copy to. */ public static void copyFile(InputStream fromFile, OutputStream toFile) throws IOException { // transfer bytes from the inputfile to the outputfile byte[] buffer = new byte[1024]; int length; try { while ((length = fromFile.read(buffer)) > 0) { toFile.write(buffer, 0, length); } } // Close the streams finally { try { if (toFile != null) { try { toFile.flush(); } finally { toFile.close(); } } } finally { if (fromFile != null) { fromFile.close(); } } } } /** * Creates the specified <i><b>toFile</b></i> that is a byte for byte a copy * of <i><b>fromFile</b></i>. If <i><b>toFile</b></i> already existed, then * it will be replaced with a copy of <i><b>fromFile</b></i>. The name and * path of <i><b>toFile</b></i> will be that of <i><b>toFile</b></i>. Both * <i><b>fromFile</b></i> and <i><b>toFile</b></i> will be closed by this * operation. * * @param fromFile * - String specifying the path of the file to copy from. * @param toFile * - String specifying the path of the file to copy to. */ public static void copyFile(String fromFile, String toFile) throws IOException { copyFile(new FileInputStream(fromFile), new FileOutputStream(toFile)); } /** * Creates the specified <i><b>toFile</b></i> that is a byte for byte a copy * of <i><b>fromFile</b></i>. If <i><b>toFile</b></i> already existed, then * it will be replaced with a copy of <i><b>fromFile</b></i>. The name and * path of <i><b>toFile</b></i> will be that of <i><b>toFile</b></i>. Both * <i><b>fromFile</b></i> and <i><b>toFile</b></i> will be closed by this * operation. * * @param fromFile * - File for the file to copy from. * @param toFile * - File for the file to copy to. */ public static void copyFile(File fromFile, File toFile) throws IOException { copyFile(new FileInputStream(fromFile), new FileOutputStream(toFile)); } /** * Creates the specified <i><b>toFile</b></i> that is a byte for byte a copy * of <i><b>fromFile</b></i>. If <i><b>toFile</b></i> already existed, then * it will be replaced with a copy of <i><b>fromFile</b></i>. The name and * path of <i><b>toFile</b></i> will be that of <i><b>toFile</b></i>. Both * <i><b>fromFile</b></i> and <i><b>toFile</b></i> will be closed by this * operation. * * @param fromFile * - FileInputStream for the file to copy from. * @param toFile * - FileInputStream for the file to copy to. */ public static void copyFile(FileInputStream fromFile, FileOutputStream toFile) throws IOException { FileChannel fromChannel = fromFile.getChannel(); FileChannel toChannel = toFile.getChannel(); try { fromChannel.transferTo(0, fromChannel.size(), toChannel); } finally { try { if (fromChannel != null) { fromChannel.close(); } } finally { if (toChannel != null) { toChannel.close(); } } } } /** * Parses a file containing sql statements into a String array that contains * only the sql statements. Comments and white spaces in the file are not * parsed into the String array. Note the file must not contained malformed * comments and all sql statements must end with a semi-colon ";" in order * for the file to be parsed correctly. The sql statements in the String * array will not end with a semi-colon ";". * * @param sqlFile * - String containing the path for the file that contains sql * statements. * * @return String array containing the sql statements. */ public static String[] parseSqlFile(String sqlFile) throws IOException { return parseSqlFile(new BufferedReader(new FileReader(sqlFile))); } /** * Parses a file containing sql statements into a String array that contains * only the sql statements. Comments and white spaces in the file are not * parsed into the String array. Note the file must not contained malformed * comments and all sql statements must end with a semi-colon ";" in order * for the file to be parsed correctly. The sql statements in the String * array will not end with a semi-colon ";". * * @param sqlFile * - InputStream for the file that contains sql statements. * * @return String array containing the sql statements. */ public static String[] parseSqlFile(InputStream sqlFile) throws IOException { return parseSqlFile(new BufferedReader(new InputStreamReader(sqlFile))); } /** * Parses a file containing sql statements into a String array that contains * only the sql statements. Comments and white spaces in the file are not * parsed into the String array. Note the file must not contained malformed * comments and all sql statements must end with a semi-colon ";" in order * for the file to be parsed correctly. The sql statements in the String * array will not end with a semi-colon ";". * * @param sqlFile * - Reader for the file that contains sql statements. * * @return String array containing the sql statements. */ public static String[] parseSqlFile(Reader sqlFile) throws IOException { return parseSqlFile(new BufferedReader(sqlFile)); } /** * Parses a file containing sql statements into a String array that contains * only the sql statements. Comments and white spaces in the file are not * parsed into the String array. Note the file must not contained malformed * comments and all sql statements must end with a semi-colon ";" in order * for the file to be parsed correctly. The sql statements in the String * array will not end with a semi-colon ";". * * @param sqlFile * - BufferedReader for the file that contains sql statements. * * @return String array containing the sql statements. */ public static String[] parseSqlFile(BufferedReader sqlFile) throws IOException { String line; StringBuilder sql = new StringBuilder(); String multiLineComment = null; while ((line = sqlFile.readLine()) != null) { line = line.trim(); // Check for start of multi-line comment if (multiLineComment == null) { // Check for first multi-line comment type if (line.startsWith("/*")) { if (!line.endsWith("}")) { multiLineComment = "/*"; } // Check for second multi-line comment type } else if (line.startsWith("{")) { if (!line.endsWith("}")) { multiLineComment = "{"; } // Append line if line is not empty or a single line comment } else if (!line.startsWith("--") && !line.equals("")) { sql.append(line); } // Check for matching end comment } else if (multiLineComment.equals("/*")) { if (line.endsWith("*/")) { multiLineComment = null; } // Check for matching end comment } else if (multiLineComment.equals("{")) { if (line.endsWith("}")) { multiLineComment = null; } } } sqlFile.close(); return sql.toString().split(";"); } } 

Answer 3

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

添加Gradle依赖很容易（但是Jar也可用于Ant / Eclipse），并且可以在以下位置find文档：
https://github.com/jgilfelt/android-sqlite-asset-helper

正如文件中所解释的：

1. 将依赖添加到你的模块的gradle构build文件中：

    dependencies { compile 'com.readystatesoftware.sqliteasset:sqliteassethelper:+' } 

2. 将数据库复制到资产目录中，名为assets/databases的子目录中。 例如：
   assets/databases/my_database.db

   （或者，您可以将数据库压缩到zip文件中，例如assets/databases/my_database.zip 。这不是必需的，因为APK已经被压缩为一个整体。）

3. 创build一个类，例如：

    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); } } 

Answer 4

我想直到今天最好的和最新的方式是使用SQLiteAssetHelper类。

本教程通过在Android中导入和使用外部数据库完美地指导您

Android SQLiteAssetHelper库允许您在桌面计算机中构buildSQLite数据库，并在您的Android应用程序中导入和使用它。 我们来创build一个简单的应用程序来演示这个库的应用。

步骤1 ：使用您最喜爱的SQLite数据库应用程序创build一个数据库quotes.db（DB Browser for SQLite是一个可移植的跨平台免费软件，可用于创build和编辑SQLite数据库）。 使用单个列“quote”创build一个表格“quotes”。 将一些随机引号插入表格的“引号”中。

第二步 ：数据库可以直接导入到项目中，也可以作为压缩文件导入。 如果数据库太大，build议使用压缩文件。 您可以创buildZIP压缩或GZ压缩。

压缩的db文件的文件名必须是quotes.db.zip ，如果使用ZIP压缩或者quotes.db.gz ，则使用GZ压缩。

第3步 ：创build一个包名称为com.javahelps.com.javahelps.externaldatabasedemo的新应用程序External Database Demo 。

第4步 ：打开build.gradle （Module：app）文件并添加以下依赖项。

 dependencies { compile 'com.readystatesoftware.sqliteasset:sqliteassethelper:+' } 

一旦保存了build.gradle文件，点击“立即同步”链接更新项目。 您可以通过右键单击build.gradle文件并selectSynchronize build.gradle选项来Synchronize build.gradle 。

第5步 ：右键单击应用程序文件夹，并创build新的资产文件夹。

第6步 ：在assets文件夹内创build一个新的文件夹“databases”。

第7步 ：复制并粘贴assets/databases文件夹中的quotes.db.zip文件。

第8步 ：创build一个新的类DatabaseOpenHelper

 package com.javahelps.externaldatabasedemo; import android.content.Context; import com.readystatesoftware.sqliteasset.SQLiteAssetHelper; public class DatabaseOpenHelper extends SQLiteAssetHelper { private static final String DATABASE_NAME = "quotes.db"; private static final int DATABASE_VERSION = 1; public DatabaseOpenHelper(Context context) { super(context, DATABASE_NAME, null, DATABASE_VERSION); } } Notice that rather than extending SQLiteOpenHelper, the DatabaseOpenHelper extends SQLiteAssetHelper class. 

第9步 ：创build一个新的类DatabaseAccess并input代码，如下所示。 高级Android数据库教程中提供了有关此类的更多详细信息。

 package com.javahelps.externaldatabasedemo; import android.content.Context; import android.database.Cursor; import android.database.sqlite.SQLiteDatabase; import android.database.sqlite.SQLiteOpenHelper; import java.util.ArrayList; import java.util.List; public class DatabaseAccess { private SQLiteOpenHelper openHelper; private SQLiteDatabase database; private static DatabaseAccess instance; /** * Private constructor to aboid object creation from outside classes. * * @param context */ private DatabaseAccess(Context context) { this.openHelper = new DatabaseOpenHelper(context); } /** * Return a singleton instance of DatabaseAccess. * * @param context the Context * @return the instance of DabaseAccess */ public static DatabaseAccess getInstance(Context context) { if (instance == null) { instance = new DatabaseAccess(context); } return instance; } /** * Open the database connection. */ public void open() { this.database = openHelper.getWritableDatabase(); } /** * Close the database connection. */ public void close() { if (database != null) { this.database.close(); } } /** * Read all quotes from the database. * * @return a List of quotes */ public List<String> getQuotes() { List<String> list = new ArrayList<>(); Cursor cursor = database.rawQuery("SELECT * FROM quotes", null); cursor.moveToFirst(); while (!cursor.isAfterLast()) { list.add(cursor.getString(0)); cursor.moveToNext(); } cursor.close(); return list; } } In this class only the `getQuotes` method is implemented to read the data from the database. You have the full freedom to insert, 

像往常一样更新和删除数据库中的任何行。 有关更多详细信息，请点击此链接高级Android数据库。

所有数据库相关的设置都已经完成，现在我们需要创build一个ListView来显示引号。

第10步 ：在你的activity_main.xml添加一个ListView 。

 <FrameLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent" android:layout_height="match_parent" android:paddingBottom="@dimen/activity_vertical_margin" android:paddingLeft="@dimen/activity_horizontal_margin" android:paddingRight="@dimen/activity_horizontal_margin" android:paddingTop="@dimen/activity_vertical_margin" tools:context=".MainActivity"> <ListView android:id="@+id/listView" android:layout_width="match_parent" android:layout_height="match_parent" android:layout_gravity="center" /> </FrameLayout> 

第11步 ：在MainActivity的onCreate方法中查找ListView的对象，并提供从数据库读取的引号。

 package com.javahelps.externaldatabasedemo; import android.os.Bundle; import android.support.v7.app.ActionBarActivity; import android.widget.ArrayAdapter; import android.widget.ListView; import java.util.List; public class MainActivity extends ActionBarActivity { private ListView listView; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); this.listView = (ListView) findViewById(R.id.listView); DatabaseAccess databaseAccess = DatabaseAccess.getInstance(this); databaseAccess.open(); List<String> quotes = databaseAccess.getQuotes(); databaseAccess.close(); ArrayAdapter<String> adapter = new ArrayAdapter<String>(this, android.R.layout.simple_list_item_1, quotes); this.listView.setAdapter(adapter); } } 

第12步 ：保存所有更改并运行应用程序。

除了这篇文章，你可以在这里下载SQLiteAssetHelper

Answer 5

我的解决scheme既不使用任何第三方库，也不会强制您调用SQLiteOpenHelper子类上的自定义方法来初始化创build数据库。 它也照顾数据库升级。 所有需要完成的事情都是SQLiteOpenHelper子类。

先决条件：

1. 您希望随应用程序一起提供的数据库。 它应该包含一个名为android_metadata的1×1表，其中除了对应用程序唯一的表之外，其属性locale的值为en_US 。

子类化SQLiteOpenHelper ：

1. 子类SQLiteOpenHelper 。
2. 在SQLiteOpenHelper子类中创build一个private方法。 此方法包含将数据库内容从“资产”文件夹中的数据库文件复制到应用程序包上下文中创build的数据库的逻辑。
3. 覆盖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: } } } 

最后，要获得数据库连接，只需调用getReadableDatabase()子类的getReadableDatabase()或getWritableDatabase() ，它将负责创build一个数据库，从“资产”文件夹中的指定文件复制数据库内容，如果数据库不存在。

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

Answer 6

从我看到你应该是运送已经有表格设置和数据的数据库。 但是，如果你想（并根据你有的应用程序types），你可以允许“升级数据库选项”。 Then what you do is download the latest sqlite version, get the latest Insert/Create statements of a textfile hosted online, execute the statements and do a data transfer from the old db to the new one.

Answer 7

Currently there is no way to precreate an SQLite database to ship with your apk. The best you can do is save the appropriate SQL as a resource and run them from your application. Yes, this leads to duplication of data (same information exists as a resrouce and as a database) but there is no other way right now. The only mitigating factor is the apk file is compressed. My experience is 908KB compresses to less than 268KB.

The thread below has the best discussion/solution I have found with good sample code.

http://groups.google.com/group/android-developers/msg/9f455ae93a1cf152

I stored my CREATE statement as a string resource to be read with Context.getString() and ran it with SQLiteDatabse.execSQL().

I stored the data for my inserts in res/raw/inserts.sql (I created the sql file, 7000+ lines). Using the technique from the link above I entered a loop, read the file line by line and concactenated the data onto "INSERT INTO tbl VALUE " and did another SQLiteDatabase.execSQL(). No sense in saving 7000 "INSERT INTO tbl VALUE "s when they can just be concactenated on.

It takes about twenty seconds on the emulator, I do not know how long this would take on a real phone, but it only happens once, when the user first starts the application.

Answer 8

Finally I did it!! I have used this link help Using your own SQLite database in Android applications , but had to change it a little bit.

1. If you have many packages you should put the master package name here:

   private static String DB_PATH = "data/data/masterPakageName/databases";

2. I changed the method which copies the database from local folder to emulator folder! It had some problem when that folder didn't exist. So first of all, it should check the path and if it's not there, it should create the folder.

3. In the previous code, the copyDatabase method was never called when the database didn't exist and the checkDataBase method caused exception. so I changed the code a little bit.

4. If your database does not have a file extension, don't use the file name with one.

it works nice for me , i hope it whould be usefull for u too

  package farhangsarasIntroduction; import java.io.File; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.util.ArrayList; import java.util.HashMap; import android.content.Context; import android.database.Cursor; import android.database.sqlite.SQLiteDatabase; import android.database.sqlite.SQLiteException; import android.database.sqlite.SQLiteOpenHelper; import android.util.Log; public class DataBaseHelper extends SQLiteOpenHelper{ //The Android's default system path of your application database. private static String DB_PATH = "data/data/com.example.sample/databases"; private static String DB_NAME = "farhangsaraDb"; 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() { boolean dbExist; try { dbExist = checkDataBase(); } catch (SQLiteException e) { e.printStackTrace(); throw new Error("database dose not exist"); } if(dbExist){ //do nothing - database already exist }else{ try { copyDataBase(); } catch (IOException e) { e.printStackTrace(); throw new Error("Error copying database"); } //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(); } } /** * 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. throw new Error("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{ //copyDataBase(); //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; File databaseFile = new File( DB_PATH); // check if databases folder exists, if not create one and its subfolders if (!databaseFile.exists()){ databaseFile.mkdir(); } //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(); } @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) { } you to create adapters for your views. } 

Answer 9

Shipping the database inside the apk and then copying it to /data/data/... will double the size of the database (1 in apk, 1 in data/data/... ), and will increase the apk size (of course). So your database should not be too big.

Answer 10

Android already provides a version-aware approach of database management. This approach has been leveraged in the BARACUS framework for Android applications.

It enables you to manage the database along the entire version lifecycle of an app, beeing able to update the sqlite database from any prior version to the current one.

Also, it allows you to run hot-backups and hot-recovery of the SQLite.

I am not 100% sure, but a hot-recovery for a specific device may enable you to ship a prepared database in your app. But I am not sure about the database binary format which might be specific to certain devices, vendors or device generations.

Since the stuff is Apache License 2, feel free to reuse any part of the code, which can be found on github

编辑：

If you only want to ship data, you might consider instantiating and persisting POJOs at the applications first start. BARACUS got a built-in support to this (Built-in key value store for configuration infos, eg "APP_FIRST_RUN" plus a after-context-bootstrap hook in order to run post-launch operations on the context). This enables you to have tight coupled data shipped with your app; in most cases this fitted to my use cases.

Answer 11

If the required data is not too large (limits I don´t know, would depend on a lot of things), you might also download the data (in XML, JSON, whatever) from a website/webapp. AFter receiving, execute the SQL statements using the received data creating your tables and inserting the data.

If your mobile app contains lots of data, it might be easier later on to update the data in the installed apps with more accurate data or changes.

Answer 12

I wrote a library to simplify this process.

 dataBase = new DataBase.Builder(context, "myDb"). // setAssetsPath(). // default "databases" // setDatabaseErrorHandler(). // setCursorFactory(). // setUpgradeCallback() // setVersion(). // default 1 build(); 

It will create a dataBase from assets/databases/myDb.db file. In addition you will get all those functionality:

• Load database from file
• Synchronized access to the database
• Using sqlite-android by requery, Android specific distribution of the latest versions of SQLite.

Clone it from github .

Answer 13

I'm using ORMLite and below code worked for me

 public class DatabaseProvider extends OrmLiteSqliteOpenHelper { private static final String DatabaseName = "DatabaseName"; private static final int DatabaseVersion = 1; private final Context ProvidedContext; public DatabaseProvider(Context context) { super(context, DatabaseName, null, DatabaseVersion); this.ProvidedContext= context; SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(context); boolean databaseCopied = preferences.getBoolean("DatabaseCopied", false); if (databaseCopied) { //Do Nothing } else { CopyDatabase(); SharedPreferences.Editor editor = preferences.edit(); editor.putBoolean("DatabaseCopied", true); editor.commit(); } } private String DatabasePath() { return "/data/data/" + ProvidedContext.getPackageName() + "/databases/"; } private void CopyDatabase() { try { CopyDatabaseInternal(); } catch (IOException e) { e.printStackTrace(); } } private File ExtractAssetsZip(String zipFileName) { InputStream inputStream; ZipInputStream zipInputStream; File tempFolder; do { tempFolder = null; tempFolder = new File(ProvidedContext.getCacheDir() + "/extracted-" + System.currentTimeMillis() + "/"); } while (tempFolder.exists()); tempFolder.mkdirs(); try { String filename; inputStream = ProvidedContext.getAssets().open(zipFileName); zipInputStream = new ZipInputStream(new BufferedInputStream(inputStream)); ZipEntry zipEntry; byte[] buffer = new byte[1024]; int count; while ((zipEntry = zipInputStream.getNextEntry()) != null) { filename = zipEntry.getName(); if (zipEntry.isDirectory()) { File fmd = new File(tempFolder.getAbsolutePath() + "/" + filename); fmd.mkdirs(); continue; } FileOutputStream fileOutputStream = new FileOutputStream(tempFolder.getAbsolutePath() + "/" + filename); while ((count = zipInputStream.read(buffer)) != -1) { fileOutputStream.write(buffer, 0, count); } fileOutputStream.close(); zipInputStream.closeEntry(); } zipInputStream.close(); } catch (IOException e) { e.printStackTrace(); return null; } return tempFolder; } private void CopyDatabaseInternal() throws IOException { File extractedPath = ExtractAssetsZip(DatabaseName + ".zip"); String databaseFile = ""; for (File innerFile : extractedPath.listFiles()) { databaseFile = innerFile.getAbsolutePath(); break; } if (databaseFile == null || databaseFile.length() ==0 ) throw new RuntimeException("databaseFile is empty"); InputStream inputStream = new FileInputStream(databaseFile); String outFileName = DatabasePath() + DatabaseName; File destinationPath = new File(DatabasePath()); if (!destinationPath.exists()) destinationPath.mkdirs(); File destinationFile = new File(outFileName); if (!destinationFile.exists()) destinationFile.createNewFile(); OutputStream myOutput = new FileOutputStream(outFileName); byte[] buffer = new byte[1024]; int length; while ((length = inputStream.read(buffer)) > 0) { myOutput.write(buffer, 0, length); } myOutput.flush(); myOutput.close(); inputStream.close(); } @Override public void onCreate(SQLiteDatabase sqLiteDatabase, ConnectionSource connectionSource) { } @Override public void onUpgrade(SQLiteDatabase sqLiteDatabase, ConnectionSource connectionSource, int fromVersion, int toVersion) { } } 

Please note, The code extracts database file from a zip file in assets

Answer 14

I modified the class and the answers to the question and wrote a class that allows updating the database via DB_VERSION.

 import android.content.Context; import android.database.SQLException; import android.database.sqlite.SQLiteDatabase; import android.database.sqlite.SQLiteOpenHelper; import java.io.File; 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 = "info.db"; private static String DB_PATH = ""; private static final int DB_VERSION = 1; private SQLiteDatabase mDataBase; private final Context mContext; private boolean mNeedUpdate = false; public DatabaseHelper(Context context) { super(context, DB_NAME, null, DB_VERSION); if (android.os.Build.VERSION.SDK_INT >= 17) DB_PATH = context.getApplicationInfo().dataDir + "/databases/"; else DB_PATH = "/data/data/" + context.getPackageName() + "/databases/"; this.mContext = context; copyDataBase(); this.getReadableDatabase(); } public void updateDataBase() throws IOException { if (mNeedUpdate) { File dbFile = new File(DB_PATH + DB_NAME); if (dbFile.exists()) dbFile.delete(); copyDataBase(); mNeedUpdate = false; } } private boolean checkDataBase() { File dbFile = new File(DB_PATH + DB_NAME); return dbFile.exists(); } private void copyDataBase() { if (!checkDataBase()) { this.getReadableDatabase(); this.close(); try { copyDBFile(); } catch (IOException mIOException) { throw new Error("ErrorCopyingDataBase"); } } } private void copyDBFile() throws IOException { InputStream mInput = mContext.getAssets().open(DB_NAME); //InputStream mInput = mContext.getResources().openRawResource(R.raw.info); OutputStream mOutput = new FileOutputStream(DB_PATH + DB_NAME); byte[] mBuffer = new byte[1024]; int mLength; while ((mLength = mInput.read(mBuffer)) > 0) mOutput.write(mBuffer, 0, mLength); mOutput.flush(); mOutput.close(); mInput.close(); } public boolean openDataBase() throws SQLException { mDataBase = SQLiteDatabase.openDatabase(DB_PATH + DB_NAME, null, SQLiteDatabase.CREATE_IF_NECESSARY); return mDataBase != null; } @Override public synchronized void close() { if (mDataBase != null) mDataBase.close(); super.close(); } @Override public void onCreate(SQLiteDatabase db) { } @Override public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { if (newVersion > oldVersion) mNeedUpdate = true; } } 

Using a class.

In the activity class, declare variables.

 private DatabaseHelper mDBHelper; private SQLiteDatabase mDb; 

In the onCreate method, write the following code.

 mDBHelper = new DatabaseHelper(this); try { mDBHelper.updateDataBase(); } catch (IOException mIOException) { throw new Error("UnableToUpdateDatabase"); } try { mDb = mDBHelper.getWritableDatabase(); } catch (SQLException mSQLException) { throw mSQLException; } 

If you add a database file to the folder res/raw then use the following modification of the class.

 import android.content.Context; import android.database.SQLException; import android.database.sqlite.SQLiteDatabase; import android.database.sqlite.SQLiteOpenHelper; import java.io.File; 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 = "info.db"; private static String DB_PATH = ""; private static final int DB_VERSION = 1; private SQLiteDatabase mDataBase; private final Context mContext; private boolean mNeedUpdate = false; public DatabaseHelper(Context context) { super(context, DB_NAME, null, DB_VERSION); if (android.os.Build.VERSION.SDK_INT >= 17) DB_PATH = context.getApplicationInfo().dataDir + "/databases/"; else DB_PATH = "/data/data/" + context.getPackageName() + "/databases/"; this.mContext = context; copyDataBase(); this.getReadableDatabase(); } public void updateDataBase() throws IOException { if (mNeedUpdate) { File dbFile = new File(DB_PATH + DB_NAME); if (dbFile.exists()) dbFile.delete(); copyDataBase(); mNeedUpdate = false; } } private boolean checkDataBase() { File dbFile = new File(DB_PATH + DB_NAME); return dbFile.exists(); } private void copyDataBase() { if (!checkDataBase()) { this.getReadableDatabase(); this.close(); try { copyDBFile(); } catch (IOException mIOException) { throw new Error("ErrorCopyingDataBase"); } } } private void copyDBFile() throws IOException { //InputStream mInput = mContext.getAssets().open(DB_NAME); InputStream mInput = mContext.getResources().openRawResource(R.raw.info); OutputStream mOutput = new FileOutputStream(DB_PATH + DB_NAME); byte[] mBuffer = new byte[1024]; int mLength; while ((mLength = mInput.read(mBuffer)) > 0) mOutput.write(mBuffer, 0, mLength); mOutput.flush(); mOutput.close(); mInput.close(); } public boolean openDataBase() throws SQLException { mDataBase = SQLiteDatabase.openDatabase(DB_PATH + DB_NAME, null, SQLiteDatabase.CREATE_IF_NECESSARY); return mDataBase != null; } @Override public synchronized void close() { if (mDataBase != null) mDataBase.close(); super.close(); } @Override public void onCreate(SQLiteDatabase db) { } @Override public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { if (newVersion > oldVersion) mNeedUpdate = true; } } 

http://blog.harrix.org/article/6784

Answer 15

Shipping the app with a database file, in Android Studio 3.0

Shipping the app with a database file is a good idea for me. The advantage is that you don't need to do a complex initialization, which sometimes costs lots of time, if your data set is huge.

Step 1: Prepare database file

Have your database file ready. It can be either a .db file or a .sqlite file. If you use a .sqlite file, all you need to do is to change file extension names. The steps are the same.

In this example, I prepared a file called testDB.db. It has one table and some sample data in it like this

Step 2: Import the file into your project

Create the assets folder if you haven't had one. Then copy and paste the database file into this folder

Step 3: Copy the file to the app's data folder

You need to copy the database file to the app's data folder in order to do further interaction with it. This is a one time action (initialization) to copy the database file. If you call this code multiple times, the database file in data folder will be overwritten by the one in assets folder. This overwrite process is useful when you want to update the database in future during the app update.

Note that during app update, this database file will not be changed in the app's data folder. Only uninstall will delete it.

The database file needs to be copied to /databases folder. Open Device File Explorer. Enter data/data/<YourAppName>/ location. This is the app's default data folder mentioned above. And by default, the database file will be place in another folder called databases under this directory

Now, the copy file process is pretty much like the what Java is doing. Use the following code to do the copy paste. This is the initiation code. It can also be used to update(by overwriting) the database file in future.

 //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 } 

Then refresh the folder to verify the copy process

Step 4: Create database open helper

Create a subclass for SQLiteOpenHelper , with connect, close, path, etc. I named it 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) { } } 

Step 5: Create top level class to interact with the database

This will be the class that read & write your database file. Also there is a sample query to print out the value in the database.

 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 } } } 

Step 6: Test running

Test the code by running the following lines of codes.

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

Hit the run button and cheer!