Wat is JDBC? Inleiding tot Java Database Connectivity

JDBC (Java Database Connectivity) is de Java API die de verbinding met een database beheert, queries en opdrachten afgeeft en resultaatsets verwerkt die uit de database zijn verkregen. JDBC werd in 1997 uitgebracht als onderdeel van JDK 1.1 en was een van de eerste componenten die werd ontwikkeld voor de Java-persistentielaag.

JDBC is aanvankelijk ontworpen als een client-side API, waarmee een Java-client kan communiceren met een gegevensbron. Dat veranderde met JDCB 2.0, dat een optioneel pakket bevatte dat JDBC-verbindingen aan de serverzijde ondersteunt. Elke nieuwe JDBC-release sindsdien bevat updates voor zowel het client-side pakket ( java.sql) als het server-side pakket ( javax.sql). JDBC 4.3, de meest recente versie op het moment van schrijven, werd in september 2017 uitgebracht als onderdeel van Java SE 9.

Dit artikel geeft een overzicht van JDBC, gevolgd door een praktische inleiding tot het gebruik van de JDBC API om een ​​Java-client te verbinden met SQLite, een lichtgewicht relationele database.

Hoe JDBC werkt

JDBC is ontwikkeld als een alternatief voor de op C gebaseerde ODBC-API (Open Database Connectivity) en biedt een interface op programmeerniveau die de mechanica van Java-applicaties die communiceren met een database of RDBMS afhandelt. De JDBC-interface bestaat uit twee lagen:

  1. De JDBC-API ondersteunt communicatie tussen de Java-toepassing en de JDBC-manager.
  2. Het JDBC-stuurprogramma ondersteunt de communicatie tussen de JDBC-manager en het databasestuurprogramma.

JDBC is de algemene API waarmee uw toepassingscode communiceert. Daaronder staat het JDBC-compatibele stuurprogramma voor de database die u gebruikt.

Figuur 1 is een architectonisch overzicht van JDBC in de Java-persistentielaag.

JavaWorld /

JDBC gebruiken om verbinding te maken met een database

Een van de gelukkige feiten van programmeren in het Java-ecosysteem is dat u waarschijnlijk een stabiele JDBC-databaseconnector zult vinden voor elke database die u kiest. In deze tutorial gebruiken we SQLite om JDBC te leren kennen, vooral omdat het zo gemakkelijk te gebruiken is.

De stappen om verbinding te maken met een database met JDBC zijn als volgt:

  1. Installeer of zoek de database die u wilt openen.
  2. Voeg de JDBC-bibliotheek toe.
  3. Zorg ervoor dat het JDBC-stuurprogramma dat u nodig hebt zich op uw klassenpad bevindt.
  4. Gebruik de JDBC-bibliotheek om verbinding te maken met de database.
  5. Gebruik de verbinding om SQL-opdrachten uit te voeren.
  6. Sluit de verbinding als u klaar bent.

We zullen deze stappen samen doorlopen.

Een JDBC-stuurprogramma zoeken

Om een ​​stuurprogramma te vinden voor de database die u wilt gebruiken, zoekt u op internet naar uw database en JDBC. Als u bijvoorbeeld " mysql jdbc driver" typt, wordt een stuurprogramma voor MySQL weergegeven. Ik daag je uit om een ​​Java-compatibele database te vinden zonder JDBC-stuurprogramma!

Stap 1. Download en installeer SQLite

SQLite is een zeer compacte database. Het is niet bedoeld voor productiegebruik, maar het is een uitstekende keuze om snel dingen uit te proberen. SQLite gebruikt een bestand als zijn functionele database, zonder dat enige service of daemon-installaties nodig zijn.

Download de SQLite-voorbeelddatabase om aan de slag te gaan met deze demo. Pak het .dbbestand uit en sla het ergens op dat u niet snel zult vergeten.

Dit bestand bevat zowel een functionele bestandsgebaseerde database als een voorbeeldschema en gegevens die we kunnen gebruiken.

SQL en JDBC

NoSQL is de afgelopen tien jaar populair geworden, maar relationele databases blijven het meest gebruikte type datastore. Een relationele database is een gestructureerde opslagplaats die bestaat uit tabellen met kolommen en rijen. SQL (Structured Query Language) is de taal die gegevensarchitecten gebruiken om zaken te doen als het maken, lezen, bijwerken en verwijderen van nieuwe records in een relationele database. JDBC is een adapterlaag van Java naar SQL: het geeft Java-ontwikkelaars een gemeenschappelijke interface om verbinding te maken met een database, vragen en opdrachten te geven en antwoorden te beheren.

Stap 2. Importeer JDBC in uw Java-applicatie

We zouden onze codering in een IDE kunnen doen, maar direct coderen in een teksteditor zal de eenvoud van JDBC beter demonstreren. Om te beginnen heeft u een compatibele JDK-installatie voor uw besturingssysteem nodig.

Assuming you have the Java platform developer tools installed, we can start by creating a simple Java program. In your text editor, paste in the code shown in Listing 1. Call this file WhatIsJdbc.java.

Listing 1. A simple Java program

 class WhatIsJdbc{ public static void main(String args[]){ System.out.println("Hello JavaWorld"); } } 

Now compile the code by entering the command: javac WhatIsJdbc.java. Compiling will output the WhatIsJdbc.class file. Execute this file from the command line with the call: java WhatIsJdbc.

[ See "What is the JDK? Introduction to the Java Developer Kit" for more about interacting with the JDK on the command line.]

Once you have a basic Java program, you can include the JDBC libraries. Paste in the code from Listing 2 at the head of your simple Java program.

Listing 2. JDBC imports

 import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; import java.sql.ResultSet; import java.sql.Statement; 

Each of these imports provides access to a class that facilitates the standard Java database connection:

  • Connection represents the connection to the database.
  • DriverManager obtains the connection to the database. (Another option is DataSource, used for connection pooling. )
  • SQLException handles SQL errors between the Java application and the database.
  • ResultSet and Statement model the data result sets and SQL statements.

We'll see each of these in action shortly.

Step 3. Add the JDBC driver to your classpath

Next, you'll add the SQLite driver to your classpath. A JDBC driver is a class that implements the JDBC API for a specific database.

Download the SQLite driver from GitHub. Be sure to get the most recent .jar file and store it somewhere you'll remember.

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 Statementss and ResultSets 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 PreparedStatements 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 PreparedStatements.

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.

Hoewel JDBC voldoende is voor eenvoudigere toepassingen, zullen de meeste ontwikkelaars uiteindelijk naar de Java Persistence API (JPA) kijken om een ​​meer formele gegevenstoegangslaag te ontwikkelen. JPA vereist meer werk vooraf en een geavanceerder begrip van de applicatiearchitectuur, maar het levert u een meer consistente, geïsoleerde en goed gedefinieerde gegevenstoegangslaag op. Zie de bijlage bij dit artikel, "Wat is JPA? Inleiding tot de Java Persistence API" voor meer informatie over het ontwikkelen van de gegevenspersistentielaag voor uw Java-toepassingen.

Dit verhaal, "Wat is JDBC? Inleiding tot Java Database Connectivity" is oorspronkelijk gepubliceerd door JavaWorld.