It is becoming increasingly rare to carry out any given computing task using a single computer in isolation. Most often, whether or not the user is aware of it, part of the task performed takes place on one or more other computers networked to the user's computer.

As network computing has developed, it has become more common for different types of computers to specialize in specific areas. Some computers do nothing but store archives of files and software for on-demand use by network users, some computers specialize in super-high-resolution graphics for desktop design and engineering, others focus on high-volume centralized database transaction processing, and many simply function as general purpose workstations which present graphical user interfaces to all these services to end-users.

This new diversification of network computing tasks has resulted in a new general paradigm for software architecture called client/server. In this architecture, most software applications have exactly two components: the Client component and the Server component.

A client is a member of a class of programs in a modern software architecture paradigm called client/server software Architecture in which all applications have two components: the client component and the server component. The client component typically has the following characteristics:

• A client is executed on-demand; only when there is a need for it (contrasted with a server which usually is always executing).
• A client is active; it initiates all dialogue to a server as needed to perform its tasks. (A server is passive and waits for requests, never initiating any communications with a client).
• A client interfaces with humans (whereas a server normally runs in the background and interfaces only with other software (clients)).
• At any given time there probably numerous instances of the client component of the application running on different computers throughout the network, all of which are connecting to only one or two servers (a server typically is a centralized process which serves many clients).

A server is a member of a class of programs in a modern software architecture paradigm called client/server software Architecture, in which all applications have two components: the client component and the server component. The server component typically has the following characteristics:

• A server is most often centralized, usually on a large computer (a client usually runs in multiple instances on desktops or other small stations throughout a network.)
• A server is passive; it does little or nothing until it receives an explicit request from a client to do something. (A client is active since it's a tool in the hands of a human).
• A server usually runs continuously waiting for requests, while a client runs only on-demand (when invoked by a human).
• A server usually runs in the background and interfaces only with other software (clients), and rarely interfaces directly with humans (whereas a client is usually invoked by a human and takes commands from a human).
• A server must handle multiple tasks concurrently since many clients may be requesting it's services simultaneously. A client usually works for one person and does one thing after another in sequence, as the user commands it.

The CLI requires the use of intelligent database drivers that accept a CLI call and translate it into the native database Server's access language. With the proper driver any Front end can access the Database with the help of Called Level Interface. CLI is a procedure interface to the SQL. You write SQL to query over the database. So CLI is a SQL Wrapper. CLI provides a driver Manager that talks to a driver through a Service Provider Interface(SPI).

ODBC is also based on the SQL CLI .

Abbreviation of Open DataBase Connectivity, a standard database access method developed by Microsoft . The goal of ODBC is to make it possible to access any data from any application , regardless of which database management system is handling the data. ODBC manages this by inserting a middle layer, called a database driver, between an application and the DBMS. The purpose of this layer is to translate the application's data queries into commands that the DBMS understands. For this to work, both the application and the DBMS must be ODBC-compliant -- that is, the application must be capable of issuing ODBC commands and the DBMS must be capable of responding to them.

JDBC specification includes eight new Java interfaces and ten new classes

These are divided into following four groups

• JDBC Core interfaces and classes
• Java Language Extension
• Java Utility Extension
• SQL Metadata Interface

These are seven Interfaces and two Classes. These are the interfaces and abstract classes all JDBC drivers must implements. You used these classes to locates local or remote database, established the connection, submit queries, process the result set.

Driver Interface: This class is used for locating the driver for the database.

Driver Manager Class: This class is used at run time to load the driver objects and creates new database connection Object.

DriverPropertyInfo Class: This is the special class to get the meta information about the driver.

Connection Interface: You use the connection object to connect to the database. You can connect to the multiple database or single database. Connection class is used for the commit and rollback.

Statement Interface: Statement objects are used to execute SQL on a given Connection object.

Prepared Statement Interface : Prepared Statement Interface object is precompiled SQL and is used to execute the same SQL statement multiple times using different parameter. There are series of method to set the parameter fields of the Prepared Statement (setXXX).

Callable Statement Interface: These objects are used for the stored procedure.

Result Set Interface: Result set object encapsulates the rows returned by the database when you execute the query on the Statement Object. The object maintains a cursor that points to the current row of data. We can move this cursor forward and backward. You can retrieved the data from the result set into Java object by using getXXX.

Result Set Meta Data: You used this object to retrieve number, types, properties of the Result Set. 

These contains four classes.

Bignum Class: This class is used to stores a high precision of data hence JDBC has a new class with the floating point capabilities.

The SQLException class, SQLWarning class and DataTruncation class are used for Exception handling in the JDBC.

This contains three classes. As database used fine-grained time and date utilities so JDBC has a new classes which are extension of Date class of java.util.

It has Date, Time, TimeStamp classes.

All the commercial database provides information at the run time ,So to discover the information of the database at run time you need DataBaseMeta Class.

There are basically four types of JDBC Drivers

1. The JDBC-ODBC bridge provides JDBC access via most ODBC drivers.
2. A native-API partly-Java driver
3. A net-protocol all-Java driver
4. A native-protocol all-Java driver

1. JDBC -ODBC Bridge Driver This types of driver used JDBC to talk to ODBC Driver. Note that some ODBC binary code and in many cases database client code must be loaded on each client machine that uses this driver.
2. A native-API partly-Java driver converts JDBC calls into calls on the client API for Oracle, Sybase, Informix, DB2, or other DBMS. Note that, like the bridge driver, this style of driver requires that some binary code be loaded on each client machine.
3. A net-protocol all-Java driver translates JDBC calls into a DBMS-independent net protocol which is then translated to a DBMS protocol by a server. This net server middleware is able to connect its all Java clients to many different databases.
4. A native-protocol all-Java driver converts JDBC calls into the network protocol used by DBMS directly. This allows a direct call from the client machine to the DBMS server and is a practical solution for Intranet access.

• In this case at the Server Side we are managing the Driver Manager and the Driver. There are no Server Object in this case.
• Client invokes normal JDBC calls which is transferred to the JDBC driver Server(middle tier) via ORB or RPC to the JDBC Driver Manager on the Server side.
• The example of RPC is Symantec Café which uses sockets based RPC to communicate between the client and the Server

• In this type of Implementation the Client talks to the Server Object using ORB. Client has nothing to deals with the database. Any function that deals with the database is on the server Side.
• On the Server Side, the Server Object gets the request from the client and Load the Appropriate Driver for the database and with the help of JDBC Driver Manager and get connected to the Database.

Debit and Credit

In this application we have a database called Bank. We use CORBA to organize the Benchmark. Client is updating the database using the JDBC API. Clients are also registering there callbacks to the Server Coordinator via CORBA. Finally the Coordinator uses CORBA to controls the Clients. MultiConsole (Applet) controls the Coordinator via CORBA. It is totally multithreaded scenario in a CORBA environment.

MultiConsole is the client applets that also serves as the control panel for Coordinator(Server). You can use this applets to tells the clients when to stop and start invoking the methods .

Coordinator is the Server application that knows how to runs the Clients. It tells ours clients when to start and stop. The clients must registered with the Server (Callbacks) inorder to received method invocations by the server. Coordinator tells each clients to start and start the JDBC invocations. MultiConsole is the Control panel for the server Coordinator

The IDL interface for the Coordinator is

module MultiCoordinator

{ interface Coordinator

{ // object for registering and controlling client counting

boolean register(in string clientNumber,in Client::ClientControl clientObjRef);

boolean start();

string stop();

};

};

Here we are using the register( ) method to register the client on the Coordinator Server for the callbacks

Client has many threads interacting with each other and their Servers. In this Single client is controlled by the server.

DebitCredit2TClient this provide the main method for the client program. It creates an instance of the DebitCredit2Tclient by calling the class constructor. The class constructors does the following things

• Create the user interface.
• Creates a BankDB object and connect to the database.
• Creates the new thread ClientContolThread(for the Coordinator Server to send the callbacks).It starts the ClientControlThread at the higher priority(Callback Thread).
• Creates a DebitCreditThread at the regular priority. This thread used BankDB Object to invokes innovation on the database(Database Thread).

ClientDebitCreditThread extends the JAVA Thread class. It implements the run method which implements continuos loop. It generates two random number TellerID and BranchID and invokes the method on the BankDB object which invokes JDBC invocations on the database.

ClientControlThread extend JAVA thread Class. It is the thread which register the Client(DebitCredit2Tclient) with the Server(Coordinator). It creates the instance of the ClientControlImpl which implements function Stop( ) and Start( ) defined at the Client side IDL. It export the object(by Register method of the Server) to the Coordinator and listen to the Server for the Callbacks.

ClientControlImpl this is the class which implements the Client IDL methods stop( ) and Start( ).

It implements the IDL

module Client

{ interface ClientControl

{ // start and stop operations for controlling client counting

boolean start();

string stop();

};

};

In this we use two Protocol CORBA and JDBC .In this 2- Tier Application we use CORBA to Organize the benchmark.MultiConsole Applet controls the Coordinator via CORBA. Client uses CORBA to register for the callbacks. Coordinator uses CORBA to controls the races.

Steps

1. Create the JDBC Bank Object
2. Create the ClientControlThread for the callbacks
3. Create the ClientDebitCreditThread for JDBC transactions
4. Connect to the database the BankDB object using ClientControlThread

1. Register for the callback with the Server
2. The Coordinator tells every client to start
3. Pass the Command to the main thread(DebitCredit2Tclient) to invoke startcounting Method
4. Activate the ClientDebitCreditThread object
5. Invoke the JDBC transactions on the BankDB using ClientDebitCreditThread
6. Coordinator tells every Client to Stop
7. Pass the command to the main thread(DebitCredit2Tclient)
8. Suspend the ClientDebitCreditThread(JDBC transaction thread)

In General you see Three Tier is better than the 2-tier in many ways, 3-tier is faster than 2-tier with the exception of JDBC, Load Balancing can be done very easily, Easy to integrate, More secure than two tier

etc .

Steps

Prompt >javac *.java

Brain K. Cottman "OPENjdbc: Pure CORBA JDBC Data Access"

Orfali, R., D. Harkey. Client/Server Programming with JAVA and CORBA,

John Wiley and Sons, New York, NY,1996.

Siegel, J.(ed.).CORBA Fundamentals and Programming,

John Wiley and Sons, New York, NY,1996.

JavaSoft (Sun Microsystems Inc.) " JDBC - Connecting Java and Databases",

JavaSoft 1996.

Morrison, M.. Java Unleashed

Sams Net Publishing 1997

Visual Café(SYMANTEC) for Java, User's Guide

Symantec Corporation 1997

Higgs Mike "CORBA ,JAVA,JDBC ,UDAS: Universal Data Access"

Taylor,Art . JDBC Developer's Resource

Database Programming On the Internet

INFORMIX Press CA USA ,1997