Apa itu JDBC? Pengantar Konektivitas Database Java

JDBC (Java Database Connectivity) adalah Java API yang mengelola koneksi ke database, mengeluarkan kueri dan perintah, dan menangani kumpulan hasil yang diperoleh dari database. Dirilis sebagai bagian dari JDK 1.1 pada tahun 1997, JDBC adalah salah satu komponen pertama yang dikembangkan untuk lapisan persistensi Java.

JDBC awalnya disusun sebagai API sisi klien, memungkinkan klien Java untuk berinteraksi dengan sumber data. Itu berubah dengan JDCB 2.0, yang menyertakan paket opsional yang mendukung koneksi JDBC sisi server. Setiap rilis JDBC baru sejak saat itu telah menampilkan pembaruan untuk paket sisi klien ( java.sql) dan paket sisi server ( javax.sql). JDBC 4.3, versi terbaru saat tulisan ini dibuat, dirilis sebagai bagian dari Java SE 9 pada September 2017.

Artikel ini menyajikan ikhtisar JDBC, diikuti dengan pengenalan langsung tentang penggunaan JDBC API untuk menghubungkan klien Java dengan SQLite, database relasional ringan.

Bagaimana JDBC bekerja

Dikembangkan sebagai alternatif dari API ODBC (Open Database Connectivity) berbasis C, JDBC menawarkan antarmuka tingkat pemrograman yang menangani mekanisme aplikasi Java yang berkomunikasi dengan database atau RDBMS. Antarmuka JDBC terdiri dari dua lapisan:

  1. JDBC API mendukung komunikasi antara aplikasi Java dan manajer JDBC.
  2. Pengandar JDBC mendukung komunikasi antara manajer JDBC dan pengandar database.

JDBC adalah API umum tempat kode aplikasi Anda berinteraksi. Di bawahnya adalah pengandar yang sesuai JDBC untuk database yang Anda gunakan.

Gambar 1 adalah gambaran arsitektur JDBC di lapisan persistensi Java.

JavaWorld /

Menggunakan JDBC untuk menghubungkan ke database

Salah satu fakta beruntung dari pemrograman di ekosistem Java adalah kemungkinan besar Anda akan menemukan konektor database JDBC yang stabil untuk database apa pun yang Anda pilih. Dalam tutorial ini kita akan menggunakan SQLite untuk mengenal JDBC, terutama karena sangat mudah digunakan.

Langkah-langkah untuk menghubungkan ke database dengan JDBC adalah sebagai berikut:

  1. Instal atau temukan database yang ingin Anda akses.
  2. Sertakan perpustakaan JDBC.
  3. Pastikan driver JDBC yang Anda butuhkan ada di jalur kelas Anda.
  4. Gunakan perpustakaan JDBC untuk mendapatkan koneksi ke database.
  5. Gunakan koneksi untuk mengeluarkan perintah SQL.
  6. Tutup koneksi setelah Anda selesai.

Kami akan melalui langkah-langkah ini bersama.

Menemukan driver JDBC

Untuk menemukan driver untuk database yang ingin Anda gunakan, cukup lakukan pencarian web untuk database dan JDBC Anda. Misalnya, mengetik " mysql jdbc driver" akan memunculkan driver untuk MySQL. Saya menantang Anda untuk menemukan database yang kompatibel dengan Java tanpa driver JDBC!

Langkah 1. Unduh dan instal SQLite

SQLite adalah database yang sangat kompak. Ini tidak dimaksudkan untuk penggunaan produksi, tetapi merupakan pilihan yang bagus untuk mencoba berbagai hal dengan cepat. SQLite menggunakan file sebagai database fungsionalnya, tanpa memerlukan layanan atau instalasi daemon apa pun.

Untuk memulai demo ini, lanjutkan dan unduh database sampel SQLite. Buka .dbzip file dan simpan di tempat yang tidak akan Anda lupakan.

File ini berisi database fungsional berbasis file serta skema sampel dan data yang dapat kita gunakan.

SQL dan JDBC

NoSQL telah menjadi populer selama dekade terakhir, tetapi database relasional tetap menjadi jenis database yang paling umum digunakan. Sebuah database relasional adalah gudang terstruktur yang terdiri dari tabel dengan kolom dan baris. SQL (Structured Query Language) adalah bahasa data yang digunakan arsitek untuk melakukan hal-hal seperti membuat, membaca, memperbarui, dan menghapus catatan baru dalam database relasional. JDBC adalah lapisan adaptor dari Java ke SQL: ini memberi pengembang Java antarmuka umum untuk menghubungkan ke database, mengeluarkan kueri dan perintah, dan mengelola tanggapan.

Langkah 2. Impor JDBC ke dalam aplikasi Java Anda

Kita dapat melakukan pengkodean dalam IDE, tetapi pengkodean langsung di editor teks akan lebih menunjukkan kesederhanaan JDBC. Untuk memulai, Anda harus memiliki instalasi JDK yang kompatibel untuk sistem operasi Anda.

Dengan asumsi Anda telah menginstal alat pengembang platform Java, kita dapat mulai dengan membuat program Java sederhana. Di editor teks Anda, tempelkan kode yang ditunjukkan pada Daftar 1. Panggil file ini WhatIsJdbc.java.

Kode 1. Sebuah program Java sederhana

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

Sekarang mengkompilasi kode dengan memasukkan perintah: javac WhatIsJdbc.java. Kompilasi akan menampilkan WhatIsJdbc.classfile. Jalankan file ini dari baris perintah dengan panggilan: java WhatIsJdbc.

[Lihat "Apa itu JDK? Pengantar Java Developer Kit" untuk mengetahui selengkapnya tentang berinteraksi dengan JDK pada baris perintah.]

Setelah Anda memiliki program Java dasar, Anda dapat memasukkan perpustakaan JDBC. Tempelkan kode dari Daftar 2 di bagian atas program Java sederhana Anda.

Daftar 2. Impor JDBC

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

Setiap impor ini menyediakan akses ke kelas yang memfasilitasi koneksi database Java standar:

  • Connection mewakili koneksi ke database.
  • DriverManagermendapatkan koneksi ke database. (Opsi lainnya adalah DataSource, digunakan untuk penggabungan koneksi.)
  • SQLException menangani kesalahan SQL antara aplikasi Java dan database.
  • ResultSetdan Statementmodelkan kumpulan hasil data dan pernyataan SQL.

Kami akan segera melihat masing-masing ini beraksi.

Langkah 3. Tambahkan driver JDBC ke classpath Anda

Selanjutnya, Anda akan menambahkan driver SQLite ke classpath Anda. Sebuah driver JDBC adalah sebuah kelas yang mengimplementasikan API JDBC untuk database tertentu.

Unduh driver SQLite dari GitHub. Pastikan untuk mendapatkan .jarfile terbaru dan simpan di tempat yang akan Anda ingat.

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.

Meskipun JDBC cukup untuk aplikasi yang lebih sederhana, sebagian besar pengembang pada akhirnya akan menggunakan Java Persistence API (JPA) untuk mengembangkan lapisan akses data yang lebih formal. JPA membutuhkan lebih banyak pekerjaan di muka dan pemahaman yang lebih canggih tentang arsitektur aplikasi, tetapi JPA memberi Anda lapisan akses data yang lebih konsisten, terisolasi, dan terdefinisi dengan baik. Lihat pendamping artikel ini, "Apa itu JPA? Pengantar Java Persistence API" untuk informasi selengkapnya tentang mengembangkan lapisan persistensi data untuk aplikasi Java Anda.

Artikel ini, "Apa itu JDBC? Pengantar Konektivitas Database Java" pertama kali diterbitkan oleh JavaWorld.