In diesem Artikel werden die grundlegenden Kenntnisse und Fähigkeiten von JDBC anhand von Beispielen beschrieben. Teilen Sie es als Referenz mit allen. Die spezifische Analyse lautet wie folgt:
1. Was ist JDBC?
Laienhaft ausgedrückt verwendet die JDBC-Technologie ein Java-Programm, um SQL-Anweisungen an die Datenbank zu senden. Die Datenbank führt die SQL-Anweisungen nach dem Empfang aus und gibt die Ergebnisse zur Verwaltung an das Java-Programm zurück.
2. Was sind die Bedingungen für die Nutzung von JDBC?
A) Die Adresse des Zieldatenbankhosts
B) Die von der Datenbanksoftware auf dem Host belegte Portnummer
C) Benutzername, der zum Anmelden bei der Datenbank verwendet wird
D) Passwort für diesen Benutzernamen
E) Stellen Sie eine Verbindung zur Datenbank her
3. Prinzipien der JDBC-Technologie
Wir wissen, dass es verschiedene Arten von Datenbanken gibt und die von verschiedenen Herstellern erstellten Datenbankstandards und -spezifikationen unterschiedlich sind. Wenn wir derzeit JAVA-Code zum Senden von SQL-Anweisungen verwenden, müssen wir einen Satz nach dem anderen für verschiedene Datenbanken schreiben. Eine Reihe von Operationscodes, was für Programmentwickler einen enormen Entwicklungskostenaufwand darstellt, so SU Als Unternehmen N die JDBC-Technologie entwickelte, legte es fest, dass die Datenbankhersteller einen Treiber zur Implementierung dieser Schnittstellen bereitstellen müssen. Solange Programmentwickler den Treiber der Datenbank während der Entwicklung verwenden, müssen sie eine konsistente Methode verwenden Für die Entwicklung ist es nicht erforderlich, eine Reihe von Codes zu schreiben, um sie an verschiedene Datenbanken anzupassen.
4. Kern-API in JDBC
|- Treiber: Die von der Treiberklasse implementierte Schnittstelle.
|-Connection connect(String url, Properties info) – wird verwendet, um eine Verbindung zur Datenbank herzustellen und das Verbindungsobjekt abzurufen
Parameter, die in den Eigenschaften festgelegt werden müssen:
URL: URL-String der Datenbankverbindung. Protokoll+Datenbank-Unterprotokoll+Host+Port+Datenbank
Benutzer: Datenbankbenutzername
Passwort: Passwort des Benutzers
|-Connection: Schnittstelle zur Verbindung mit der Datenbank
|- Statement createStatement() – Erstellen Sie ein Statement-Objekt zum Senden von SQL-Anweisungen
|- PreparedStatement PrepareStatement(String SQL) – Erstellt ein PreparedStatement-Objekt zum Senden vorkompilierter SQL-Anweisungen
|-CallableStatement PrepareCall(String SQL) – Erstellen Sie ein CallableStatement-Objekt zum Aufrufen gespeicherter Prozeduren.
|-Anweisung: Wird zum Ausführen statischer SQL-Anweisungen verwendet
|-intexecuteUpdate(String sql) –Aktualisierungsvorgang ausführen (DDL+DML)
|-ResultSetexecuteQuery(String sql) – Abfrageoperation ausführen (DQL)
|- PreparedStatement: Wird zum Ausführen vorkompilierter SQL-Anweisungen verwendet
|- intexecuteUpdate() – Aktualisierungsvorgang durchführen
|- ResultSetexecuteQuery() – Abfrageoperation ausführen
|- CallableStatement: SQL wird zum Ausführen gespeicherter Prozeduren verwendet
|- ResultSetexecuteQuery() – Rufen Sie die gespeicherte Prozedur auf
|- ResultSet: Ergebnismenge. Wird zum Kapseln der Abfragedaten der Datenbank verwendet
|-boolean next() – Bewegt den Datensatzcursor in die nächste Zeile
|- Object getObject(int columnsIndex) – Ruft den Wert des Feldes ab
Nachdem wir verstanden haben, welche APIs es gibt, verwenden wir JDBC zum Senden von SQL-Anweisungen~
5. Verwenden Sie das Statement-Objekt, um die Datenbank zu betreiben
DDL- und DML-Operationen
Schritt 1
Importieren Sie das Paket, da ich eine MySQL-Datenbank verwende. Um die JDBC-Technologie verwenden zu können, müssen Sie daher den vom MySQL-Datenbankhersteller bereitgestellten Datenbanktreiber verwenden. Daher besteht der erste Schritt darin, das Datenbanktreiberpaket in das Projekt zu importieren.
Verwendeter Paketname: mysql-connector-java-5.1.7-bin.jar
Schritt 2
Erstellen Sie eine gewöhnliche Klasse, fügen Sie eine Methode hinzu und kopieren Sie den Code in die Methode wie folgt: //URL
private String url = "jdbc:mysql://localhost:3306/vmaxtam";
//Benutzer
privater String user = "root";
//Passwort
privater String passwort = „root“;
public void testDDL()throws Exception{
//1.Treiber registrieren
Class.forName("com.mysql.jdbc.Driver");
//2. Stellen Sie die Verbindung her
Connection conn = DriverManager.getConnection(URL, Benutzer, Passwort);
//3. Statement-Objekt erstellen
Anweisung stmt = conn.createStatement();
//4. SQL-Anweisung vorbereiten
String sql = "CREATE TABLE student(sid INT PRIMARY KEY,sname VARCHAR(20),age INT)";
//5. Senden Sie die SQL-Anweisung über das Anweisungsobjekt und geben Sie das Ausführungsergebnis zurück
int count = stmt.executeUpdate(sql);
//6.Ausführungsergebnisse drucken
System.out.println("Betroffene „+count+“ Datensätze");
}
//7. Ressourcen schließen
if(Anweisung!=null)
{
Anweisung.close();
}
if(conn!=null)
{
conn.close();
}
Wenn Sie DQL- und DDL-Vorgänge ausführen möchten, können Sie die SQL-Anweisung schreiben und dann die Methode „executlUpdate“ der Anweisung aufrufen, um die SQL-Anweisung für die Datenbank auszuführen. Diese Methode gibt einen ganzzahligen Wert zurück, der angibt, wie viele Zeilen in der Datenbank betroffen sind.
Wenn wir das obige Programm nicht ändern und erneut SQL-Anweisungen an die Datenbank senden möchten, müssen wir ein Programm schreiben, um erneut eine Verbindung herzustellen, und nach dem Vorgang müssen wir das Anweisungsobjekt und das Verbindungsobjekt schließen, was sehr umständlich ist . Daher extrahieren wir im Allgemeinen den Verbindungsprozess und den Objektfreigabeprozess in eine Toolklasse. Der Code in der Tool-Klasse lautet wie folgt:
Kopieren Sie den Code wie folgt: public class sqlUtil {
private static String url = "jdbc:mysql://localhost:3306/vmaxtam";
privater statischer String user = "root";
privater statischer String passwort = „root“;
// Verbindung herstellen
öffentliche statische Verbindung getconnection() {
Verbindungsverbindung = null;
versuchen {
// 1. Treiber registrieren
Class.forName("com.mysql.jdbc.Driver");
// 2. Stellen Sie die Verbindung her
conn = DriverManager.getConnection(URL, Benutzer, Passwort);
// 3. Holen Sie sich das Anweisungsobjekt
Anweisungserklärung = conn.createStatement();
} Catch (Ausnahme e) {
// TODO Automatisch generierter Catch-Block
e.printStackTrace();
}
Rücklaufverbindung;
}
// 7. Schließen Sie die Ressource
public static void close(Anweisungsanweisung, Verbindungsverbindung) {
{
versuchen {
if (Anweisung != null)
Anweisung.close();
if (Verbindung != null) {
Verbindung.close();
}
} Catch (SQLException e) {
// TODO Automatisch generierter Catch-Block
e.printStackTrace();
}
}
}
}
Folgende Punkte sind zu berücksichtigen:
1) Ein Benutzer muss den Treiber nur einmal registrieren. Es ist nicht erforderlich, den Treiber jedes Mal zu registrieren, wenn er eine Verbindung zur Datenbank herstellt. Daher schreiben wir den Registrierungsprozess des Treibers in einen statischen Codeblock.
2) Die URL, der Benutzername, das Passwort und der Treiberklassenname sind im Programm fest codiert. Um die Datenbank oder den Benutzer ändern zu können, ohne den Code zu ändern, schreiben wir diese Informationen normalerweise in eine Konfigurationsdatei.
Die Konfigurationsdatei wird in das src-Verzeichnis des Projekts geschrieben und trägt den Namen db.properties
Kopieren Sie den Code wie folgt: url=jdbc:mysql://localhost:3306/vmaxtam
Benutzer=root
Passwort=root
driversClass=com.mysql.jdbc.Drive
Lesen Sie dann die Konfigurationsdatei in sqlUtil und optimieren Sie sie schließlich in den folgenden Code. Kopieren Sie den Code wie folgt: public class sqlUtil {.
privater statischer String url = null;
privater statischer String user = null;
privater statischer String passwort = null;
privater statischer String driversClass= null;
statisch{
versuchen {
//1. Holen Sie sich das Bytecode-Objekt
Classclazz = sqlUtil.class;
//2. Rufen Sie getResourceAsStream auf, um den Pfad abzurufen
InputStream inputStream = clazz.getResourceAsStream("/db.properties");
Eigenschaften pro = neue Eigenschaften();
pro.load(inputStream);
//3. Parameter lesen
url=pro.getProperty("url");
passwort=pro.getProperty("passwort");
user=pro.getProperty("user");
driversClass=pro.getProperty("driverClass");
Class.forName(driverClass);
} Catch (Ausnahme e) {
e.printStackTrace();
System.out.println("Registrierung fehlgeschlagen!" + e.getMessage());
throw new RuntimeException(e);
}
}
// Verbindung herstellen
öffentliche statische Verbindung getconnection() {
Verbindungsverbindung = null;
versuchen {
// Verbindung herstellen
conn = DriverManager.getConnection(URL, Benutzer, Passwort);
// Anweisungsobjekt abrufen
Anweisungserklärung = conn.createStatement();
} Catch (Ausnahme e) {
e.printStackTrace();
}
Rücklaufverbindung;
}
// Schließe die Ressource
public static void close(Anweisungsanweisung, Verbindungsverbindung) {
{
versuchen {
if (Anweisung != null)
Anweisung.close();
if (Verbindung != null) {
Verbindung.close();
}
} Catch (SQLException e) {
// TODO Automatisch generierter Catch-Block
e.printStackTrace();
}
}
}
}
DQL-Betrieb
Wie kann man also JDBC verwenden, um Daten in der Datenbank abzufragen?
Kopieren Sie den Codecode wie folgt: @Test
public void testdsl() löst eine Ausnahme aus {
//Verbindung herstellen
cnn2=sqlUtil.getconnection();
Anweisungserklärung = cnn2.createStatement();
//SQL-Anweisung vorbereiten
String sql = "select * from subject";
//Rufen SieexecuteQuery auf, um die Abfrageanweisung auszuführen
ResultSet res = Statement.executeQuery(sql);
//Nach Abschluss der Abfrage zeigt res auf den Tabellenkopf. Wenn Sie Daten abrufen möchten, müssen Sie weiterhin auf die nächste Zeile des Abfrageergebnisses verweisen. Wenn keine nächste Datenzeile vorhanden ist, wird 0 zurückgegeben.
while(res.next())
{
//Erhalten Sie den Wert des Felds „sjid“ im Abfrageergebnis und stellen Sie sicher, dass der Typ klar ist
int id = res.getInt("sjid");
//Erhalten Sie den Wert des Felds „sjname“ im Abfrageergebnis, und der Typ muss klar sein
String name = res.getString("sjname");
System.out.println("ID:" + id + "NAME:" + name);
}
sqlUtil.close(Anweisung, cnn2);
}
Das Obige ist die Verwendung von Statement-Objekten zum Betreiben der Datenbank ~
6. Verwenden Sie PreparedStatement, um die Datenbank zu betreiben
Das PreparedStatement-Objekt ist eigentlich ein spezielles Statement-Objekt, das SQL-Anweisungen vorkompilieren kann. Wenn Sie die Parameter festlegen, können Sie dann die SQL-Anweisung ausführen
Der Kopiercode für DDL- und DML-Operationen lautet wie folgt: package com.vmaxtam.sqltest;
import java.sql.Connection;
import java.sql.PreparedStatement;
import org.junit.Test;
öffentliche Klasse PreparedStatementTest {
Verbindungsverbindung = null;
@Prüfen
public void ddldmlTest() löst eine Ausnahme aus {
// 1. Stellen Sie die Verbindung her
Verbindung = sqlUtil.getconnection();
// 2. SQL-Anweisungen, vorkompilierte Anweisungen und Parameter vorbereiten? Nummernplatzhalter
String sql = "INSERT INTO SUBJECT VALUES(?,?)";
// 3. Holen Sie sich das Objekt
PreparedStatement vorbereitetStatement = Connection.prepareStatement(sql);
/*
* 4. Um die SQL-Parameter festzulegen, müssen Sie die Parameternummer und ihren Typ kennen. Der erste Satz unten gibt an: Der erste Parameter der SQL-Anweisung ist vom Typ int und der Parameterwert ist auf 3 usw. festgelegt An.
*/
vorbereitetStatement.setInt(1, 3);
vorbereitetStatement.setString(2, "Englisch");
// 5. Übergeben Sie es an die Datenbank, um SQL auszuführen
int num = vorbereitetStatement.executeUpdate();
System.out.println("Es sind" + num + "betroffene Datensätze vorhanden");
sqlUtil.close(preparedStatement, Verbindung);
}
}
Das Obige besteht darin, das PreparedStatement-Objekt zum Senden von Einfügungsanweisungen zu verwenden. Auf die gleiche Weise können DDL- und DML-Anweisungen gesendet werden.
Vorteile der PreparedStatement-Vorkompilierung:
Durch die Vorkompilierung von PreparedStatement können Sie verschiedene Ziele abfragen, indem Sie unterschiedliche Parameter festlegen. Auf der Datenbankseite wird nur eine vorkompilierte Anweisung gespeichert. Wenn Sie jedoch Statement zum Senden einer Anweisung verwenden, wird jedes Mal, wenn eine Anweisung gesendet wird, eine gespeichert Datenbank, die viel Speicher beanspruchen kann.
Der Kopiercode für die DQL-Operation lautet wie folgt: @Test
public void dqlTest() löst eine Ausnahme aus {
// 1. Stellen Sie die Verbindung her
Verbindung = sqlUtil.getconnection();
// 2. SQL-Anweisungen, vorkompilierte Anweisungen und Parameter vorbereiten? Nummernplatzhalter
String sql = "select * from subject where sjid=? or sjname=?";
// 3. Holen Sie sich das Objekt
PreparedStatement vorbereitetStatement = Connection.prepareStatement(sql);
/*
* 4. Um die SQL-Parameter festzulegen, müssen Sie die Parameternummer und ihren Typ kennen. Der erste Satz unten gibt an: Der erste Parameter der SQL-Anweisung ist vom Typ int und der Parameterwert ist auf 3 usw. festgelegt An.
*/
vorbereitetStatement.setInt(1, 2);
vorbereitetStatement.setString(2, "Chinese");
// 5. Übergeben Sie es an die Datenbank, um SQL auszuführen
ResultSet rst = vorbereitetStatement.executeQuery();
//6.Iterieren Sie die Ergebnismenge
while(rst.next())
{
int id = rst.getInt("sjid");
String name = rst.getString("sjname");
System.out.println("ID:" + id + "NAME:" + name);
}
//7. Schließen Sie die Verbindung
sqlUtil.close(preparedStatement, Verbindung);
}
Sie können auch die Methode „executeQuery();“ aufrufen und die Ausgabe iterieren, nachdem Sie die Ergebnismenge ~ erhalten haben
Da Statement und PreparedStatement so ähnlich sind, vergleichen wir ihre Vor- und Nachteile
Der Unterschied zwischen Statement und PreparedStatement:
1. Andere Grammatik
Die Anweisung unterstützt nur die statische Kompilierung und SQL-Anweisungen sind hartcodiert.
PreparedStatement unterstützt die Vorkompilierung. Verwendung? Kommen Sie und nehmen Sie Platz.
2. Unterschiedliche Effizienz
Die Anweisung sendet jedes Mal eine SQL-Anweisung, unterstützt kein Caching und weist eine geringe Ausführungseffizienz auf.
PreparedStatement unterstützt die Vorkompilierung und wird in der Datenbank zwischengespeichert. Es müssen nur Parameter gesendet werden, und die Ausführungseffizienz ist schnell.
3. Unterschiedliche Sicherheit
Die Aussage lässt sich leicht injizieren.
Injektion: Schlaue Elemente können spezielle SQL-Anweisungen schreiben, um die Datenbank zu gefährden.
Zum Beispiel: Um die Informationen eines bestimmten Benutzers abzufragen
Allgemeine Situation: SELECT * FROM user_list wobei Benutzername=xxx und Passwort=xxx sind (xxx sollte hier den eigenen Benutzernamen und das Passwort des Benutzers eintragen)
Injektionssituation: SELECT * FROM user_list where username='abc' or 1=1 -- password=xxx;
Auf diese Weise ist 1 = 1 gleich und das Zeichen „--“ wird vor dem Passwort hinzugefügt, und der folgende Inhalt wird zu einem Kommentar und wird nicht ausgeführt. Mit anderen Worten: Alle Benutzerinformationen können ohne Passwörter abgefragt werden.
PreparedStatement kann die Injektion verhindern, da es die Parameter in der SQL-Anweisung angibt.
Fazit: Es wird empfohlen, PreparedStatement zu verwenden, da es schneller und sicherer ist .
7. Verwenden Sie CallableStatement, um gespeicherte Prozeduren auszuführen
Mit CallableStatement werden nur gespeicherte Prozeduren ausgeführt. Um gespeicherte Prozeduren zu erstellen, müssen wir sie noch in der Datenbank erstellen.
Schritt 1
Jetzt hat die Datenbank eine gespeicherte Prozedur erstellt:
Kopieren Sie den Code wie folgt: DELIMITER $
CREATE PROCEDURE pro_add(IN a INT , IN b VARCHAR(20),OUT c INT)
BEGINNEN
SELECT * FROM SUBJECT WHERE sjid=a OR sjname=b;
SET c=a+a+a+a;
ENDE $
Schritt 2
Verwenden Sie Java-Code, um die Ausgabeparameter auszuführen und abzurufen. Kopieren Sie den Code wie folgt: @Test
public void calaST() löst eine Ausnahme aus {
//Verbindung herstellen
Verbindung= sqlUtil.getconnection();
//SQL-Anweisung vorbereiten
String sql = "CALL pro_add(?,?,?)";
//Das callableStatement-Objekt abrufen
CallableStatement cbs = Connection.prepareCall(sql);
//Eingabeparameter festlegen, genau wie bei PreparedStatement
cbs.setInt(1, 3);
cbs.setString(2, "Math");
/*Wie stellt man also die Ausgabeparameter ein?
* Ausgabeparameter müssen registriert werden!
*/
cbs.registerOutParameter(3, java.sql.Types.INTEGER);//Sie müssen integrierte Objekte verwenden, um Parametertypen festzulegen
//SQL-Anweisung ausführen
cbs.executeQuery();
//Verwenden Sie die getXXX-Methode, um die Ausgabeparameter der entsprechenden Position abzurufen
Ganzzahl num= cbs.getInt(3);
System.out.println("a*4 ist " + num);
//Schließen Sie die Ressource
sqlUtil.close(cbs, Verbindung);
}
Ich hoffe, dass dieser Artikel für die Java-Programmierung aller hilfreich sein wird.