MySQL-Verbindung aufbauen

Diebspiel

Administrator

Beiträge: 313

Sonntag, 13. Januar 2013, 18:21

MySQL-Verbindung aufbauen

Autor: Flav
Datum: 5. Mai 2011

Da Datenbanken und insbesondere MySQL sehr weit verbreitet sind, möchte ich euch in diesem Thread erläutern wie ihr via Java eine Verbindung herstellen könnt.

Zuerst einmal laden wir uns die aktuellste Version von Connector/J,dem offiziellen JDBC-Treiber (Java Database Connectivity) für MySQL runter. Die Library müssen wir anschließend dem Classpath hinzufügen, wer sich schonmal eine der beiden Launchers vom Banana-Chat (start.bat und start.sh) angeschaut hat, weiß vielleicht schon wie das auszusehen hat. Hierzu startet man die JVM (Java Virtual Machine) mit der Option -cp bzw. -classpath und übergibt die Library als Parameter:

java -cp mysql-connector-java-X-bin.jar

Wer eine ältere Version der JVM nutzt muss auch noch den Treiber mit Hilfe der Option -D angeben oder diesen durch das Programm während der Laufzeit initialisieren lassen, aber für gewöhnlich braucht man das heute nicht mehr zu tun. Ob das vielleicht doch der Fall ist erkennt ihr
daran, dass ihr eine Fehlermeldung "No suitable driver" erhaltet. Aber darauf möchte ich nicht weiter eingehen, da die JVM sowieso immer auf dem neuesten Stand sein sollte wird das auch nicht der Fall sein, sonst wird euch Google sicherlich weiterhelfen.

Zunächst schauen wir uns an wie man eine Verbindung aufbaut, anschließend werde ich das dann etwas genauer erklären.

Java-Quelltext

Connection con = null;

try {
    con = DriverManager.getConnection(URL, USER, PASSWORD);
} catch (SQLException e) {
    e.printStackTrace();
} finally {
    if (con != null) {
        try {
            con.close();
        } catch (SQLException e) {
        }
    }
}

Ausserhalb des gesamten Blocks deklarieren wir eine neue Variable con der Klasse Connection mit dem Wert null, dieser weisen wir dann innerhalb des try-Blocks einen neuen Wert zu. Dabei greifen wir auf die Methode getConnection der Klasse java.sql.DriverManager zu, welcher drei Parameter übergeben wird. Die zwei Letzteren sollten eindeutig sein, der Erste lässt sich wie folgt beschreiben:
In JDBC wird eine Datenbank durch eine URL dargestellt. Für MySQL hat diese folgendes Format: jdbc:mysql://HOST:PORT/SCHEMA, wobei schema dem Name der Datenbank entspricht.
Schon jetzt steht die Verbindung und man kann damit arbeiten. Allerdings nur innerhalb des try-Blocks, was aber aufgrund der vielen Ausnahmen bei Datenbank so gewollt ist, da die Verbindung im letzten Block (finally) wieder geschlossen wird. Kommt es zu einer Ausnahme, wird diese im catch-Block ausgegeben.

Oft greift man nicht nur einmal auf die Datenbank zu, hierbei versucht man das ständige Schließen und Wiederherstellen einer Verbindung zu vermeiden. Dies erreicht man durch einen sogenannten Pool, die Verbindung wird hier nicht wirklich geschlossen sondern nur wieder freigegeben. Um eine Verbindung herzustellen greift man auf einen Pool zu, welcher möglicherwiese eine freie Verbindung zur Verfügung hat, ist dies der Fall wird diese geblockt und anschließend zurückgegeben. Es wird noch schnell geprüft, ob die Verbindung noch gültig ist bzw. ob es zu einem Timeout kam, in diesem Fall wird die Verbindung wiederhergestellt. Hat der Pool keine freie Verbindung zur Verfügung wird eine neue hergestellt um einen Stau zu vermeiden, auch diese kann anschließend wieder verwendet werden.
Das Aufbauen eines Pools wird von Anfängern oft als sehr lästig empfunden, da es von Erfahreneren oft auch als sehr schwierig dargestellt wird, ist es aber nicht. Ich habe hier zwei Klassen für euch, die sehr simpel aufgebaut und dennoch sehr effektiv sind. Ich verwende sie für alle meine Projekte, unter anderem dem Emulator, egal ob klein oder groß.

PoolConnection.java

Java-Quelltext

import java.io.FileInputStream;
import java.io.IOException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Properties;

/**
 *
 * @author Flav
 */
public class PoolConnection {
    private final static String
            url,
            user,
            password;

    private Connection con;
    private boolean inUse;

    static {
        Properties config = new Properties();

        try {
            FileInputStream in = new FileInputStream("database.properties");
            config.load(in);
            in.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

        url = config.getProperty("url");
        user = config.getProperty("user");
        password = config.getProperty("password");
    }

    public PoolConnection() {
        inUse = true;
    }

    public Connection connect() throws SQLException {
        if (con == null || !con.isValid(0)) {
            con = DriverManager.getConnection(url, user, password);
        }

        return con;
    }

    public boolean isInUse() {
        return inUse;
    }

    public void setInUse() {
        inUse = true;
    }

    public void close() {
        inUse = false;
    }
}

ConnectionPool.java

Java-Quelltext

import java.util.ArrayList;
import java.util.List;

/**
 *
 * @author Flav
 */
public class ConnectionPool {
    private final static List<PoolConnection> pool;

    static {
        pool = new ArrayList<PoolConnection>();
    }

    public static PoolConnection getConnection() {
        synchronized (pool) {
            for (PoolConnection pcon : pool) {
                if (!pcon.isInUse()) {
                    pcon.setInUse();
                    return pcon;
                }
            }

            PoolConnection pcon = new PoolConnection();
            pool.add(pcon);
            return pcon;
        }
    }
}

Die Authentifizierungsdaten (URL, Benutzername und Passwort) gibt man in einer Datei database.properties an. Diese sieht so aus:

	Quellcode
1 2 3	url = URL user = USER password = PASSWORD

Eine Verbindung wird ähnlich aufgebaut, der einzige Unterschied ist, dass man auf einen Pool zugreift.

	Java-Quelltext
1 2 3 4 5 6 7 8 9	PoolConnection pcon = ConnectionPool.getConnection(); try { Connection con = pcon.connect(); } catch (SQLException e) { e.printStackTrace(); } finally { pcon.close(); }

Ich hoffe das Tutorial war einigermaßen verständlich, hätte ich mehr Zeit wäre es definitiv noch detailierter gewesen. Ansonsten stehe ich euch für jegliche Fragen zur Verfügung, sofern ihr euch zumindest die Mühe gemacht habt es selbst zu versuchen.

Kein Support per PN. Nur im Forum!