如何使用现有的数据库与一个Android应用程序

我已经创建了一个SQLite数据库。我想使用这个数据库文件与我的Android项目。我想将这个数据库与我的应用程序捆绑在一起。

而不是创建一个新的数据库，应用程序如何访问这个数据库并将其用作自己的数据库呢?

223631 次浏览
小开

你可以使用内容提供者来做到这一点。应用程序中使用的每个数据项对应用程序来说都是私有的。如果应用程序希望跨应用程序共享数据，只有一种技术可以实现这一点，即使用内容提供程序，内容提供程序提供访问私有数据的接口。

小开

如果您已经拥有一个数据库，请将其保存在资产文件夹中，并将其复制到应用程序中。更多细节，参见Android数据库基础。

小开
最佳答案

<强>注意: 在尝试这段代码之前，请在下面的代码中找到这一行:

private static String DB_NAME ="YourDbName"; // Database name

DB_NAME是数据库的名称。假设您在assets文件夹中有一个数据库副本，例如，如果您的数据库名称是ordersDB，那么DB_NAME的值将是ordersDB，

private static String DB_NAME ="ordersDB";

将数据库保存在资产的文件夹中，然后执行以下操作:

DataHelper类:

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;


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


public class DataBaseHelper extends SQLiteOpenHelper {


private static String TAG = "DataBaseHelper"; // Tag just for the LogCat window
private static String DB_NAME ="YourDbName"; // Database name
private static int DB_VERSION = 1; // Database version
private final File DB_FILE;
private SQLiteDatabase mDataBase;
private final Context mContext;


public DataBaseHelper(Context context) {
super(context, DB_NAME, null, DB_VERSION);
DB_FILE = context.getDatabasePath(DB_NAME);
this.mContext = context;
}


public void createDataBase() throws IOException {
// If the database does not exist, copy it from the assets.
boolean mDataBaseExist = checkDataBase();
if(!mDataBaseExist) {
this.getReadableDatabase();
this.close();
try {
// Copy the database from assests
copyDataBase();
Log.e(TAG, "createDatabase database created");
} catch (IOException mIOException) {
throw new Error("ErrorCopyingDataBase");
}
}
}


// Check that the database file exists in databases folder
private boolean checkDataBase() {
return DB_FILE.exists();
}


// Copy the database from assets
private void copyDataBase() throws IOException {
InputStream mInput = mContext.getAssets().open(DB_NAME);
OutputStream mOutput = new FileOutputStream(DB_FILE);
byte[] mBuffer = new byte[1024];
int mLength;
while ((mLength = mInput.read(mBuffer)) > 0) {
mOutput.write(mBuffer, 0, mLength);
}
mOutput.flush();
mOutput.close();
mInput.close();
}


// Open the database, so we can query it
public boolean openDataBase() throws SQLException {
// Log.v("DB_PATH", DB_FILE.getAbsolutePath());
mDataBase = SQLiteDatabase.openDatabase(DB_FILE, null, SQLiteDatabase.CREATE_IF_NECESSARY);
// mDataBase = SQLiteDatabase.openDatabase(DB_FILE, null, SQLiteDatabase.NO_LOCALIZED_COLLATORS);
return mDataBase != null;
}


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


}

编写DataAdapter类，如下所示:

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


public class TestAdapter {


protected static final String TAG = "DataAdapter";


private final Context mContext;
private SQLiteDatabase mDb;
private DataBaseHelper mDbHelper;


public TestAdapter(Context context) {
this.mContext = context;
mDbHelper = new DataBaseHelper(mContext);
}


public TestAdapter createDatabase() throws SQLException {
try {
mDbHelper.createDataBase();
} catch (IOException mIOException) {
Log.e(TAG, mIOException.toString() + "  UnableToCreateDatabase");
throw new Error("UnableToCreateDatabase");
}
return this;
}


public TestAdapter open() throws SQLException {
try {
mDbHelper.openDataBase();
mDbHelper.close();
mDb = mDbHelper.getReadableDatabase();
} catch (SQLException mSQLException) {
Log.e(TAG, "open >>"+ mSQLException.toString());
throw mSQLException;
}
return this;
}


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


public Cursor getTestData() {
try {
String sql ="SELECT * FROM myTable";
Cursor mCur = mDb.rawQuery(sql, null);
if (mCur != null) {
mCur.moveToNext();
}
return mCur;
} catch (SQLException mSQLException) {
Log.e(TAG, "getTestData >>"+ mSQLException.toString());
throw mSQLException;
}
}
}

现在你可以这样使用它:

TestAdapter mDbHelper = new TestAdapter(urContext);
mDbHelper.createDatabase();
mDbHelper.open();


Cursor testdata = mDbHelper.getTestData();


mDbHelper.close();

编辑:感谢JDx

对于4.1 Android  (Jelly Bean)，更改:

DB_PATH = "/data/data/" + context.getPackageName() + "/databases/";

:

DB_PATH = context.getApplicationInfo().dataDir + "/databases/";

在DataHelper类中，此代码将在Jelly Bean 4.2多用户上工作。

编辑:不使用硬编码路径，我们可以使用

DB_PATH = context.getDatabasePath(DB_NAME).getAbsolutePath();

这将为我们提供数据库文件的完整路径，并适用于所有Android版本

小开

关于这个问题，我与其他DatabaseHelpers有麻烦，不知道为什么 这对我来说是有效的:

import java.io.File;
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;
import android.util.Log;


public class DatabaseHelper extends SQLiteOpenHelper {


private static final String TAG = DatabaseHelper.class.getSimpleName();


private final Context context;
private final String assetPath;
private final String dbPath;


public DatabaseHelper(Context context, String dbName, String assetPath)
throws IOException {
super(context, dbName, null, 1);
this.context = context;
this.assetPath = assetPath;
this.dbPath = "/data/data/"
+ context.getApplicationContext().getPackageName() + "/databases/"
+ dbName;
checkExists();
}


/**
* Checks if the database asset needs to be copied and if so copies it to the
* default location.
*
* @throws IOException
*/
private void checkExists() throws IOException {
Log.i(TAG, "checkExists()");


File dbFile = new File(dbPath);


if (!dbFile.exists()) {


Log.i(TAG, "creating database..");


dbFile.getParentFile().mkdirs();
copyStream(context.getAssets().open(assetPath), new FileOutputStream(
dbFile));


Log.i(TAG, assetPath + " has been copied to " + dbFile.getAbsolutePath());
}


}


private void copyStream(InputStream is, OutputStream os) throws IOException {
byte buf[] = new byte[1024];
int c = 0;
while (true) {
c = is.read(buf);
if (c == -1)
break;
os.write(buf, 0, c);
}
is.close();
os.close();
}


@Override
public void onCreate(SQLiteDatabase db) {
}


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

如果你有预构建的数据库，那么将其复制到资产文件夹中，并创建一个新类DataBaseHelper，实现SQLiteOpenHelper 请使用以下代码:

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;


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


public class DataBaseHelperClass extends SQLiteOpenHelper{
//The Android's default system path of your application database.
private static String DB_PATH = "/data/data/package_name/databases/";
// Data Base Name.
private static final String DATABASE_NAME = "DBName.sqlite";
// Data Base Version.
private static final int DATABASE_VERSION = 1;
// Table Names of Data Base.
static final String TABLE_Name = "tableName";


public Context context;
static SQLiteDatabase sqliteDataBase;


/**
* Constructor
* Takes and keeps a reference of the passed context in order to access to the application assets and resources.
* @param context
* Parameters of super() are    1. Context
*                              2. Data Base Name.
*                              3. Cursor Factory.
*                              4. Data Base Version.
*/
public DataBaseHelperClass(Context context) {
super(context, DATABASE_NAME, null ,DATABASE_VERSION);
this.context = context;
}


/**
* Creates a empty database on the system and rewrites it with your own 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.
* */
public void createDataBase() throws IOException{
//check if the database exists
boolean databaseExist = checkDataBase();


if(databaseExist){
// Do Nothing.
}else{
this.getWritableDatabase();
copyDataBase();
}// end if else dbExist
} // end createDataBase().


/**
* 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
*/
public boolean checkDataBase(){
File databaseFile = new File(DB_PATH + DATABASE_NAME);
return databaseFile.exists();
}


/**
* 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 transferring byte stream.
* */
private void copyDataBase() throws IOException{
//Open your local db as the input stream
InputStream myInput = context.getAssets().open(DATABASE_NAME);
// Path to the just created empty db
String outFileName = DB_PATH + DATABASE_NAME;
//Open the empty db as the output stream
OutputStream myOutput = new FileOutputStream(outFileName);
//transfer bytes from the input file to the output file
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();
}


/**
* This method opens the data base connection.
* First it create the path up till data base of the device.
* Then create connection with data base.
*/
public void openDataBase() throws SQLException{
//Open the database
String myPath = DB_PATH + DATABASE_NAME;
sqliteDataBase = SQLiteDatabase.openDatabase(myPath, null, SQLiteDatabase.OPEN_READWRITE);
}


/**
* This Method is used to close the data base connection.
*/
@Override
public synchronized void close() {
if(sqliteDataBase != null)
sqliteDataBase.close();
super.close();
}


/**
* Apply your methods and class to fetch data using raw or queries on data base using
* following demo example code as:
*/
public String getUserNameFromDB(){
String query = "select User_First_Name From "+TABLE_USER_DETAILS;
Cursor cursor = sqliteDataBase.rawQuery(query, null);
String userName = null;
if(cursor.getCount()>0){
if(cursor.moveToFirst()){
do{
userName = cursor.getString(0);
}while (cursor.moveToNext());
}
}
return userName;
}




@Override
public void onCreate(SQLiteDatabase db) {
// No need to write the create table query.
// As we are using Pre built data base.
// Which is ReadOnly.
}


@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
// No need to write the update table query.
// As we are using Pre built data base.
// Which is ReadOnly.
// We should not update it as requirements of application.
}
}

希望这对你有所帮助……


提交答案