Java Database Connection (JDBC)

Architecture, types of drivers

JDBC

JDBC stands for Java Database Connectivity, which is a

standard Java API for database-independent connectivity
between the Java programming language and a wide range
of databases.
The JDBC library includes APIs for each of the tasks
mentioned below that are commonly associated with
database usage:
Making a connection to a database.
Creating SQL or MySQL statements.
Executing SQL or MySQL queries in the database.
Viewing & Modifying the resulting records.
JDBC
(cont’d)
Fundamentally, JDBC is a specification that provides a
complete set of interfaces that allows for portable access
to an underlying database. Java can be used to write
different types of executable, such as −
Java Applications
Java Applets
Java Servlets
Java Server Pages (JSPs)
Enterprise JavaBeans (EJBs).
JDBC
(cont’d)
All of these different executables are able to use a JDBC
driver to access a database, and take advantage of the
stored data.
JDBC provides the same capabilities as ODBC
JDBC Architecture
The JDBC API supports both two-tier and three-tier processing
models for database access but in general, JDBC Architecture
consists of two layers :
JDBC API
This provides the application-to-JDBC Manager connection.
JDBC Driver API
This supports the JDBC Manager-to-Driver Connection.
The JDBC API
uses a driver manager and database-specific drivers to provide
transparent connectivity to heterogeneous databases.
The JDBC driver manager
ensures that the correct driver is used to access each data source. The
driver manager is capable of supporting multiple concurrent drivers
connected to multiple heterogeneous databases.
JDBC Architecture
(cont’d)
Common JDBC Components
The JDBC API provides the following interfaces and classes −
Driver Manager
This class manages a list of database drivers. Matches connection
requests from the java application with the proper database driver
using communication sub protocol. The first driver that recognizes a
certain sub protocol under JDBC will be used to establish a database
Connection.
Driver
This interface handles the communications with the database server.
You will interact directly with Driver objects very rarely. Instead,
you use Driver Manager objects, which manages objects of this type.
It also abstracts the details associated with working with Driver
objects.
JDBC Architecture
(cont’d)
Connection
This interface with all methods for contacting a database. The
connection object represents communication context, i.e., all
communication with database is through connection object only.
Statement
You use objects created from this interface to submit the SQL
statements to the database. Some derived interfaces accept parameters
in addition to executing stored procedures.
Result Set
These objects hold data retrieved from a database after you execute an
SQL query using Statement objects. It acts as an iterator to allow you
to move through its data.
SQLException
This class handles any errors that occur in a database application.
JDBC Architecture
(cont’d)
Figure 1: Two-tier Architecture for Data Access.
JDBC Architecture
(cont’d)
In the two-tier model, a Java applet or application
talks directly to the data source.
This requires a JDBC driver that can communicate
with the particular data source being accessed.
A user's commands are delivered to the database or
other data source, and the results of those statements
are sent back to the user.
The data source may be located on another machine to
which the user is connected via a network.
JDBC Architecture
(cont’d)
This is referred to as a client/server configuration,
with the user's machine as the client, and the machine
housing the data source as the server.
The network can be an intranet, which, for example,
connects employees within a corporation, or it can be
the Internet.
In the three-tier model, commands are sent to a
"middle tier" of services, which then sends the
commands to the data source.
JDBC Architecture
(cont’d)
The data source processes the commands and sends
the results back to the middle tier, which then sends
them to the user.
MIS directors find the three-tier model very attractive
because the middle tier makes it possible to maintain
control over access and the kinds of updates that can
be made to corporate data.
Another advantage is that it simplifies the deployment
of applications. Finally, in many cases, the three-tier
architecture can provide performance advantages.
JDBC Architecture
(cont’d)
Figure 2: Three-tier Architecture for Data Access.
JDBC Architecture
(cont’d)
Until recently, the middle tier has often been written
in languages such as C or C++, which offer fast
performance.
However, with the introduction of optimizing
compilers that translate Java byte code into efficient
machine-specific code and technologies such as
Enterprise JavaBeans™, the Java platform is fast
becoming the standard platform for middle-tier
development.
This is a big plus, making it possible to take
advantage of Java's robustness, multithreading, and
security features.
JDBC Architecture
(cont’d)
With enterprises increasingly using the Java
programming language for writing server code, the
JDBC API is being used more and more in the middle
tier of a three-tier architecture.
Some of the features that make JDBC a server
technology are its support for connection pooling,
distributed transactions, and disconnected row sets.
The JDBC API is also what allows access to a data
source from a Java middle tier.
JDBC Driver
JDBC drivers implement the defined interfaces in the
JDBC API, for interacting with your database server.
For example, using JDBC drivers enable you to open
database connections and to interact with it by sending
SQL or database commands then receiving results
with Java.
The Java.sql package that ships with JDK, contains
various classes with their behaviors defined and their
actual implementations are done in third-party drivers.
Third party vendors implements the java.sql.
Driver interface in their database driver.
JDBC Driver
(cont’d)
JDBC Drivers Types
JDBC driver implementations vary because of the
wide variety of operating systems and hardware
platforms in which Java operates.
Sun has divided the implementation types into four
categories, Types 1, 2, 3, and 4, which is explained
below:
Type 1 − JDBC-ODBC Bridge Driver
In a Type 1 driver, a JDBC bridge is used to access
ODBC drivers installed on each client machine.
JDBC Driver
(Type 1 cont’d)
Using ODBC, requires configuring on your system a
Data Source Name (DSN) that represents the target
database.
When Java first came out, this was a useful driver
because most databases only supported ODBC access
but now this type of driver is recommended only for
experimental use or when no other alternative is
available.
JDBC Driver
(Type 1 cont’d)
Figure 3: Type 1 – JDBC – ODBC Bridge Driver
The JDBC-ODBC Bridge that comes with JDK 1.2 is a good
example of this kind of driver.
JDBC Driver
(cont’d)
Type 2 − JDBC-Native API
In a Type 2 driver, JDBC API calls are converted into
native C/C++ API calls, which are unique to the database.
These drivers are typically provided by the database
vendors and used in the same manner as the JDBC-ODBC
Bridge.
The vendor-specific driver must be installed on each client
machine.
JDBC Driver
(Type 2 cont’d)
If we change the Database, we have to change the
native API, as it is specific to a database and they are
mostly obsolete now, but you may realize some speed
increase with a Type 2 driver, because it eliminates
ODBC's overhead.
JDBC Driver
(Type 2 cont’d)
Figure 4: Type 2 – JDBC – Native API
The Oracle Call Interface (OCI) driver is an example of a
Type 2 driver.
JDBC Driver
(cont’d)
Type 3 − JDBC-Net pure Java
In a Type 3 driver, a three-tier approach is used to
access databases.
The JDBC clients use standard network sockets to
communicate with a middleware application server.
The socket information is then translated by the
middleware application server into the call format
required by the DBMS, and forwarded to the database
server.
JDBC Driver
(Type 3 cont’d)
This kind of driver is extremely flexible, since it
requires no code installed on the client and a single
driver can actually provide access to multiple
databases.
JDBC Driver
(Type 3 cont’d)
Figure 5: Type 3 – JDBC – Net pure Java
JDBC Driver
(Type 3 cont’d)
You can think of the application server as a JDBC
"proxy," meaning that it makes calls for the client
application.
As a result, you need some knowledge of the
application server's configuration in order to
effectively use this driver type.
Your application server might use a Type 1, 2, or 4
driver to communicate with the database,
understanding the nuances will prove helpful.
JDBC Driver
(cont’d)
Type 4 − 100% Pure Java
In a Type 4 driver, a pure Java-based driver
communicates directly with the vendor's database
through socket connection.
This is the highest performance driver available for
the database and is usually provided by the vendor
itself.
This kind of driver is extremely flexible, you don't
need to install special software on the client or server.
JDBC Driver
(Type 4 cont’d)
Figure 6: Type 4 – 100% Pure Java
JDBC Driver
(Type 4 cont’d)
Further, these drivers can be downloaded
dynamically.
MySQL's Connector/J driver is a Type 4 driver.
Because of the proprietary nature of their
network protocols, database vendors usually
supply type 4 drivers.
JDBC Driver
(cont’d)
Which Driver should be Used?
If you are accessing one type of database, such as Oracle,
Sybase, or IBM, the preferred driver type is 4.
If your Java application is accessing multiple types of
databases at the same time, type 3 is the preferred driver.
Type 2 drivers are useful in situations, where a Type 3 or
Type 4 driver is not available yet for your database.
The Type 1 driver is not considered a deployment-level
driver, and is typically used for development and testing
purposes only.