Was ist JDBC? Einführung in die Java-Datenbankkonnektivität
JDBC (Java Database Connectivity) ist die Java-API, die die Verbindung zu einer Datenbank, die Ausgabe von Abfragen und Befehlen sowie die Verarbeitung von Ergebnismengen aus der Datenbank verwaltet. JDBC wurde 1997 als Teil von JDK 1.1 veröffentlicht und war eine der ersten Komponenten, die für die Java-Persistenzschicht entwickelt wurden.
JDBC wurde ursprünglich als clientseitige API konzipiert, die es einem Java-Client ermöglicht, mit einer Datenquelle zu interagieren. Dies änderte sich mit JDCB 2.0, das ein optionales Paket enthielt, das serverseitige JDBC-Verbindungen unterstützt. In jeder neuen JDBC-Version wurden seitdem sowohl das clientseitige Paket ( java.sql
) als auch das serverseitige Paket ( javax.sql
) aktualisiert . JDBC 4.3, die aktuellste Version dieses Artikels, wurde im September 2017 als Teil von Java SE 9 veröffentlicht.
Dieser Artikel bietet einen Überblick über JDBC, gefolgt von einer praktischen Einführung in die Verwendung der JDBC-API zum Verbinden eines Java-Clients mit SQLite, einer kompakten relationalen Datenbank.
Wie JDBC funktioniert
JDBC wurde als Alternative zur C-basierten ODBC-API (Open Database Connectivity) entwickelt und bietet eine Schnittstelle auf Programmierebene, die die Mechanik von Java-Anwendungen behandelt, die mit einer Datenbank oder einem RDBMS kommunizieren. Die JDBC-Schnittstelle besteht aus zwei Ebenen:
- Die JDBC-API unterstützt die Kommunikation zwischen der Java-Anwendung und dem JDBC-Manager.
- Der JDBC-Treiber unterstützt die Kommunikation zwischen dem JDBC-Manager und dem Datenbanktreiber.
JDBC ist die allgemeine API, mit der Ihr Anwendungscode interagiert. Darunter befindet sich der JDBC-kompatible Treiber für die von Ihnen verwendete Datenbank.
Abbildung 1 zeigt eine Architekturübersicht von JDBC in der Java-Persistenzschicht.

Verwenden von JDBC zum Herstellen einer Verbindung zu einer Datenbank
Eine der glücklichen Tatsachen beim Programmieren im Java-Ökosystem ist, dass Sie wahrscheinlich einen stabilen JDBC-Datenbankconnector für jede Datenbank finden, die Sie auswählen. In diesem Tutorial werden wir SQLite verwenden, um JDBC kennenzulernen, hauptsächlich weil es so einfach zu bedienen ist.
Die Schritte zum Herstellen einer Verbindung mit einer Datenbank mit JDBC lauten wie folgt:
- Installieren oder suchen Sie die Datenbank, auf die Sie zugreifen möchten.
- Schließen Sie die JDBC-Bibliothek ein.
- Stellen Sie sicher, dass sich der benötigte JDBC-Treiber in Ihrem Klassenpfad befindet.
- Verwenden Sie die JDBC-Bibliothek, um eine Verbindung zur Datenbank herzustellen.
- Verwenden Sie die Verbindung, um SQL-Befehle auszugeben.
- Schließen Sie die Verbindung, wenn Sie fertig sind.
Wir werden diese Schritte gemeinsam durchlaufen.
Einen JDBC-Treiber finden
Um einen Treiber für die Datenbank zu finden, die Sie verwenden möchten, führen Sie einfach eine Websuche nach Ihrer Datenbank und JDBC durch. Wenn Sie beispielsweise " mysql jdbc driver
" eingeben, wird ein Treiber für MySQL angezeigt. Ich fordere Sie auf, eine Java-kompatible Datenbank ohne JDBC-Treiber zu finden!
Schritt 1. Laden Sie SQLite herunter und installieren Sie es
SQLite ist eine sehr kompakte Datenbank. Es ist nicht für die Produktion gedacht, aber eine gute Wahl, um Dinge schnell auszuprobieren. SQLite verwendet eine Datei als funktionale Datenbank, ohne dass Dienst- oder Dämoninstallationen erforderlich sind.
Laden Sie zunächst die SQLite-Beispieldatenbank herunter, um mit dieser Demo zu beginnen. Entpacken Sie die .db
Datei und speichern Sie sie an einem Ort, den Sie nicht vergessen werden.
Diese Datei enthält sowohl eine funktionale dateibasierte Datenbank als auch ein Beispielschema und Daten, die wir verwenden können.
SQL und JDBC
NoSQL ist in den letzten zehn Jahren immer beliebter geworden, aber relationale Datenbanken sind nach wie vor die am häufigsten verwendete Art von Datenspeichern. Eine relationale Datenbank ist ein strukturiertes Repository, das aus Tabellen mit Spalten und Zeilen besteht. SQL (Structured Query Language) ist die Sprache, mit der Datenarchitekten beispielsweise neue Datensätze in einer relationalen Datenbank erstellen, lesen, aktualisieren und löschen. JDBC ist eine Adapterschicht von Java zu SQL: Sie bietet Java-Entwicklern eine gemeinsame Schnittstelle zum Herstellen einer Verbindung zu einer Datenbank, zum Ausgeben von Abfragen und Befehlen sowie zum Verwalten von Antworten.
Schritt 2. Importieren Sie JDBC in Ihre Java-Anwendung
Wir könnten unsere Codierung in einer IDE durchführen, aber die Codierung direkt in einem Texteditor wird die Einfachheit von JDBC besser demonstrieren. Zu Beginn benötigen Sie eine kompatible JDK-Installation für Ihr Betriebssystem.
Angenommen, Sie haben die Java-Plattform-Entwicklertools installiert, können Sie zunächst ein einfaches Java-Programm erstellen. Fügen Sie in Ihrem Texteditor den in Listing 1 gezeigten Code ein. Rufen Sie diese Datei auf WhatIsJdbc.java
.
Listing 1. Ein einfaches Java-Programm
class WhatIsJdbc{ public static void main(String args[]){ System.out.println("Hello JavaWorld"); } }
Kompilieren Sie nun den Code, indem Sie den folgenden Befehl eingeben : javac WhatIsJdbc.java
. Beim Kompilieren wird die WhatIsJdbc.class
Datei ausgegeben . Führen Sie diese Datei über die Befehlszeile mit dem Aufruf aus : java WhatIsJdbc
.
[Weitere Informationen zur Interaktion mit dem JDK in der Befehlszeile finden Sie unter "Was ist das JDK? Einführung in das Java Developer Kit".]
Sobald Sie ein grundlegendes Java-Programm haben, können Sie die JDBC-Bibliotheken einschließen. Fügen Sie den Code aus Listing 2 am Anfang Ihres einfachen Java-Programms ein.
Listing 2. JDBC-Importe
import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; import java.sql.ResultSet; import java.sql.Statement;
Jeder dieser Importe bietet Zugriff auf eine Klasse, die die Standardverbindung der Java-Datenbank erleichtert:
Connection
repräsentiert die Verbindung zur Datenbank.DriverManager
erhält die Verbindung zur Datenbank. (Eine weitere Option wirdDataSource
für das Verbindungspooling verwendet.)SQLException
Behandelt SQL-Fehler zwischen der Java-Anwendung und der Datenbank.ResultSet
undStatement
modellieren Sie die Datenergebnismengen und SQL-Anweisungen.
Wir werden diese in Kürze in Aktion sehen.
Schritt 3. Fügen Sie den JDBC-Treiber zu Ihrem Klassenpfad hinzu
Als Nächstes fügen Sie den SQLite-Treiber Ihrem Klassenpfad hinzu. Ein JDBC-Treiber ist eine Klasse, die die JDBC-API für eine bestimmte Datenbank implementiert.
Laden Sie den SQLite-Treiber von GitHub herunter. Stellen Sie sicher, dass Sie die neueste .jar
Datei erhalten und an einem Ort speichern, an den Sie sich erinnern werden.
The next time you execute your Java program, you will pull that .jar
file in via the classpath. There are several ways to set the classpath. Listing 3 shows how to do it using a command-line switch.
Listing 3. Executing SQLite driver on the Java classpath
java.exe -classpath /path-to-driver/sqlite-jdbc-3.23.1.jar:. WhatIsJdbc
Notice that we've set the classpath to point at the driver and the local directory; this way Java will still find our class file.
Step 4. Obtain a database connection
The classpath now has access to the driver. Now, change your simple Java application file to look like the program in Listing 4.
Listing 4. Using the JDBC Connection class to connect to SQLite
import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; import java.sql.ResultSet; import java.sql.Statement; class WhatIsJdbc{ public static void main(String[] args) { Connection conn = null; try { String url = "jdbc:sqlite:path-to-db/chinook/chinook.db"; conn = DriverManager.getConnection(url); System.out.println("Got it!"); } catch (SQLException e) { throw new Error("Problem", e); } finally { try { if (conn != null) { conn.close(); } } catch (SQLException ex) { System.out.println(ex.getMessage()); } } } }
Compile and execute this code. Assuming all goes well, you will get an affirming message.
No suitable driver found?
If you've received an error that looks like "No suitable driver found for jdbc:sqlite
," then you need to revisit the classpath and make sure it points to the driver you downloaded. Failed driver connection is the most common stumbling block for beginners using JDBC. Don't sweat it; just fix it.
Now we're ready for some SQL commands.
Step 5. Query the database
With the live connection object in hand, we can do something useful, like querying the database. Listing 5 shows how to query SQLite using the JDBC Connection
and Statement
objects.
Listing 5. Querying the database with JDBC
import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; import java.sql.ResultSet; import java.sql.Statement; class WhatIsJdbc{ public static void main(String[] args) { Connection conn = null; try { String url = "jdbc:sqlite:path-to-db-file/chinook/chinook.db"; conn = DriverManager.getConnection(url); Statement stmt = null; String query = "select * from albums"; try { stmt = conn.createStatement(); ResultSet rs = stmt.executeQuery(query); while (rs.next()) { String name = rs.getString("title"); System.out.println(name); } } catch (SQLException e ) { throw new Error("Problem", e); } finally { if (stmt != null) { stmt.close(); } } } catch (SQLException e) { throw new Error("Problem", e); } finally { try { if (conn != null) { conn.close(); } } catch (SQLException ex) { System.out.println(ex.getMessage()); } } } }
In Listing 5 we use our Connection
object to obtain a Statement
object: conn.createStatement()
. We then use this object to execute an SQL query: stmt.executeQuery(query)
.
The executeQuery
command returns a ResultSet
object, which we then use to iterate over the data with while (rs.next())
. In this example, you should see the album titles we've queried on as output.
Notice that we also closed the connection, via a call to conn.close()
.
Network connections with JDBC
The database connection string in Listing 5 is for a local connection: jdbc:sqlite:path-to-db-file/chinook/chinook.db
. To access the database via a network, the connection string would need to include the network URL and (usually) credentials for accessing it.
Doing more with JDBC
So far we've covered the basics of using JDBC to connect to a database and issue SQL commands. While Statements
s and ResultSet
s work well for common scenarios, you'll likely need additional options for larger or more complex applications. Fortunately, the JDBC library continues evolving to meet most database access needs.
PreparedStatements
One easy way to increase the flexibility of your code is to replace the Statement
class with PreparedStatement
, as shown in Listing 6.
Listing 6. Using JDBC PreparedStatements
String prepState = "insert into albums values (?, ?);"; PreparedStatement prepState = connection.prepareStatement(sql); prepState.setString(1, "Uprising"); prepState.setString(2, "Bob Marley and the Wailers "); int rowsAffected = preparedStatement.executeUpdate();
PreparedStatement
replaces Statement
's hard-coded values with question marks (?
). Using PreparedStatement
s optimizes your code for reuse: a PreparedStatement
is compiled only once, and can then be reused with a variety of parameters. As your code base grows, you simply insert new values into the statement, instead of hacking the string object itself.
Batch updates
Whenever an application has several updates to issue, doing them in batches can greatly benefit performance. The essence of batching is to take the multiple updates and collect them together, then issue them all at once. Listing 7 uses JDBC's batch methods to perform a batch update of several PreparedStatement
s.
Listing 7. Batching with PreparedStatement
prepState.setString(1, "Uprising"); prepState.setString(2, "Bob Marley and the Wailers"); preparedStatement.addBatch(); prepState.setString(1, "Wildflowers"); prepState.setString(2, "Tom Petty and the Heartbreakers"); preparedStatement.addBatch(); int[] rowsAffected = preparedStatement.executeBatch();
JDBC transactions
Transactions in relational databases allow for a set of updates to be wrapped in an interaction that either succeeds or fails altogether. The basics of using a transaction via JDBC are to tell the system to turn off auto-commit, and then manually tell the system to commit when you are done. By default, auto-commit is on, which means whenever an executeUpdate
or executeInsert
is run, the command is committed.
Listing 8 shows a small slice of a JDBC transaction.
Listing 8. JDBC transactions
connection.setAutoCommit(false); // Use executeUpdate multiple times connection.commit();
When connection.commit()
is encountered, all the updates wrapped inside will be attempted, and if any fail, they all will be rolled back.
There are many more features in JDBC 4.3 worth exploring, including using CallableStatement
for stored procedures, using DataSource
objects for improved application performance (especially via connection pooling), and converting a JDBC ResultSet to a Java Stream.
Database-specific features
Although every JDBC-compliant database offers the same core features for connecting and interacting with a database via SQL, some databases do more than others. As an example, Oracle DB offers result caching, which is not required by the JDBC specification. Here's an example:
conn.prepareStatement ("select /*+ result_cache */ * from employees where employee_id < : 1");
This example is taken from the documentation for Oracle's JDBC OCI Driver.
Conclusion
JDBC is one of Java's oldest APIs, providing an easy-to-use solution for one of the perennial needs of Java application development. Knowing just the few JDBC calls demonstrated in this article will get you started using JDBC to connect to virtually any database. Once you've got those commands down, you can begin to explore some of the more sophisticated options that have been built into JDBC.
Während JDBC für einfachere Anwendungen ausreicht, werden die meisten Entwickler möglicherweise auf die Java Persistence API (JPA) zurückgreifen, um eine formellere Datenzugriffsschicht zu entwickeln. JPA erfordert mehr Vorarbeit und ein besseres Verständnis der Anwendungsarchitektur, bietet Ihnen jedoch eine konsistentere, isoliertere und klarere Datenzugriffsschicht. Weitere Informationen zum Entwickeln der Datenpersistenzschicht für Ihre Java-Anwendungen finden Sie im Begleiter zu diesem Artikel, "Was ist JPA? Einführung in die Java-Persistenz-API".
Diese Geschichte "Was ist JDBC? Einführung in die Java-Datenbankkonnektivität" wurde ursprünglich von JavaWorld veröffentlicht.