What is a JDBC-Enabled Application?

A JDBC-enabled application is simply a Java application that uses JDBC API to interact with a relational database.

JDBC-enabled applications are Java programs designed to interact with databases using standardized connectivity protocols. These applications can range from enterprise resource planning (ERP) systems to financial reporting tools, ensuring seamless data retrieval and manipulation.

It can:

• Connect to different databases (MySQL, Oracle, PostgreSQL, SQL Server, etc.)
• Execute SQL queries (SELECT, INSERT, UPDATE, DELETE)
• Retrieve and process results
• Manage transactions (commit, rollback) How a JDBC-Enabled Application Works

The workflow is like this:

• Load JDBC Driver

The driver enables communication with a specific database.

• Class.forName("com.mysql.cj.jdbc.Driver");
• Establish Connection

Application requests a connection from the database.

• Connection con = DriverManager.getConnection(
• "jdbc:mysql://localhost:3306/mydb", "root", "password");
• Create and Execute Statements

SQL commands are sent through Statement, PreparedStatement, or CallableStatement.

• Statement stmt = con.createStatement();
• ResultSet rs = stmt.executeQuery("SELECT * FROM students");
• Process Results

Application reads results using ResultSet.

• while (rs.next()) {
• System.out.println(rs.getInt("id") + " " + rs.getString("name")); 12. }

13. Transaction Management (optional but important) con.setAutoCommit(false); // execute multiple queries con.commit();   // confirm changes con.rollback(); // undo if error

6. Close Resources

Always close ResultSet, Statement, and Connection to free resources.

con.close();

Features of JDBC-Enabled Applications

• Database Independent (just change driver & connection URL)
• Portable (works on any platform with Java)
• Secure (with PreparedStatements to prevent SQL injection)
• Scalable (can be extended with connection pooling, middleware, etc.)

What is a JDBC Driver?                                                             

JBDC drivers are unique implementation tools used for connecting to a particular database for interaction with the database server. There are various types of these drivers:

• JDBC-ODBC bridge driver (Type 1): This JDBC bridge driver contains a mapping to another data access API, such as ODBC drivers, which requires configuring on each system a Data Source Name (DSN) that represents the targeted database.
• JDBC-Native API (Type 2): This is a driver that utilizes the client-side libraries of the target database, also called a native-API driver.
• JDBC-Net pure Java (Type 3): Type 3 drivers use a three-tier approach to access databases through middleware to change JDBC calls into each database-specific call
• 100% pure Java (Type 4): This type of driver is the highest performance driver and is used for databases such as Oracle, IBM, and Sybase. It works directly with the vendor’s database using a socket connection.

JDBC Driver Types

The JDBC specification defines 4 types of drivers:

• Type-1: JDBC-ODBC Bridge Driver
  • Converts JDBC calls into ODBC (Open Database Connectivity) calls.
  • ODBC driver further communicates with the database.
  • Requires ODBC installed on client machine.
  • Disadvantages: Slow, platform-dependent, requires ODBC setup.
  • Rarely used today (removed from Java 8).

Flow:

Java App → JDBC API → Type-1 Driver → ODBC → Database

• Type-2: Native API Driver
  • Converts JDBC calls into native (C/C++) API calls of the database.
  • Requires database client libraries to be installed.
  • Faster than Type-1 but still platform-dependent.

Flow:

Java App → JDBC API → Type-2 Driver → Native DB Library → Database

• Type-3: Network Protocol Driver (Middleware Driver)
  • JDBC calls are sent to a middleware server using a database-independent protocol.
  • Middleware translates these calls into database-specific protocol.
  • Advantage: No client-side database libraries needed, works across databases.
  • Disadvantage: Middleware adds extra network overhead.

Flow:

Java App → JDBC API → Type-3 Driver → Middleware Server → Database

Type-4: Thin Driver (Pure Java Driver)

• Directly converts JDBC calls into database-specific network protocol.
• Written entirely in Java → platform-independent.
• Fastest, most commonly used today (e.g., MySQL Connector/J, Oracle Thin Driver).
• No need for client libraries or middleware.

Flow:

Java App → JDBC API → Type-4 Driver → Database

Comparison Table

Example: Using a Type-4 Driver (MySQL) import java.sql.*;



class JDBCDemo {     public static void main(String[] args) {

        try {

            // Load Type-4 Driver

            Class.forName("com.mysql.cj.jdbc.Driver");



            // Establish Connection

            Connection con = DriverManager.getConnection(

                "jdbc:mysql://localhost:3306/mydb", "root", "password");



            // Create Statement

Statement stmt = con.createStatement();



            // Execute Query

            ResultSet rs = stmt.executeQuery("SELECT * FROM students");



            // Process Results             while (rs.next()) {

                System.out.println(rs.getInt("id") + " " + rs.getString("name"));

            }



            // Close             con.close();

        } catch (Exception e) {

            System.out.println("Error: " + e);

        }

    }

}

Real-World JDBC Drivers

• MySQL → com.mysql.cj.jdbc.Driver (Connector/J)
• Oracle → oracle.jdbc.driver.OracleDriver (Thin Driver)
• PostgreSQL → org.postgresql.Driver
• SQL Server → com.microsoft.sqlserver.jdbc.SQLServerDriver

CRUD operations using JDBC

1. Insert Operation

To demonstrate the insert operation, I will use the same code from the blog post titled “Retrieve a Data Set from a Database”.

The initial part of the code, which connects the Java application to the database, remains unchanged. From there, we will modify the code to handle data insertion.

Below is the code that inserts a new customer record into the customer table of the aloka_p database.

import java.sql.*;  // Import SQL classes for database operations 
 
public class Main {     public static void main(String[] args) { 
        // Database connection parameters 
        String url = "jdbc:mysql://localhost:3306/aloka_p";  // JDBC URL (DB: aloka_p) 
        String userName = "root";  // MySQL username 
        String password = "Dinesh@12345";  // MySQL password 
        String query = "INSERT INTO customer VALUES (456, 'Shakya', '20245568', '0778835357', 'example_06@gmail.com');";   
                 try { 
            // Step 1: Load MySQL JDBC driver (optional in Java 8+) 
            Class.forName("com.mysql.cj.jdbc.Driver"); 
             
            // Step 2: Establish the connection to the database 
            Connection con = DriverManager.getConnection(url, userName, password);             System.out.println("Connected to database"); 
             
            // Step 3: Create a statement to execute the query 
            Statement stmt = con.createStatement(); 
             
            // Step 4: Execute the SQL INSERT query 
int rowsInserted = stmt.executeUpdate(query);  // Returns number of affected rows 
             
            // Print the result 
            System.out.println(rowsInserted + " row(s) inserted."); 
             
            // Step 5: Close the connection             con.close(); 
            System.out.println("Disconnected from database"); 
             
        } catch (Exception e) { 
            // Handle any exceptions (driver issues, SQL errors, etc.) 
            System.out.println("Error: " + e.getMessage()); 
        } 
    } 
} 

Step 4 of the code is crucial. The executeUpdate() method, which is called using the Statement object, is responsible for executing the INSERT query. This method returns the number of rows affected by the operation and the return type is integer. In this case, the output indicates that 1 row was inserted.

After running the code, if you check the customer table in the aloka_p database, you will see that the new customer details have been successfully added.

02. Update operation.

Let’s try to execute a update query.

In the example below I try to update the cust_name of customer Shakya to Shakya_01 in the customer table.

import java.sql.*;  // Import SQL package to enable JDBC operations 
 
public class Main {     public static void main(String[] args) { 
        // Step 1: Define database connection parameters 
        String url = "jdbc:mysql://localhost:3306/aloka_p";  // JDBC URL (localhost, port 3306, database 'aloka_p') 
        String userName = "root";  // MySQL username 
        String password = "Dinesh@12345";  // MySQL password 
         
        // Step 2: Define the SQL update query 
        String query = "update customer set cust_name = 'Shakya_01' where cust_id = 456;"; 
                 try { 
            // Step 3: Load the MySQL JDBC driver (optional in Java 8+) 
            Class.forName("com.mysql.cj.jdbc.Driver");   
             
            // Step 4: Establish a connection to the MySQL database 
            Connection con = DriverManager.getConnection(url, userName, password);             System.out.println("Connected to database"); 
             
            // Step 5: Create a statement to execute SQL queries 
            Statement stmt = con.createStatement(); 
             
            // Step 6: Execute the update SQL query 
            stmt.executeUpdate(query);  // Executes the update query (modifies records in the database) 
             
            // Step 7: Close the database connection 
con.close();
            System.out.println("Disconnected from database"); 
             
        } catch (Exception e) { 
            // Step 8: Handle any errors that occur during connection or query execution             System.out.println("Error: " + e.getMessage()); 
        } 
    } 
} 

03. Delete operation.

In the below code I try to delete the customer ID(cust_id) 457 entry.

import java.sql.*; 
 
public class Main {     public static void main(String[] args) { 
        String url = "jdbc:mysql://localhost:3306/aloka_p"; 
        String userName = "root"; 
        String password = "Dinesh@12345"; 
        String query = "delete from customer where cust_id = 457;"; 
         try { 
            Class.forName("com.mysql.cj.jdbc.Driver"); 
            Connection con = DriverManager.getConnection(url, userName, password); 
            System.out.println("Connected to database");             Statement stmt = con.createStatement();             stmt.executeUpdate(query); 
            con.close();
            System.out.println("Disconnected from database"); 
 
        } catch (Exception e) { 
            System.out.println("Error: " + e.getMessage()); 
        } 
    } 
} 

JDBC vs ODBC

What is ODBC?

• ODBC (Open Database Connectivity) is a standard API developed by Microsoft (early 1990s) that allows applications to connect to any databases (like Oracle, MySQL, SQL Server) using ODBC drivers.
• It is language-independent (i.e. it can be used with with C, C++, Java, Python, etc.) and relies on the ODBC driver manager for communication.

What is JDBC?

• JDBC (Java Database Connectivity) is a Java API developed by Sun Microsystems (now Oracle) that enables Java applications to interact with relational databases.
• It is Java-specific and works through JDBC drivers.

JDBC vs ODBC: Key Differences

How JDBC and ODBC Work

• JDBC:

Java App → JDBC API → JDBC Driver → Database

• ODBC:

App (C/C++/Java etc.) → ODBC API → ODBC Driver Manager → ODBC Driver → Database

Quick Example

JDBC Example (Java + MySQL):

Connection con = DriverManager.getConnection( 
    "jdbc:mysql://localhost:3306/testdb", "root", "password"); 
 
Statement stmt = con.createStatement(); 
ResultSet rs = stmt.executeQuery("SELECT * FROM students"); 
 
while (rs.next()) { 
    System.out.println(rs.getInt("id") + " " + rs.getString("name")); 
} 
con.close(); 

ODBC Example (C + SQL Server):

SQLHENV hEnv; 
SQLHDBC hDbc; 
SQLHSTMT hStmt; 
 
SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &hEnv); 
SQLAllocHandle(SQL_HANDLE_DBC, hEnv, &hDbc); 
SQLConnect(hDbc, (SQLCHAR*)"DSN=TestDB;", SQL_NTS,(SQLCHAR*)"user", SQL_NTS,(SQLCHAR*)"password", SQL_NTS); 

What is a JDBC Driver?

A JDBC driver is a software component (usually a .jar file) that implements the interfaces defined in the JDBC API and allows Java applications to interact with a specific database. Each databases (MySQL, Oracle, PostgreSQL, SQL Server) have their own driver.

Where to Find JDBC Drivers

• Official Database Vendor Websites o MySQL → MySQL Connector/J o Oracle → Oracle JDBC Driver o PostgreSQL → PostgreSQL JDBC Driver o SQL Server → Microsoft JDBC Driver for SQL Server o SQLite → SQLite JDBC Driver
• Maven Central Repository (for projects using Maven/Gradle) Example (MySQL Connector/J):
•  
• mysql
• mysql-connector-java
• 8.0.33
•  
• Third-party providers

Some drivers are commercial (e.g., DataDirect JDBC), offering extra features like performance tuning and advanced security.

Installing the Driver

• For standalone Java apps → Download .jar file and add it to your project’s classpath.
• For IDEs (Eclipse, IntelliJ, NetBeans) → Add the driver .jar to the library section of your project.
• For Maven/Gradle projects → Just add the dependency in your pom.xml or build.gradle.

Checking Your Driver

Once added, load it in your code:

Class.forName("com.mysql.cj.jdbc.Driver"); // Example for MySQL

Or (in modern JDBC) just use:

Connection con = DriverManager.getConnection(

    "jdbc:mysql://localhost:3306/mydb", "user", "password");

(Driver auto-loads if present in classpath).

Connection Pooling with JDBC

• What is Connection Pooling?
  • In JDBC, a connection pool is a cache of database connections maintained so that connections can be reused when future requests to the database are required.
  • Instead of creating a new connection every time (which is expensive and timeconsuming), the application borrows an existing connection from the pool and returns it back once finished.

This improves performance, especially for web applications with high traffic.

Why Use Connection Pooling?

• Reduced overhead: Creating a new database connection for every request is slow. Connection pooling reuses existing ones.
• Efficient resource usage: Limited database connections are shared among users.
• Better scalability: Applications handle more requests with fewer resources.
• Improved performance: Eliminates repeated connection setup/teardown.

How It Works

• Application starts → a pool of database connections is created.
• When a query/request needs a connection:
• It checks the pool. o If a free connection is available → assign it to the client.
• If none are available → wait or create a new one (up to a limit).
• After the client is done → the connection is returned to the pool, not closed.
• The pool manages idle connections (timeouts, validation, cleanup).
• Popular Connection Pooling Libraries
  • HikariCP (fastest, lightweight, modern choice)
  • Apache DBCP (widely used)
  • C3P0 (older but still used in some apps)
  • HikariCP is recommended for new applications.

6. Benefits of Connection Pooling

• Faster performance (connections reused)
• Efficient database usage (limited connections)
• Highly scalable (used in enterprise apps)
• Automatic management (timeouts, retries, cleanup)

JDBC and JNDI

Both JDBC (Java Database Connectivity) and JNDI (Java Naming and Directory Interface) are important Java technologies, but they serve different purposes. Sometimes, they are even used together in enterprise applications.

• JDBC (Java Database Connectivity)
  • A Java API that allows applications to interact directly with relational databases.
  • Used to establish connections, execute SQL queries, and manage results.
  • Works at the database interaction level.

Example:

Connection conn = DriverManager.getConnection(

    "jdbc:mysql://localhost:3306/mydb", "user", "password");

• JNDI (Java Naming and Directory Interface)
  • A Java API for accessing naming and directory services (like DNS, LDAP, RMI registries, application servers).
  • Provides a way to look up resources (like databases, mail servers, or queues) using logical names rather than hardcoding details.
  • Often used in Java EE / Jakarta EE applications.

Example (looking up a JDBC DataSource via JNDI):

Context ctx = new InitialContext();

DataSource ds = (DataSource) ctx.lookup("java:comp/env/jdbc/MyDB");

Connection conn = ds.getConnection();

Here, instead of embedding the DB connection details in code, you configure them in the server (Tomcat, GlassFish, JBoss, etc.) and use JNDI to fetch them.

How JDBC and JNDI Work Together

• JDBC is the actual API that talks to the database.
• JNDI acts like a middle layer that allows applications to find and use JDBC resources without hardcoding connection info.
• This is very useful in enterprise applications for:

o Connection pooling o Centralized resource management o Security (credentials not exposed in code)

• Comparison

Feature JDBC JNDI

Purpose Direct DB access via SQL Lookup for resources (DB, LDAP, etc.)

Scope Database-only General resource access

Configuration Connection details in code Connection details in server config

Best for Small/simple apps Enterprise/large apps

Conclusion-

JDBC (Java Database Connectivity) is a powerful and standard API that enables seamless communication between Java applications and relational databases. It provides the essential tools and interfaces for establishing database connections, executing SQL queries, and performing core CRUD operations (Create, Read, Update, Delete). Through its components— DriverManager, Connection, Statement, and ResultSet—JDBC simplifies database interaction while maintaining platform independence.

The JDBC architecture ensures smooth interaction between applications and databases via drivers, which come in different types (Type 1 to Type 4) to suit various needs. With JDBC, developers can build database-enabled applications, whether through simple connections, advanced connection pooling, or integrating with JNDI for resource lookup and enterprise solutions.

While JDBC is designed specifically for Java applications, ODBC provides a more general interface across languages. JDBC, however, offers greater portability and ease for Java developers. Finding the right JDBC driver is essential, as each database vendor provides its own optimized drivers to ensure efficiency and compatibility.

In essence, JDBC acts as the bridge between Java programs and databases, making it possible to build scalable, secure, and data-driven applications. From simple queries to enterprise-level systems, JDBC remains a cornerstone of Java’s data access strategy.

Next Blog- Annotations in Java