Thema in Kurzform
Wir zeigen dir in diesem Tutorial, wie du dein Java-Programm mit einer MySQL-Datenbank verbindest.
// Voraussetzung: Einbindung des Java-MySQL Connectors
// Datenbankadresse und Anmeldedaten
String url = "jdbc:mysql://localhost:3306/falconbyte";
String user = "root";
String pass = "";
try {
// Verbindung aufbauen
Connection con = DriverManager.getConnection(url, user, pass);
System.out.println("Verbindung erfolgreich hergestellt");
} catch (SQLException e) {
System.out.println(e.getMessage());
}Exkurs: MySQL-Datenbank
Bevor wir loslegen und Java mit einer MySQL-Datenbank verbinden, sollten wir uns erst einmal klar machen, was eine MySQL-Datenbank überhaupt ist und wie wir eine solche möglichst einfach erstellen. Wenn du dich in MySQL schon auskennst, kannst du diesen Schritt überspringen.
Was ist eine MySQL-Datenbank?
Eine Datenbank ist - allgemein gesagt - eine strukturierte Sammlung von Daten. Dabei basieren MySQL-Datenbanken auf dem relationalen Datenbankmodell, das heißt, das die Daten in Form von Tabellen (Spalten und Zeilen) organisiert sind. Jede Zeile in einer Tabelle ist ein Datensatz. MySQL-Datenbanken laufen auf einem MySQL-Server.
MySQL-Datenbank erstellen
Am einfachsten können wir eine MySQL-Datenbank mithilfe des Tools phpMyAdmin erstellen und verwalten. Sofern wir unsere Datenbank auf einem lokalen System betreiben wollen, bietet sich die Installation des kostenlosen XAMPP-Programmpakets an, das uns eine ideale lokale Entwicklungsumgebung mit Apache Server, MySQL-Server und phpMyAdmin zur Verfügung stellt.
Nach der Installation von XAMPP starten wir aus dem Programm heraus den Apache- und MySQL-Server. Erst jetzt ist phpMyAdmin "lauffähig" und wir können sehr unkompliziert MySQL-Datenbanken erstellen. Um zu phpMyAdmin zu gelangen, geben wir im Browser die Adresse localhost/phpmyadmin ein. Wenn alles nach Plan läuft, sehen wir nun die phpMyAdmin-Startseite.
Um eine neue Datenbank zu erstellen, klicken wir in phpMyAdmin im Seitenmenu links auf Neu und geben anschließend einen passenden Namen der Datenbank ein, die wir anlegen wollen. Nennen wir sie doch einfach mal falconbyte - das klingt gut :)
Tabelle erstellen
Die Datenbank braucht jetzt noch mindestens eine Tabelle, in die Datensätze gespeichert werden können. Dazu wählen wir links im Menu von phpMyAdmin die eben erstellte falconbyte-Datenbank aus.
Anschließend geben wir unter Erzeuge Tabelle den Namen der Tabelle und die gewünschte Spaltenzahl ein. Als Namen setzen wir staedteUSA fest. Die Tabelle soll aus 4 Spalten bestehen.
Jetzt werden wir aufgefordert, die Struktur der Tabelle anzulegen. Die entsprechenden Eingaben sehen beispielhaft so aus:
Wenn wir fertig sind, kann die Tabelle mit einem Klick auf Speichern (unten rechts) erzeugt werden.
Datensätze einfügen
Was jetzt noch fehlt, ist der Inhalt, also Datensätze für unsere Tabelle. Hierzu klicken wir im Seitenmenu links unterhalb des Datenbank-Icons auf die Tabelle staedteUSA. Anschließend wählen wir oben im Menu den Button Einfügen aus.
Jetzt tragen wir die gewünschten Datensätze mit gültigen Werten ein und klicken auf OK:
MySQL Java Connector
Soweit so gut - wir haben nun eine MySQL-Datenbank mit einer Beispieltabelle aufgezogen. Es bedarf aber noch ein paar Vorbereitungen, um von einem Java-Programm darauf zugreifen zu können.
Zuerst müssen wir nämlich den MySQL Connector/J in unser Programm laden. Der Connector stellt die JDBC (Java Database Connectivity Language) Treiberklassen bereit, mit denen wir eine Verbindung zur MySQL-Datenbank herstellen können und außerdem die Datenbank verwalten können.
MySQL Connector downloaden
Den Connector downloaden wir unter https://dev.mysql.com/downloads/connector/j/. Bei der Auswahl des Betriebssystems kann "Platform independent" auswgewählt werden. Wir erhalten ein zip- bzw. tar-Archiv und entpacken es. Der Connector ist eine JAR-Datei namens mysql-connector-java-8.0.23.jar (je nach Versionsnummer unterschiedlich).
MySQL Connector einbinden
Jetzt können wir die JAR-Treiber-Datei in unser Java-Programm einbinden. Dies ist je nach IDE etwas unterschiedlich. Wir zeigen das Prozedere am Beispiel von intelliJ und Eclipse.
intelliJ
Um den MySQL Connector mit intelliJ in ein Java-Projekt einzubinden, gehst du so vor:
- Auf File in der oberen Menuleiste klicken.
- Project Structure auswählen.
- Modules auf der linken Seite klicken.
- Den Tab Dependencies wählen
- + Zeichen drücken
- 1 JARs or directories auswählen
Eclipse
Und nun die Anleitung für das Einbinden in Eclipse:
- Die JAR-Datei via drag & drop in den Projektordner (Seitenmenu links) ziehen. Es erscheint ein Dialogfeld das wir mit Copy files bestätigen.
- Rechtsklick auf die JAR-Datei im Eclipse-Projektverzeichnis > Build Pathauswählen und dann Configurate Build Path...
- Es erscheint ein neues Fenster. Hier unter dem Tab Libraries auf Modulepathund anschließend auf Add JARs... klicken
- Jetzt wählen wir den MySQL Connector aus, der sich ja im Projektverzeichnis befindet. Dann auf OK klicken.
- Das Ganze mit Apply and Close bestätigen und fertig!
Mit der MySQL-Datenbank verbinden
Jetzt ist unser Java-Programm technisch vorbereitet, um zu einer MySQL-Datenbank zu verbinden. Wir können also endlich mit dem Programmieren anfangen.
Klassen und Interfaces importieren
Der erste Schritt ist der Import der für die Arbeit mit MySQL notwendigen JDBC-Klassen und -Interfaces. Diese finden sich gesammelt im Paket java.sql:
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
import java.sql.ResultSet;
import java.sql.SQLException;Was sind die Aufgaben der einzelnen Klassen und Interfaces?
- Connection repräsentiert die Verbindung zur Datenbank und weiß, wie mit dieser kommuniziert werden kann.
- DriverManager liefert mit der statischen getConnection()-Methode die benötigte Connection-Instanz zurück.
- Statement führt die SQL-Abfrage durch und liefert das Ergebnis in Form eines Objekts vom Typ ResultSet zurück.
- ResultSet speichert die Datenreihen, die durch die SQL-Abfrage erzeugt wurde.
- SQLException benötigen wir für das ExceptionHandling beim Umgang mit MySQL-Datenbanken.
Verbindung zur Datenbank herstellen
Stellen wir jetzt zunächst die Verbindung zu unserer Beispiel-Datenbank her, die wir oben mit phpMyAdmin erstellt haben. Hier ist der Code:
package paket1;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
import java.sql.ResultSet;
import java.sql.SQLException;
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");
} catch (SQLException e) {
System.out.println(e.getMessage());
}
}
}Wir haben hierzu eine Klasse namens Testverbindung mit Main-Methode geschrieben. Die SQL-Klassen und Interfaces sind entsprechend importiert. Problemlos können wir den Import auch mit import java.sql.*; abkürzen.
Innerhalb der Main-Methode legen wir zunächst drei Strings fest, welche die JDBC URL sowie den Benutzernamen und das Passwort der Datenbank repräsentieren. Bei der lokalen XAMPP-Installation ist der Benutzername standardmäßig mit "root" gesetzt und das Passwort ist ein leerer String.
Etwas genauer müssen wir die JDBC URL unter die Lupe nehmen. Diese fordert ein bestimmtes Format und besteht aus vier Teilen: Protokollname, Datenbank-Typ und Adresse (inkl. Port) sowie Name der Datenbank:
Bei der lokalen XAMPP-Installation ist localhost:3306 die Standardadresse. Der Datenbankname lautet, wie zuvor in phpMyAdmin festgelegt, falconbyte.
Jetzt wird es spannend. Der finale Schritt beginnt und wir versuchen endlich, die Verbindung zur Datenbank herzustellen! Dazu rufen wir die statische Methode getConnection() auf, wobei wir die drei vorbereiteten Strings (url, user, pass) als Argumente einsetzen.
Bei erfolgreicher Verbindung liefert die Methode eine Instanz vom Typ Connection zurück, welche die Datenbank-Verbindung repräsentiert. Da wir dieses Objekt gleich noch unbedingt benötigen, um mit der Datenbank zu kommunizieren und SQL-Abfragen durchzuführen, halten wir es fest, indem wir es mit der Variablen con referenzieren.
Sollte die Verbindung nicht möglich sein (Server offline, falsche JDBC URL oder Anmeldedaten etc.) wird eine SQL-Exception geworfen, die wir brav mit einem try-catch-Block behandeln. Eine entsprechende Fehlermeldung wird auf der Konsole ausgegeben.
SQL-Abfrage durchführen
Führen wir nun testweise eine SQL-Abfrage durch, um die oben erstelle Tabelle in Java abzuholen:
Statement stm = con.createStatement();
ResultSet rs = stm.executeQuery("SELECT * FROM staedteUSA;");Mit der Methode createStatement(), die wir auf der Connection-Instanz aufrufen, wird ein Objekt vom Typ Statement erzeugt. Statement wiederum besitzt eine Methode namens executeQuery(), mit der wir SQL-Abfragen losschicken können.
Die Ergebnisdaten der SQL-Abfrage werden schließlich in einem Objekt vom Typ ResultSet gespeichert:
Das Zusammenspiel der einzelnen SQL-Klassen und -Interfaces sieht so aus:
In unserem Beispiel führen wir die SQL-Abfrage SELECT * FROM staedteUSA; durch. Das bedeutet, das wir alle Datensätze der Tabelle staedteUSA ausgelesen haben wollen.
Daten in Java anzeigen
Wie gesagt sind die Ergebnisdaten unserer SQL-Abrage im Objekt vom Typ ResultSet gespeichert, auf das die Referenz rs zeigt. Die Daten sind darin in einzelnen Reihen (=Datensätze) gespeichert.
Um an diese Daten ranzukommen, müssen wir sie zeilenweise auslesen. Dazu verwenden wir die ResultSet-Methoden next() und getString() in Kombination mit einer while-Schleife:
while(rs.next()){
System.out.println(rs.getString(1) + " " +
rs.getString(2) + " " +
rs.getString(3) + " " +
rs.getString(4));
}Beim Aufruf der next()-Methode springt der Cursor eine Datenreihe im ResultSet weiter. Sie liefert true zurück, 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 vollständige Programm
Das vollständige Programm zum Verbindungsaufbau mit der MySQL-Test-Datenbank sowie dem Auslesen einer MySQL-Tabelle seht Ihr hier:
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();
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));
}
} catch (SQLException e) {
System.out.println(e.getMessage());
}
}
}
