Thema in Kurzform
Zur MySQL-Datenbank verbinden und Datensätze auslesen ist kein Problem für Sie? Dann machen wir uns jetzt daran, neue Datensätze einzufügen, bestehende zu bearbeiten oder zu löschen.
// Neuen Datensatz einfügen
String einfuegen = "INSERT INTO tabelle_name(spalte1, spalte2) VALUES (wert1, wert2);";
Statement stm = con.createStatement();
stm.execute(einfuegen);// Datensatz bearbeiten
String update = "UPDATE tabelle_name SET spalte1=wert1, spalte2=wert2 WHERE id=wert";";
Statement stm = con.createStatement();
stm.execute(update);// Datensatz löschen
String loeschen = "DELETE FROM tabelle_name WHERE id=wert";";
Statement stm = con.createStatement();
stm.execute(loeschen);Ausgangslage
SQL-Beispieltabelle
Wir haben unser Java-Programm mit einer MySQL-Datenbank verbunden.
Als Beispieltabelle verwenden wir eine kleine Auflistung von US-Städten. Wenn Sie auch mit dieser Beispieltabelle arbeiten möchten, können Sie diese downloaden (rechte Maustaste -> Ziel speichern unter...) und via phpMyAdmin in Ihre Datenbank importieren. Die Tabelle staedteUSA hat folgenden Inhalt:
+----+---------------+-------------+----------------+
| 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 |
+----+---------------+-------------+----------------+Der manipulative Zugriff auf die Daten einer MySQL-Tabelle ist komplexer als die bloße Abfrage mit SELECT. Schließlich möchten wir die Daten der Tabelle auf unterschiedliche Art bearbeiten. Wir konzentrieren uns in diesem Kapitel auf drei Operationen:
- Datensätze einfügen mit INSERT
- Datensätze bearbeiten mit UPDATE
- Datensätze löschen mit DELETE
Das Java-Programm
Um die drei SQL-Operationen in Java zu veranschaulichen, schreiben wir eine Klasse namens Testverbindung. Die Klasse hat neben der Instanzreferenz auf die Connection folgende Methoden:
Jede Methode implementiert also einen unterschiedliche Art des Datenbankzugriffs.
Der Code-Rohbau der Klasse inklusive Main-Methode für den Start sieht entsprechend so aus:
package paket1;
import java.sql.*;
public class Testverbindung {
Connection con;
public void verbinden(){
// Zur MySQL-Datenbank verbinden
}
public void auslesen(){
// Tabelle auslesen
}
public void einfuegen(){
// neuen Datensatz einfügen
}
public void bearbeiten(){
// Datensatz mit gewählter nr bearbeiten (Einwohnerzahl ändern)
}
public void loeschen(){
// Datensatz mit gewählter nr löschen
}
public static void main(String[] args){
// Objekt von Testverbindung erzeugen
// Methoden aufrufen
}
}Auf die beiden Methoden verbinden() und auslesen() gehen wir hier nicht näher ein. Wie wir eine Datenbank verbinden und auslesen haben wir ja in den beiden vorgehenden Kapiteln schon gesehen.
Neuen Datensatz einfügen mit INSERT INTO
Für das Hinzufügen eines neuen Datensatzes in eine Tabelle wird eine SQL-Anweisung namens INSERT INTO benötigt. Die allgemeine SQL-Syntax lautet wie folgt:
INSERT INTO name_tabelle (spalte1, spalte2, ...) VALUES (wert1, wert2, ...);Nach den Schlüsselwörten INSERT INTO folgt der Name der Tabelle, in die eingefügt werden soll. Direkt dahinter werden in runden Klammern kommasepariert die Spalten genannt, die mit entsprechenden Werten belegt werden. Die konkreten Werte selbst werden ebenfalls in runden Klammern nach dem Wörtchen VALUES gelistet.
Jezt können wir den SQL-String passend zusammenbauen. Sagen wir beispielsweise, dass wir die Stadt Las Vegas in staedteUSA einfügen wollen:
String einfuegen =
"INSERT INTO staedteUSA(nr, name, bundesstaat, einwohnerInMio) VALUES (7, 'Las Vegas', 'Nevada', 0.64);";Keep in mind: Zeichenketten-Werte müssen von einfachen Anführungszeichenumgeben sein müssen.
Java-Methode fertigstellen
Zum Ausführen der INSERT-Anweisung wird der SQL-String als Argument der Methode execute übergeben:
Statement stm = con.createStatement();
stm.execute(einfuegen);Beim Versuch, SQL-Anweisungen auszuführen, kann viel schieflaufen (falsche SQL-Syntax, falsche Tabellen-Spaltenbezeichnungen etc.). Deshalb verlang der Compiler eine Ausnahmebehandlung mit try/ catch.
Die fertige Methode einfuegen() sieht schließlich so aus:
public void einfuegen(int nr, String name, String bundesstaat, double einwohnerInMio){
try {
String einfuegen =
"INSERT INTO staedteUSA(nr, name, bundesstaat, einwohnerInMio) VALUES (" + nr + ",'" + name + "','" + bundesstaat + "'," + einwohnerInMio + ");";
Statement stm = con.createStatement();
stm.execute(einfuegen);
} catch (SQLException e) {
e.printStackTrace();
}
}Wir haben Methode außerdem noch vier Parameter spendiert. Die entsprechenden Argumente, die wir beim Aufruf von einfuegen() dann konkret einegebn, werden benutzt, um den SQL-Abfragestring variabel zusammenzubauen.
Datensatz bearbeiten mit UPDATE
Zum Bearbeiten bzw. Aktualisieren eines bestehenden Datensatzes werden die SQL-Anweisungen UPDATE und SET eingesetzt.
Die allgemeine SQL-Syntax sieht so aus:
UPDATE tabelle_name SET spalte1=wert1, spalte2=wert2, ... WHERE bedingung;Wichtig ist die WHERE-Bedingung am Ende. So können Datensätze gezielt ausgewählt und dann aktualisiert werden. Fehlt dieser "Filter", werden alle Datensätze der Tabelle geändert!
Für eine Änderung der Einwohnerzahl von Miami (hat die nr 6) stellt sich der SQL-String wie folgt dar:
String einfuegen =
"UPDATE staedteUSA SET einwohnerInMio = 0.5 WHERE nr = 6;";Wie gesagt: Damit die Einwohnerzahl ausschließlich von Miami geändert wird, muss dieser Datensatz eindeutig identifiziert werden. Hierzu dient die WHERE-Suche nach der Stadt-Nr, die in der Tabelle nur einmal vorkommen sollte.
Java-Methode fertigstellen
Die fertigen Methode bearbeiten() sehen wir hier:
public void bearbeiten(int nr, double einwohnerInMio){
try {
String update =
"UPDATE staedteUSA SET einwohnerInMio=" + einwohnerInMio + " WHERE nr=" + nr + ";";
Statement stm = con.createStatement();
stm.execute(update);
} catch (SQLException e) {
e.printStackTrace();
}
}Auch hier wird der SQL-String durch stm.execute() ausgeführt und das Exception Handling ist Pflicht. Außerdem geben wir der Methode wieder ein paar Parameter mit: Einen zur Auswahl des Datensatzes und den zweiten für die neue Einwohnerzahl.
Datensatz löschen mit DELETE
Die nächste Art, den Inhalt einer MySQL-Tabelle zu manipulieren, ist das Löschen von Datensätzen:
DELETE FROM tabelle_name WHERE bedingung;Und hier ein Beispiel für das Löschen des Datensatzes Chigago (nr=2):
String loeschen =
"DELETE FROM staedteUSA WHERE nr=2";Fertige Java-Methode
Die fertige Java-Methode zum Löschen sehen wir hier:
public void loeschen(int nr){
try {
String loeschen =
"DELETE FROM staedteUSA WHERE nr=" + nr + ";";
Statement stm = con.createStatement();
stm.execute(loeschen);
} catch (SQLException e) {
e.printStackTrace();
}
}Zum Schluß noch der gesamte Code der Klasse 🥰
package paket1;
import java.sql.*;
public class Testverbindung {
Connection con;
public void verbinden(){
String url = "jdbc:mysql://localhost:3306/falconbyte";
String user = "root";
String pass = "";
try {
con = DriverManager.getConnection(url, user, pass);
} catch (SQLException e) {
System.out.println(e.getMessage());
}
}
public void auslesen(){
try {
String abfrage = "SELECT * FROM staedteUSA";
Statement stm = con.createStatement();
ResultSet rs = stm.executeQuery(abfrage);
while(rs.next()) {
System.out.println(rs.getString(1) + " " +
rs.getString(2) + " " +
rs.getString(3) + " " +
rs.getString(4));
}
} catch (SQLException e) {
e.printStackTrace();
}
}
public void einfuegen(int nr, String name, String bundesstaat, double einwohnerInMio){
try {
String einfuegen = "INSERT INTO staedteUSA(nr, name, bundesstaat, einwohnerInMio) VALUES (" + nr + ",'" + name + "','" + bundesstaat + "'," + einwohnerInMio + ");";
Statement stm = con.createStatement();
stm.execute(einfuegen);
} catch (SQLException e) {
e.printStackTrace();
}
}
public void bearbeiten(int nr, double einwohnerInMio){
try {
String update =
"UPDATE staedteUSA SET einwohnerInMio=" + einwohnerInMio + " WHERE nr=" + nr + ";";
Statement stm = con.createStatement();
stm.execute(update);
} catch (SQLException e) {
e.printStackTrace();
}
}
public void loeschen(int nr){
try {
String loeschen =
"DELETE FROM staedteUSA WHERE nr=" + nr + ";";
Statement stm = con.createStatement();
stm.execute(loeschen);
} catch (SQLException e) {
e.printStackTrace();
}
}
// Instanz erzeugen und alle Methoden testweise aufrufen
public static void main(String[] args){
Testverbindung tv = new Testverbindung();
tv.verbinden();
tv.einfuegen(8, "Seattle", "Washington", 0.7);
tv.bearbeiten(8, 0.71);
tv.loeschen(7);
tv.auslesen();
}
}Prepared Statement
Zur Einführung in SQL-Statements eignete sich das Interface Statement sehr gut. In einem Produktivsystem sollten wir es aber nicht einsetzen. Besser ist da der Gebrauch des davon abgeleiteten Sub-Interfaces PreparedStatement (dt.: "vorbereitete Anweisungen").
Mit einem PreparedStatement ergeben sich Vorteile in mehreren Bereichen:
- Bessere Performance
- Höhere Sicherheit
- Einfachere Lesbarkeit
Wie wir Prepared Statements einsetzen, schauen wir uns in diesem Kapitel an.
