Jetzt anmelden...

Login
Passwort
Registrieren
20.03.21 5038 Views Kommentare [4] 5 1

credit: ©MiaStendal

Java Tutorial #41

Java MySQL Verbindung aufbauen (Tutorial)

Größere Datenmengen werden in Datenbanken gespeichert. Weit verbreitet sind dabei MySQL-Datenbanken, welche die Daten in Form von Tabellen organisieren. Wir zeigen dir in diesem Tutorial, wie du dein Java-Programm mit einer MySQL-Datenbank verbindest.

Download als eBook

Schnelles Code-Beispiel:

// 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());
}

    Inhaltsverzeichnis

  1. Exkurs: MySQL-Datenbank
  2. MySQL Java Connector
  3. Mit der MySQL-Datenbank verbinden
  4. SQL-Abfrage durchführen
  5. Übungen

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:

Java MySQL verbinden

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:

Java MySQL verbinden

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:

  1. Auf File in der oberen Menuleiste klicken.
  2. Project Structure auswählen.
  3. Modules auf der linken Seite klicken.
  4. Den Tab Dependencies wählen
  5. + Zeichen drücken
  6. 1 JARs or directories auswählen

Java MySQL verbinden intelliJ

Eclipse

Und nun die Anleitung für das Einbinden in Eclipse:

  1. Die JAR-Datei via drag & drop in den Projektordner (Seitenmenu links) ziehen. Es erscheint ein Dialogfeld das wir mit Copy files bestätigen.
  2. Rechtsklick auf die JAR-Datei im Eclipse-Projektverzeichnis > Build Path auswählen und dann Configurate Build Path...
  3. Es erscheint ein neues Fenster. Hier unter dem Tab Libraries auf Modulepath und anschließend auf Add JARs... klicken
  4. Jetzt wählen wir den MySQL Connector aus, der sich ja im Projektverzeichnis befindet. Dann auf OK klicken.
  5. Das Ganze mit Apply and Close bestätigen und fertig!

Java MySQL verbinden Eclipse

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:

Java MySQL Datenbank URL verbinden

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:

Java MySQL Datenbank verbinden

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());
    }
}
}

Übungen

einfach

Wie lautet die JDBC URL für die folgende Datenbank:

  1. Hostname: db1239
  2. Name der Datenbank: DatenbankFuerFirma

Lösung ein-/ausblenden

mittel

Welche Aussage über den folgenden Code ist korret(eine Auswahl)?

package paket1;

import java.sql.*;

public class Testverbindung {

    static void test(){
        String url = "jdbc:mysql://localhost:3306/falconbyte";
        String user = "root";
        String pass = "";

        Connection con = DriverManager.getConnection(url, user, pass);
    }

        public static void main (String[]args){
            Testverbindung.test();
        }
}

A. Code nicht compilierbar: Es werden nicht alle benötigten Klassen importiert.
B. Code nicht compilierbar: Statische Methoden sind bei der Datenbankverbindung nicht zulässig.
C. Code nicht compilierbar: Die Interfaces Statement und ResultSet werden nicht eingesetzt.
D. Code nicht compilierbar: Es findet kein Exception-Handling statt.
E. Der Code lässt sich prima compilieren.

Lösung ein-/ausblenden

schwer

Bilden Sie folgende MySQL-Tabelle nach bzw. importierten Sie diese (falke.sql).

+----+----------+-------------+-----------+
| id | name     | rasse       | alterTier |
+----+----------+-------------+-----------+
|  1 | Drago    | Turmfalke   |        12 |
|  2 | Merlin   | Turmfalke   |        10 |
|  3 | Redhead  | Rotfußfalke |         5 |
|  4 | Lancelot | Silberfalke |         7 |
|  5 | Parzival | Buntfalke   |         1 |
+----+----------+-------------+-----------+   

Schreiben Sie Sie eine Verbindung zur Datenbank her und führen Sie eine MySQL-Abfrage durch, die alle Turmfalken auf der Konsole ausgibt

Lösung ein-/ausblenden

Falconbyte unterstützen

Kommentar schreiben

Alle Kommentare

Collio
17.01.2022 - 19:49

Vielen Dank - habs kapiert :-)

maxi
12.10.2021 - 06:31

cool

Severin
19.09.2021 - 18:03

Einfach und professionell erklährt.
Danke!

Programmer22
31.08.2021 - 09:21

Top!

Schleifen in Java

Schleifenstrukturen gehören zu den wichtigsten Grundlagen in der Programmierung überhaupt.

switch/ case Anweisung

Benötigen wir eine Unterscheidung nach vielen Fällen empfehlen sich switch-case-Statements.

Konstruktoren bei Vererbung

Trainieren Sie ihre Konstruktoren-Skills

FALCONBYTE.NET

Handmade with 🖤️

© 2018-2021 Stefan E. Heller

Impressum | Datenschutz

Falconbyte GitHub facebook programmieren lernen twitter programmieren lernen discord programmieren lernen