Java

UNIT – 5
J2EE MULTI TIER ARCHITECTURE
 J2EE is four tier architecture. They layers are named as follows:

 Client tier
 Web tier
 Enterprise Java bean tier (Business Logic tier)
 Enterprise Information Systems tier (Database tier)
Client Tier
 The client tier consists of programs that interact with the user i.e. any component that is
capable of initiating a request to the server is said to sit in the client tier of the J2EE
architecture. Eg for client tier component would be a HTML page, browser etc.
Web Tier
 Web tier provides internet functionality to a J2EE application. Web tier component
receives the request from the client tier component and forwards the request to the
appropriate business logic tier to process it.
 Due to security perspective and other issues the business logic is delegated to the next
tier. Example of web tier component would be a servlets.
Enterprise Java Bean Tier

 This tier contains the business logic for J2EE applications. It’s here where one or more
Enterprise JavaBeans reside, each encoded with business logic that are called upon
indirectly by clients.
 The Enterprise JavaBean tier is keystone to every J2EE applications because Enterprise
JavaBean working on theis tier enable multiple instance of an application to concurrently
access business logic and data so as not impede the performance.
Enterprise Information System Tier
 EIS links a J2EE application to resources and legacy systems that are available on the
corporate backbone network. It’s on the EIS where a J2EE application directly or
indirectly interfaces with a variety of technologies including DBMS and mainframes.
The Concept of JDBC
 JDBC (Java Database Connectivity) is an API for the java programming language that
defines how a client may access the database. It provides methods for querying and
updating data in database. JDBC is oriented towards relational databases.
 JDBC consist of two components:
 JDBC APIs
 JDBC Driver
JDBC API
 They are the library functions that performs common task associated with database usage
like: Opening\Closing the connection with the database, Creating SQL statements.
Executing that SQL queries in the database and Viewing and Modifying the resulting
records
JDBC Driver
A JDBC driver is a software component enabling a java application to interact with a database. It
is the actual implementation of the defined interfaces in the JDBC API for interacting with your
database server.
JDBC driver Types
Type1 JDBC driver: (JDBC to ODBC bridge)
 These drivers implement the JDBC API as a mapping to another data access API, such as
ODBC (Open Database Connectivity). The JDBC-to-ODBC driver also called as JDBC-
ODBC Bridge.
 The JDBC to ODBC driver receives messages from a J2EE components that conform to
the JDBC specification, those messages are then translated by the JDBC-to-ODBC driver
into the ODBC message format which is then translated into the message format
understood by DBMS.
Type 2 Java/Native Code Driver
 Java/Native code driver uses Java classes to generate platform-specific code that is code
only understood by a specific DBMS. The manufacturer of the DBMS provides both the
Java/Native code drier and API classes so the J2EE component can generate platform
specific code.
 The obvious disadvantage of using a Java/Native code driver is the loss of some
portability of code.
Type 3 JDBC Driver
 The type3 JDBC driver also referred as Java Protocol, which is the most commonly used
JDBC driver. The Type 3 JDBC driver converts SQL queries into JDBC formatted
statements. The JDBC statements then translated into the format required by the DBMS
Type 4 JDBC Driver

 Type 4 JDBC driver is also known as Type 4 database Protocol. This driver is similar to
the Type3 except SQL queries are translated into the format required by the DBMS. SQL
queries do not need to be converted to JDBC formatted systems. This is the fastest way to
communicate SQL queries to the DBMS.
JDBC Packages
 JDBC API is contained in 2 packages:

 java.sql
 javax.sql
java.sql: It contains core java database objects of the JDBC API i.e. it includes java data objects
that provides the basics for connecting to the DBMS and interacting with data stored in the
DBMD.
javax.sql: This extends java.sql and it includes java data objects that interact with Java Naming
and Directory interface (JNDI) and Java data objects that manage connection pooling among
other advanced JDBC features.
A Brief Overview of the JDBC process
 JDBC process includes the steps for interacting with a DBMS. This process is divided
into 5 routines. These include:
1) Loading JDBC driver
2) Connecting to the DBMS
3) Creating and Executing a statement
4) Processing data returned by the DBMS
5) Terminating the Connection with the DBMS
Loading the JDBC driver

 The JDBC driver must be loaded before the J2EE component can connect to the DBMS.
The Class.forName( ) method is used to load the JDBC driver.
 Suppose a developer wants to work offline and write a J2EE component that interacts
with Microsoft access on the developers PC. The developer must write a routine that
loads the JDBC/ODBC Bridge driver called sun.jdbc.odbc.JdbcOdbcDriver.
 The driver is loaded by calling the Class.forName( ) method and passing it the name of
the driver as shown below:
Class.forName(“sun.jdbc.odbc.JdbcOdbcDriver”);
Connect to the DBMS
 J2EE component must connect to the DBMS using the DriverManager.getConnection( )

method. The javax.sql.DriverManager class is the highest class in the java.sql hierarchy
and is responsible for manager driver information.
 The DriverManager.getConnection( ) method is passed the URL of the database and
the user ID and Password if required by the DBMS. The URL is a string object that
contains the driver name and the name of the database that is being accessed by the
J2EE component.
String url = “jdbc:odbc:CustomerInformation”;

String userID=”Pradeep”;
String password=”Sweatha”;
Statement DataRequest;
Private Connection Db;
Try
{
Db=DriverManager.getConnection(url,userID,password);
}
Create and Execute a SQL statement
 The next step after loading drivers and connection successfully made is to send a SQL
query to the DBMD for processing. A SQL query consists of series of SQL commands
that direct the DBMS to do something such as to return row of data to the J2EE
components.
 The Connect.createStatement method is used to create a statement object. The
statement object is then used to execute a query and return ResultSet object that contains
the response from the DBMS, which is usually one or more rows of information
requested by the J2EE component.
 Typically a query is assigned to a string object which is passed to the statement object
executeQuery( ) method. Once the ResultSet is receive from the DBMS the close( )
method is called to the terminate the statement.
ResultSet Results;
Try
{
String query = “SELECT * FROM Customers”;
DataRequest = Database.createStatement( );
DataRequest= Db.createStatement( );
Results=DataRequest.executeQuery(query);
DataRequest.close( );
}
Process Data Returned by the DBMS
The output of the SQL query will be encapsulated in ResultSet object. A ResultSet object contains zero or
more records (or rows). We should iterate over each record in order to print it in the console as shown
below:
ResultSet results;
String FirstName;
String LastName;
String printrow;
Boolean Records= Results.next( );
if(!Records)
{
System.out.println(“No data found”);
Return;
}
else
{
do
{
FirstName= Results.getString(FirstName);
LastName= Results.getString(LastName);
printrow=FirstName+” “+ LastName
System.out.println(printrow);
}while(Results.next( ) );
}
Terminating the Connection with the DBMS

 The last step of all is to close the database connection. This releases the external
resources like cursor, handlers etc. typically closing the connection should be done in the
finally block using the statement Db.close ( );
Statement Objects
The statement object is used whenever a J2EE component need to immediately execute a query
without first having the query compiled. The statement object contains three types of methods in
it:
1) executeQuery( ): this method returns one ResultSet object that contains rows, columns
and metadata that represent data requested by query.
2) execute( ): this method of the statement object is used when there may be multiple results
returned.
3) executeUpdate( ): this method is used to execute queries that contain UPDATE and
DELETE SQL statements which changes values in row and removes a row respectively.
The executeUpdate ( ) method returns an integer indicating the number of rows that were
updated by the query. The executeUpdate( ) method is used to INSERT,UPDATE,
DELETE and DDL statements.

ResultSet Results;
Connection Db;
Try
{
}
Catch(ClassNotFoundException error)
{
System.err.println(“Unable to load the JDBC/ODBC driver”+ error);
System.exit(1);
}
Catch(SQLExcpetion error)
{
System.err.println(“Cannot connect to the database.”+ error);
System.exit(2);
}
Try
{
String query = “SELECT * FROM Customers”;
DataRequest= Db.createStatement( );
Results=DataRequest.executeQuery(query);
}
{
System.err.println(“SQL error.”+ error);
System.exit(3);
}
Db.close( );
Using the statement Object to execute a query

Connection Db;
int rowUpdated;
Try
{
}
{
System.err.println(“Unable to load the JDBC/ODBC driver”+
error);
System.exit(1);
}
{
System.exit(2);
}
Try
{
String query= “UPDATE Customers SET PAID=’Y’ WHERE
BALANCE=’0’;
rowsUpdated=DataRequest.executeUpdate(query);
}
{
System.exit(3);
}
Db.close( );
Using the execute Update method
Prepared Statement
 The PreparedStatement is used to compile the query first before executing it. The
PreparedStatement interface extends the Statement interface which gives you added
functionality. This statement gives us the fliexibility of supplying input arguments
dynamically.
 All parameters are represented by the? Symbol which is known as the place holder. We
must supply values for every parameter before executing the SQL statement.
 The setxxx( ) method is used to replace the question mark with the value passed to the
setxxx( ) method. There are a number of setxxx( ) methods available in the
PrepareStatement object each of which specifies the data type of the value that is being
passed to the setxxx( ) method.
 The setxxx( ) requires two parameters. The first parameter is an integer that identifies the
position of the question mark placeholder and the second parameter is the value that
replaces the question mark place holder.
 Next executeQuery( ) method of the PreparedStatement object is called. This method
does not require a parameter because the query that is to be executed is already associated
with the PreparedStatement object.
 The advantage of using the PreparedStatement object is that the query is precompiled once and
the setxxx( ) method called as needed to change the specified values of the query without
having to recompile the query.

ResultSet Results;
Connection Db;
Try
{
}
{
System.err.println(“Unable to load the JDBC/ODBC driver”+ error);
System.exit(1);
}
{
System.exit(2);
}
Try
{
String query= “SELECT * FROM Customers WHERE CustNumber= ?”;
PreparedStatement pstatement=Db.preparedStatement(query);
Pstatement.setString(1,”123”);
Results= pstatement.executeQuery( );
pstatement.close( );
}
{
System.exit(3);
}
Db.close( );
Callable Statement
 The CallabaleStatement object is used to call a stored procedure from within a J2EE
object. A stored procedure is a block of code and is identified by a unique name.
 The CallableStatement object uses three types of parameters when calling a stored
procedurers. These parameters are IN, OUT and INOUT
 The IN parameter contains any data that needs to be passed to the stored procedure
whose value is assigned using the setxxx( ) method.
 The OUT parameter contains the value returned by the stored procedures, if any. The
OUT parameter must be registered using the registerOutParameter( ) method and that is
later retrieved by the J2EE component using the getxxx( ) method.
 The INOUT parameter is a single parameter that is used to both pass information to the
stored procedure and retrieve information from the stored procedures.
 The prepareCall( ) method of the connection object is called and is passed the query.
This method returns a CallabaleStatement object which is called cstatement. Since an
OUT parameter is used by the stored procdure, the procedure must be registered using the
registerOutParameter() of the CallabaleStatement object.
 The registerOutParameter( ) method requires 2 parameters. The first parameter is an
integer that respresent the number of the parameter which is 1 meaning the first
parameter of the stored procedure. The second parameter is the data type of the value
returned by the stored procedure

String lastOrderNumber;
Connection Db;
Try
{
}
{
System.err.println(“Unable to load the JDBC/ODBC driver”+
error);
System.exit(1);
}
{
System.exit(2);
}
Try
{
String query= “{ CALL LastOrderNumber (? ) “;
callableStatement cstatement=Db.prepeareCall(query);
cstatement.registerOutParameter(1,Types.VARCHAR);
cstatement.execute( );
lastOrderNumber=cstatement.getString(1);
cstatement.close( );
}
{
System.exit(3);
}
Db.close( );
Difference between Statement, Prepared statement and Callable Statement
Statement PreparedStatement CallableStatement

The statement object is used it is used to compile the query first It is used to execute a call to the
whenever a component needs to before executing it stored procedure
immediately execute a query without
compiling first
No input/ output arguments can be Input arguments can be supplied Both inputs and output arguments
supplied dynamically can be supplied dynamically
createStatement( ) method of prepareStatement( ) method of prepareCall( ) of connection object is
connection object us used to get the connection object is used to get the used to get the callableStatement
Statement object PreparedStatement object object.
ResultSet:
 The ResultSet object contains methods that are used to copy data from the ResultSet into
a java collection object or variable for further processing.
 Data in a ResultSet object is logically organized into a virtual table consisting of rows
and columns.
 In addition to data, the ResultSet object also contains metadata such as column names,
column size, and column data type.
 The ResultSet uses a virtual cursor to point to a row of the virtual table.
 The virtual cursor is positioned above the first row of data when the ResultSet is returned
by the executeQuery () method. This means that the virtual cursor must be moved to the
first row using the next () method.
 The next() method returns a Boolean true if the row contains data, otherwise, a Boolean
false is returned indicating that no more rows exist in the ResultSet.
 Once the virtual cursor points to a row, the getxxx() method is used to copy data from the
row to a collection, object, or variable.
 getxxx () method is data type specific . For example, the getString() method is used to
copy String data from a column of the ResultSet. The data type of the getxxx () method
must be the same data type as the column in the ResultSet.
 getxxx() method requires one parameter, which is an integer that represents the number
of the column that contains the data. For example, getString(1) copies the data from the
first column of the ResultSet.
1. Reading The ResultSet:

String userID = “jim”;
String password = “Keogh”;
String printrow;
String FirstName;
String LastName;
ResultSet Results;
Connection Db;
try {
Db = DriverManager.getConnection(url,userID,password);
}
catch (ClassNotFoundException error) {
System.err.println(“Unable to load the JDBC/ODBC bridge.” +error);
System.exit(1);
}
catch(SQLException error) {
System.err.println(“cannot connect to the database. “ +error);
System.exit(2);
}
try {
String query = “SELECT FirstName, LastName FROM Customers”;
DataRequest = Db.createStatement();
Results = DataRequest.executeQuery (query);
}
catch (SQLException error) {
System.err.println(“SQL error. “ +error);
System.exit(3);
}
boolean Records = Results.next();
if(!Records) {
System.out.println(“No data returned”);
System.exit(4);
}
try {
do {
FirstName = Results.getString(1);
LastName = Results.getString(2);
printrow = FirstName + “ “ + LastName;
} while ( Results.next() );
DataRequest.close();
}
System.err.println(“Data display error. “ + error);
System.exit(5);
}
2. Scrollable ResultSet:
 There are six methods of the ResultSet object that are used to position the virtual cursor.
 1. first()
2. last()
3. previous()
4. absolute()
5. relative()
6. getRow()
 first() method moves the virtual cursor to the first row in the ResultSet.
 last() method positions the virtual cursor at the last row in the ResultSet.
 previous() method moves the virtual cursor to the previous row.
 absolute() method positions the virtual cursor at the row number specified by the integer
passed as a parameter to the absolute() method.
 relative() method moves the virtual cursor the specified number of rows contained in the
parameter. The parameter is a positive or negative integer where the sign represents the
direction the virtual cursor is moved.
 getRow() method returns an integer that represents the number of the current row in the
ResultSet.
 The Statement object that is created using the createStatement () of the Connection object
must be set up to handle a scrollable ResultSet by passing the createStatement() method
one of three constants. These constants are
1. TYPE_FORWARD_ONLY.
2. TYPE_SCROLL_INSENSITIVE.
3. TYPE_SCROLL_SENSITIVE.
 The TYPE_FORWARD_ONLY constant restricts the virtual cursor to downward

movement, which is the default setting. TYPE_SCROLL_SENSITIVE and
TYPE_SCROLL_INSENSITIVE constants permit the virtual cursor to move in both
directions.

String printrow;
String FirstName;
String LastName;
ResultSet Results;
Connection Db;
try {
}
System.exit(1);
}
System.exit(2);
}
try {
DataRequest = Db.createStatement(TYPE_SCROLL_INSENSITIVE);
}

System.exit(3);
}
if(!Records) {
System.exit(4);
}
try {
do {
Results.first();
Results.last();
Results.previous();
Results.absolute(10);
Results.relative(-2);
Results.realtive(2);
FirstName = Results.getString(1);
LastName = Results.getString(2);
printrow = FirstName + “ “ + LastName;
} while ( Results.next() );
}
System.exit(5); }
3. Updatable ResultSet:
 Rows contained in the ResultSet can be updatable similar to how rows in a table can be
updated.
 This is made possible by passing the createStatement() method of the Connection object
the CONCUR_UPDATABLE. Alternatively, the CONCUR_READ_ONLY constant
can be passed to the createStatement() method to prevent the ResultSet from being
updated.
 There are three ways in which a ResultSet can be changed. These are updating values in a
row, deleting a row, and inserting a new row. All of these are accomplished by using
methods of the Statement object.
a. Update ResultSet:
 The updatexxx() method is used to change the value of a column in the current row of the
ResultSet. The xxx in the updatexxx() method is replaced with the datatype of the column
that is to be updated.
 The updatexxx() method requires two parameters. The first is either the number or name
of the column of the ResultSet that is being updated and second parameter is the value
that will replace the value in the column of the ResultSet.
 The updateRow() method is called after all the updatexxx() methods are called.
b. Delete Row in the ResultSet:

 The deleteRow() method is used to remove a row from a ResultSet.
 The deleteRow() method is passed an integer that contains the number of the row to be
deleted.
 The deleteRow() method is then passed a zero integer indicating that the current row
must be deleted, as shown in the following statement.
Results.deleteRow(0);
c. Insert Row in the ResultSet:

 Inserting a row into the ResultSet is accomplished using basically the same technique as
is used to update the ResultSet.
 The insertRow() method is called after the updatexxx() methods, which causes a new row
to be inserted into the ResultSet having values that reflect the parameters in the
updatexxx() methods.
a. Update ResultSet:
ResultSet Results;
Connection Db;
try {
}
System.exit(1);
}
System.exit(2);
}
try {
String query = “SELECT FirstName, LastName FROM Customers WHERE
FirstName = ‘Mary’ and LastName = ‘Smith’ ”;
DataRequest = Db.createStatement(ResultSet.CONCUR_UPDATABLE);
}

System.exit(3);
}
if(!Records) {
System.exit(4);
}
try {
Results.updateString(“LastName” , “Smith”);
Results.updateRow();
}
System.exit(5);
}
c. Insert Row in the ResultSet:

ResultSet Results;
Connection Db;
try {
}
System.exit(1);
}
System.exit(2);
}
try {
DataRequest = Db.createStatement(CONCUR_UPDATABLE);
}

System.exit(3);
}
if(!Records) {
System.exit(4);
}
try {
Results.updateString(1,”Tom”);
Results.updateString(2, “Smith”);
Results.insertRow();
}
System.exit(5);
}
Transaction Processing:
 A database transaction consists of a set of SQL statements, each of which must be
successfully completed for the transaction to be completed. If one fails, SQL statements
that executed successfully up to that point in the transaction must be rolled back.
 A database transaction isn’t completed until the J2EE component calls the commit ()
method of the Connection object. All SQL statements executed prior to the call to the
commit () method can be rolled back. However, once the commit () method is called,
none of the SQL statements can be rolled back.
 The commit () method was automatically called because the DBMS has an AutoCommit
feature that is by default set to true.
 If a J2EE component is processing a transaction, the AutoCommit feature must be

deactivated by calling the setAutoCommit () method and passing it a false parameter.
Once the transaction is completed, the setAutoCommit () method is called again this
timing passing a true parameter, reactivating the AutoCommit feature.
Executing a database transaction using commit () methods:

Statement DataRequest1, DataRequest2;
Connection Db;
try {
}
System.exit(1);
}
System.exit(2); }
try {
Db.setAutoCommit(false)
String query1 = “UPDATE Customers SET Street = ‘5 Main Street’ “ +
“WHERE FirstName = ‘Bob’ “ ;
“WHERE FirstName = ‘Tim’ “ ;
DataRequest1 = Db.createStatement();
Db.executeUpdate(query1);
Db.commit();
DataRequest1.close();
Db.close();
}
catch(SQLException ex) {
System.err.println(“SQLException: “ + ex.getMessage() );
if (con != null) {
try {
System.err.println(“Transaction is being rolled back “);
Con.rollback();
}
catch (SQLException excep) {
System.err.print(“SQLException: “);
System.err.println(excep.getMessage());
} } }
Executing a database transaction using savepoints:
 The J2EE component can control the number of tasks that are rolled back by using
savepoints. A savepoint, introduced in JDBC 3.0, is a virtual marker that defines the task
at which the rollback stops.
 There can be many savepoints used in a transaction. Each savepoint is identified by a

unique name. the savepoint name is then passed to the rollback() method to specify the
point within the transaction where the rollback is to stop.
Statement DataRequest1, DataRequest2;
Connection Db;
try {
}
System.exit(1);
}
System.exit(2); }
try {
Savepoint s1 = Db.setSavepoint(“sp1”);
Db.commit();
DataRequest1.close();
Db.releaseSavepoint(“sp1”);
Db.close();
}
try {
Db.rollback(sp1);
}
System.err.println(“rollback error. “ + error.getMessage());
System.exit(3);
}
System.err.println(“SQL error.” + error.getMessage());
System.exit(4);
}
Batching SQL Statements in to transaction:

Connection Db;
try {
}
System.exit(1);
}
System.exit(2); }
try {
DataRequest = Db.createStatement();
DataRequest.addBatch(query1);
DataRequest.addBatch(query2);
int [ ] updated = DataRequest.executeBatch();
Db.commit();
Db.close();
}
catch(BatchUpdatedException error) {
System.out.println(“Batch error.”);
System.out.println(“SQL state: “ + error.getSQLState());
System.out.println(“Message : “ + error.getMessage());
System.out.println(“Vendor:” + error.getErrorCode());
int [ ] updated = error.getUpdatecount();
int count = updated.length();
for (int i=0; i<count; i++) {
System.out.print(updated[i]);
}
SQLException sql = error;
While (sql != null)
{
System.out.println(“SQL error “ + sql);
sql = sql.getnextException();
}
try {
DataRequest.clearBatch();
}
catch(BatchUpdatedException error) {
System,out.println(“Unable to clear the batch: “ +error.getMessage());
}
}
MetaData:
 Metadata is data about data. A J2EE component can access metadata by using the
DatabaseMetadata interface. The DatabaseMetadata interface is used to retrieve
information about databases, tables, columns and indexex among other information about
the DBMS.
 A J2EE component retireves metadata about the database by calling the getMetaData()
method of the Connection object. The getMetaData() method returns a
DatabaseMetaData object that contains information about the database and its
components.
 Here are some of the more commonly used DatabaseMetaData object methods.
 getDatabaseProductName()  Returns the product name of the
database
 getUserName()  Returns the username
 getURL()  Returns the URL of the database
 getSchemas()  Returns all the schema names available in this database
 getPrimaryKeys()  Returns primary keys.
 getProcedures() Returns stored procedure names.
 getTables()  Returns names of tables in the database.
ResultSet Metadata:
 Metadata that describes the ResultSet is called ResultSet Metadata.
 Meatadata that describes the ResultSet is retrieved by calling the getMetaData() method
of the ResultSet object.This returns a ResultSetMetaData object, as is illustrated in the
following code statement.
ResultSetMetaData rm = Result.getMetaData()
 Once the ResultSet MetaData is retrieved, the J2EE component can call methods of the
ResultSetMetaData object to retrieve specific kinds of metadata. The more commonly
called methods are as follows.
 getColumnCount()  Returns the number of columns contained in the

ResultSet.
 getColumnName(int number )  Returns the name of the column specified by
the column number
 getColumnType(int number)  Returns the data typeof the column specified
by the column number.
Data Types:
 Following Table contains a list of data types and their Java equivalents. You can use this
list to determine the proper data name to use to replace the xxx in the setxxx() and
getxxx() methods.
SQL Type Java Type

CHAR String
VARCHAR String
LONGVARCHAR String
NUMERIC java.math.BigDecimal
DECIMAL java.math.BigDecimal
BIT Boolean
TINYINT Byte
SMALLINT Short
INTEGER Integer
BIGINT Long
REAL float
FLOAT float
DOUBLE double
BINARY Byte[]
VARBINARY Byte[]
LONGVARBINARY Byte[]
BLOB java.sql.Blob
CLOB java.sql.Clob
ARRAY java.sql.Array
STRUCT java.sql.Struct
REF java.sql.Ref
DATALINK java.sql.Types
DATE java.sql.Date
TIME java.sql.Time
TIMESTAMP java.sql.Timesstamp
Exceptions:
 There are three kinds of exceptions that are thrown by JDBC methods
 SQLException : it commonly reflects a syntax error in the query and is thrown

by many of the methods contained in java.sql.package.
 SQLWarning : It throws warnings received by the connection from the DBMS.
The getWarning() method of the Connection object retrieves the warning and the
getNextWarning() method retrieves the subsequent warnings.
 DataTruncation: It is thrown whenever a data is lost due to the truncation of the

data value.

Java

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Java

Uploaded by

Copyright:

Available Formats

UNIT – 5

J2EE MULTI TIER ARCHITECTURE

 J2EE is four tier architecture. They layers are named as follows:

Enterprise Java Bean Tier

Enterprise Information System Tier

The Concept of JDBC

JDBC driver Types

Type1 JDBC driver: (JDBC to ODBC bridge)

Type 2 Java/Native Code Driver

Type 3 JDBC Driver

Type 4 JDBC Driver

 JDBC API is contained in 2 packages:

A Brief Overview of the JDBC process

Loading the JDBC driver

 J2EE component must connect to the DBMS using the DriverManager.getConnection( )

String url = “jdbc:odbc:CustomerInformation”;

Create and Execute a SQL statement

Process Data Returned by the DBMS

Terminating the Connection with the DBMS

String url = “jdbc:odbc:CustomerInformation”;

Using the statement Object to execute a query

String url = “jdbc:odbc:CustomerInformation”;

String url = “jdbc:odbc:CustomerInformation”;

String url = “jdbc:odbc:CustomerInformation”;

Difference between Statement, Prepared statement and Callable Statement

Statement PreparedStatement CallableStatement

1. Reading The ResultSet:

 previous() method moves the virtual cursor to the previous row.

 The TYPE_FORWARD_ONLY constant restricts the virtual cursor to downward

String url = “jdbc:odbc:CustomerInformation”;

catch (SQLException error) {

b. Delete Row in the ResultSet:

c. Insert Row in the ResultSet:

catch (SQLException error) {

c. Insert Row in the ResultSet:

catch (SQLException error) {

 If a J2EE component is processing a transaction, the AutoCommit feature must be

String url = “jdbc:odbc:CustomerInformation”;

 There can be many savepoints used in a transaction. Each savepoint is identified by a

Batching SQL Statements in to transaction:

 getColumnCount()  Returns the number of columns contained in the

SQL Type Java Type

 SQLException : it commonly reflects a syntax error in the query and is thrown

 DataTruncation: It is thrown whenever a data is lost due to the truncation of the

You might also like