android sqlite t2_wowomnom_Fotolia_85154667

Android SQLite Datenbank Tutorial – Teil 2: Integrieren einer SQLite Datenbank in Android


In der zweiten Lektion unseres mehrteiligen Android SQLite Tutorials werden wir das Rahmenwerk unserer SQLite Anwendung erstellen.

Dazu werden wir drei Java-Klassen mit Hilfe von Android Studio anlegen. Jede dieser Klassen übernimmt eine bestimmte Aufgabe bei der Arbeit mit dem SQLite Datenbanksystem.

Doch bevor wir die Klassen anlegen, werden wir uns ausführlich mit dem SQLite Datenbanksystem befassen und dabei auch auf die Frage eingehen, wie SQLite in das Android System integriert ist.

Anschließend beschreiben wir auf welche Art die SQLite Datenbank in unsere Einkaufslisten-App integriert werden soll. Dabei gehen wir auch auf die drei zu erstellenden Java-Klassen näher ein.

Wir stellen jede der drei Klassen einzeln vor und erklären wofür wir die jeweilige Klasse benötigen.

Am Ende der Lektion werden wir überprüfen, ob die neuen Klassen ordnungsgemäß angelegt wurden und dazu die Log-Meldungen in Android Studio überwachen.

Nun wünschen wir euch viel Spaß bei dem zweiten Teil unseres Android SQLite Datenbank Tutorials. Los geht’s!

1. Was ist das SQLite Datenbanksystem und wie ist SQLite in das Android System integriert?

SQLite ist eine Programmbibliothek, welche ein relationales Datenbanksystem enthält.

Das Open Source Datenbanksystem unterstützt eine Vielzahl der SQL-Sprachbefehle und wurde vor allem für den Einsatz in eingebetteten Umgebungen entworfen.

Besonders häufig wird das Datenbanksystem SQLite auf Betriebssystemen für Smartphones und Tablets eingesetzt, bspw. Symbian OS oder Android.

Der große Vorteil des SQLite Datenbanksystems ist der minimale Aufbau der Bibliothek. Die gesamte SQLite-Bibliothek ist nur einige hundert Kilobyte groß und lässt sich direkt in die Android Anwendung integrieren. Es wird keine weitere Server-Software benötigt.

Durch das Einbinden der SQLite-Bibliothek wird eine Android App um sehr nützliche Datenbankfunktionen erweitert, ohne auf externe Software angewiesen zu sein. Die SQLite-Datenbank besteht aus einer einzigen Datei, die alle Tabellen, Indizes usw. enthält.

Für die Kommunikation mit dem Datenbanksystem wird die spezielle Kommandosprache SQL verwendet, mit der folgende Operationen durchgeführt werden können:

  • Definition der Tabellenstruktur
  • Anlegen und Löschen von Tabellen
  • Einfügen, Ändern und Löschen von Datensätzen, die eigentlich Tabellenzeilen sind
  • Suchen von Daten aus einer oder mehreren Tabellen mit Hilfe von Suchkriterien

SQLite unterstützt die drei Datentypen TEXT, INTEGER und REAL. In Java würden diese Datentypen den Typen String, Long bzw. Double am ehesten entsprechen. Alle anderen Datentypen müssen in einen dieser drei Typen konvertiert werden, bevor sie in der Datenbank abgespeichert werden können.

Weiterhin prüft SQLite nicht, ob der Datentyp des zu speichernden Eintrags tatsächlich dem Datentyp der zugewiesenen Spalte entspricht. SQLite erzwingt somit keine Typsicherheit. Fehlerhafte Eingaben werden in der Regel akzeptiert und in Zeichenketten umgewandelt.

Weitere Informationen über SQLite findet ihr an folgenden Stellen im Internet:

1.1 Was ist eine relationale Datenbank?

Eine Datenbank im Allgemeinen ist ein Konstrukt zum Ablegen von Daten. Die Daten werden in Tabellen abgelegt und organisiert. Eine Tabelle besteht aus einer vorgegebenen Anzahl an Spalten und Zeilen.

Die Daten verschiedener Tabellen können sich gegenseitig referenzieren und dadurch Beziehungen (Relationen) aufweisen. Dann haben wir es mit relationalen Datenbanken zu tun.

In den beiden unten aufgeführten Tabellen sind Benutzer- und Rechnungsdaten abgelegt und organisiert. Jede Zeile einer Tabelle bildet einen sog. Datensatz und setzt sich aus den Werten mehrerer Spalten (Felder) zusammen.

Benutzerdaten
User-ID Benutzername
1 Fred The Red
2 Fritzle
3 Brian The Lion
4 Attila
Rechnungsdaten
Rechnungs-Nr Betrag Status User-ID
2308 120 € offen 3
2309 79 € offen 3
2310 10 € bezahlt 2
2311 199 € offen 4

Beide Tabellen besitzen jeweils eine Spalte, deren Werte innerhalb der Tabelle eindeutig sind. In den Spalten User-ID bzw. Rechnungs-Nr. gleicht kein Wert dem anderen, sie werden als Primärschlüssel bezeichnet.

In der rechten Tabelle (Rechnungsdaten) wird neben der Primärschlüssel-Spalte Rechnungs-Nr. zusätzlich die Primärschlüssel-Spalte User-ID der linken Tabelle verwendet. In diesem Fall spricht man von einem Fremdschlüssel. Somit wird die Spalte User-ID als Fremdschlüssel-Spalte in der Tabelle Rechnungsdaten verwendet.

Über den Fremdschlüssel kann eine Verbindung von einem Datensatz einer Tabelle zu einem anderen Datensatz einer anderen Tabelle hergestellt werden. So kann über den Fremdschlüssel von der Tabelle Rechnungsdaten auf die Datensätze der Tabelle Benutzerdaten verwiesen werden.

1.2 Wie ist das SQLite Datenbanksystem in Android integriert

In Android ist das SQLite Datenbanksystem fester Bestandteil der Laufzeitumgebung. Dadurch kann jede Android App sehr einfach und effizient Daten in Form einer Datenbank ablegen und auslesen.

Das Einrichten und die Administration der Datenbank wird von Android übernommen. Wir müssen nur mit Hilfe von SQL-Anweisungen die Datenbank anlegen und updaten. Anschließend wird die Datenbank automatisch vom Android System verwaltet.

Die Klassen, die für das Einbinden einer SQLite-Datenbank in einer Android App benötigt werden, sind in dem Package android.database.sqlite zusammengefasst. Wir werden in diesem Android SQLite Tutorial die Klasse SQLiteOpenHelper verwenden und dabei näher kennenlernen.

Wenn wir in unserer Android App eine Datenbank erzeugen, wird diese standardmäßig in dem Verzeichnis DATA/data/PACKAGE_NAME/databases/FILENAME angelegt. Dabei sind die folgenden drei Platzhalter variabel:

  • DATA – ist der Pfad der App-Umgebung, kann mit Environment.getDataDirectory() ausgegeben werden.
  • PACKAGE_NAME – ist der Name des Packages unserer Android Anwendung.
  • FILENAME – ist der Dateiname der Datenbank, den wir in unserem Code vorgeben.

Der Pfad zu unserer Datenbank wird folgendermaßen aussehen:

/data/data/de.programmierenlernenhq.shoppinglisthq/databases/shopping_list.db.

2. Einsatz der SQLite Datenbank in unserer Android App

Es gibt verschiedene Wege eine SQLite-Datenbank in einer Android App zu verwenden. Dabei besitzt jeder Ansatz seine eigenen Vor- und auch Nachteile.

Wir wählen für dieses SQLite Tutorial den Mittelweg, der einen einfachen und übersichtlichen Zugriff auf die SQLite Datenbank ermöglicht, dabei aber nicht zu komplex ist.

Für unseren Ansatz werden wir drei Klassen verwenden, die im gemeinsamen Zusammenspiel das Speichern und Auslesen von Daten aus der SQLite-Datenbank übernehmen.

Die drei Java-Klassen werden wir jeweils in einem eigenen Abschnitt ausführlich vorstellen. In diesem Abschnitt stehen die Beziehungen der drei Klassen untereinander im besonderen Fokus.

In der unteren Liste sind die drei benötigten Klassen aufgeführt:

  • ShoppingMemo – Instanzen dieser Klasse können die Daten eines SQLite-Datensatzes aufnehmen. Sie repräsentieren die Datensätze im Code. Wir werden mit Objekten dieser Klasse den ListView füllen .
  • ShoppingMemoDbHelper – Sie ist eine Hilfsklasse mit deren Hilfe wir die SQLite-Datenbank erstellen lassen. Sie enthält weiterhin wichtige Konstanten, die wir für die Arbeit mit der Datenbank benötigen, wie den Tabellennamen, die Datenbankversion oder die Namen der Spalten.
  • ShoppingMemoDataSource – Diese Klasse ist unser Data Access Object und für das Verwalten der Daten verantwortlich. Es unterhält die Datenbankverbindung und ist für das Hinzufügen, Auslesen und Löschen von Datensätzen zuständig. Außerdem wandelt es Datensätze in Java-Objekte für uns um, so dass der Code unserer Benutzeroberfläche nicht direkt mit den Datensätzen arbeiten muss.

Wie aus den Beschreibungen zu den drei Klassen schon hervorgeht, ist jede Klasse auf die andere angewiesen. Die Grundlage bildet die Klasse ShoppingMemo, die wir für das Arbeiten mit den Datensätzen verwenden. Sie ist sozusagen das Datenobjekt und einem Datensatz unserer Datenbank nachgebildet.

Unsere Arbeiterklasse ist die ShoppingMemoDataSource-Klasse, die alle Verwaltungsaufgaben an der Datenbank übernimmt. Sie lässt mit Hilfe der Helper-Klasse die Datenbank erzeugen und hält die Verbindung zur Datenbank aufrecht. Durch sie können wir auf die Datensätze der Tabelle in unserer Datenbank zugreifen und diese verändern. Sie ist unser Zugriff auf die Daten, eben ein Data Access Object (DAO).

Alle wichtigen, konstanten Informationen über unsere Datenbank, wie Tabellenname, Versionsnummer, Spaltennamen oder SQL-Befehle sind in der Hilfsklasse ShoppingMemoDbHelper gesammelt. Sie ist von der Klasse SQLiteOpenHelper abgeleitet und kann daher eine Datenbank erzeugen.

Mit der DAO-Klasse ShoppingMemoDataSource nutzen wir die Helper-Klasse und lassen uns über sie eine Datenbank erzeugen und auch wieder schließen.

Steuern werden wir die ganzen Datenbankzugriffe von der MainActivity aus, die eine Instanz der ShoppingMemoDataSource-Klasse besitzen wird. Somit müssen wir dem Data Access Object nur mitteilen welche Operationen an der Datenbank ausgeführt werden sollen.

Die tatsächliche Durchführung übernimmt dann das DAO für uns.

In der unteren Abbildung sind die vier Klassen unserer Android SQLite-App dargestellt. Die Darstellung entspricht keiner Norm, sie zeigt einfach nur die Beziehungen der einzelnen Klassen zueinander.

android sqlite datenbank

Beziehungen der Klassen unserer SQLite-App untereinander

In der Abbildung entspricht die Klasse DataSource unserer Klasse ShoppingMemoDataSource, die Klasse DbHelper entspricht ShoppingMemoDbHelper und die Klasse DataObject entspricht ShoppingMemo. Die unterschiedlichen Klassennamen wurden aus Platzgründen gewählt.

In den nächsten Abschnitten werden wir die drei zu erstellenden Klassen genauer vorstellen. Dabei gehen wir auch auf die speziellen Aufgaben ein, welche die jeweilige Klasse bei der Integration der SQLite Datenbank in unsere Android App übernimmt.

3. Die Klasse ShoppingMemo – Mit ihr repräsentieren wir die Datensätze unserer SQLite Datenbank

Wir werden nun die Klasse ShoppingMemo in unserem Android Studio Projekt neu anlegen.

Diese Klasse entspricht den Datensätzen in der Tabelle unserer SQLite Datenbank. Jeder Datensatz besteht aus einer eindeutigen id, dem Namen des Produkts product und der benötigten Menge quantity.

Diesen Datensatz-Aufbau werden wir mit der neuen Klasse ShoppingMemo nachbilden, so dass Instanzen dieser Klasse die Daten eines SQLite-Datensatzes in sich aufnehmen können.

Um die neue Java-Klasse anzulegen, öffnen wir das, im vorherigen Teil erstellte, SQLite-Projekt in Android Studio. Die neue Klasse legen wir folgendermaßen an:

  1. Rechtsklick auf den Package-Namen in der Projekt-Ansicht.
  2. Dann auf den Menüeintrag New klicken.
  3. Und schließlich auf Java Class klicken.
android sqlite data object

Die neue Klasse ShoppingMemo in Android Studio anlegen

In der oberen Abbildung ist das eben beschriebene Vorgehen noch einmal dargestellt.

Als Nächstes öffnet sich der Dialog Create New Class. Darin nehmen wir Eingaben in den Feldern Name und Kind vor.

  1. Name – Hier geben wir als Namen der Klasse “ShoppingMemo” ein.
  2. Kind – An dieser Stelle wählen wir Class aus.
android sqlite data object class

Den Namen der neuen Klasse vorgeben

Mit einem Klick auf den OK-Button wird die neue Klasse ShoppingMemo automatisch von Android Studio angelegt. Sie befindet sich im Package-Ordner unseres Android Projekts, worin sich auch die MainActivity-Klasse befindet.

Wir öffnen nun die erzeugte Klasse ShoppingMemo im Android Studio Editor mit einem Doppelklick auf den Klassennamen in der linken Projektleiste. Anschließend ersetzen wir den Quellcode der Klasse mit der folgenden Klassendefinition.

Achtung! Falls ihr einen anderen Package-Namen für euer Projekt gewählt haben solltet, müsst ihr diesen in der Package-Anweisung in Zeile 1 angeben.


In Android Studio sollte die eben erstellte Klasse ShoppingMemo jetzt folgendermaßen aussehen:

android sqlite data object code

Die neue Klasse ShoppingMemo in Android Studio mit eingefügtem Quelltext

In der oberen Abbildung ist die Klasse ShoppingMemo im Editor von Android Studio bereits geöffnet. Der weiter oben aufgeführte Quellcode wurde schon eingefügt. Außerdem ist auch der Speicherort ihrer Klassendatei in der Projektleiste (Markierung A) zu sehen.

Die Klasse besitzt die drei Membervariablen product, quantity und id, auf die mit Hilfe der get- und set-Methoden zugegriffen werden kann.

Mit dem Konstruktor können wir die ShoppingMemo-Objekte erzeugen lassen. Die drei Instanzvariablen product, quantity und id werden beim Erzeugen der Objekte direkt mit den übergebenen Werten gefüllt.

Später werden wir die ShoppingMemo-Klasse nutzen, um die Daten der Datensätze unserer SQLite-Datenbank in Java-Objekten zu speichern. Diese Objekte entsprechen dann exakt einem Datensatz. Wir können dann mit den Objekten in unserem Code weiterarbeiten und ihren Inhalt bequem in einer Liste, bspw. mit Hilfe eines ListViews, ausgeben.

Wir können ihren Inhalt auch verändern und später die Änderungen in dem korrespondierenden Datensatz mit Hilfe der Objekte vornehmen. Die Klasse ShoppingMemo hilft uns somit Ordnung in das Datenchaos zu bringen und ermöglicht einen sichereren Umgang mit der SQLite-Datenbank.

4. Die Klasse ShoppingMemoDbHelper – Unsere Hilfsklasse für das Erzeugen der SQLite Datenbank

In diesem Arbeitsschritt werden wir eine weitere neue Java-Klasse in Android Studio anlegen. Die neue Klasse ShoppingMemoDbHelper wird uns bei dem Erzeugen und Updaten der SQLite Datenbank unterstützen.

Wie ihr Name schon andeutet, ist sie eine Hilfsklasse, die wir nicht zwingend benötigen. Sie vereinfacht aber die Arbeit mit der SQLite Datenbank sehr stark.

Die Hilfsklasse leiten wir von der Klasse SQLiteOpenHelper aus dem Package android.database.sqlite ab. Diese Elternklasse wird das eigentliche Erzeugen der SQLite Datenbank für uns übernehmen. Wir delegieren dies nur mit unserer Hilfsklasse ShoppingMemoDbHelper an sie weiter.

Wie schon im vorherigen Abschnitt beschrieben, legen wir die neue Java-Klasse folgendermaßen an:

  1. Rechtsklick auf den Package-Namen in der Projekt-Ansicht.
  2. Dann auf den Menüeintrag New klicken.
  3. Und schließlich auf Java Class klicken.
android sqlite dbhelper class

Die neue Klasse ShoppingMemoDbHelper in Android Studio anlegen

Danach öffnet sich der Dialog Create New Class. Darin nehmen wir Eingaben in den Feldern Name und Kind vor.

  1. Name – Hier geben wir als Namen der Klasse “ShoppingMemoDbHelper” ein.
  2. Kind – An dieser Stelle wählen wir Class aus.
android sqlite dbhelper class name

Den Namen der neuen Klasse ShoppingMemoDbHelper vorgeben

Mit einem Klick auf den OK-Button wird die neue Klasse ShoppingMemoDbHelper automatisch von Android Studio angelegt. Sie befindet sich im Package-Ordner unseres Android Projekts, worin sich auch die MainActivity und ShoppingMemo Klassen befinden.

Wir öffnen nun die erzeugte Klasse ShoppingMemoDbHelper im Android Studio Editor mit einem Doppelklick auf den Klassennamen in der linken Projektleiste. Anschließend ersetzen wir den Quellcode der Klasse mit der folgenden Klassendefinition.

Achtung! Falls ihr einen anderen Package-Namen für euer Projekt gewählt haben solltet, müsst ihr diesen in der Package-Anweisung in Zeile 1 angeben.


In dem oberen Quelltext passiert noch nicht viel. Wir sehen das minimale Grundgerüst unserer Hilfsklasse und die notwendigen Import-Anweisungen.

Da sich unsere Klasse von der SQLiteOpenHelper-Klasse ableitet, müssen wir einen der beiden verfügbaren Konstruktoren verwenden (Zeile 14) und die beiden Methoden onCreate() und onUpgrade() überschreiben.

Mit dem Aufruf des Konstruktors der Elternklasse in Zeile 14 geben wir die wichtigen Daten für das Erzeugen der SQLite Datenbank an die SQLiteOpenHelper-Klasse weiter. Dabei enthält der context die Informationen über die Umgebung, in der die Datenbank ausgeführt wird, wie bspw. der Pfad zur Datenbank.

Den Datenbanknamen werden wir später in einer String-Konstante angeben, daher arbeiten wir hier mit einem Platzhalter. Das letzte Argument gibt die Version unserer Datenbank an. Bei jedem Datenbank-Upgrade wird dieser Wert um eins erhöht.

In Android Studio sollte die eben erstellte Klasse ShoppingMemoDbHelper jetzt folgendermaßen aussehen:

android sqlite dbhelper code

Die neue Klasse ShoppingMemoDbHelper in Android Studio mit eingefügtem Quelltext

Wie das Erzeugen der SQLite Datenbank erfolgt, werden wir im nächsten Teil des Tutorials ausführlich beschreiben. Dann wird die Klasse ShoppingMemoDbHelper vervollständigt werden.

Für den Moment ist das minimale Grundgerüst aber ausreichend, so dass wir nun zur dritten und letzten neuen Java-Klasse unserer Android SQLite-App kommen.

5. Die Klasse ShoppingMemoDataSource – Unsere Arbeiterklasse, sie regelt die SQLite Datenbankzugriffe

Kommen wir nun zu unserer Arbeiterklasse ShoppingMemoDataSource. Sie ist für alle Datenbankzugriffe verantwortlich. Mit ihrer Hilfe schreiben wir Datensätze in die Tabelle unserer SQLite Datenbank und lesen diese auch wieder aus.

Die ShoppingMemoDataSource-Klasse besitzt eine Membervariable vom Datentyp SQLiteDatabase, in der wir unsere Datenbank-Objekte abspeichern werden. Dadurch hält die ShoppingMemoDataSource-Klasse die Verbindung zu unserer Datenbank aufrecht.

Weiterhin besitzt sie eine Membervariable vom Typ ShoppingMemoDbHelper, mit deren Hilfe wir die SQLite Datenbank erstellen lassen bzw. die Verbindung zur Datenbank herstellen können, wenn bereits eine Datenbank angelegt wurde.

Außerdem wird die Arbeiterklasse weitere Funktionen zur Verfügung stellen, die das Arbeiten mit den Datensätzen erleichtern. Dazu werden wir in späteren Teilen dieses SQLite Tutorials ausführlich eingehen.

Nun wollen wir die Klasse ShoppingMemoDataSource anlegen. Wie schon in den vorherigen Abschnitten beschrieben, legen wir die neue Java-Klasse folgendermaßen an:

  1. Rechtsklick auf den Package-Namen in der Projekt-Ansicht.
  2. Dann auf den Menüeintrag New klicken.
  3. Und schließlich auf Java Class klicken.
android sqlite data source class

Die neue Klasse ShoppingMemoDataSource in Android Studio anlegen

Danach öffnet sich der Dialog Create New Class. Darin nehmen wir Eingaben in den Feldern Name und Kind vor.

  1. Name – Hier geben wir als Namen der Klasse “ShoppingMemoDataSource” ein.
  2. Kind – An dieser Stelle wählen wir Class aus.
android sqlite data source class name

Den Namen der neuen Klasse ShoppingMemoDataSource vorgeben

Mit einem Klick auf den OK-Button wird die neue Klasse ShoppingMemoDataSource automatisch von Android Studio angelegt. Sie befindet sich im Package-Ordner unseres Android Projekts, worin sich auch die MainActivity, ShoppingMemo und ShoppingMemoDbHelper Klassen befinden.

Wir öffnen nun die erzeugte Klasse ShoppingMemoDataSource im Android Studio Editor mit einem Doppelklick auf den Klassennamen in der linken Projektleiste. Anschließend ersetzen wir den Quellcode der Klasse mit der folgenden Klassendefinition.

Achtung! Falls ihr einen anderen Package-Namen für euer Projekt gewählt haben solltet, müsst ihr diesen in der Package-Anweisung in Zeile 1 angeben.


Die Klasse ShoppingMemoDataSource besteht momentan nur aus den beiden Membervariablen database und dbHelper, sowie aus dem Konstruktor ShoppingMemoDataSource(Context context).

In dem Konstruktor erzeugen wir eine ShoppingMemoDbHelper-Instanz und übergeben ihr den Context, also die Umgebung in der unsere App ausgeführt wird. Mit Hilfe der erzeugten Instanz dbHelper werden wir später die Verbindung zu unserer SQLite Datenbank herstellen.

Mehr gibt es im Moment zu dem Quellcode der Klasse ShoppingMemoDataSource nicht zu sagen. Auch diese Klasse wird mit dem SQLite Tutorial mitwachsen und Lektion für Lektion weiter vervollständigt werden.

In Android Studio sollte die eben erstellte Klasse ShoppingMemoDataSource nun folgendermaßen aussehen:

android sqlite data source code

Die neue Klasse ShoppingMemoDataSource in Android Studio mit eingefügtem Quelltext

Jetzt haben wir die drei benötigten Klassen angelegt und mit Quellcode befüllt. Als Nächstes sollten wir unsere Android App ausführen und testen, ob alle Arbeitsschritte korrekt durchgeführt wurden.

Wir werden dazu etwas Testcode in der MainActivity-Klasse ergänzen und anschließend unsere App auf einem Android Gerät ausführen.

6. Einfügen des Testcodes in die MainActivity und Ausführen der Android App

Jetzt sind wir fast am Ende vom zweiten Teil des Android SQLite Tutorials angekommen. Wir haben in dieser Lektion drei neue Java-Klassen erstellt, mit deren Hilfe wir in den späteren Teilen des Tutorials auf die SQLite Datenbank zugreifen werden.

Doch bevor wir mit der Datenbank arbeiten können, müssen wir sicherstellen, dass die drei neuen Klassen korrekt funktionieren.

Um dies zu testen, fügen wir den folgenden Testcode in die MainActivity-Klasse ein:


In der unteren Abbildung ist dargestellt, an welche Stelle der Codeblock einzufügen ist. Sie ist mit einem blauen Rahmen (B) markiert. Außerdem darf die Import-Anweisung (Markierung A) nicht vergessen werden.

Bei euch sollte die MainActivity-Klasse jetzt folgendermaßen aussehen:

android sqlite main activity code

Mit diesem Code testen wir, ob die Klassen richtig erstellt wurden

Mit dem eingefügten Testcode werden wir folgende Dinge überprüfen:

  • Testen der ShoppingMemo-Klasse – In Zeile 10 erzeugen wir die ShoppingMemo-Instanz testMemo und geben ihren Inhalt mit der Log-Anweisung in Zeile 11 wieder aus.
  • Testen der beiden anderen Klassen – In Zeile 13 erzeugen wir ein ShoppingMemoDataSource-Objekt. Dadurch werden die beiden Konstruktoren der Klassen ShoppingMemoDataSource und ShoppingMemoDbHelper der Reihe nach aufgerufen und die darin angegebenen Log-Meldungen ausgegeben.

Auf diese Weise können wir prüfen, ob die drei Klassen richtig angelegt wurden. Diese Tests sind keine Funktionstests und garantieren auch nicht die Korrektheit unseres Quellcodes. Mit diesen Tests könnt ihr schnell herausfinden, ob etwas beim Befolgen der Arbeitsschritte fehlgeschlagen ist.

In den beiden nächsten Unterabschnitten werden wir unsere Android SQLite-App auf einem Android Gerät ausführen und die Log-Meldungen in Android Studio überprüfen. Wenn ihr die gleichen Log-Meldungen erhaltet, sollte das Anlegen der drei Klassen erfolgreich verlaufen sein.

6.1 Ausführen der Android SQLite-App

Nun wollen wir unsere App ausführen und testen. Dazu installieren wir die Anwendung auf unser angeschlossenes Android Gerät (Smartphone oder Tablet) oder in einer AVD des Android Emulators.

Wie eine Android App installiert wird, könnt ihr in den folgenden beiden Teilen unseres großen Android App Programmieren Tutorials nachlesen:

Hier noch einmal in Kürze die wichtigsten Arbeitsschritte.

Zuerst schließen wir unser Android Gerät an den PC an und stellen eine Verbindung über die ADB (Android Debug Bridge) her. Danach klicken wir auf das Run 'app'-Symbol. Unser Android Projekt wird dadurch neu erstellt und auf dem angeschlossenen Gerät ausgeführt.

Das Run 'app'-Symbol befindet sich in der oberen Menüleiste, siehe folgende Abbildung:

android sqlite app starten

Android App über das Run App-Symbol starten

Nach einigen Momenten öffnet sich der Choose Device-Dialog. In ihm nehmen wir die folgenden Einstellungen vor:

  1. Radio Button Choose a running device aktivieren
  2. Das angeschlossene Android Gerät auswählen
  3. Mit einem Klick auf den OK-Button die Installation unserer App auf das Gerät starten
android choose device

Auswählen des angeschlossenen Android Geräts zum Aufspielen unserer App

Der Dialog schließt sich und unsere Android App wird auf das angeschlossene Gerät übertragen und installiert. Die Installation dauert nur einen kurzen Augenblick und verläuft fast unbemerkt im Hintergrund. Danach wird unsere App automatisch gestartet.

6.2 Überprüfen der Log-Meldungen in Android Studio

Unsere SQLite-App sollte jetzt auf dem Android Gerät gestartet worden sein. Die grafische Benutzeroberfläche der Anwendung hat sich nicht geändert, daher sieht auf dem Gerät alles genau so aus wie in Lektion 1.

Um die Log-Meldungen zu überprüfen, öffnen wir in Android Studio die Android-Ansicht bei angeschlossenem Android Gerät.

In der folgenden Abbildung ist die Android-Ansicht (Markierung A) bereits aktiviert und auch die Log-Meldungen (Markierung B) werden schon im logcat angezeigt.

android sqlite log

Überprüfen der Log-Meldungen in Android Studio

Da uns die vielen anderen Log-Meldungen beim Überprüfen der eigenen Meldungen stören, werden wir jetzt einen Log-Filter anlegen, den wir auch in späteren Lektionen des SQLite Tutorials wiederverwenden können.

Den Log-Filter legen wir in Android Studio wie folgt an:

  1. Zuerst auf die Drop-Down Liste Show only selected application in der Android-Ansicht klicken.
  2. Anschließend auf den letzten Eintrag Edit Filter Configuration klicken.
android sqlite log filter

Anlegen eines Log-Filters in Android Studio

Im Anschluss öffnet sich der Dialog Create New Logcat Filter, in dem wir die Filtereinstellungen vornehmen und dadurch nach unseren Tags suchen werden.

Wir nehmen darin die folgenden beiden Eingaben vor:

  1. Filter Name – Als Bezeichnung unseres Log-Filters geben wir SQLite-App Filter an.
  2. Log Tag (regex) – Hier geben wir folgende Verknüpfung ein MainActivity|ShoppingMemo, mit der wir unsere LOG_TAGs aus den vielen anderen Meldungen herausfiltern.
android sqlite log filter dialog

Der “Create New Logcat Filter”-Dialog von Android Studio

Mit einem Klick auf den OK-Button wird der Log-Filter erstellt und dabei automatisch aktiviert. Jetzt werden mit Hilfe des Filters die Log-Meldungen unserer App aus der Menge der anderen Meldungen herausgefiltert.

In der unteren Abbildung sind die drei Log-Meldungen unserer Android App dargestellt. Der eben angelegte Log-Filter ist aktiviert (rote Markierung A). Unsere Meldungen werden im logcat-Textbereich angezeigt und sind von einem blauen Rahmen umschlossen (Markierung B).

android sqlite log filtered

Überprüfen der Log-Meldungen in Android Studio, diesmal mit aktivem Log-Filter

Wenn auch bei euch die drei Log-Meldungen ausgegeben werden, hat das Erstellen der neuen Java-Klassen ordnungsgemäß funktioniert. Somit haben wir den Grundstein für unsere SQLite Datenbank Anwendung gelegt.

In den nächsten Lektionen werden wir mit den erstellten Klassen weiterarbeiten und über sie auf die SQLite Datenbank zugreifen. Dabei werdet ihr auch besser nachvollziehen können, warum wir diese Vorgehensweise gewählt haben und welche Vorteile beim Arbeiten mit dem Datenbanksystem dadurch entstehen.

Zusammenfassung

In dieser, doch etwas längeren, Lektion des Android SQLite Tutorials haben wir das Fundament für unsere Datenbank Anwendung gelegt. Die Android App macht momentan noch nichts, ist aber jetzt schon in der Lage eine SQLite Datenbank zu erzeugen.

Dies haben wir erreicht, indem wir drei neue Klassen mit Hilfe von Android Studio angelegt und diese mit Quellcode befüllt haben. Jede der drei Java-Klassen übernimmt dabei eine bestimmte Aufgabe.

Die ShoppingMemo-Klasse repräsentiert die Datensätze unserer SQLite Datenbank. Die ShoppingMemoDbHelper-Klasse hilft uns beim Erstellen und Aktualisieren der Datenbank. Die eigentliche Arbeit wird von der ShoppingMemoDataSource-Klasse übernommen, sie regelt alle Datenbankzugriffe, ob lesend oder schreibend, für unsere App.

Vor dem Anlegen der neuen Klassen haben wir das SQLite Datenbanksystem näher kennengelernt und erfahren, wie SQLite in der Android Plattform integriert ist. Danach haben wir den Ansatz vorgestellt, der beschreibt, wie wir die SQLite Datenbank in unserer Android App einsetzen wollen.

Am Ende der Lektion haben wir die MainActivity-Klasse mit Testcode erweitert und dadurch überprüft, ob alle drei Klassen korrekt angelegt wurden.

Nun sind wir bereit für den nächsten Schritt auf dem Weg hin zu einer funktionsfähigen Android SQLite Anwendung. In der nächsten Lektion werden wir eine Tabelle in unserer SQLite Datenbank anlegen und dabei SQL-Queries näher kennenlernen.


Comments 12

  1. Pingback: Android SQLite Tutorial - Teil 1: SQLite Projekt anlegen

  2. Jojo

    Ich habe den Code aus eurem Artikel mehrere Male kopiert und bekomme jedesmal nur 2 Meldungen im Log, die 1. (“Inhalt der Testmemo: 5x Birnen”) wird mir nicht angezeigt.
    Kann es sein, das dies an der Android Version, auf welche die App kompiliert wird (nicht die minimal Anforderung!) liegt?

    1. Post
      Author
      Chris

      Hallo Jojo,

      die erste Meldung (“Inhalt der Testmemo: 5x Birnen”) sollte auch bei dir auf jeden Fall angezeigt werden. Gerade da die anderen beiden Meldungen bei dir auch angezeigt werden. Eventuell liegt es an dem Log-Filter, da die erste Meldung von der MainActivity aus versendet wird. Versuche mal ohne Log-Filter die Meldungen zu betrachten oder nur Meldungen der MainActivity anzeigen zu lassen.

      Ich hoffe das hilft dir weiter :)

      Viele Grüße, Chris

    1. Post
      Author
      Chris

      Hallo Uli,

      danke für das Lob! Es freut mich wenn das Tutorial nützlich ist und den Lesern hilft.

      Viele Grüße, Chris

  3. Rene

    Hi, also ich habe da ein “kurioses” Problem mit den Log Ausgaben. Ich lasse das Projekt auf einem Huawei Mate S laufen. Die App läuft dort Problemlos und ohne Fehlermeldung, jedoch übergibt sie keinerlei Daten an den logcat. Auf dem Device läuft Android 5.1.1, API 22.

    Wenn ich das Projekt jetzt aber über den Emulator laufen lasse, dann wird die Log Ausgabe aber ausgegeben. Kann das an einer falschen ADB Anbindung zwischen dem Huawei liegen?!

    1. Post
      Author
      Chris

      Hallo Rene,

      ja, es kann schon an dem Zusammenspiel zwischen dem Huawei und Android Studio (bzw. der ADB) liegen. Es gab schon einmal eine Leserin, die über ein Problem mit ihrem Huawei berichtet hatte. Vielleicht ist auf Huawei-Geräten auch das Android Logging System etwas anders implementiert worden?

      Viele Grüße, Chris

  4. Tobias

    Hallo,

    wirkliche ein gelungenes Tutorial , das hat mir sehr geholfen!

    Ich habe jedoch ein Problem, dass ich die Datenabnkeinträge nicht angezeigt bekomme. Bei mir zeigts in der Log nur eine Art Adresse an:

    D/MainActivity: Inhalt der Testmemo:
    com.example.tuttiadmin.knobel_statistik.KnobelMemo@1780e24

    Also sind Einträge drin, aber ich kann die Daten so nicht sehen …

    1. Post
      Author
      Chris

      Hallo Tobias,

      danke für’s Lob!

      Ist in deiner Klasse KnobelMemo die Methode toString() implementiert? Falls nicht, könnte das die Lösung sein.

      Viele Grüße, Chris

      1. Tobias

        Hallo Chris,

        ja das wars :D

        Ich habe die Methoden automatisch angelegt und die String Methode total übersehen haha,

        vielen Dank !

  5. Avo

    Hallo,
    mir gefällt das Tutorial echt gut, es ist sehr angenehm geschrieben, Danke!
    Leider möchte bei mir in der Helper Klasse einiges nicht.
    1. die super Funktion nicht und gibt mir auch keine Gründe warum.
    2. Er nutzt den Import der SQLiteOpenHelper nicht.
    3. Die Overrides sagen mir, dass sie nicht Overriden
    Wäre schön, wenn jemand Ideen hat woran es liegt

    1. Post
      Author
      Chris

      Hallo Avo,

      danke für dein Lob!

      Schwer zu sagen, woran es liegt. Wenn du möchtest, kannst Du mir deine Projektdateien (den ganzen Android Studio Projektordner) als ZIP per E-Mail zusenden. Die E-Mail Adresse kannst Du im Impressum finden. Ich schaue dann mal, ob ich etwas herausfinden kann. Sollte die Zip-Datei zu groß sein, dann schicke nur die Java Quellcode-Dateien.

      Viele Grüße, Chris

Hinterlasse eine Antwort

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