>>Hibernate Architecture
The Hibernate architecture includes many
objects such as persistent object, session
factory, transaction factory, connection
factory, session, transaction etc.
The Hibernate architecture is categorized in
four layers.
 Java application layer
 Hibernate framework layer
 Backhand API layer
 Database layer
Diagram of hibernate architecture:
Detailed view of the Hibernate Application
Architecture with important its core classes.
Hibernate framework uses many objects such
as session factory, session, transaction etc.
Alongwith existing Java API such as JDBC
(Java Database Connectivity), JTA (Java
Transaction API) and JNDI (Java Naming
Directory Interface).
Elements of Hibernate Architecture
SessionFactory
o The SessionFactory is a factory of
session and client of ConnectionProvider.
o It holds second level cache of data.
o The org.hibernate.SessionFactory
interface provides factory method to get
the object of Session.
Session
o The session object provides an interface
between the application and data stored
in the database.
o It is a short-lived object and wraps the
JDBC connection.
o It holds a first-level cache (mandatory)
of data.
o The org.hibernate.Session interface
provides methods to insert, update and
delete the object.
o It also provides factory methods for
Transaction, Query and Criteria.
Transaction
o The transaction object specifies the
atomic unit of work. It is optional.
o The org.hibernate.Transaction interface
provides methods for transaction
management.
ConnectionProvider
o It is a factory of JDBC connections.
o It abstracts application from
DriverManager or DataSource. It is
optional.
TransactionFactory
o It is a factory of Transaction.
>>JDBC Drivers
Java Database Connectivity (JDBC) is an
application programming interface (API) for
the programming language Java, which defines
how a client may access any kind of tabular
data, especially relational database. It acts as
a middle layer interface between java
 applications and database. The JDBC classes
are contained in the Java
Package java.sql and javax.sql.
JDBC helps you to write Java applications
that manage these three programming
activities:
1. Connect to a data source, like a database.
2. Send queries and update statements to
the database
3. Retrieve and process the results received
from the database in answer to your
query
Structure of JDBC  converts JDBC method calls into native calls
JDBC drivers are client-side adapters
(installed on the client machine, not on the
server) that convert requests from Java
programs to a protocol that the DBMS can
understand. There are 4 types of JDBC
drivers:
1. Type-1 driver JDBC-ODBC bridge driver
2. Type-2 driver Native-API driver
3. Type-3 driver Network Protocol driver
4. Type-4 driver Thin driver
Type-1 Driver (JDBC-ODBC Bridge Driver)
Type-1 driver or JDBC-ODBC bridge driver
uses ODBC driver to connect to the database.
The JDBC-ODBC bridge driver converts
JDBC method calls into the ODBC function
calls. Type-1 driver is also called Universal
driver because it can be used to connect to
any of the databases.
 As a common driver is used in order to
interact with different databases, the
data transferred through this driver is
not so secured.
 The ODBC bridge driver is needed to be
installed in individual client machines.
 Type-1 driver isn’t written in java, that’s
why it isn’t a portable driver.
 This driver software is built-in with JDK
so no need to install separately.
 It is a database independent driver.
Type-2 Driver (Native-API Driver)
The Native API driver uses the client -side
libraries of the database. This driver
of the database API. In order to interact
with different database, this driver needs
their local API, that’s why data transfer is
much more secure as compared to type-1
driver.
 Driver needs to be installed separately in
individual client machines
 The Vendor client library needs to be
installed on client machine.
 Type-2 driver isn’t written in java, that’s
why it isn’t a portable driver
 It is a database dependent driver.
Type-3 driver (Network Protocol Driver)
The Network Protocol driver uses middleware
(application server) that converts JDBC calls
directly or indirectly into the vendor-specific
database protocol. Here all the database
connectivity drivers are present in a single
server, hence no need of individual client-side
installation.
 Type-3 drivers are fully written in Java,
hence they are portable drivers.
 No client side library is required because
of application server that can perform
many tasks like auditing, load balancing,
logging etc.
 Network support is required on client
machine.
 Maintenance of Network Protocol driver
becomes costly because it requires
database-specific coding to be done in the
middle tier.
 Switch facility to switch over from one
database to another database.
Type-4 Driver (Thin Driver)
Type-4 driver is also called native protocol
driver. This driver interact directly with
database. It does not require any native
database library, that is why it is also known
as Thin Driver.
 Does not require any native library and
Middleware server, so no client-side or
server-side installation.
 It is fully written in Java language, hence
they are portable drivers.
>>JSP Life Cycle
A JSP life cycle is defined as the process
from its creation till the destruction.
Paths Followed By JSP
The following are the paths followed by a JSP
 Compilation
 Initialization
 Execution
 Cleanup
The four phases have been described below −
JSP Compilation
When a browser asks for a JSP, the JSP
engine first checks to see whether it needs
to compile the page. If the page has never
been compiled, or if the JSP has been
modified since it was last compiled, the JSP
engine compiles the page.
The compilation process involves three steps
−
 Parsing the JSP.
 Turning the JSP into a servlet.
 Compiling the servlet.
JSP Initialization
When a container loads a JSP it invokes
the jspInit() method before servicing any
requests. If you need to perform JSP-
specific initialization, override
the jspInit() method −
public void jspInit(){
// Initialization code...
}
JSP Execution
This phase represents all interactions with
requests until the JSP is destroyed.
Whenever a browser requests a JSP and the
page has been loaded and initialized, the JSP
engine invokes the _jspService() method in
the JSP.
void _jspService(HttpServletRequest
request, HttpServletResponse response) {
 // Service handling code...
}
The _jspService() method of a JSP is invoked
on request basis. This is responsible for
generating the response for that request and
this method is also responsible for generating
responses to all seven of the HTTP methods,
i.e. GET, POST, DELETE, etc.
JSP Cleanup
The destruction phase of the JSP life cycle
represents when a JSP is being removed from
use by a container.
The jspDestroy() method is the JSP
equivalent of the destroy method for The above diagram depicts the Model, View
servlets. Override jspDestroy when you need and Controller to the Struts2 high level
to perform any cleanup, such as releasing architecture. The controller is implemented
database connections or closing open files. with a Struts2 dispatch servlet filter as well
public void jspDestroy() {
as interceptors, this model is implemented
// Your cleanup code goes here.
with actions, and the view is a combination of
}
result types and results. The value stack and
OGNL provides common thread, linking and
enabling integration between the other
>>Struts 2 - Architecture
components.
From a high level, Struts2 is a pull-MVC (or
Apart from the above components, there will
MVC2) framework. The Model-ViewController
be a lot of information that relates to
pattern in Struts2 is implemented with the
configuration. Configuration for the web
following five core components −
application, as well as configuration for
 Actions
actions, interceptors, results, etc.
 Interceptors
This is the architectural overview of the
 Value Stack / OGNL
Struts 2 MVC pattern.
 Results / Result types
Request Life Cycle
 View technologies
Based on the above diagram, you can
Struts 2 is slightly different from a
understand the work flow through user's
traditional MVC framework, where the action
request life cycle in Struts 2 as follows −
takes the role of the model rather than the
 User sends a request to the server for
controller, although there is some overlap.
requesting for some resource (i.e. pages).
 The Filter Dispatcher looks at the
request and then determines appropriate
Action.
 Configured interceptor functionalities
applies such as validation, file upload etc.
 Selected action is performed based on
the requested operation.
 Again, configured interceptors are applied
to do any post-processing if required.
 Finally, the result is prepared by the view
and returns the result to the user.
>>Login Authentication (Stored
Procedure)
First create one table named Emp_Login in
the SQL database which looks as :  CommandType.StoredProcedure;
Insert the One Record in the table as:
Insert into Emp_Login
(username,password) values ('abc','xyz')
Stored Procedure named EmpLogin
Create  procedure EmpLogin
( }
@Usename Varchar (20),
@password varchar (10)
) con.Close();
as
Begin
Select COUNT(*) from EmpLogin where
username=@usename and
password=@password
END
In the above Stored Procedure named
EmpLogin the variable @usename is used for
the username and @password is used for the
password. The select query counts the
number of users from the table whose name
matches with the exact two variables; that is
@usename and @password which comes from
the front end user input page.
Loginapplication
Then the  <form> section of the Default.aspx
page looks as in the following:
protected void Button_Click
(objectsender, EventArgs e)
{
connection();
query = "EmpLogin";
SqlCommand com = new SqlCommand(query, con);
com.CommandType =
com.Parameters.AddWithValue("@usename",
TextBox1.Text.ToString()); // username 
com.Parameters.AddWithValue("@password",
TextBox2.Text.ToString()); // password
int usercount = (Int32)com.ExecuteScalar();
//for taking single value
if (usercount == 1)  // comparing users from table 
{
Response.Redirect("Welcome.aspx");
//for sucsseful login
else
{
Label1.Text = "Invalid User Name or
Password";  //for invalid login
}
}
The most important part of the preceding
code is the if condition part, integer variable
user count is used to count the single value
from the Stored Procedure using
ExecuteScalar, if the records are found in
the table it returns 1 then the page is
redirected to the Welcome page otherwise it
gives Invalid User.
>>EJB Architecture
The EJB architecture consists of three main
components: enterprise beans (EJBs), the
EJB container, and the Java application
server. EJBs run inside an EJB container, and
the EJB container runs inside a Java
application server.
There are three types of EJB i.e. session
beans, message-driven beans and entity
beans.
 Session beans are invoked by the client
and make enterprise functionality such
 as transactions and resource management
available to the client programmatically.
 Message-driven beans also encapsulate
and deliver enterprise functionality, but
they are asynchronous, and event driven.
Message-driven beans listen and respond
to events and cannot be invoked by the
client.
 Entity beans summarizes the state that
can be remained in the database. Now, it
is replaced with JPA (Java Persistent
API).
>EJB vs JavaBeans
Enterprise JavaBeans was the first
component-based development model for Java
EE. EJB is similar to JavaBeans in being
component based, but that's where the
similarity ends:
 A JavaBean is a Java class that
encapsulates multiple objects and
conforms to certain conventions.
JavaBeans are used mainly for client-side
development.
 An enterprise bean (EJB) is a Java class
with specific server-side capabilities.
Enterprise beans are used in large-scale
business applications and systems.
>Session Beans
A session bean is the most generic type of
enterprise bean, representing a chunk of
business functionality that can be called by a
client. The client in this case could be another
class in the local JVM or a remote call.
The EJB container manages the session bean
lifecycle, which is determined by the bean's
state:
 Stateless session beans are similar to
the request scope in the Java Servlet
API. Stateless session beans contain a
chunk of callable functionality but are
otherwise stateless.
 Stateful session beans are associated
with one client only and attach to that
client's ongoing session. Stateful session
beans function similarly to the session
scope in the Servlet API.
 Singleton beans are like application scope
in the Servlet API. A singleton session
bean exists only once for each client.
>Thread Safety with Session Beans
A stateful session bean can only be accessed
by one client at a time, so thread safety is
guaranteed when you're working with this
type of bean. Stateless session beans and
singleton beans are more flexible, allowing
concurrent connections which is managed by
developer.
>Message-Driven Beans
Message-driven beans (MDBs) are invoked
via JMS (Java Message Service) messages.
JMS works like a distributed Command
pattern, where the message-driven bean acts
as the listener for the command. When a
message arrives on a topic or queue, the
message-driven bean listening on that topic is
invoked.
Message-driven beans are not as commonly
used as session beans, but they are powerful.
Being asynchronous and event-driven, they're
especially useful for long-running jobs where
it's important to conserve resources.
The simplest architecture would consist of
the EJB application and its container and
server, which coordinate with the message
service processing the MDBs.
Diagram of an MDB architecture
Working with message-driven beans is more
involved than using session beans. In an event-
driven environment you'll typically need
a message broker like ActiveMQ.
>EJB annotations
Annotations make it very easy to configure
enterprise beans for a wide range of
functionality found in Java EE.
@Stateless Annotation example
import javax.ejb.Stateless;
@Stateless
 public class MyStatelessBean {
public String getGreeting() {
return "Hello JavaWorld.";
} Step 3: Set values to the place holders
} Set the values to the place holders using the
This stateless bean contains a simple
signature that takes no arguments and
returns a string. Don't let simplicity fool you,
though: this bean can do anything you need it
to, including interacting with other beans,
services, or your application's data layer.
@EJB annotation example
public class MyServlet extends
HttpServlet {
@EJB
MyStatelessBean myEjb;
public void doGet(HttpServletRequest
request, HttpServletResponse response){
response.getWriter().write("EJB Says " +
testStatelessEjb.getGreeting());
}}
Here, we inject the stateless bean into a
servlet, and then it's available for use.
>>Insert Image into Database Java
To hold an image in MySQL database
generally blob type is used.
Step 1: Connect to the database
You can connect to a database using
the getConnection() method
Connect to the MySQL database by passing
the MySQL URL which is
jdbc:mysql://localhost/sampleDB (sampleDB
is the database name), username and
password as parameters to the
getConnection() method.
String mysqlUrl =
"jdbc:mysql://localhost/sampleDB";
Connection con =
DriverManager.getConnection(mysqlUrl,
"root", "password");
Step 2: Create a Prepared statement
Create a PreparedStatement object using
the prepareStatement() method of the
Connection interface. To this method pass
the insert query (with place holders) as a
parameter.
PreparedStatement pstmt =
con.prepareStatement("INSERT INTO
MyTable VALUES(?, ?)");
setter methods of the PreparedStatement
interface. Chose the methods according to
the datatype of the column.
And if it is of Blob type you can set value to it
using the setBinaryStream() or setBlob()
methods.
pstmt.setString(1, "sample image");
//Inserting Blob type
InputStream in = new FileInputStream
("E:\\images\\image.jpg");
pstmt.setBlob(2, in);
Step 4: Execute the statement
import java.io.FileInputStream;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
public class InsertImageToMySqlDB {
public static void main(String args[])
throws Exception{
      //Registering the Driver
DriverManager.registerDriver(new
com.mysql.jdbc.Driver());
//Getting the connection
String mysqlUrl =
"jdbc:mysql://localhost/sampleDB";
Connection con =
DriverManager.getConnection(mysqlUrl,
"root", "password");
System.out.println("Connection
established ......");
PreparedStatement pstmt =
con.prepareStatement("INSERT INTO
MyTable VALUES(?,?)");
pstmt.setString(1, "sample image");
//Inserting Blob type
InputStream in = new
FileInputStream("E:\\images\\cat.jpg");
pstmt.setBlob(2, in);
//Executing the statement
pstmt.execute();
System.out.println("Record inserted......");
   }
}