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.
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.
– En este tutorial trabajaremos bajo Windows por lo que para su implementación en nuestros ejemplos lo haremos en tiempo de ejecución para mayor facilidad, sin embargo al descargar el paquete lo instalamos para tener el mismo disponible en nuestro equipo. 2 – In diesem Tutorial werden wir unter Windows arbeiten, um die Implementierung in unseren Beispielen zu vereinfachen. Wenn wir jedoch das Paket herunterladen, installieren wir es, um es in unserem Team verfügbar zu machen.
– Ahora procederemos a probar que todo funcione correctamente en nuestro equipo, para ello haremos un pequeño código donde veremos si connector/J fue cargado exitosamente en nuestro sistema, para ello utilizaremos el siguiente código: 3 – Jetzt werden wir beweisen, dass alles in unserem Team korrekt funktioniert. Dazu werden wir einen kleinen Code erstellen, in dem wir sehen, ob der Connector / J erfolgreich in unser System geladen wurde. Dazu werden wir den folgenden Code verwenden:
öffentliche Klasse PruebaConexion { public static void main (String [] args) { versuche { Klasse <?> C = Class.forName ("com.mysql.jdbc.Driver"); System.out.println ("Geladene Klasse:" + c.getName ()); } catch (ClassNotFoundException ex) { System.err.println (ex); } } }
– Para ejecutar este ejemplo necesitamos incluir la dependencia, es recomendable que tengamos el .jar en la misma ruta de nuestro archivo PruebaConexion.java . 4 – Um dieses Beispiel auszuführen, müssen wir die Abhängigkeit einschließen. Es wird empfohlen, dass sich die .jar- Datei im selben Pfad wie unsere Datei TestConexion.java befindet . Nachdem dies behandelt wurde, kompilieren wir unsere Datei, öffnen eine Konsole und fügen zur Laufzeit mit dem Befehl -cp die .jar zum Klassenpfad hinzu. Schauen wir uns die Befehlszeile an:
javac -cp mysql-connector-java-5.1.34-bin.jar Testen Sie Connection.java
– Por último para ejecutar nuestro archivo solo necesitamos ejecutar la siguiente instrucción: 5 – Zum Schluss müssen wir nur noch die folgende Anweisung ausführen, um unsere Datei auszuführen:
java -cp mysql-connector-java-5.1.34-bin.jar Testverbindung
Wenn wir in unserer Konsole ein Ergebnis wie das folgende haben, können wir anfangen, mit Operationen an Datenbanken zu arbeiten :
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:
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:
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.
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:
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.
