Tutorial – greenDAO from Scratch – Teil 1

Auf der Suche nach einem OR-Mapper für Android fanden wir greenDAO. Was wir jedoch nicht fanden war ein Tutorial, das auch ohne Auschecken eines Repositories auskam (mal ganz von deutscher Sprache abgesehen!). Da wir der Meinung sind, dass ein gutes Tutorial alle Schritte beinhaltet und nicht auf einem vorgefertigten Projekt aufsetzt müssen wir nun mit gutem Beispiel vorangehen und selbst aktiv werden.



Hier ist also unser Tutorial: greenDAO from Scratch – keine Repositories, keine online-Abhängigkeiten.

Um den Rahmen dieses Tutorials nicht zu sprengen gehen wir auf genauere Rahmenbedingungen (wie Installation von Android Studio o.ä.) nicht ein.

Ebenso werden wir im Rahmen dieses Tutorials evtl. Gewisse Dinge außer Acht lassen, die in einer fertigen App besser nicht vorkommen, wie z.B. Laden von Daten im UI-Thread.

In diesem kleinen Kurs erstellen wir eine App, mit der wir verliehene Gegenstände verwalten können. Diese beschränkt sich dabei auf das wesentliche und wird nicht auf das Adressbuch zugreifen (aber hey, das ist doch eine schöne Aufgabe 😉 ) oder Ähnliches. Wir haben am Ende dieser Serie:
den Generator für unser Datenmodell (Teil 1 – dieser Teil)
RecyclerView zur Listendarstellung (Teil 2)
Activities für CRUD (Teil 3)

Inhalt Teil 1:

  1. Grau ist die Theorie – unser Datenmodell
  2. Erstellen des Projekts
  3. Herunterladen der Abhängigkeiten
  4. Anpassung der Projektstruktur
  5. Einfügen der Bibliotheken
  6. Anpassen des Build-Skripts des Generator-Moduls
  7. Erstellung des Datenmodells
  8. Generieren der Klassen des Datenmodells

Grau ist die Theorie – unser Datenmodell

Das Datenmodell besteht aus nur zwei Entitäten: Personen (Person) und Verleihvorgängen (Lease). Gegenstände verwalten wir nicht – diese werden einfach als Freitext im Verleihvorgang eingetragen. Es ergeben sich folgende Attribute:

Person
id
name
comment
Lease
id
item
comment
leasedate
returndate

 

Erstellen des Projekts

Wir starten Android Studio. Sollte bereits ein Projekt offen sein, dann schließen wir dieses über das Menü mit „File“ -> „Close Project“.

Auf der rechten Seite in dem kleinen Fenster wählen wir unter „Quick Start“ „Start a new Android Studio project“ aus:

neues Projekt

Danach fragt Android Studio nach dem Projektnamen, wir nennen es „LeaseGreenDao“, und unserem „Company Name“.

Da letzteres gleichzeitig das Package bestimmt habe ich „tutorials.devteam83.com“ eingetragen – ihr solltet hier eure eigene Domain (+ Unterpakete) einsetzen, solltet dann aber im weiteren Verlauf darauf achten, dies immer so zu machen:

neues Projekt konfigurieren

Im folgenden Dialog fragt Android Studio nach den „Target Android Devices“ unseres Projektes – da dieses Tutorial nicht genauer auf die Eigenschaften verschiedener Versionen eingehen soll wählt einfach „Phone and Tablet“ und API 21:

SDK auswählen

AS möchte es uns anschließend leicht machen und gleich eine Activity generieren – wir lehnen dankend ab (und wählen „Add No Activity“ aus):

Projekterstellung - no Activity

Nach dem Erstellen des Projektes sieht AS nun erstmal sehr aufgeräumt aus – nur sehen wir auch von unserem Projekt nicht viel. Das ändern wir, indem wir auf „Project“ klicken:

Projekt anzeigen

Die Baumansicht, die wir nun sehen, zeigt nicht die wirkliche Ordnerstruktur unseres Projekts, daher klicken wir nun auf „Android“ -> „Project“:

Project Ansicht auswählen

 

Herunterladen der Abhängigkeiten

 

Wie zu Anfang bereits beschrieben, soll unser Projekt ohne externe Abhängigkeiten auskommen. Daher müssen wir zunächst drei Bibliotheken in form von .jar-Dateien herunterladen. Da ich nicht auf exakte Versionen verweisen möchte, hier nun Links auf Suchen auf maven.org (Download jeweils mit Klick auf jar auf der rechten Seite):

http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22de.greenrobot%22%20AND%20a%3A%22greendao%22

http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22de.greenrobot%22%20AND%20a%3A%22greendao-generator%22

http://search.maven.org/#search%7Cga%7C1%7Corg.freemarker

Von freemarker bitte folgendes herunterladen:

Freemarker auswählen

Anpassung der Projektstruktur

GreenDAO generiert die für unser Datenmodell benötigten Klassen in unser Android Projekt hinein. Um diesen Generator (ein Java-Programm) von unserer App zu trennen, müssen wir zunächst ein neues Modul anlegen. Wir machen einen Rechtsklick auf „LeaseGreenDao“ und wählen „New“ -> „Module“

neues Modul erstellen

und wählen als Typ „Java Library“ aus:

Wizard - Java Library auswählen

Ich habe nun folgende Daten eingetragen – diese sind aber für das Funktionieren des Generators nicht wichtig (müssen nur an anderen Stellen wiederholt werden!):

Bibliothek erstellen

Einfügen der Bibliotheken

Im nächsten Schritt fügen wir „greendao-generator“ und „freemarker“ in das Generator Modul per Copy-and-Paste in den „libs“ Ordner ein:

Einfügen der Bibliotheken

Anpassen des Build-Scripts des Generator-Moduls

Damit Gradle unsere eingefügten JARs auch kennt müssen wir folgende Zeilen in build.gradle des Generator Moduls im Block „dependencies“ einfügen:

compile files('libs/greendao-generator-1.3.1.jar')
compile files('libs/freemarker-2.3.22.jar')

Achtet darauf, dass ihr jeweils die genauen Dateinamen (Version!) eurer heruntergeladenen Bibliotheken angebt.


Wie bereits erwähnt ist der Generator von greenDAO eine eigene Applikation, daher fügen wir ganz am Anfang des Build-Skripts diese Zeile ein:

apply plugin: 'application'

und teilt Gradle mit, welche die Hauptklasse der Applikation ist:

mainClassName = "com.devteam83.tutorials.leasegreendao.LeaseDaoGenerator"

Danach sieht die Datei build.gradle vom Generator-Modul so aus:

apply plugin: 'application'
apply plugin: 'java'

mainClassName = "com.devteam83.tutorials.leasegreendao.LeaseDaoGenerator"
dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    compile files('libs/greendao-generator-1.3.1.jar')
    compile files('libs/freemarker-2.3.22.jar')
}

Danach klickt ihr oben rechts auf „Sync Now“.

Erstellung des Datenmodells

Wir kommen jetzt in die spannende Phase der Erstellung useres Datenmodells: Wir teilen dem Generator mit, wie unser Datenmodell aussehen soll. Dafür öffnen wir die Klasse „LeaseDaoGenerator“ und fügen folgende Methode hinzu:

public static void main(String args[]) throws Exception {
        Schema schema = new Schema(1, "com.devteam83.tutorials.leasegreendao.model");
    }

Wir erstellen also ein „Schema“, geben ein Package an und die Datenbank-Version 1. Wenn ihr die Zeilen einfügt, dann schlägt euch Android Studio die nötigen Imports vor – achtet darauf, die richtigen zu nehmen:

Packages importieren lassen
Anschließend weisen wir greenDAO an unsere Entitäten zu erstellen:

Entity person = schema.addEntity("Person");
person.addIdProperty();
person.addStringProperty("name");
person.addStringProperty("comment");

Entity lease = schema.addEntity("Lease");
lease.addIdProperty();
lease.addStringProperty("item");
lease.addStringProperty("comment");
lease.addLongProperty("leasedate");
lease.addLongProperty("returndate");

Das war jetzt relativ einfach, erzeugt aber lediglich zwei disjunkte Entitäten, die keine Relationen zueinander haben. Da aber jeder Verleihvorgang zu einer Person gehören soll, müssen wir folgendes einfügen:

Property personId = lease.addLongProperty("personId").getProperty();
lease.addToOne(person, personId);

Wir speichern uns bei der Erstellung also die Property personId zwischen, um mit addToOne() die Beziehung (ein Verleihvorgang gehört zu einer Person) abzubilden.
Gleichzeitig gehören zu einer Person aber beliebig viele Verleihvorgänge, auf die wir unter Umständen auch zugreifen wollen:

ToMany personToLease = person.addToMany(lease, personId);
personToLease.setName("leases");

Anschließend müssen wir nur noch die Methode zum erstellen der Entitäten aufrufen:

new DaoGenerator().generateAll(schema, "../app/src/main/java");

Die komplette Klasse sieht nun also so aus:

package com.devteam83.tutorials.leasegreendao;

import de.greenrobot.daogenerator.DaoGenerator;
import de.greenrobot.daogenerator.Entity;
import de.greenrobot.daogenerator.Property;
import de.greenrobot.daogenerator.Schema;
import de.greenrobot.daogenerator.ToMany;

public class LeaseDaoGenerator {
    public static void main(String args[]) throws Exception {
        Schema schema = new Schema(1, "com.devteam83.tutorials.leasegreendao.model");

        Entity person = schema.addEntity("Person");
        person.addIdProperty();
        person.addStringProperty("name");
        person.addStringProperty("comment");

        Entity lease = schema.addEntity("Lease");
        lease.addIdProperty();
        lease.addStringProperty("item");
        lease.addStringProperty("comment");
        lease.addLongProperty("leasedate");
        lease.addLongProperty("returndate");

        Property personId = lease.addLongProperty("personId").getProperty();
        lease.addToOne(person, personId);

        ToMany personToLease = person.addToMany(lease, personId);
        personToLease.setName("leases");

        new DaoGenerator().generateAll(schema, "../app/src/main/java");
    }
}

Generieren der Klassen des Datenmodells

Um die Klassen unseres Datenmodells zu generieren, müssen wir an der rechten Seite des Fensters auf „Gradle“ klicken und von „leasedaogenerator“ den „run“-Task starten.

 

Wenn kein Fehler auftritt, dann sollte folgende Ausgabe erscheinen:

Processed 2 entities in 185ms

BUILD SUCCESSFUL

Total time: 4.1 secs
23:11:50: External task execution finished 'run'.

… und in unserer App sind folgende Dateien erschienen:

generierte Klassen

Herzlichen Glückwunsch!

Sollte dies nicht der Fall sein, dann geh bitte alle Schritte nochmal genau durch oder lass einen Kommentar hier…

Das war Teil 1 – im 2. Teil arbeiten wir an unserem Projekt weiter und benutzen greenDAO in unserer kleinen App.

One thought on “Tutorial – greenDAO from Scratch – Teil 1

Schreib einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind markiert *

CAPTCHA-Bild

*