JDBI - Eine Java Sql Library

  • JDBI ist eine Java Library welche es erleichtert MySQL Datenbanken zu benutzen. In diesen Tutorial werde ich eine kleine Einleitung in diese Library geben und euch von den Vorteilen überzeugen. Dabei werde ich zudem auf verschiedene Maven-Repos zurückgriefen.

    1 Warum sollte man eine Library für SQL benutzen?

    Library haben meist den Vorteil, dass man sich eine ganze Menge Code und Arbeit spart. Dies bietet auch die JDBI Library, welche dazu entwickelt wurde, dem Programmierer Arbeit abzunehmen und trotzdem nicht auf Leistung zu verzichten. JDBI ist eine sehr leistungsstarke Library und bietet zwei verschiedene API´s. Dazu gehören die fluent API und die objective API. In diesem Tutorial möchte ich aber gerne mich auf die letztere konzentrieren. Weitere Informationen darüber sind auf der offiziellen Webseite von JDBI zu finden.


    2 Was benötigen wir dafür?

    Da ich für dieses Tutorial wie schon geschrieben Maven Kentnisse voraussetze, welche ich hier nur noch die zwei Dependencies vorgeben und die dazu benötige, welche wir benötigen.

    3 Eine erste Verbindung aufbauen

    Zu aller erst fangen wir mal in der Main Klasse eures Vorhabens an. Um nun eine Verbindung aufzubauen müssen wir zuerst eine Variable festlegen auf welche wir im Nachhinein immer wieder zugreifen werden. Aus diesem Grund habe ich dieser Variable den Modifier static zugewiesen. Dazu gibts dann noch eine GET Funktion um diese auch zu erreichen.

    Java
    1. private static Handle sql;
    2. public static Handle getSql() {
    3. return sql;
    4. }


    Da meist kein aktueller Datenbank-Treiber von APIs wie Spigot etc. mitgeliefert wird, bauen wir und zu Absicherung eine neue Klasse, welche diese von sich selbst auch mitbringt.


    Kommen wir zurück zur Main Klasse und gehen in unsere main() Funktion rein. Hier müssen wir den gerade erstellen Treiber nun laden. Dies geschieht in etwa so:

    Java
    1. try {
    2.     new Driver();
    3. } catch (ClassNotFoundException | SQLException e) {
    4.     System.err.println("Could not load MySQL driver.");
    5.     System.err.println(e.getStackTrace().toString());
    6.     return;
    7. }


    Die Verbindung wird selbst nun ziemlich einfach aufgebaut. Wir erstellen ein neues DBI Objekt und übergeben alle wichtigen Verbindungsinformationen. Dazu gehören Host, Port, Datenbank, User und das Passwort. Gegebenenfalls kann man noch Argumente wie autoReconnect hinzufügen. Dazu erstellen wir und ein paar Variablen und tragen dort unsere Informationen ein. Natürlich kann dies auch über eine Konfigurationsdatei realisiert werden.

    Java
    1. String host = "127.0.0.1";
    2. int port = 3306;
    3. String database = "dantenbank";
    4. String user = "einUser"
    5. String password = "passwort";
    6. DBI dbi = new DBI("jdbc:mysql://" + host + ":" + port + "/" + database + "?user=" + user + "&password=" + password + "&autoReconnect=true");

    Um die Verbindung nun zu öffnen, setzten wir unsere schon erstellte Variable sql mit der Funktion open() aus dem DBI Objekt.

    Java
    1. sql = dbi.open();

    Herzlichen Glückwunsch. Wir haben eine Verbindung aufgebaut. Im weiteren Schritt werden wir diesen auch mal benutzen.

    4 Tabellen und Objekte

    Ein riesen großer Vorteil von JDBI ist, dass man einfach seine Tabellen in Objekte parsen kann und diese dann zu weiteren Programmierung verwendet. Hierzu denken wir uns zum Start eine einfache Struktur aus und bauen uns eine passende Java Klasse. Als Beispiel habe ich eine Benutzer Tabelle ausgewählt, da diese verschiedene Datentypen zur besseren Anschauung wiederspiegelt. Im folgenden ist zuerst die Struktur und danach das dazugehörige Objekt zu finden.


    fg24yukh.png


    Natürlich wollen wir nun dieses Objekt beschreiben und kommen somit zum nächsten großen Punkt, den Mappern und DAO´s.

    5 Mapper und DAO´s

    Die Mapper und DAO´s stellen die eigentliche Schnittstelle zwischen SQL und Java dar. Hier beschreiben wir die Objekte und suchen und das aus, was wir wirklich aus der Datenbank haben wollen.

    Um nun unser Erstelltes Objekt auch zu füllen, benötigen wir eine neue Klasse. Diese nenne ich hier mal UserMapper.java. Diese implementiert einen ResultSetMapper<User> und verlangt unser zu beschreibendes Objekt. Zudem fordert dieses Interface eine map() Methode. Als Rückgabewert erhalten wir hier unser schon übergebenes Objekt. Um die Daten aus der Datenbank zu lesen greifen wir über das ResultSet auf die einzelnen Felder zu. Die ganze Klasse sieht dann am Schluss so aus.

    Da wir diese Methode nicht so einfach aufrufen können und Java ja noch gar nicht weiß, welche Tabelle wir wir wollen, erstellen wir uns nun unser UserDAO. Dies ist ein Interface welches uns Funktionen zur Verfügung stellt um die Tabelle zu verändern. Hier arbeiten wir mit SqlUpdate und SqlQuery. SqlUpdate ist für das Erstellen der Tabelle, Hinzufügen und Löschen von Einträgen und für das Updaten dieser zuständig. SqlQuery gibt uns die Möglichkeit die eingetragenen Daten auszulesen. Hierfür ist auf jeden Fall ein wenig Kenntnis mit SQL erforderlich, da wir all unsere Statements selber schreiben. Also fangen wir mal an. Zuerst mache ich mir einen Variable um dort meinen Tabellen-Namen zu vermerken. Dies wird mir im weiteren Verlauf ein wenig Arbeit sparen und ist bei Änderungen ganz hilfreich.

    Java
    1. String TABLE_NAME = "user";

    Danach erstellen wir uns ein SqlUpdate welches zum erstellen der Tabelle da ist. Darunter definieren wir eine Funktion void createTable();, welche wir dann im Nachhinein aufrufen werden.

    SQL
    1. @SqlUpdate("CREATE TABLE IF NOT EXISTS `" + TABLE_NAME
    2. + "` (`id` INT NOT NULL PRIMARY KEY AUTO_INCREMENT, `name` VARCHAR(32) NOT NULL,"
    3. + " `city` VARCHAR(32) NOT NULL, `street` VARCHAR(64) NOT NULL, `number` INT NOT NULL,"
    4. + " `registered` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, `description` TEXT)")
    5. void createTable();

    Danach basteln wir uns noch weitere Funktionen zum Hinzufügen, Updaten und Löschen zusammen. Mit der @Bind() Annotation verbinden wir die gesetzten Variablen, welche mit : eingeleitet werden, mit unseren Java Variablen, die von der Methode gefordert werden.

    Da wir auch die eingefügten Daten wieder auslesen möchten, erstellen wir uns noch weitere Funktionen um diese über alle möglichen Variationen zu erreichen. Dies muss man natürlich nicht machen, ich mache es hier aber trotzdem der Vollständigkeit halber. Dazu benötigen wir die schon erwähnte @SqlQuery Annotation. Wichtig ist hierbei noch, dass wir den Richtigen Mapper über @RegisterMapper(UserMapper.class) registrieren und uns überlegen, ob wir eine Liste oder ein einzelnes Objekt zurück bekommen.

    Und damit währen wir sogar schon wieder mit diesem Punkt fertig. Nun kommen wir zum Endsport und erstellen die Funktionen um nun wirklich auf die Daten zuzugreifen.

    6 Daten aus der Tabelle benutzen

    Um die Daten nun benutzen zu könne müssen wir ganz einfach eine Instanz unseres DAO`s an der gewünschten Stelle erstellen. Dies sähe dann in etwa so aus:

    Java
    1. UserDAO userDAO = Main.getSql().attach(UserDAO.class);

    Nun können wir über diese Instanz auf die Funktionen, welche wir vorhin geschrieben haben, zugreifen. Diese schreiben wir in ein neues Objekt, welches bei uns User ist. Mit diesem Objekt können wir nun ganz einfach weiter arbeiten und zum Beispiel die Beschreibung auslesen.

    Java
    1. User user = userDAO.selectByName("DevTek");
    2. String description = user.getDescription();

    Damit währen wir dann auch schon fertig.

    7 Schlusswort

    Ich hoffe ich konnte euch die Library JDBI ein bisschen näher bringen. Da dies eine ziemlich einfache und sehr starke Library ist, kann ich jedem empfehlen diese sich mal anzusehen. Falls noch fragen offen sind, schreibt es einfach hier drunter in die Kommentare.


    7.1 Quellen:

    http://jdbi.org/

Teilen

Kommentare 1