Android
GreenDAO

Einführung

Hilfsmethoden für SELECT-, INSERT-, DELETE-, UPDATE-Abfragen

Dieses Beispiel zeigt eine Hilfsklasse, die nützliche Methoden beim Ausführen der Datenabfragen enthält. Jede Methode hier verwendet Java Generic's, um sehr flexibel zu sein.

public <T> List<T> selectElements(AbstractDao<T, ?> dao) {
    if (dao == null) {
        return null;
    }
    QueryBuilder<T> qb = dao.queryBuilder();
    return qb.list();
}

public <T> void insertElements(AbstractDao<T, ?> absDao, List<T> items) {
    if (items == null || items.size() == 0 || absDao == null) {
        return;
    }
    absDao.insertOrReplaceInTx(items);
}

public <T> T insertElement(AbstractDao<T, ?> absDao, T item) {
    if (item == null || absDao == null) {
        return null;
    }
    absDao.insertOrReplaceInTx(item);
    return item;
}

public <T> void updateElements(AbstractDao<T, ?> absDao, List<T> items) {
    if (items == null || items.size() == 0 || absDao == null) {
        return;
    }
    absDao.updateInTx(items);
}

public <T> T selectElementByCondition(AbstractDao<T, ?> absDao,
                                      WhereCondition... conditions) {
    if (absDao == null) {
        return null;
    }
    QueryBuilder<T> qb = absDao.queryBuilder();
    for (WhereCondition condition : conditions) {
        qb = qb.where(condition);
    }
    List<T> items = qb.list();
    return items != null && items.size() > 0 ? items.get(0) : null;
}

public <T> List<T> selectElementsByCondition(AbstractDao<T, ?> absDao,
                                             WhereCondition... conditions) {
    if (absDao == null) {
        return null;
    }
    QueryBuilder<T> qb = absDao.queryBuilder();
    for (WhereCondition condition : conditions) {
        qb = qb.where(condition);
    }
    List<T> items = qb.list();
    return items != null ? items : null;
}

public <T> List<T> selectElementsByConditionAndSort(AbstractDao<T, ?> absDao,
                                                    Property sortProperty,
                                                    String sortStrategy,
                                                    WhereCondition... conditions) {
    if (absDao == null) {
        return null;
    }
    QueryBuilder<T> qb = absDao.queryBuilder();
    for (WhereCondition condition : conditions) {
        qb = qb.where(condition);
    }
    qb.orderCustom(sortProperty, sortStrategy);
    List<T> items = qb.list();
    return items != null ? items : null;
}

public <T> List<T> selectElementsByConditionAndSortWithNullHandling(AbstractDao<T, ?> absDao,
                                                                    Property sortProperty,
                                                                    boolean handleNulls,
                                                                    String sortStrategy,
                                                                    WhereCondition... conditions) {
    if (!handleNulls) {
        return selectElementsByConditionAndSort(absDao, sortProperty, sortStrategy, conditions);
    }
    if (absDao == null) {
        return null;
    }
    QueryBuilder<T> qb = absDao.queryBuilder();
    for (WhereCondition condition : conditions) {
        qb = qb.where(condition);
    }
    qb.orderRaw("(CASE WHEN " + "T." + sortProperty.columnName + " IS NULL then 1 ELSE 0 END)," + "T." + sortProperty.columnName + " " + sortStrategy);
    List<T> items = qb.list();
    return items != null ? items : null;
}

public <T, V extends Class> List<T> selectByJoin(AbstractDao<T, ?> absDao,
                                                 V className,
                                                 Property property, WhereCondition whereCondition) {
    QueryBuilder<T> qb = absDao.queryBuilder();
    qb.join(className, property).where(whereCondition);
    return qb.list();
}

public <T> void deleteElementsByCondition(AbstractDao<T, ?> absDao,
                                          WhereCondition... conditions) {
    if (absDao == null) {
        return;
    }
    QueryBuilder<T> qb = absDao.queryBuilder();
    for (WhereCondition condition : conditions) {
        qb = qb.where(condition);
    }
    List<T> list = qb.list();
    absDao.deleteInTx(list);
}

public <T> T deleteElement(DaoSession session, AbstractDao<T, ?> absDao, T object) {
    if (absDao == null) {
        return null;
    }
    absDao.delete(object);
    session.clear();
    return object;
}

public <T, V extends Class> void deleteByJoin(AbstractDao<T, ?> absDao,
                                              V className,
                                              Property property, WhereCondition whereCondition) {
    QueryBuilder<T> qb = absDao.queryBuilder();
    qb.join(className, property).where(whereCondition);
    qb.buildDelete().executeDeleteWithoutDetachingEntities();
}

public <T> void deleteAllFromTable(AbstractDao<T, ?> absDao) {
    if (absDao == null) {
        return;
    }
    absDao.deleteAll();
}

public <T> long countElements(AbstractDao<T, ?> absDao) {
    if (absDao == null) {
        return 0;
    }
    return absDao.count();
}

Erstellen einer Entität mit GreenDAO 3.X, die einen zusammengesetzten Primärschlüssel enthält

Wenn Sie ein Modell für eine Tabelle erstellen, die einen zusammengesetzten Primärschlüssel enthält, ist für das Objekt Entity zusätzliche Arbeit erforderlich, damit die Entität des Modells diese Einschränkungen erfüllt.

Das folgende Beispiel für eine SQL-Tabelle und Entity veranschaulicht die Struktur zum Speichern einer Überprüfung, die ein Kunde für einen Artikel in einem Online-Shop hinterlassen hat. In diesem Beispiel möchten wir, dass die Spalten customer_id und item_id ein zusammengesetzter Primärschlüssel sind, der nur eine Überprüfung zwischen einem bestimmten Kunden und einem Artikel item_id .

SQL-Tabelle

CREATE TABLE review (
    customer_id STRING NOT NULL,
    item_id STRING NOT NULL,
    star_rating INTEGER NOT NULL,
    content STRING,
    PRIMARY KEY (customer_id, item_id)
);

Normalerweise würden wir die Annotationen @Id und @Unique über den jeweiligen Feldern in der Entitätsklasse verwenden. Für einen zusammengesetzten Primärschlüssel machen wir jedoch Folgendes:

1. Fügen Sie die @Index Annotation in die @Entity @Index Annotation auf Klassenebene ein. Die value-Eigenschaft enthält eine durch Kommas getrennte Liste der Felder, aus denen der Schlüssel besteht. Verwenden Sie die angegebene unique Eigenschaft, um die Eindeutigkeit des Schlüssels zu erzwingen.

2. GreenDAO erfordert jede Entität einen hat long oder Long Objekt als Primärschlüssel. Wir müssen dies immer noch zur Entity-Klasse hinzufügen, wir müssen es jedoch nicht verwenden oder sich keine Sorgen darüber machen, dass dies Auswirkungen auf unsere Implementierung hat. Im Beispiel unten heißt es localID

Entität

@Entity(indexes = { @Index(value = "customer_id,item_id", unique = true)})
public class Review {

    @Id(autoincrement = true)
    private Long localID;

    private String customer_id;
    private String item_id;

    @NotNull
    private Integer star_rating;

    private String content;

    public Review() {}
}

Erste Schritte mit GreenDao v3.X

Nachdem Sie die GreenDao-Bibliotheksabhängigkeit und das Gradle-Plugin hinzugefügt haben, müssen Sie zunächst ein Entitätsobjekt erstellen.

Entität

Eine Entität ist ein einfaches altes Java-Objekt (POJO) , das einige Daten in der Datenbank modelliert. GreenDao verwendet diese Klasse, um eine Tabelle in der SQLite-Datenbank zu erstellen und automatisch Hilfsklassen zu generieren, mit denen auf Daten zugegriffen werden kann, ohne dass SQL-Anweisungen geschrieben werden müssen.

@Entity
public class Users {

    @Id(autoincrement = true)
    private Long id;

    private String firstname;
    private String lastname;

    @Unique
    private String email;

    // Getters and setters for the fields...

}

Einmaliges GreenDao-Setup

Bei jedem Start einer Anwendung muss GreenDao initialisiert werden. GreenDao schlägt vor, diesen Code in einer Application-Klasse zu behalten oder irgendwo nur einmal ausgeführt zu werden.

DaoMaster.DevOpenHelper helper = new DaoMaster.DevOpenHelper(this, "mydatabase", null);
db = helper.getWritableDatabase();
DaoMaster daoMaster = new DaoMaster(db);
DaoSession daoSession = daoMaster.newSession();

GreenDao-Hilfsklassen

Nachdem das Entitätsobjekt erstellt wurde, erstellt GreenDao automatisch die Hilfsklassen, die für die Interaktion mit der Datenbank verwendet werden. Diese werden ähnlich wie der Name des erstellten Entitätsobjekts benannt, gefolgt von Dao und werden vom daoSession Objekt abgerufen.

UsersDao usersDao = daoSession.getUsersDao();

Viele typische Datenbankaktionen können jetzt mit diesem Dao-Objekt mit dem Entitätsobjekt ausgeführt werden.

Abfrage

String email = "[email protected]";
String firstname = "John";

// Single user query WHERE email matches "[email protected]"
Users user = userDao.queryBuilder()
                .where(UsersDao.Properties.Email.eq(email)).build().unique();

// Multiple user query WHERE firstname = "John"
List<Users> user = userDao.queryBuilder()
                .where(UsersDao.Properties.Firstname.eq(firstname)).build().list();

Einfügen

Users newUser = new User("John","Doe","[email protected]");
usersDao.insert(newUser);

Aktualisieren

// Modify a previously retrieved user object and update
user.setLastname("Dole");
usersDao.update(user);

Löschen

// Delete a previously retrieved user object
usersDao.delete(user);