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:
- Grau ist die Theorie – unser Datenmodell
- Erstellen des Projekts
- Herunterladen der Abhängigkeiten
- Anpassung der Projektstruktur
- Einfügen der Bibliotheken
- Anpassen des Build-Skripts des Generator-Moduls
- Erstellung des Datenmodells
- 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:
| id |
| name |
| comment |
| 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:
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:
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:
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):
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:
Die Baumansicht, die wir nun sehen, zeigt nicht die wirkliche Ordnerstruktur unseres Projekts, daher klicken wir nun auf „Android“ -> „Project“:
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%7Corg.freemarker
Von freemarker bitte folgendes herunterladen:
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“
und wählen als Typ „Java Library“ aus:
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!):
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:
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:
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:
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.
Hey, ich habe eine Helfer-Klasse geschrieben, die es ein wenig beschleunigt grosse Klassen zu schreiben.
https://gist.github.com/meierjan/bd0973dfd709e077779c