SchoolofofComputing

School Computing Science

Science andand Engineering
Engineering
Course Name: Machine Learning Course Code: B110210T

Topic : Database Connectivity in

Java(JDBC)
Program : BCA-IO(AIML)
Course Code :E1UA505C
Semester : 5th
Course Name : Programming in Java
Submitted By:
Name : Anurag Kumar Jha
Admission No : 21SCSE1430008

Program Name: BCA Faculty Name: Dr. Alok Katiyar

 Objective

 What is JDBC?
 Why use JDBC?
 Architecture of JDBC
 JDBC Components
 Steps to Connect to a Database
 Performing CRUD Operations
 Conclusion

Program Name: BCA

 What is JDBC
Java Database Connectivity (JDBC) is an acronym for a Java-based API (Application Programming Interface) that
allows Java applications to interact with relational databases. It provides a standard method for Java programs to
connect to databases and execute SQL queries.

Key Points:
API for Database Interaction: JDBC serves as a bridge between Java applications and relational databases, enabling
seamless communication.

Standard Interface: JDBC provides a standardized interface, allowing developers to interact with databases without
being concerned about the underlying details of different database management systems (DBMS).

SQL Query Execution: With JDBC, developers can execute SQL queries, retrieve data, and update the database
directly from Java code.

Platform Independence: JDBC is designed to be platform-independent, meaning that Java applications can connect
to and interact with databases on any platform as long as the appropriate JDBC drivers are available.

Faculty Name: Name:

Program Dr. Sudeept
BCAYadav
 Use of JDBC
•Seamless Database Connectivity:
JDBC provides a seamless and standardized way for Java applications to connect to various relational databases.
This connectivity is crucial for applications requiring persistent data storage.

•Database Independence:
JDBC promotes database independence, allowing developers to write code that can work with different database
management systems without modification. This reduces the coupling between the application and the specific
database technology.

•Integration with Java Applications:

JDBC integrates well with Java applications, enabling developers to incorporate database functionality directly into
their Java code. This tight integration facilitates efficient data retrieval and manipulation within the application.

•CRUD Operations:
JDBC simplifies the implementation of CRUD operations (Create, Read, Update, Delete) in Java applications. This
means that developers can easily insert, retrieve, update, and delete data in the database using Java code.

•Security and Transaction Management:

JDBC supports secure data transactions and management. Developers can implement transactional behavior in
their applications, ensuring data integrity and consistency in the database.
Faculty Name: Name:
Program Dr. Sudeept
BCAYadav
 Architecture of JDBC
JDBC supports two main types of architecture for connecting
to a database:

1. Two-tier architecture: In a two-tier architecture, the

application communicates directly with the database. This is a
simple and efficient model for small applications, but it can
be difficult to manage and scale for large applications.

2. Three-tier architecture: In a three-tier architecture, the

application communicates with the database through a
middle tier of services. This model provides more flexibility
and scalability, as the middle tier can be used to handle tasks
such as security, caching, and load balancing.

Faculty Name: Name:

Program Dr. Sudeept
BCAYadav
 JDBC Components
JDBC consists of four main components:

• JDBC API: The JDBC API provides a set of interfaces and classes that define the standard
way for Java programs to interact with databases.

• JDBC Driver Manager: The JDBC Driver Manager is responsible for loading and managing
JDBC drivers. When an application tries to connect to a database, the Driver Manager
loads the appropriate JDBC driver for that database.

• JDBC Driver: The JDBC driver is a software component that enables a Java program to
communicate with a specific database. It translates JDBC API calls into database-specific
commands that the database can understand.

• Database: The database is the target of JDBC interactions. It stores and manages the
data that the Java application needs to access.

• JDBC is a widely used and well-supported API, making it a popular choice for Java
developers who need to connect to and interact with databases.

Faculty Name: Name:

Program Dr. Sudeept
BCAYadav
 Steps to Connect to a Database

Connection Establishment Process:

1. Import JDBC Packages:
• Explanation:
-Before using JDBC, relevant packages need to be imported into the Java program. Commonly used packages include java sql
for core JDBC functionality.
• Example:

2. Load and Register the JDBC Driver:

•Explanation:
-Use the Class.forName("driver_class_name") method to dynamically load and register the JDBC driver. This step is
essential for enabling communication between the Java application and the specific database.
•Example:

Faculty Name: Dr. Sudeept Yadav

 Steps to Connect to a Database

3. Establish a Connection:
• Explanation:
-Utilize the DriverManager.getConnection("jdbc_url", "username", "password") method to establish a
connection to the database. The JDBC URL specifies the database location, and the
username/password are credentials for authentication.
• Example:

4. Create a Statement:
• Explanation:
• Create a Statement object from the established Connection. The Statement is used
for executing SQL queries on the database.
• Example:

Faculty Name: Dr. Sudeept Yadav

 Steps to Connect to a Database
5. Execute the Query:
• Explanation:
-Use the executeQuery() method of the Statement to execute a SELECT SQL query. For other types of queries or
updates, methods like executeUpdate() are used.
• Example:

6. Process the Results:

• Explanation:
-Process the ResultSet to retrieve and manipulate the data returned by the database.
• Example:

Faculty Name: Dr. Sudeept Yadav

 Steps to Connect to a Database
7. Close the Connection:
• Explanation:
• To free up system resources, it's essential to close the resources (Connection, Statement, ResultSet) once they are
no longer needed.
• Example:

Faculty Name: Dr. Sudeept Yadav

 Performing CRUD Operation

1. Create (INSERT):
• Explanation:
• To add new data to the database, an INSERT SQL statement is used. JDBC provides the executeUpdate()
method of the Statement class for such operations.
• Example:
String insertQuery = "INSERT INTO mytable (column1, column2) VALUES ('value1', 'value2')";
int rowsAffected = statement.executeUpdate(insertQuery);

2. Read (SELECT):
• Explanation:
• To retrieve data from the database, a SELECT SQL statement is used. The executeQuery() method of the
Statement class is employed for this purpose.
• Example:
String selectQuery = "SELECT * FROM mytable";
ResultSet resultSet = statement.executeQuery(selectQuery);
while (resultSet.next()) {
// Process each row of the result set
String name = resultSet.getString("name");
// Additional processing...
}

Faculty Name: Dr. Sudeept Yadav

 Performing CRUD Operation

3. Update (UPDATE):
• Explanation:
• To modify existing data in the database, an UPDATE SQL statement is used. Similar to INSERT, the executeUpdate()
method is utilized.
• Example:
String updateQuery = "UPDATE mytable SET column1 = 'new_value' WHERE condition";
int rowsAffected = statement.executeUpdate(updateQuery);

4. Delete (DELETE):
• Explanation:
• To remove data from the database, a DELETE SQL statement is used. The executeUpdate() method handles DELETE
operations.
• Example:
• String deleteQuery = "DELETE FROM mytable WHERE condition";
int rowsAffected = statement.executeUpdate(deleteQuery);

Faculty Name: Dr. Sudeept Yadav

 Conclusion

JDBC serves as the backbone for Java applications seeking efficient database connectivity. Through its three-tier
architecture and key components, it enables seamless interaction with relational databases. The emphasis on
exception handling ensures robust applications, providing both error recovery and valuable diagnostic information.
Best practices, such as resource closure and PreparedStatement usage, enhance performance and security. JDBC's
reliability, scalability, and adherence to standards make it an indispensable tool for developers, empowering dynamic
and responsive applications in the realm of database-driven Java development. Thank you for your attention, and I'm
open to any questions or discussions.

Faculty Name: Dr. Sudeept Yadav