CHAPTER 10

Servlet Programming
 Introduction
• Several years ago, client-server applications have become very
popular for building enterprise applications.
• In this model, client application is usually installed on the client’s
personal computer, which then sends requests to the server
application via network.
• In such a model, client applications usually contained most of the
presentation and application logic and the interaction with the
server application is done through a GUI.
• Such application clients are referred to as fat clients since the
application logic is also included in the client application. Any
change in the application logic requires reinstallation of the client
application on all the computers.
• With the advent of internet, application clients are completely
replaced with web clients.
• In this model, both the application logic and presentation logic are
physically separated from the clients PC and moved to the server
side.
• The Web client delegates all the user interactions to the server side
application logic which then processes the requests and uses the
presentation tier components to send the response.
• Since the application logic is no longer present on the client PC, web
clients are referred to as thin clients.
• Since the presentation logic is also moved to the server side, the
layout of the user interface can also be controlled from the server
side.
• A web client in this case is nothing but a browser application like
Internet Explorer, FireFox etc.
• Applications that use web clients for user interaction are called as
Web Applications.
• Web clients to interact with server side applications, use
the following:
1. A general purpose browser like Internet Explorer to send
requests and display the response.
2. HTML markup for defining the user interfaces for interaction
with the server
3. HTTP protocol to send and receive requests and responses.
• The way the web applications work is,
1. Web client like IE sends a request using HTTP protocol.
2. The server side program takes the HTTP request, processes it
and sends a HTTP response back to the web client. The
response includes body content in HTML format.
3. Web client then reads the HTTP response, formats the HTML
and displays it to the user.
• Since HTTP plays an important role in web applications,
let’s first know some basics about it and then look at the
server side details.
 HTTP
• HTTP stands for Hyper Text Transfer Protocol. Following are some of
the important properties of HTTP:
1. It is a stateless protocol, meaning that every HTTP request is
independent of each other.
2. It can send data in the request. The server side program reads
the data, processes it and sends the response back. This is the
most important feature of HTTP, the ability to send data to
server side program.
• Based on how the data is sent in the request, HTTP requests are
categorized into several types, but the most important and widely
used are the GET requests and POST requests.
• A typical HTTP request is identified by something called URI
(Uniform Resource Identifier) as shown below:
• http:// <host name>:<port number>/<request details>
 GET Request
• GET request is the simplest of all the requests.
• This type of request is normally used for accessing server-side static
resources such as HTML files, images etc.
• This doesn’t mean that GET requests cannot be used for retrieving
dynamic resources. To retrieve dynamic resources, some data must
be sent in the request and GET request can send the data by
appending it in the URI itself as shown below:
http://somedomain.com?uid=John&role=admin
• In the above URI, the HTTP request sends two pieces of data in the
form of name value pairs. Each name-value pair must be separated by
‘&’ symbol. The server side program will then read the data, process
it, and send a dynamic response.
• Though GET request is simplest of all, it has some limitations:
1. All the data in the request is appended to the URI itself making the
data visible to every one. When secure information need to be sent,
GET request is not the solution.
2. GET requests can only send text data and not the binary data.
Therefore in situations where you need to upload image files to
server, GET request cannot be used.
 POST Request
• POST request is normally used for accessing dynamic
resources.
• POST requests are used when we need to send large amounts
of data to the server.
• Moreover, the data in the POST request is hidden behind the
scenes therefore making data transmittal more secure.
• In most of the real world applications, all the HTTP requests
are sent as POST requests.
• Now that we know the basics of HTTP, let’s move on to the
server side of the web applications.
Server Side of the Web Application
• The server- side is the heart of any web application as it
comprises of the following:
– Static resources like HTML files, XML files, Images etc
– Server programs for processing the HTTP requests
– A runtime that executes the server side programs
– A deployment tool for deploying the programs in the server
• In order to meet the above requirements, J2EE offers the
following:
– Servlet and JSP technology to build server side programs
– Web Container for hosting the server side programs.
– Deployment descriptor which is an XML file used to configure
the web application.
 Web Container
• A Web container is the heart of Java based web application
which is a sophisticated program that hosts the server side
programs like Servlets.
• Once the Servlet programs are deployed in this container, the
container is ready to receive HTTP requests and delegate
them to the programs that run inside the container.
• These programs then process the requests and generate the
responses.
• Also a single web container can host several web applications.
• Look at the following figure that shows how a typical web
container looks like:
• There are several J2EE Web Containers available in the
market. One of the most notable one is the Apache’s Tomcat
container which is available for free of cost.
• This is what we will install for running web applications.
• Having just the web container is not sufficient. We need to
have a programming model to build server side programs that
run within this container.
• J2EE supports two key technologies to build server side
components in Java. These are Servlet and JSP technologies.
 Structure of a Web Application
• For the web container to run the web application, the web application
must follow a standard directory structure within the container.
• Let’s say we want to build a web application named myweb. The
directory structure for this application must be as shown below:

• where webapps is a standard directory within the web container

(Tomcat installation directory). It is from this directory, you need to
start creating the directory structure.
• Following table lists the purpose of each directory:

Directory Description

myweb This directory represents the entire web

application
WEB-INF This directory contains the configuration
file like web.xml
classes This directory must contain all the Java
class files in the web application
• All the static resources namely html files, image files can be stored
directly under myweb directory.
• Creating this directory structure is one of the steps in the
environment configuration section at the beginning of the chapter.
• With the above directory structure, all the components within
myweb application should be accessed with the URL starting with:
• http://localhost:8080/myweb/
• If you want to create another web application like mywebproject,
you must again create the same directory structure with
mywebproject as the root directory and should access the
components using the URL starting with:
• http://localhost:8080/mywebproject/
• At this point please make sure you created the directory structure
as outlined in environment configuration section.
 Servlet Technology
• Servlet technology is a standard J2EE technology used for
building dynamic web applications in Java.
• Using Servlet technology is again nothing but using the
standard classes and interfaces that it comes with.
• These classes and interfaces form what we call as Servlet API.
Definition of Servlet
• A server side Java program that uses the above API is called as
Servlet. In simple terms, a Servlet is a server side Java
program that processes HTTP requests and generates HTTP
response.
 Servlet API
• Though there are several classes and interfaces in this API, we are
interested in the most important ones shown in Table
• At this point, we have the following two important things to
build the web applications in Java:
1. Servlet Technology to build the server-side programs.
2. A Web Container like Tomcat to run the server-side programs.
• Are the above two things good enough to build applications?
The answer is big No. We are missing the most important
component here. This is nothing but the deployment
descriptor.
• Once we have a Web container and several Servlets, it is the
deployment descriptor that tells the web container what
servlets to run. So, this is the key component of any web
application. Let’s see what this is.
 Deployment Descriptor
• A deployment descriptor is a standard XML file named web.xml that is
used by the web container to run the web applications.
• Every web application will have one and only one deployment
descriptor (web.xml file). This file defines the following important
information pertaining to a Servlet:
• 1. Servlet name and Servlet class
• 2. The URL mapping used to access the Servlet
• Let’s assume we wrote a servlet named FormProcesssingServlet in a
package named myservlets. The definition for this servlet in the
web.xml will be as shown below:
<servlet>
<servlet-name>FormProcessingServlet</servlet-name>
<servlet-class>myservlets.FormProcessingServlet</servlet-class>
</servlet>
• The servlet name can be any arbitrary name, but it’s a good practice to have
the class name as the servlet name. However, the servlet class tag must
represent the fully qualified name of the servlet which includes the package
name as shown above. This completes Step 1.
• The next thing we need to define is the URL mapping which identifies how
the servlet is accessed from the browser. For the above servlet, the url
mapping will be as shown below:
• <servlet-mapping>
– <servlet-name>FormProcessingServlet</servlet-name>
– <url-pattern>/FormProcessingServlet</url-pattern>
• </servlet-mapping>
• If you noticed carefully, the servlet name in both the XML snippets is the
same. This is how we bind the url mapping with a servlet. The url pattern
defines how the servlet will be accessed. With the above mapping, the
FormProcessingServlet should be accessed with the following URL:
• http://localhost:8080/myweb/FormProcessingServlet The web container
then delegates the request to myservlets.FormProcessing Servlet class to
process the request.
 Steps for Writing a Servlet
• Writing a servlet is very simple. Trust me. You just have to
follow a standard process as shown below:
• 1. Create a class that extends HttpServlet
• 2. Define 3 methods namely init(), doGet() and doPost().
• These three methods are the standard methods for any
servlet. These are called as callback methods that the web
container invokes automatically when a HTTP request comes
to this servlet.
• For all the GET requests, the web container invokes the
doGet() method, and for POST requests it invokes the doPost()
method.
import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
public class TestServlet extends HTTPServlet {
public void init(ServletConfig config) throws ServletException {
// This method is called before the following methods are called
//and gets called only ONCE. This is like a constructor. We do all
// the initialization here.
}
public void doGet(HTTPServletRequest req, HTTPServletResponse
res) throws ServletException,IOException {
// This method gets called automatically for GET requests. This
//method can only process GET
}
public void doPost(HTTPServletRequest req,
HTTPServletResponse res) throws ServletException,IOException {
// This method gets called automatically for POST requests.This
//method can only process POST
}
}
• If you look at the above servlet, it does the following things
• 1. Imports all the servlet classes
• 2. The class extends HttpServlet
• 3. Defined 3 methods init(),doGet() and doPost()
• These three methods are the standard methods for any
servlet.
• These are called as callback methods that the web container
invokes automatically when a HTTP request comes to this
servlet.
• For all the GET requests, the web container invokes the
doGet() method, and for POST requests it invokes the doPost()
method.
 LifeCycle of a Servlet
• The life cycle of a servlet represents how the web container uses the
servlet to process the requests. Following is what a web container does
with a servlet:
1. Loads the Servlet
2. Instantiates the Servlet
3. Initializes the servlet by executing the init() method.
4. Invokes the doGet() or doPost() methods to process the requests.
5. Repeats Step 4 until all the requests are processed
6. Destroy the servlet
• Before we start writing examples, remember the following
three important points:
• 1. Any request sent by typing the URL in the browser is always
a GET request
• 2. When a hyperlink is clicked, it’s always a GET request
• 3. When a html form is submitted it can either be GET or POST
import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
public class GreetingServlet extends HttpServlet {
public void doGet(HttpServletRequest req,
HttpServletResponse res) throws ServletException, IOException {
res.setContentType("text/html");
PrintWriter pw = res.getWriter();
// Send the message
pw.println("<h1>Welcome to Servlets </h1>");
}
}
• This is a simple servlet which defined just the doGet() method
since we will only send a request from the browser which is a
GET request.
• This method takes two arguments namely HttpServletRequest
and HttpServletResponse.
• The former is used to read the data from the request and the
later is used to send the response back to the browser.
• In this example we only use the response object to send a
greeting message to the browser.
• To send a response, we need to do three things as outlined
below:
• 1. Define the type of the response data. This is done using the
following statement:
– res.setContentType("text/html"); The above line specifies
that we are sending HTML response back.
• 2. Open a stream/channel to the browser to send the
response. This is done using the following statement:
– PrintWriter pw = res.getWriter();
• 3. Send the html message to the browser. To send response
message to the browser, we use the println() method as
shown below:
– pw.println("<h1>Welcome to Servlets </h1>");
 Steps to run the Servlet
1. Save the servlet program in the following directory as
/myweb/WEB-INF/classes/myservlets/GreetingServlet
2. Compile the servlet as shown below:
C:/>jakarta-tomcat-4.1.31>webapps>myweb>WEB-
INF>classes>javac myservlet\*.java
3. Update and save the web.xml file in the WEB-INF directory as
shown below:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD
Web Application 2.3//EN" "http://java.sun.com/dtd/web-
app_2_3.dtd">
<web-app>
<display-name>myweb</display-name>
<!-- Servlet Definitions -- >
<servlet>
<servlet-name>GreetingServlet</servlet-name>
<servlet-class>myservlets.GreetingServlet</servlet-
class>
</servlet>
<!-- Servlet Mappings -- >
<servlet-mapping>
<servlet-name>GreetingServlet</servlet-name>
<url-pattern>/GreetingServlet</url-pattern>
</servlet-mapping>
</web-app>
4. Start the server by clicking the startup.bat in the bin directory.
5. Type the following URL in the browser
• http://localhost:8080/myweb/GreetingServlet
 Servlet Initialialization
• Initializing a servlet is one of the most common practices.
• Servlet initialization is done in the init() method of the servlet.
• Defining initialization parameters for servlets in web.xml is a good
practice as it eliminates hard coding in the servlet.
• The web container while loading the servlet, invokes the init() method
of the servlet as part of the life cycle and passes the parameters
defined in the web.xml to it.
• The other advantage with this is, in the future if the initialization
values need to be changed, you only have to change the web.xml
without having to recompile the entire web application.
• Initialization parameters to a servlet are defined in the web.xml using
the <init-param> element as shown below:
<init-param>
<param-name>driver</param-name>
<param-value>com.mysql.jdbc.Driver</param-value>
</init-param>
• With the above definition, a servlet can access the parameter
in the init() method as shown below:
public void init(ServletConfig config){
String drivername = config.getInitParameter(“driver”);
}
• As you can see from the above code, the ServletConfig class
defines a method named getInitParameter() that takes the
name of the initialization parameter defined in the web.xml
for that servlet, and returns the value.
• Therefore drivername will be initialized with
com.mysql.jdbc.Driver.
<init-param>
<param-name>driver</param-name>
</param-value>com.mysql.jdbc.Driver</param-value>
</init-param>
• With the above definition, a servlet can access the parameter in
the init() method as shown below:
• public void init(ServletConfig config) {
String drivername = config.getInitParameter(“driver”);
}
• As you can see from the above code, the ServletConfig class
defines a method named getInitParameter() that takes the
name of the initialization parameter defined in the web.xml for
that servlet, and returns the value.
import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
public class InitServlet extends HttpServlet {
String drivername;
String databaseURL;
public void init(ServletConfig config) throws ServletException {
drivername = config.getInitParameter("driver");
databaseURL = config.getInitParameter("URL");
}
public void doGet(HttpServletRequest req,
HttpServletResponse res) throws ServletException, IOException {
res.setContentType("text/html");
PrintWriter pw = res.getWriter();
// Send the response
pw.println("<h1>Driver Name is : </h1><br/>" + drivername);
pw.println("<h1>DB URL is : </h1>" + databaseURL);
}
}
• If you look at the above code, the init() method reads two
parameters namely drivername and databaseURL using the
ServletConfig object.
• The parameter keys namely driver and URL will be defined in the
web.xml in the servlet definition as shown below:
<servlet>
<servlet-name>InitServlet</servlet-name>
<servlet-class>myServlets.InitServlet</servlet-class>
<init-param>
<param-name>driver</param-name>
<param-value>com.mysql.jdbc.Driver</param-value>
</init-param>
<init-param>
<param-name>URL</param-name>
<param-
value>jdbc:mysql://localhost:3306/MyDB</param-value>
</init-param>
</servlet>
 Reading HTML Form Data
• HTML form processing is one of the most common things that any
web application does.
• I think you might have noticed on various websites where you fill in
html form with all the information and submit it for processing.
• The application then responds with a confirmation message
something like “information is successfully processed”.
• Registration pages, Email composing etc are some of the examples.
• Following are the steps for processing a HTML form using a Servlet
• 1. User fills the data in the html page and submits it.
• 2. The form data will then be sent to Servlet
• 3. Servlet reads the form data, processes it and send a
confirmation.
 Session Management
• The examples we saw until now just deal with one servlet. However,
a typical web application comprises of several servlets that require
collaborating with each other to give a complete response.
• For instance, if you go online to purchase a book, you need to go
through multiple pages like search page, shopping page, billing page
etc before you can complete the transaction. In situations like this,
it is important that one servlet shares information or data with
other servlet.
• In web application terminology we call the shared data or
information as state. Having state is just not sufficient. Someone
must be able to pass this state from one servlet to other servlet so
that they can share the data.
• So, who does this state propagation? Can HTTP do this?
• No, because HTTP is a stateless protocol which means it cannot
propagate the state. So, is there anyone to help us out here to make
the state available to all the servlets?
• Yes, there is one guy who is always there for our rescue and it’s
none other than web container (Tomcat).
• A web container provides a common storage area called as session
store the state and provides access to this session to all the servlets
within the web application.
• For instance, servlet A can create some state (information) and
store it in the session. Servlet B can then get hold of the session and
read the state.
• Since the state (data or information) in the session is user specific,
the web container maintains a separate session for each and every
user as shown in the following diagram.
• If you look at the above figure, every user will have his own session
object for storing the state pertaining to his transaction and all the
servlets will have access to the same session. Also notice, the
session objects are present within the container.
• Now that we know what a session is, let’s see how a servlet uses
the session for sharing the data across multiple pages in a web
application. A servlet can do the following four most important
operations to work with sessions.
1. Create the session
2. Store the data in the session
3. Read the data from the session
4. Destroy the session or invalidate the session.
• The above four operations are called as Session Management
operations. Let’s see each of them one by one.
 Creating a Session
• The servlet API provides us with a class called HttpSession to
work with sessions. To create a session, we do the following:
HttpSession session = request.getSession(true);
• The above method returns a new session object if one is not
present, otherwise it returns the old session object that is
already created before.
 Storing the data in Session
• Data in session is stored as key-value pair just like in HashMap
or Hashtable. The value can be any Java object and the key is
usually a String. To store the data we use the setAttribute()
method as shown below:
session.setAttribute(“price”,new Double(“12.45”));
 Reading the data from the Session
• To read the data, we need to use the getAttribute() method by
passing in the key as shown below which then returns the
value object:
Double d = (Double)session.getAttribute(“price”);
 Destroying the Session
• A session is usually destroyed by the last page or servlet in the
web application. A session is destroyed by invoking the
invalidate() method as shown below:
session.invalidate();
 Request Dispatching
• Request dispatching is the ability of one servlet to dispatch or
delegate the request to another servlet for processing.
• In simple words, let's say we have a servlet A which doesn't
know how to completely process the request. Therefore, after
partially processing the request, it should forward the request
to another servlet B. This servlet then does the rest of the
processing and sends the final response back to the browser.
• The class used for dispatching requests is the
RequestDispatcher interface in Servlet API. This interface has
two methods namely forward() and include().
 The forward() method
• This method is used for forwarding request from one servlet to
another.
• Consider two servlets A and B. Using this method, A gets the
request, which then forwards the request to B, B processes the
request and sends the response to the browser.
• This method takes HttpServletRequest and HttpServletResponse as
parameters.
RequestDispatcher rd = req.getRequestDispatcher("shop.html");
rd.forward(req, res);
 The include() method
• With this method, one servlet can include the response of other
servlet. The first servlet will then send the combined response back
to the browser.
• This method also takes HttpServletRequest and
HttpServletResponse as parameters.
RequestDispatcher rd=req.getRequestDispatcher("BannerServlet");
rd.include(req, res);
A Simple Web Project Model
Following is how the application works:
1. The login.html sends the login information to the LoginServlet.
2. The login.html also sends the user to register.html to register
3. The LoginServlet will process the login information. If login
fails, it redirects the user back to login.html page. Otherwise, it
takes the user to shop.html page.
4. The register.html will take the customers information and
sends it to RegistrationServlet. This servlet saves all the data in
the database and sends him to the shop.html.
5. The user will shop the products in shop.html. Upon checkout,
shopping cart information will be sent to
OrderProcessingServlet which processes the order and saves
all the billing details in the session. It then forwards the
request to billing.html page.
6. The billing.html page will take the credit card information
and sends the data to BillingServlet.
7. BillingServlet uses the billing data in the session and bills the
customer. It then forwards to ConfirmationServlet that
displays the confirmation message with a thank you
greeting.
8. The response of BannerServlet will be included in the
response of ConfirmationServlet.