Einführung in diesen Abschnitt:
In diesem Abschnitt lernen wir weiter die dritte Methode der Android-Datenspeicherung und des Datenzugriffs kennen: die SQLite-Datenbank. Anders als bei anderen SQL-Datenbanken müssen wir keine weitere Datenbanksoftware auf dem Telefon installieren. Das Android-System hat diese Datenbank bereits integriert, sodass wir uns nicht mit der Installation und Konfiguration anderer Datenbanksoftware (Oracle, MSSQL, MySQL usw.) oder dem Ändern von Ports herumschlagen müssen! Das war die Einführung. Jetzt lernen wir dieses Ding kennen~
1. Grundlegende Konzepte
1) Was ist SQLite? Warum SQLite verwenden? Welche Merkmale hat SQLite?
Antwort: Lassen Sie mich es unten im Detail erklären:
①SQLite ist eine leichtgewichtige relationale Datenbank mit schneller Ausführungsgeschwindigkeit und geringem Ressourcenverbrauch, sehr gut für mobile Geräte geeignet. Sie unterstützt nicht nur die Standard-SQL-Syntax, sondern folgt auch den ACID-Prinzipien (Datenbanktransaktionen). Sie erfordert kein Konto und ist sehr bequem zu verwenden!
②Zuvor haben wir gelernt, Dateien und SharedPreferences zum Speichern von Daten zu verwenden, aber in vielen Fällen sind Dateien nicht unbedingt wirksam, z. B. wenn Multithread-Parallelzugriff im Spiel ist; Apps müssen komplexe Datenstrukturen verarbeiten, die sich ändern können, und so weiter! Zum Beispiel Einzahlungen und Abhebungen bei einer Bank! Die Verwendung der ersten beiden Methoden erschiene wirkungslos oder umständlich. Das Aufkommen von Datenbanken kann dieses Problem lösen, und Android stellt uns ein so leichtgewichtiges SQLite bereit – warum also nicht nutzen?
③SQLite unterstütztfünf Datentypen: NULL, INTEGER, REAL (Gleitkommazahl), TEXT (Zeichenketten-Text) und BLOB (Binärobjekt). Obwohl es nur fünf sind, kann es dennoch andere Datentypen wie varchar, char usw. speichern. Das liegt daran, dass SQLite eine ganz besondere Eigenschaft hat:Du kannst Daten eines beliebigen Datentyps in einem beliebigen Feld speichern, ohne dich um den für das Feld deklarierten Datentyp zu kümmern.Zum Beispiel kannst du eine Zeichenkette in einem Integer-Feld speichern. Natürlichaußer bei Feldern, die als PRIMARY KEY INTEGER PRIMARY KEY deklariert sind, die nur 64-Bit-Ganzzahlen speichern können.! Außerdem ignoriert SQLite beim Parsen von CREATE TABLE-Anweisungen die Datentypinformationen, die auf den Feldnamen in der CREATE TABLE-Anweisung folgen. Zum Beispiel ignoriert die folgende Anweisung die Typinformationen des Felds name:CREATE TABLE person (personid integer primary key autoincrement, name varchar(20))
Zusammenfassung der Funktionen:
SQLite verwendetDateien, um die Datenbank zu speichern. Eine Datei ist eineDatenbank, und eine Datenbank enthält mehrereTabellen, und eine Tabelle hat mehrereDatensätze, jeder Datensatz besteht aus mehrerenFeldern, jedes Feld hat einen entsprechendenWert, und für jeden Wert können wir einenTypangeben oder darauf verzichten, einen Typ anzugeben (außer bei Primärschlüsseln).
PS: Übrigens ist das in Android integrierte SQLite die Version SQLite 3~
2) Einige verwandte Klassen:
Hehe, wenn wir etwas Neues lernen, ist das, was uns am meisten missfällt, auf neue Begriffe zu stoßen, oder? Sprechen wir zuerst über die drei Klassen, die wir bei der Arbeit mit der Datenbank verwenden:
- SQLiteOpenHelper: Abstrakte Klasse. Durch Vererbung dieser Klasse überschreiben wir die Methoden zum Erstellen und Aktualisieren der Datenbank. Wir können auch über ein Objekt dieser Klasse eine Datenbankinstanz erhalten oder die Datenbank schließen!
- SQLiteDatabase: Datenbankzugriffsklasse: Wir können Objekte dieser Klasse verwenden, um Operationen wie Einfügen, Löschen, Aktualisieren und Abfragen in der Datenbank auszuführen.
- Cursor: Cursor, etwas Ähnliches wie ResultSet in JDBC, eine Ergebnismenge! Er kann einfach als ein Zeiger verstanden werden, der auf einen bestimmten Datensatz in der Datenbank zeigt.
2. Verwenden der Klasse SQLiteOpenHelper zum Erstellen von Datenbanken und Verwalten von Versionen
Bei Apps, die eine Datenbank verwenden, können wir die Datenbankdatei nicht manuell für sie erstellen, daher müssen wir die Datenbanktabelle beim ersten Start der App erstellen. Und wenn unsere Anwendung aktualisiert wird und die Struktur der Datenbanktabelle geändert werden muss, muss die Datenbanktabelle aktualisiert werden. Für diese beiden Vorgänge stellt Android unsSQLiteOpenHelpermit zwei Methoden,onCreate( )und onUpgrade() zur Implementierung.
Methodenanalyse:
- onCreate(database): Erzeugt die Datenbanktabelle, wenn die Software zum ersten Mal verwendet wird.
- onUpgrade(database,oldVersion,newVersion): Sie wird aufgerufen, wenn sich die Datenbankversion ändert. Im Allgemeinen muss die Versionsnummer nur während eines Software-Upgrades geändert werden. Die Datenbankversion wird vom Programmierer gesteuert. Angenommen, die aktuelle Datenbankversion ist 1. Aufgrund von Geschäftsänderungen wird die Struktur der Datenbanktabelle geändert. Zu diesem Zeitpunkt muss die Software aktualisiert werden. Beim Aktualisieren der Software möchten Sie die Struktur der Datenbanktabelle auf dem Telefon des Benutzers aktualisieren. Um dieses Ziel zu erreichen, können Sie die ursprüngliche Datenbankversion auf 2 oder eine andere Zahl festlegen, die sich von der alten Versionsnummer unterscheidet.
Code-Beispiel:
public class MyDBOpenHelper extends SQLiteOpenHelper {
public MyDBOpenHelper(Context context, String name, CursorFactory factory,
int version) {super(context, "my.db", null, 1); }
@Override
//数据库第一次创建时被调用
public void onCreate(SQLiteDatabase db) {
db.execSQL("CREATE TABLE person(personid INTEGER PRIMARY KEY AUTOINCREMENT,name VARCHAR(20))");
}
//软件版本号发生改变时调用
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
db.execSQL("ALTER TABLE person ADD phone VARCHAR(12) NULL");
}
}
Codeanalyse:
Der obige Code: Wenn die App zum ersten Mal gestartet wird, erstellen wir die Datei my.db und führen die Methode in onCreate() aus, wodurch eine Person-Tabelle erstellt wird. Sie hat zwei Felder: den Primärschlüssel personId und das Feld name. Wenn wir dann die db-Versionsnummer ändern, wird beim nächsten Start die Methode in onUpgrade() aufgerufen, wodurch ein weiteres Feld in die Tabelle eingefügt wird! Da hier außerdem ein Feld eingefügt wird, gehen keine Daten verloren. Wenn die Tabelle neu erstellt würde, gingen alle Daten in der Tabelle verloren. Im nächsten Abschnitt zeigen wir Ihnen, wie Sie dieses Problem lösen!
Ablaufzusammenfassung:
- Schritt 1: Definieren Sie eine benutzerdefinierte Klasse, die von SQLiteOpenHelper erbt.
- Schritt 2: Legen Sie im super() des Konstruktors dieser Klasse den Datenbanknamen und die zu erstellende Versionsnummer fest.
- Schritt 3: Überschreiben Sie die onCreate()-Methode, um die Tabellenstruktur zu erstellen.
- Schritt 4: Überschreiben Sie die onUpgrade()-Methode, um die Operationen zu definieren, die ausgeführt werden sollen, wenn sich die Versionsnummer ändert.
3. Wie man die von uns erzeugte db-Datei anzeigt
Wenn wir getWritableDatabase() auf dem obigen MyDBOpenhelper-Objekt aufrufen, wird unsere db-Datenbankdatei im folgenden Verzeichnis erstellt:

Wir stellen fest, dass es zwei Datenbanken gibt. Erstere ist die von uns erstellte Datenbank, während Letztere eine temporäre Protokolldatei ist, die erzeugt wird, damit die Datenbank Transaktionen unterstützen kann! Ihre Größe beträgt im Allgemeinen 0 Bytes! Aber imFile Explorerdort können wir wirklich keine Dateien öffnen; nicht einmal txt lässt sich öffnen, geschweige denn .db! Daher stehen unten zwei Wege zur Auswahl:
- 1. Zuerst exportieren, dann mit einem grafischen SQLite-Tool ansehen.
- 2. Nach dem Konfigurieren der adb-Umgebungsvariablen über adb shell ansehen (Kommandozeile, ein Tool zum Angeben)!
Nun, als Nächstes demonstriere ich die oben genannten zwei Methoden. Wählen Sie einfach die aus, die Ihnen gefällt~~
Methode 1: Verwenden Sie ein grafisches SQLite-Tool, um die db-Datei anzuzeigen
Es gibt viele Software dieser Art. Der Autor verwendet SQLite Expert Professional. Natürlich können Sie auch andere Tools verwenden. Bei Bedarf können Sie herunterladen:SQLiteExpert.zip
Exportieren Sie unsere db-Datei auf den Computerdesktop, öffnen Sie SQLiteExpert, und die Oberfläche sieht wie folgt aus:

Fragen Sie mich nicht, wie man es benutzt. Nachdem Sie die db importiert haben, spielen Sie selbst damit. Es ist einfach zu bedienen; wenn Sie es nicht verstehen, suchen Sie einfach bei Baidu danach~
Was Methode 2 betrifft, wollte ich sie ursprünglich ausprobieren, aber später stellte ich fest, dass der sqlite-Befehl nicht gefunden werden konnte. Nach ein paar Versuchen habe ich aufgegeben. Ich werde es später bei Bedarf sorgfältig untersuchen. Wenn Sie interessiert sind, können Sie Guo Lins "First Line of Code — Android" finden und versuchen, dem Flussdiagramm zu folgen! Hier poste ich nur den ersten Teil; den Befehlsteil müssen Sie im Buch nachlesen!
Methode 2: Die adb-Shell-Befehlszeile lässt dich angeben und abheben
1. SDK-Umgebungsvariablen konfigurieren:
Rechtsklick auf Arbeitsplatz ——> Erweiterte Systemeinstellungen -> Umgebungsvariablen -> Neue Systemvariable-> Kopieren Sie den platform-tools-Pfad des SDK: Zum Beispiel den des Autors:C:\Software\Coding\android-sdks-as\platform-tools

Bestätigen Sie, suchen Sie dann die Umgebungsvariable Path, bearbeiten Sie sie und fügen Sie am Ende hinzu:%SDK_HOME%;

Öffnen Sie dann die Kommandozeile, geben Sie adb ein, und eine Menge Dinge werden aufblitzen, was bedeutet, dass die Konfiguration erfolgreich war!
——————Wichtiger Punkt——————: Bevor Sie die nachfolgenden Kommandozeilenanweisungen ausführen, kann es mehrere Fälle für Ihre Testmaschine geben: 1.Nativer EmulatorIn Ordnung, überspringen Sie diesen Teil und fahren Sie unten fort.Genymotion-EmulatorKein Glück, Genymotion Shell kann die folgenden Befehle nicht ausführen.Echtes Gerät (gerootet)Öffnen Sie dannFile ExplorerPrüfen Sie, ob es etwas im Verzeichnis data/data/ gibt? Nichts? Hier ist eine Methode: Installieren Sie zuerst einenRE File Manager, dann erteilen Sie RERoot-Berechtigung, gehen Sie dann zum Root-Verzeichnis: Halten Sie dann das Datenverzeichnis gedrückt, und ein Dialogfeld wie dieses wird angezeigt:



Warten Sie dann, bis es die Berechtigungen langsam ändert. Nachdem die Änderung abgeschlossen ist, öffnen Sie erneut denFile Explorervon DDMS, wir können sehen:

Großartig, jetzt können wir sehen, was in data/data ist!——————————————————————
Wechseln Sie in die adb shell und geben Sie dann den folgenden Befehl ein, um zum Datenbankverzeichnis unserer App zu gelangen:

Geben Sie dann die folgenden Befehle der Reihe nach ein:
- sqlite3my.db: öffnet die Datenbankdatei
- .tableZeigt an, welche Tabellen in der Datenbank vorhanden sind. Danach können Sie direkt Datenbankanweisungen eingeben, z. B. eine Abfrage: Select * from person
- .schema: Zeigt die CREATE TABLE-Anweisung an
- .quit: Datenbankbearbeitung beenden
- .exit: Gerätekonsole beenden
...Aufgrund des Problems "system/bin/sh sqlite3: not found" funktionieren alle nachfolgenden Sqlite-Befehle nicht. Für Effekt-Screenshots schlagen Sie bitte selbst in Guo Daxias Buch nach~ Im Folgenden exportieren wir zuerst die db-Datei und verwenden dann ein grafisches Datenbanktool, um sie anzuzeigen!
4. Verwenden von Android-APIs zum Bedienen von SQLite
Wenn Sie datenbankbezogene Syntax noch nicht gelernt haben oder zu faul sind und keine Datenbanksyntax schreiben möchten, können Sie einige von Android bereitgestellte API-Methoden zum Bedienen von Datenbanken verwenden. Im Folgenden schreiben wir ein einfaches Beispiel, um die Verwendung dieser APIs zu demonstrieren!
Code-Beispiel:
Screenshot des Laufeffekts:

Implementierungscode:
Das Layout ist zu einfach, nur vier Buttons, deshalb poste ich es nicht, sondern poste nur denMainActivity.java-Code:
public class MainActivity extends AppCompatActivity implements View.OnClickListener {
private Context mContext;
private Button btn_insert;
private Button btn_query;
private Button btn_update;
private Button btn_delete;
private SQLiteDatabase db;
private MyDBOpenHelper myDBHelper;
private StringBuilder sb;
private int i = 1;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
mContext = MainActivity.this;
myDBHelper = new MyDBOpenHelper(mContext, "my.db", null, 1);
bindViews();
}
private void bindViews() {
btn_insert = (Button) findViewById(R.id.btn_insert);
btn_query = (Button) findViewById(R.id.btn_query);
btn_update = (Button) findViewById(R.id.btn_update);
btn_delete = (Button) findViewById(R.id.btn_delete);
btn_query.setOnClickListener(this);
btn_insert.setOnClickListener(this);
btn_update.setOnClickListener(this);
btn_delete.setOnClickListener(this);
}
@Override
public void onClick(View v) {
db = myDBHelper.getWritableDatabase();
switch (v.getId()) {
case R.id.btn_insert:
ContentValues values1 = new ContentValues();
values1.put("name", "呵呵~" + i);
i++;
//参数依次是:表名,强行插入null值得数据列的列名,一行记录的数据
db.insert("person", null, values1);
Toast.makeText(mContext, "插入完毕~", Toast.LENGTH_SHORT).show();
break;
case R.id.btn_query:
sb = new StringBuilder();
//参数依次是:表名,列名,where约束条件,where中占位符提供具体的值,指定group by的列,进一步约束
//指定查询结果的排序方式
Cursor cursor = db.query("person", null, null, null, null, null, null);
if (cursor.moveToFirst()) {
do {
int pid = cursor.getInt(cursor.getColumnIndex("personid"));
String name = cursor.getString(cursor.getColumnIndex("name"));
sb.append("id:" + pid + ":" + name + "\n");
} while (cursor.moveToNext());
}
cursor.close();
Toast.makeText(mContext, sb.toString(), Toast.LENGTH_SHORT).show();
break;
case R.id.btn_update:
ContentValues values2 = new ContentValues();
values2.put("name", "嘻嘻~");
//参数依次是表名,修改后的值,where条件,以及约束,如果不指定三四两个参数,会更改所有行
db.update("person", values2, "name = ?", new String[]{"呵呵~2"});
break;
case R.id.btn_delete:
//参数依次是表名,以及where条件与约束
db.delete("person", "personid = ?", new String[]{"3"});
break;
}
}
}
5. Verwenden von SQL-Anweisungen zum Bedienen der Datenbank
Natürlich haben Sie vielleicht SQL gelernt und können entsprechende SQL-Anweisungen schreiben, und möchten nicht die von Android bereitgestellten APIs verwenden. Sie können direkt die von SQLiteDatabase bereitgestellten zugehörigen Methoden verwenden:
- execSQL(SQL,Object[]): Verwenden Sie SQL-Anweisungen mit Platzhaltern; dies wird zum Ausführen von SQL-Anweisungen verwendet, die den Inhalt der Datenbank ändern
- rawQuery(SQL,Object[]): Verwenden Sie SQL-Abfrageoperationen mit Platzhaltern Außerdem habe ich vorhin vergessen, das Cursor-Objekt und seine zugehörigen Eigenschaften vorzustellen. Hier eine Ergänzung: ——CursorDas Objekt ähnelt in etwa dem ResultSet in JDBC, einer Ergebnismenge! Die Verwendung ist ähnlich. Die folgenden Methoden verschieben den Datensatzzeiger des Abfrageergebnisses:
- move(offset): Gibt die Anzahl der Zeilen an, um die nach oben oder unten verschoben wird; eine positive ganze Zahl bedeutet nach unten; eine negative Zahl bedeutet nach oben!
- moveToFirst(): Bewegt den Zeiger auf die erste Zeile; gibt bei Erfolg true zurück, was auch anzeigt, dass Daten vorhanden sind
- moveToLast(): Bewegt den Zeiger auf die letzte Zeile; gibt bei Erfolg true zurück;
- moveToNext(): Bewegt den Zeiger auf die nächste Zeile; gibt bei Erfolg true zurück, was anzeigt, dass noch Elemente vorhanden sind!
- moveToPrevious(): Bewegt sich zum vorherigen Datensatz
- getCount(): Ruft die Gesamtzahl der Datensätze ab
- isFirst(): Ob es der erste Datensatz ist
- isLast(): Ob es das letzte Element ist
- moveToPosition(int): Bewegt sich zur angegebenen Zeile
Beispiel für die Verwendung:
1. Daten einfügen:
public void save(Person p)
{
SQLiteDatabase db = dbOpenHelper.getWritableDatabase();
db.execSQL("INSERT INTO person(name,phone) values(?,?)",
new String[]{p.getName(),p.getPhone()});
}
2. Daten löschen:
public void delete(Integer id)
{
SQLiteDatabase db = dbOpenHelper.getWritableDatabase();
db.execSQL("DELETE FROM person WHERE personid = ?",
new String[]{id});
}
3. Daten ändern:
public void update(Person p)
{
SQLiteDatabase db = dbOpenHelper.getWritableDatabase();
db.execSQL("UPDATE person SET name = ?,phone = ? WHERE personid = ?",
new String[]{p.getName(),p.getPhone(),p.getId()});
}
4. Daten abfragen:
public Person find(Integer id)
{
SQLiteDatabase db = dbOpenHelper.getReadableDatabase();
Cursor cursor = db.rawQuery("SELECT * FROM person WHERE personid = ?",
new String[]{id.toString()});
//存在数据才返回true
if(cursor.moveToFirst())
{
int personid = cursor.getInt(cursor.getColumnIndex("personid"));
String name = cursor.getString(cursor.getColumnIndex("name"));
String phone = cursor.getString(cursor.getColumnIndex("phone"));
return new Person(personid,name,phone);
}
cursor.close();
return null;
}
5. Datenpaginierung:
public List<Person> getScrollData(int offset,int maxResult)
{
List<Person> person = new ArrayList<Person>();
SQLiteDatabase db = dbOpenHelper.getReadableDatabase();
Cursor cursor = db.rawQuery("SELECT * FROM person ORDER BY personid ASC LIMIT= ?,?",
new String[]{String.valueOf(offset),String.valueOf(maxResult)});
while(cursor.moveToNext())
{
int personid = cursor.getInt(cursor.getColumnIndex("personid"));
String name = cursor.getString(cursor.getColumnIndex("name"));
String phone = cursor.getString(cursor.getColumnIndex("phone"));
person.add(new Person(personid,name,phone)) ;
}
cursor.close();
return person;
}
6. Abfragen der Anzahl der Datensätze:
public long getCount()
{
SQLiteDatabase db = dbOpenHelper.getReadableDatabase();
Cursor cursor = db.rawQuery("SELECT COUNT (*) FROM person",null);
cursor.moveToFirst();
long result = cursor.getLong(0);
cursor.close();
return result;
}
PS: Zusätzlich zur oben genannten Methode zum Abrufen der Anzahl kannst du auch die Methode cursor.getCount() verwenden, um die Anzahl der Datensätze zu erhalten, aber die SQL-Anweisung muss geändert werden! Zum BeispielSELECT * FROM person;
Zusammenfassung dieses Abschnitts:
In diesem Abschnitt wurde die grundlegende Verwendung des in Android integrierten SQLite vorgestellt. Es ist noch relativ einfach. Im nächsten Abschnitt beschäftigen wir uns mit etwas fortgeschritteneren Themen: SQLite-Transaktionen, wie Daten in der Datenbank behandelt werden, wenn die Anwendung aktualisiert wird, und Methoden zum Speichern großer Binärdateien in der Datenbank! Gut, das ist alles für diesen Abschnitt~