Was sind die besten Vorgehensweisen für SQLite unter Android?

Inserts, updates, deletes und reads sind in der Regel OK, die von mehreren threads, aber Brad Antwort ist nicht korrekt. Sie müssen vorsichtig sein mit, wie man erstellen Sie Ihre verbindungen, und verwenden Sie Sie. Es gibt Situationen, in denen Sie Ihre update-Aufrufe fehl, auch wenn sich Ihre Datenbank nicht beschädigt werden.

Die grundsätzliche Antwort.

Den SqliteOpenHelper-Objekt hält eine Datenbank-Verbindung. Es erscheint zu bieten Ihnen einen Lesen und schreiben-Verbindung, aber es ist wirklich nicht. Rufen Sie die read-only, und Sie erhalten die schreiben der Datenbank-Verbindung unabhängig.

So, ein Helfer Beispiel, eine db-Verbindung. Sogar, wenn Sie die Verwendung von mehreren threads, eine Verbindung gleichzeitig. Die SqliteDatabase-Objekt verwendet die java-locks halten den Zugriff serialisiert. Also, wenn 100 threads haben eine db-Instanz, ruft die eigentliche on-disk-Datenbank serialisiert werden.

So, ein Helfer, eine db-Verbindung, die serialisiert in java-code. Ein thread, der 1000 threads, wenn Sie einen Helfer Instanz zwischen Ihnen geteilt, die alle Ihre db-Zugriffs-code ist die Seriennummer. Und das Leben ist gut (ish).

Wenn Sie versuchen, auf die Datenbank schreiben vom tatsächlichen verschiedene verbindungen zur gleichen Zeit, wird man scheitern. Es wird nicht warten, bis das erste fertig ist und dann schreiben. Es wird einfach nicht schreiben Sie Ihre änderung. Schlimmer noch, wenn Sie rufen Sie nicht die richtige version von insert - /update-auf der SQLiteDatabase, werden Sie nicht bekommen eine Ausnahme. Sie erhalten nur eine Nachricht in deinem LogCat, und das wird es sein.

Also mehrere threads? Verwenden Sie einen Helfer. Zeitraum. Wenn Sie WISSEN, dass nur ein thread zu schreiben, KÖNNEN Sie in der Lage sein, mehrere verbindungen und Ihre liest wird schneller sein, aber Käufer Vorsicht. Habe ich noch nicht getestet viel.

Hier ist ein blog-post mit weit mehr detail und eine Beispiel-app.

• Android Sqlite-Verriegelung (Aktualisiert link 6/18/2012)
• Android-Datenbank-Locking-Kollisionen-Beispielsweise durch touchlab auf GitHub

Grau und ich sind eigentlich die Nachbereitung ein ORM-tool, basierend auf seiner Ormlite, das funktioniert nativ mit Android-Datenbank-Implementierungen, und folgt den sicheren Aufbau/Aufruf-Struktur, die ich beschreibe in dem blog-post. Das sollte sich sehr bald. Werfen Sie einen Blick.

In der Zwischenzeit gibt es eine follow-up-blog-post:

• Einzelne SQLite-Verbindung

Auch Kasse die Gabel durch 2point0 der zuvor erwähnten sperren Beispiel:

• Android-Datenbank-Locking-Kollisionen-Beispielsweise durch 2point0 auf GitHub

InformationsquelleAutor der Antwort Kevin Galligan

• Verwenden Thread oder AsyncTask für lang laufende Operationen (50ms+). Testen Sie Ihre app, um zu sehen, wo das ist. Die meisten Operationen (wahrscheinlich) nicht erfordern ein thread, da die meisten Operationen (wahrscheinlich), bei denen nur ein paar Zeilen. Verwenden Sie einen thread für bulk-Operationen.
• Teilen sich eine SQLiteDatabase - Instanz für jede DB auf der Festplatte zwischen threads und implementieren ein zählen-system zum nachverfolgen von offenen verbindungen.

Gibt es bewährte Verfahren für diese Szenarios?

Teilen sich ein statisches Feld zwischen allen Klassen. Ich verwendet, um ein singleton, um für diese und andere Dinge, die müssen geteilt werden. Ein zählen-System (in der Regel mit AtomicInteger) sollte auch verwendet werden, um sicherzustellen, dass Sie nie schließen Sie die Datenbank, früh-oder lassen Sie es offen.

Meine Lösung:

Die aktuelle version finden Sie unter https://github.com/JakarCo/databasemanager aber ich werde versuchen, halten Sie den code aktuell auch hier. Wenn man verstehen will, meine Lösung ist, schauen Sie auf den code, und Lesen Sie meine Notizen. Meine Noten sind in der Regel sehr hilfreich.

1. copy/paste den code in eine neue Datei mit dem Namen DatabaseManager. (oder laden Sie es aus dem github)
2. erweitern DatabaseManager und implementieren onCreate und onUpgrade wie Sie es normalerweise tun würden. Sie können mehrere Unterklassen der eine DatabaseManager Klasse, um unterschiedliche Datenbanken auf der Festplatte.
3. Die Unterklasse zu instanziieren, und rufen Sie getDb() zu verwenden, die SQLiteDatabase Klasse.
4. Nennen close() für jede Unterklasse instanziiert

Den code kopieren/einfügen:

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

import java.util.concurrent.ConcurrentHashMap;

/** Extend this class and use it as an SQLiteOpenHelper class
 *
 * DO NOT distribute, sell, or present this code as your own. 
 * for any distributing/selling, or whatever, see the info at the link below
 *
 * Distribution, attribution, legal stuff,
 * See https://github.com/JakarCo/databasemanager
 * 
 * If you ever need help with this code, contact me at [email protected] (or [email protected] )
 * 
 * Do not sell this. but use it as much as you want. There are no implied or express warranties with this code. 
 *
 * This is a simple database manager class which makes threading/synchronization super easy.
 *
 * Extend this class and use it like an SQLiteOpenHelper, but use it as follows:
 *  Instantiate this class once in each thread that uses the database. 
 *  Make sure to call {@link #close()} on every opened instance of this class
 *  If it is closed, then call {@link #open()} before using again.
 * 
 * Call {@link #getDb()} to get an instance of the underlying SQLiteDatabse class (which is synchronized)
 *
 * I also implement this system (well, it's very similar) in my <a href="http://androidslitelibrary.com">Android SQLite Libray</a> at http://androidslitelibrary.com
 * 
 *
 */
abstract public class DatabaseManager {

    /**See SQLiteOpenHelper documentation
    */
    abstract public void onCreate(SQLiteDatabase db);
    /**See SQLiteOpenHelper documentation
     */
    abstract public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion);
    /**Optional.
     * *
     */
    public void onOpen(SQLiteDatabase db){}
    /**Optional.
     * 
     */
    public void onDowngrade(SQLiteDatabase db, int oldVersion, int newVersion) {}
    /**Optional
     * 
     */
    public void onConfigure(SQLiteDatabase db){}



    /** The SQLiteOpenHelper class is not actually used by your application.
     *
     */
    static private class DBSQLiteOpenHelper extends SQLiteOpenHelper {

        DatabaseManager databaseManager;
        private AtomicInteger counter = new AtomicInteger(0);

        public DBSQLiteOpenHelper(Context context, String name, int version, DatabaseManager databaseManager) {
            super(context, name, null, version);
            this.databaseManager = databaseManager;
        }

        public void addConnection(){
            counter.incrementAndGet();
        }
        public void removeConnection(){
            counter.decrementAndGet();
        }
        public int getCounter() {
            return counter.get();
        }
        @Override
        public void onCreate(SQLiteDatabase db) {
            databaseManager.onCreate(db);
        }

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

        @Override
        public void onOpen(SQLiteDatabase db) {
            databaseManager.onOpen(db);
        }

        @Override
        public void onDowngrade(SQLiteDatabase db, int oldVersion, int newVersion) {
            databaseManager.onDowngrade(db, oldVersion, newVersion);
        }

        @Override
        public void onConfigure(SQLiteDatabase db) {
            databaseManager.onConfigure(db);
        }
    }

    private static final ConcurrentHashMap<String,DBSQLiteOpenHelper> dbMap = new ConcurrentHashMap<String, DBSQLiteOpenHelper>();

    private static final Object lockObject = new Object();


    private DBSQLiteOpenHelper sqLiteOpenHelper;
    private SQLiteDatabase db;
    private Context context;

    /** Instantiate a new DB Helper. 
     * <br> SQLiteOpenHelpers are statically cached so they (and their internally cached SQLiteDatabases) will be reused for concurrency
     *
     * @param context Any {@link android.content.Context} belonging to your package.
     * @param name The database name. This may be anything you like. Adding a file extension is not required and any file extension you would like to use is fine.
     * @param version the database version.
     */
    public DatabaseManager(Context context, String name, int version) {
        String dbPath = context.getApplicationContext().getDatabasePath(name).getAbsolutePath();
        synchronized (lockObject) {
            sqLiteOpenHelper = dbMap.get(dbPath);
            if (sqLiteOpenHelper==null) {
                sqLiteOpenHelper = new DBSQLiteOpenHelper(context, name, version, this);
                dbMap.put(dbPath,sqLiteOpenHelper);
            }
            //SQLiteOpenHelper class caches the SQLiteDatabase, so this will be the same SQLiteDatabase object every time
            db = sqLiteOpenHelper.getWritableDatabase();
        }
        this.context = context.getApplicationContext();
    }
    /**Get the writable SQLiteDatabase
     */
    public SQLiteDatabase getDb(){
        return db;
    }

    /** Check if the underlying SQLiteDatabase is open
     *
     * @return whether the DB is open or not
     */
    public boolean isOpen(){
        return (db!=null&&db.isOpen());
    }


    /** Lowers the DB counter by 1 for any {@link DatabaseManager}s referencing the same DB on disk
     *  <br />If the new counter is 0, then the database will be closed.
     *  <br /><br />This needs to be called before application exit.
     * <br />If the counter is 0, then the underlying SQLiteDatabase is <b>null</b> until another DatabaseManager is instantiated or you call {@link #open()}
     *
     * @return true if the underlying {@link android.database.sqlite.SQLiteDatabase} is closed (counter is 0), and false otherwise (counter > 0)
     */
    public boolean close(){
        sqLiteOpenHelper.removeConnection();
        if (sqLiteOpenHelper.getCounter()==0){
            synchronized (lockObject){
                if (db.inTransaction())db.endTransaction();
                if (db.isOpen())db.close();
                db = null;
            }
            return true;
        }
        return false;
    }
    /** Increments the internal db counter by one and opens the db if needed
    *
    */
    public void open(){
        sqLiteOpenHelper.addConnection();
        if (db==null||!db.isOpen()){
                synchronized (lockObject){
                    db = sqLiteOpenHelper.getWritableDatabase();
                }
        } 
    }
}

InformationsquelleAutor der Antwort Jakar

Dmytro Antwort funktioniert gut für meinen Fall.
Ich denke, es ist besser zu erklären, die Funktion als synchronisiert. zumindest für meinen Fall, es würde invoke null-Zeiger-Ausnahme anderweitig, z.B. getWritableDatabase noch nicht wieder in einem thread, und openDatabse genannt in einem anderen thread Zwischenzeit.

public synchronized SQLiteDatabase openDatabase() {
        if(mOpenCounter.incrementAndGet() == 1) {
            // Opening new database
            mDatabase = mDatabaseHelper.getWritableDatabase();
        }
        return mDatabase;
    }

InformationsquelleAutor der Antwort gonglong

nach kämpfen mit diesem für ein paar Stunden, die ich gefunden habe, dass Sie nur verwenden Sie eine db-helper-Objekt pro db-Ausführung. Zum Beispiel,

for(int x = 0; x < someMaxValue; x++)
{
    db = new DBAdapter(this);
    try
    {

        db.addRow
        (
                NamesStringArray[i].toString(), 
                StartTimeStringArray[i].toString(),
                EndTimeStringArray[i].toString()
        );

    }
    catch (Exception e)
    {
        Log.e("Add Error", e.toString());
        e.printStackTrace();
    }
    db.close();
}

als adaptiert:

db = new DBAdapter(this);
for(int x = 0; x < someMaxValue; x++)
{

    try
    {
        // ask the database manager to add a row given the two strings
        db.addRow
        (
                NamesStringArray[i].toString(), 
                StartTimeStringArray[i].toString(),
                EndTimeStringArray[i].toString()
        );

    }
    catch (Exception e)
    {
        Log.e("Add Error", e.toString());
        e.printStackTrace();
    }

}
db.close();

erstellen einer neuen DBAdapter jedes mal, wenn die Schleife iteriert war der einzige Weg, ich könnte meine strings in eine Datenbank durch meine helper Klasse.

InformationsquelleAutor der Antwort dell116

Können Sie versuchen, für die Anwendung der neuen Architektur-Ansatz angekündigt bei Google I/O-2017.

Es enthält auch neue ORM-Bibliothek namens Zimmer

Er enthält drei Komponenten: @Entity, @Dao und @Database

User.java

@Entity
public class User {
  @PrimaryKey
  private int uid;

  @ColumnInfo(name = "first_name")
  private String firstName;

  @ColumnInfo(name = "last_name")
  private String lastName;

  // Getters and setters are ignored for brevity,
  // but they're required for Room to work.
}

UserDao.java

@Dao
public interface UserDao {
  @Query("SELECT * FROM user")
  List<User> getAll();

  @Query("SELECT * FROM user WHERE uid IN (:userIds)")
  List<User> loadAllByIds(int[] userIds);

  @Query("SELECT * FROM user WHERE first_name LIKE :first AND "
       + "last_name LIKE :last LIMIT 1")
  User findByName(String first, String last);

  @Insert
  void insertAll(User... users);

  @Delete
  void delete(User user);
}

AppDatabase.java

@Database(entities = {User.class}, version = 1)
public abstract class AppDatabase extends RoomDatabase {
  public abstract UserDao userDao();
}

InformationsquelleAutor der Antwort Zimbo Rodger