Overview
Im vorherigen Kapitel haben wir gelernt, wie wir in Java zu einer MySQL-Datenbank verbinden. Wir konzentrieren uns nun darauf, gezielte SQL-Abfragen durchzuführen und nach bestimmmten Datensätzen zu suchen.
// Schnelles Code Beispiel
Connection con = DriverManager.getConnection(url, user, pass);
Statement stm = con.createStatement();
String abfrage = "SELECT * FROM staedteUSA";
ResultSet rs = stm.executeQuery(abfrage);
while(rs.next()){
System.out.println(rs.getString(1) + " " +
rs.getString(2) + " " +
rs.getString(3) + " " +
rs.getString(4));
}Ausgangslage
Wir haben im letzten Kapitel gesehen, was alles notwendig ist, damit wir unser Java-Programm mit einer MySQL-Datenbank verbinden können. Ohne Java-MySQL Connector Treiber läuft nichts. Stellen Sie also erst sicher, dass dieser installiert ist.
Wenn alle Voraussetzungen erfüllt sind, können wir zu einer MySQL-Datenbank verbinden. Hier ein Beispiel, um unser Java-Programm mit einer lokalen Test-Datenbank namens falconbyte zu verbinden:
package paket1;
import java.sql.*;
public class Testverbindung {
public static void main(String[] args){
String url = "jdbc:mysql://localhost:3306/falconbyte";
String user = "root";
String pass = "";
try {
Connection con = DriverManager.getConnection(url, user, pass);
System.out.println("Verbindung erfolgreich hergestellt!");
// Hier können SQL-Abfragen erfolgen
} catch (SQLException e) {
System.out.println(e.getMessage());
}
}
}Konnte die Verbindung hergestellt werden, wird der Text Verbindung erfolgreich hergestellt! in der Konsole angezeigt.
Soweit so gut.
MySQL-Tabelle mit SELECT auslesen
In unserer Testdatenbank liegt eine Tabelle namens staedteUSA (Download, rechte Maustase: Ziel speichern unter). Der gesamte Inhalt ist folgender:
+----+---------------+-------------+----------------+
| nr | name | bundesstaat | einwohnerInMio |
+----+---------------+-------------+----------------+
| 1 | New York City | New York | 8.33 |
| 2 | Chicago | Illinois | 2.72 |
| 3 | Las Vegas | Nevada | 0.63 |
| 4 | Los Angeles | Kalifornien | 4.00 |
| 5 | San Francisco | Kalifornien | 0.88 |
| 6 | Miami | Florida | 0.46 |
+----+---------------+-------------+----------------+
Konzentrieren wir uns jetzt darauf, wie wir in Java an diese MySQL-Tabelle rankommen.
Das Auslesen von Datensätzen einer Tabelle funktioniert über SQL. SQL steht für Structured Query Language (dt.: "Strukturierte Abfrage-Sprache") und ermöglicht es dem Anwender, über standardisierte Abfragen mit der MySQL-Datenbank zu kommunizieren. Diese Abfragen werden auch SQL statements oder Querysgenannt.
Eine SQL-Abfrage wird in Java durch ein Objekt vom Typ Statement repräsentiert, das wir als Rückgabewert beim Aufruf der Connection-Methode createStatement() erhalten:
Statement stm = con.createStatement();Auf der Statement-Referenz führen wir anschließend die Methode executeQuery() aus. Als Argument verlangt die Methode einen String, der die gewünschte SQL-Abfrage repräsentiert:
Statement stm = con.createStatement();
ResultSet rs = stm.executeQuery("SELECT * FROM staedteUSA;");Die SQL-Abfrage wird mit dem SQL-Abfragestring SELECT * FROM staedteUSA; an der Datenbank durchgeführt. Die Abfrage SELECT * FROM staedteUSA; bedeutet, dass wir den gesamten Inhalt der Tabelle staedteUSA ausgelesen bekommen wollen.
Bei erfolgreicher Abfrage werden die Ergebnisdaten dann in einem Objekt vom Typ ResultSet gespeichert. Damit haben wir einen wichtigen Schritt getan: Daten aus einer MySQL-Datenbank befinden sich nun in unserem Java-Programm!
Abfragedaten verfügbar machen
Wie gesagt speichert das ResultSet-Objekt die durch die Abfrage erzeugten Daten. Die Daten werden dabei in Form von einzelnen Reihen (=Datensätze) abgelegt. Darüber hinaus verfügt ResultSet über einen sogenannten Zeiger (Cursor), der auf die einzelnen Zeilen zeigt.
Um an die Daten ranzukommen, sie quasi "auszupacken", müssen wir sie zeilenweise aus dem ResultSet-Objekt auslesen. Dazu verwenden wir die Methoden next() und getString() in Kombination mit einer while-Schleife:
Connection con = DriverManager.getConnection(url, user, pass);
Statement stm = con.createStatement();
ResultSet rs = stm.executeQuery("select * from staedteUSA;");
while(rs.next()){
System.out.println(rs.getString(1) + " " +
rs.getString(2) + " " +
rs.getString(3) + " " +
rs.getString(4));
}Der Cursor befindet sich anfangs immer in der ersten Zeile (Position 0). Beim Aufruf der next()-Methode springt der Cursor eine Datenreihe im ResultSet weiter. Es wird true geliefert, wenn es einen weiteren Datensatz gibt oder false, wenn es keinen weiteren gibt. Indem wir rs.next() als Schleifenbedingung einsetzen, können wir alle Datensätze nacheinander durchiterieren.
Jeder einzelne Schleifendurchlauf markiert also einen Datensatz. Mithilfe der Methode getString() lassen sich nun die "Einzeldaten" eines Datensatz auslesen, wobei die Methode einen int-Wert als Argument verlangt, der für die jeweilige Spaltennummer steht. getString(1) bedeutet also den Wert der ersten Spalte des Datensatzes, getString(2) den zweiten usw.
Wir sind am Ziel! Die MySQL-Tabelle staedteUSA wird auf der Java-Konsole angezeigt:
1 New York City New York 8.33
2 Chicago Illinois 2.72
3 Las Vegas Nevada 0.63
4 Los Angeles Kalifornien 4.00
5 San Francisco Kalifornien 0.88
6 Miami Florida 0.46
Das Zusammenspiel der einzelnen SQL-Klassen und -Interfaces sieht so aus:
Vollständiger Code
Hier noch der vollständige Code:
package paket1;
import java.sql.*;
public class Testverbindung {
public static void main(String[] args){
String url = "jdbc:mysql://localhost:3306/falconbyte";
String user = "root";
String pass = "";
try {
Connection con = DriverManager.getConnection(url, user, pass);
Statement stm = con.createStatement();
ResultSet rs = stm.executeQuery("SELECT * FROM staedteUSA;");
while(rs.next()){
System.out.println(rs.getString(1) + " " +
rs.getString(2) + " " +
rs.getString(3) + " " +
rs.getString(4));
}
} catch (SQLException e) {
System.out.println(e.getMessage());
}
}
}Weitere SELECT-Abfragen
Mit der Abfrage SELECT * FROM tabellenname erhalten wir den gesamten Inhalt einer Tabelle zurück, d.h. alle Datenreihen und Spalten. Doch es gibt noch weitere nützliche Abfragen, die sich mit dem Schlüsselwort SELECT durchführen lassen.
Nur bestimmte Spalten liefern
Das Sternchen (*) bedeutet bei einer SELECT-Abfrage, dass alle Spalten zurückgeliefert werden sollen. Wollen wir nur bestimmte Spalten erhalten, ersetzen wir das Sterchnen (*) durch eine kommaseparierte Liste der gewünschten Spalten. Zum Beispiel:
Statement stm = con.createStatement();
String abfrage = "SELECT name, bundesstaat FROM staedteUSA;";
ResultSet rs = stm.executeQuery(abfrage);
while(rs.next()){
System.out.println(rs.getString(1) + " " +
rs.getString(2));
}In diesem Beispiel sollen nur die Daten aus den Spalten name und bundesstaat aus der Tabelle geholt und im ResultSet gespeichert werden. Entsprechend sieht das Ergebnis auf der Konsole aus:
New York City New York
Chicago Illinois
Las Vegas Nevada
Los Angeles Kalifornien
San Francisco Kalifornien
Miami Florida
Bedingungen mit WHERE
Sehr häufig kommt es vor, dass die Datensätze nach bestimmten Bedingungen gefiltert werden sollen. Angenommen, wir benötigen eine Ergebnistabelle mit allen Städten mit weniger als 1 Million, dann können wir das mithilfe des Schlüsselwortes WHERE und anschließender Bedingung erzielen. Der Abfrage-String sieht in diesem Fall dann so aus:
String abfrage = "SELECT * FROM staedteUSA WHERE einwohnerInMio < 1;";Die Ergebnistabelle besteht dann nur noch aus zwei Datzensätzen:
5 San Francisco Kalifornien 0.88
6 Miami Florida 0.46
Es lassen sich mit WHERE auch kombinierte Bedingungen erstellen. Hierzu verbinden wir die einzelnen Bebindungen mit den Operatoren AND bzw. OR:
String abfrage = "SELECT * FROM staedteUSA WHERE einwohnerInMio < 1 AND bundesstaat = 'Kalifornien';";Mit diese Abfrage wird nach Städten mit weniger als 1 Mio. Einwohner im Bundesstaat Kalifornien gesucht. Ein Datensatz entspricht diesen Bedingungen:
5 San Francisco Kalifornien 0.88
- Anführungszeichen beachten: Wenn wir in WHERE-Prüfungen nach Zeichenketten suchen (z.B. WHERE bundestaat = 'Kalifornien') muss der Suchbegriff in einfache Anführungszeichen gesetzt werden.
Datensätze sortieren mit SORT
Mit dem Schlüsselwort ORDER BY können wir die Datensätze einer Tabelle alphabetisch oder numerisch sortieren. Für eine aufsteigende Reihenfolge kann das Wörtchen ASC und für eine absteigende DESC ergänzt werden:
String abfrage = "SELECT * FROM staedteUSA ORDER BY einwohnerInMio DESC";1 New York City New York 8.33
4 Los Angeles Kalifornien 4.00
2 Chicago Illinois 2.72
5 San Francisco Kalifornien 0.88
3 Las Vegas Nevada 0.63
6 Miami Florida 0.46
