UNIT - IV SERVLETS, JSP AND DATABASE CONNECTIVITY
Overview of Servlet – Life Cycle of Servlet – Servlet Configuration – Running Servlet with Database
Connectivity – Servlet Support for Cookies – Session Tracking – Basics of JSP – Java Server Faces –
Multi tier Application Architecture – MVC Architecture of JSF Apps – JSF Components – Session
Tracking – Developing Dynamic Data Driven Websites.
Overview of Servlet
What are Servlets?
Java Servlets are programs that run on a Web or Application server and act as a middle layer
between a requests coming from a Web browser or other HTTP client and databases or
applications on the HTTP server.
Using Servlets, you can collect input from users through web page forms, present records from a
database or another source, and create web pages dynamically.
Java Servlets often serve the same purpose as programs implemented using the Common
Gateway Interface (CGI). But Servlets offer several advantages in comparison with the CGI.
Performance is significantly better.
Servlets execute within the address space of a Web server. It is not necessary to create a
separate process to handle each client request.
Servlets are platform-independent because they are written in Java.
Java security manager on the server enforces a set of restrictions to protect the resources
on a server machine. So servlets are trusted.
The full functionality of the Java class libraries is available to a servlet. It can
communicate with applets, databases, or other software via the sockets and RMI
mechanisms that you have seen already.
Servlets Architecture
The following diagram shows the position of Servlets in a Web Application.
Servlets Tasks
Servlets perform the following major tasks −
Read the explicit data sent by the clients (browsers). This includes an HTML form on a Web page
or it could also come from an applet or a custom HTTP client program.
Read the implicit HTTP request data sent by the clients (browsers). This includes cookies, media
types and compression schemes the browser understands, and so forth.
Process the data and generate the results. This process may require talking to a database,
executing an RMI or CORBA call, invoking a Web service, or computing the response directly.
Send the explicit data (i.e., the document) to the clients (browsers). This document can be sent in
a variety of formats, including text (HTML or XML), binary (GIF images), Excel, etc.
Send the implicit HTTP response to the clients (browsers). This includes telling the browsers or
other clients what type of document is being returned (e.g., HTML), setting cookies and caching
parameters, and other such tasks.
Servlets Packages
Java Servlets are Java classes run by a web server that has an interpreter that supports the Java
Servlet specification.
Servlets can be created using the [Link] and [Link] packages, which are a
standard part of the Java's enterprise edition, an expanded version of the Java class library that
supports large-scale development projects.
These classes implement the Java Servlet and JSP specifications. At the time of writing this
tutorial, the versions are Java Servlet 2.5 and JSP 2.1.
Java servlets have been created and compiled just like any other Java class. After you install the
servlet packages and add them to your computer's Classpath, you can compile servlets with the
JDK's Java compiler or any other current compiler.
Life Cycle of Servlet
A servlet life cycle can be defined as the entire process from its creation till the destruction.
The following are the paths followed by a servlet.
The servlet is initialized by calling the init() method.
The servlet calls service() method to process a client's request.
The servlet is terminated by calling the destroy() method.
Finally, servlet is garbage collected by the garbage collector of the JVM.
Now let us discuss the life cycle methods in detail.
The init() Method
The init method is called only once. It is called only when the servlet is created, and not
called for any user requests afterwards. So, it is used for one-time initializations, just as with
the init method of applets.
The servlet is normally created when a user first invokes a URL corresponding to the servlet,
but you can also specify that the servlet be loaded when the server is first started.
When a user invokes a servlet, a single instance of each servlet gets created, with each user
request resulting in a new thread that is handed off to doGet or doPost as appropriate. The
init() method simply creates or loads some data that will be used throughout the life of the
servlet.
The init method definition looks like this −
public void init() throws ServletException {
// Initialization code...
The service() Method
The service() method is the main method to perform the actual task. The servlet container (i.e.
web server) calls the service() method to handle requests coming from the client( browsers) and
to write the formatted response back to the client.
Each time the server receives a request for a servlet, the server spawns a new thread and calls
service. The service() method checks the HTTP request type (GET, POST, PUT, DELETE, etc.)
and calls doGet, doPost, doPut, doDelete, etc. methods as appropriate.
Here is the signature of this method −
public void service(ServletRequest request, ServletResponse response)
throws ServletException, IOException {
The service () method is called by the container and service method invokes doGet, doPost,
doPut, doDelete, etc. methods as appropriate. So you have nothing to do with service() method
but you override either doGet() or doPost() depending on what type of request you receive from
the client.
The doGet() and doPost() are most frequently used methods with in each service request. Here is
the signature of these two methods.
The doGet() Method
A GET request results from a normal request for a URL or from an HTML form that has no
METHOD specified and it should be handled by doGet() method.
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Servlet code
The doPost() Method
A POST request results from an HTML form that specifically lists POST as the METHOD and it
should be handled by doPost() method.
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Servlet code
The destroy() Method
The destroy() method is called only once at the end of the life cycle of a servlet. This method
gives your servlet a chance to close database connections, halt background threads, write cookie
lists or hit counts to disk, and perform other such cleanup activities.
After the destroy() method is called, the servlet object is marked for garbage collection. The
destroy method definition looks like this −
public void destroy() {
// Finalization code...
}
Architecture Diagram
The following figure depicts a typical servlet life-cycle scenario.
First the HTTP requests coming to the server are delegated to the servlet container.
The servlet container loads the servlet before invoking the service() method.
Then the servlet container handles multiple requests by spawning multiple threads, each thread
executing the service() method of a single instance of the servlet.
Servlet Configuration
Steps to Run This Servlet
1. Compile
[Link]
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
// A simple Hello World Servlet
public class HelloServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set response type
[Link]("text/html");
// Get output writer
PrintWriter out = [Link]();
// Write response
[Link]("<html><body>");
[Link]("<h1>Hello, this is my first servlet!</h1>");
[Link]("</body></html>");
}
}
Explanation:
Above mentions HelloServlet, which is a servlet class that extends HTTP
Servlet, allowing it to handle HTTP requests.
doGet() is used to process GET requests.
[Link]("text/html") tells the browser it is HTML content.
PrintWriter out = [Link]() is used to write the response.
out. println() sends a simple HTML message: "Hello, World!" to the client.
Compile the program,
javac -cp "C:\path\to\tomcat\lib\[Link]" [Link]
2. Folder Structure
Put your servlet class here:
Tomcat
└── webapps
└── FirstApp
├── WEB-INF
│ ├── [Link]
│ └── classes
│ └── [Link]
3. [Link] Configuration
Inside Tomcat\webapps\FirstApp\WEB-INF\[Link]:
<web-app>
<servlet>
<servlet-name>HelloServlet</servlet-name>
<servlet-class>HelloServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>HelloServlet</servlet-name>
<url-pattern>/hello</url-pattern>
</servlet-mapping>
</web-app>
4. Start Tomcat
Go to Tomcat/bin and run:
[Link]
5. Run in Browser
Open the browser and type
[Link]
Output:
Hello, this is my first servlet!
Running Servlet with Database Connectivity
To connect a Servlet with MySQL, you need to follow these steps:
1. Install MySQL and Create Database
Install MySQL server (if not already installed).
Create a database and table. Example:
CREATE DATABASE studentdb;
USE studentdb;
CREATE TABLE students (
id INT PRIMARY KEY AUTO_INCREMENT,
name VARCHAR(100),
age INT,
department VARCHAR(50)
);
2. Add MySQL JDBC Driver
Download the MySQL Connector/J (JDBC driver) from MySQL official site.
Place the [Link] file inside:
o <Tomcat Install Dir>/lib/
(so all web apps can use it), or
o WEB-INF/lib/ folder of your project.
3. Load JDBC Driver in Servlet
Use [Link]() to load driver.
Example:
[Link]("[Link]");
4. Establish Database Connection
Use [Link]():
Connection con = [Link](
"jdbc:mysql://localhost:3306/studentdb", "root", "yourpassword");
5. Write Servlet Code
Here’s a simple servlet that inserts data into MySQL:
import [Link].*;
import [Link].*;
import [Link].*;
import [Link].*;
public class StudentServlet extends HttpServlet {
public void doPost(HttpServletRequest request, HttpServletResponse
response)
throws ServletException, IOException {
[Link]("text/html");
PrintWriter out = [Link]();
String name = [Link]("name");
int age = [Link]([Link]("age"));
String dept = [Link]("department");
try {
// Load Driver
[Link]("[Link]");
// Create Connection
Connection con = [Link](
"jdbc:mysql://localhost:3306/studentdb", "root",
"yourpassword");
// Insert Query
PreparedStatement ps = [Link](
"INSERT INTO students(name, age, department) VALUES
(?, ?, ?)");
[Link](1, name);
[Link](2, age);
[Link](3, dept);
int i = [Link]();
if (i > 0) {
[Link]("<h3>Student added successfully!</h3>");
}
[Link]();
} catch (Exception e) {
[Link]("<h3>Error: " + [Link]() + "</h3>");
}
}
}
6. Configure [Link] (if needed)
If you’re not using annotations (@WebServlet), configure [Link]:
<servlet>
<servlet-name>StudentServlet</servlet-name>
<servlet-class>StudentServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>StudentServlet</servlet-name>
<url-pattern>/addStudent</url-pattern>
</servlet-mapping>
7. Create HTML Form
<form action="addStudent" method="post">
Name: <input type="text" name="name"><br>
Age: <input type="number" name="age"><br>
Department: <input type="text" name="department"><br>
<input type="submit" value="Add Student">
</form>
8. Deploy and Run
Place project in webapps folder of Tomcat.
Start Tomcat server.
Open browser:
[Link]
Servlet Support for Cookies