Java als Mehrzwecksprache ermöglicht es uns, neben den unterschiedlichen Funktionalitäten, die wir erreichen können, auch mit der Persistenz von Daten zu arbeiten, um eine Verbindung zu den verschiedenen Datenbank- Engines herzustellen, die auf dem Markt existieren.

Eine Datenbank kann so einfach wie ein Schlüsselwertsystem in einer flachen Textdatei sein, da komplexere und modernere Lösungen wie nicht relationale die Entwicklung verschiedener Verbindungsschemata zu einem obligatorischen Merkmal machen .

JDBC verwenden

JDBC ist eine Gruppe von Klassen, mit denen Java Verbindungen mit Datenbankmodulen herstellen kann. Auf diese Weise können wir die Ergebnisse der Abfragen in einem Objekt namens ResultSet abrufen .

Da jede Engine anders ist, ist es wahrscheinlich, dass das Ergebnis-Set , das wir erhalten, spezifisch für sie ist. Deshalb ist es für uns nicht praktisch, unsere Anwendung um dieses Objekt herum zu strukturieren.

Um dieses Problem zu lösen, können wir ein sogenanntes Zugriffsobjekt verwenden , mit dem wir die verschiedenen Formen unseres ResultSet verwalten können, um dessen Anwendung in unserem Programm einfacher zu implementieren, und somit hat der Entwickler weniger Probleme.

Das DAO-Entwurfsmuster

Das Datenzugriffsobjekt oder DAO ist ein Entwurfsmuster, das das sammelt, was wir im vorherigen Punkt erklärt haben. Daher müssen wir eine Zugriffsklasse für die Eigenschaften unserer Datenbank erstellen. Damit dies funktioniert, müssen wir mit dem JDBC- Satz und dem Controller arbeiten, der es uns ermöglicht, eine Verbindung mit der gewünschten Engine herzustellen. Außerdem müssen wir die von uns erläuterte logische Implementierung durchführen, um die Abhängigkeit bestimmter Komponenten zu vermeiden, die die Migration zu einer Engine nur erschweren würden von verschiedenen Datenbank.

Stellen Sie unsere erste Verbindung über JDBC her

Das erste, was wir tun müssen, um eine JDBC- Verbindung aufzubauen, ist zu identifizieren, zu welcher Engine wir eine Verbindung herstellen möchten, und dann die erforderlichen Klassen für diese Verbindung abzurufen. In diesem Fall stellen wir eine MySQL- Verbindung her. Diese Engine ist leichtgewichtig, kostenlos und Multiplattform, damit wir es auf Windows, Linux oder Mac installieren können.

Holen Sie sich den Connector / J

Connector / J ist die Gruppe von Klassen, die vom MySQL- Entwicklungsteam angeboten werden. Mit diesen Klassen können wir JDBC in Verbindung mit diesem relationalen Datenbankmanager arbeiten lassen. Um sie in unser Projekt einbinden zu können, müssen wir die folgenden Schritte ausführen.

– Debemos descargar el archivo correspondiente a nuestra plataforma, ya sea Windows o para otras desde la página oficial de MySQL en el siguiente enlace . 1 – Wir müssen die entsprechende Datei entweder unter Windows oder für andere von der offiziellen MySQL- Seite unter folgendem Link auf unsere Plattform herunterladen.

Verbindung herstellen

Als nächstes müssen wir eine effektive Verbindung zu unserer Datenbank herstellen . Dazu müssen wir eine Verbindung mit mindestens einer Tabelle auf unserem lokalen Server erstellen. Auf diese Weise können wir einige Tests durchführen, um die Erstellung einer Datenbank zu vereinfachen test und wir verwenden das folgende Skript, um die Tabelle zu erstellen und einige Testdatensätze einzufügen, um die Entwicklung des Tutorials zu beschleunigen:

 
 TABELLE ERSTELLEN, WENN KEINE 'Benutzer' existieren ( 
 `id` bigint (20) NICHT NULL AUTO_INCREMENT, 
 `name` varchar (255) NICHT NULL, 
 `date` date NICHT NULL, 
 `state` int (11) NICHT NULL, 
 PRIMARY KEY (`id`) 
 ) ENGINE = InnoDB DEFAULT CHARSET = latin1 AUTO_INCREMENT = 3; 
 
 
 INSERT IN `users` (` id`, `name`,` date`, `state`) WERTE 
 (1, 'Benutzer 1', '2015-01-01', 1), 
 (2, 'Benutzer 2', '2015-01-01', 1);

Im folgenden Java- Code konzentrieren wir uns nun darauf, die Verbindung mit der Datenbank herzustellen. Mit einem try catch-Block überprüfen wir , ob die Verbindung effektiv und fehlerfrei ist. Wenn die Verbindung hergestellt wurde, wird eine Erfolgsmeldung ausgegeben.

 import java.sql.Connection; import java.sql.DriverManager; öffentliche Klasse PruebaConexion { private static final String path = "jdbc: mysql: // localhost"; private static final String user = "unser Benutzer"; private static final String password = "unser Passwort"; public static void main (String [] args) { versuche { Verbindung mit = DriverManager.getConnection (Pfad, Benutzer, Passwort); System.out.println ("Erfolgreiche Verbindung"); } catch (Ausnahme e) { e.printStackTrace (); } } }

Anhand dieses Codes können wir feststellen, dass wir zwei Bibliotheken aus dem Paket java.sql importieren müssen. Eine ist Connection , die für die Verwaltung aller Aktivitäten zur Kommunikation mit der Datenbank verantwortlich ist, und die andere ist DeviceManager , die für die Bereitstellung der Kommunikationsweise verantwortlich ist damit Wenn wir die Schritte korrekt ausgeführt haben, sollte die folgende Meldung angezeigt werden, wenn wir unser Beispiel in der Konsole ausführen:

java -connections-base-de-datos-3.jpg

Fragen stellen

Wir haben alles bereit, um mit dem Testen unserer Abfragen zu beginnen. Dazu benötigen wir mehrere Dinge. Das erste ist bereits das Objekt, das die Verbindung zur Datenbank herstellt . Dann müssen wir die Statement- und ResultSet- Pakete mit importieren Nachdem wir zuerst Abfragen senden und dann die Antwort erhalten können, durchlaufen wir schließlich das ResultSet- Objekt, in dem wir die in die Tabelle eingefügten Daten anzeigen und bevor wir das Programm schließen, müssen wir jedes der von uns erstellten Objekte schließen So garantieren wir die Integrität unserer Daten. Sehen wir uns den Code an, der zeigt, was erklärt wurde:

 import java.sql.Connection; import java.sql.DriverManager; import java.sql.ResultSet; import java.sql.Statement; öffentliche Klasse PruebaConexion { private static final String path = "jdbc: mysql: // localhost / test"; private static final String user = "unser Benutzer"; private static final String password = "unser Passwort"; public static void main (String [] args) { versuche { Verbindung mit = DriverManager.getConnection (Pfad, Benutzer, Passwort); Anweisungsabfrage = con.createStatement (); System.out.println ("Erfolgreiche Verbindung"); ResultSet result = query.executeQuery ("SELECT * FROM users"); while (result.next ()) { String name = result.getString ("name"); String date = result.getString ("date"); System.out.println ("Name:" + Name + "Datum Registrierung:" + Datum); } result.close (); query.close (); con.close (); } catch (Ausnahme e) { e.printStackTrace (); } } }

Es ist wichtig zu erwähnen, dass wir in unserem Pfadattribut das Attribut geändert und nach localhost den Namen der Datenbank mit dem Namen test hinzugefügt haben, in der wir unsere Benutzertabelle erstellen, unsere Datei kompilieren und ausführen müssen das folgende Bild:

java -connections-base-de-datos-4.jpg

Die vorbereiteten Aussagen

Nachdem wir das Beispiel der Verbindung und der Abfragen zur Datenbank betrachtet haben, müssen wir eine Zahl namens Prepare Statement verwenden , die die Arbeit erleichtert, indem wir vorbereitete Abfragen lassen, damit wir sie mehrmals ausführen können, ohne sie immer wieder neu erstellen zu müssen. Um diese Dynamik zu erreichen, ersetzen wir einmal die Werte, die wir für Variablen ändern müssen, und übergeben dann beim Ausführen der Abfrage die tatsächlichen Werte, die wir verwenden werden.

Vorteile

Dies hat mehrere Vorteile. Wir sagten, das Erste ist, dass man etwas verwenden kann, ohne es zu wiederholen, aber es dient auch der Sicherheit, da dies uns ermöglicht, mit den Werten umzugehen, die aus dem Einkommen des Benutzers stammen können, um zusätzlich einen Angriff auf unsere Datenbank zu vermeiden Wir können auch die Lesbarkeit unseres Programms verbessern.

Im folgenden Beispiel erstellen wir eine Abfrage mit Prepared Statement , damit sie während unseres Programms mehrmals verwendet werden kann. Sehen wir uns den resultierenden Code an:

 import java.sql.Connection; import java.sql.DriverManager; import java.sql.ResultSet; import java.sql.PreparedStatement; public class PreparedStatement Test { private static final String path = "jdbc: mysql: // localhost / test"; private static final String user = "unser Benutzer"; private static final String password = "unser Passwort"; public static void main (String [] args) { versuche { Verbindung mit = DriverManager.getConnection (Pfad, Benutzer, Passwort); PreparedStatement query = with.prepareStatement ("SELECT * FROM users Where id = ?;"); System.out.println ("Erfolgreiche Verbindung"); query.setInt (1, 1); ResultSet result = query.executeQuery (); while (result.next ()) { String name = result.getString ("name"); String date = result.getString ("date"); System.out.println ("Name:" + Name + "Datum Registrierung:" + Datum); } result.close (); query.close (); con.close (); } catch (Ausnahme e) { e.printStackTrace (); } } }

Wir stellen fest, dass die Verwendung der setInt- Methode mit dem Abfrageobjekt bedeutet, dass wir den erforderlichen Parameter für die Abfrage übergeben können. Dadurch können wir denselben Parameter von der Ausführung der Abfrage trennen und dadurch Portabilität und Lesbarkeit erlangen. Abschließend kompilieren wir unser Programm und führen es aus:

java -connections-base-de-datos-5.jpg
Damit schließen wir dieses Tutorial ab, da wir die Optionen für die Arbeit mit Datenbanken in Java als sehr interessant ansehen, da sie es uns ermöglichen, Flexibilität und Vielseitigkeit in unsere Anwendungen einzubeziehen. Das Wichtigste ist, dass wenn wir Erfahrung mit anderen Sprachen haben, diese sicherlich ausgenutzt werden können.

Arbeiten mit Datenbanken in Java