如何在Android应用程序中使用现有的数据库

这个问题在这里已经有了答案:

  • 用数据库发送应用程序16个答案

  • 注意:在尝试此代码之前,请在以下代码中找到此行:

    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
        //destination path (location) of our database on device
        private static String DB_PATH = "";
        private static String DB_NAME ="YourDbName";// Database name
        private SQLiteDatabase mDataBase;
        private final Context mContext;
    
        public DataBaseHelper(Context context)
        {
            super(context, DB_NAME, null, 1);// 1? Its database 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;
        }
    
        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 exists here: /data/data/your package/databases/Da Name
        private boolean checkDataBase()
        {
            File dbFile = new File(DB_PATH + DB_NAME);
            //Log.v("dbFile", dbFile + "   "+ dbFile.exists());
            return dbFile.exists();
        }
    
        //Copy the database from assets
        private void copyDataBase() throws IOException
        {
            InputStream mInput = mContext.getAssets().open(DB_NAME);
            String outFileName = DB_PATH + DB_NAME;
            OutputStream mOutput = new FileOutputStream(outFileName);
            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
        {
            String mPath = DB_PATH + DB_NAME;
            //Log.v("mPath", mPath);
            mDataBase = SQLiteDatabase.openDatabase(mPath, null, SQLiteDatabase.CREATE_IF_NECESSARY);
            //mDataBase = SQLiteDatabase.openDatabase(mPath, 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

    对于Android 4.1(果冻豆),更改:

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

    至:

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

    在DataHelper类中,此代码将在JB 4.2多用户上运行。


    试用在Android应用程序中使用自己的SQLite数据库。


    如果您预先构建了数据库而不是将其复制到资产文件夹中,并创建一个新类作为实现SQLiteOpenHelper的 DataBaseHelper而不是使用以下代码:

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

    希望对你有帮助...

    链接地址: http://www.djcxy.com/p/74571.html

    上一篇: How to use an existing database with an Android application

    下一篇: Debugging using PDB and source files in Symbol package