Servlets

COMPLETE REFERENCE TO JAVA –

HERBERT SCHILDT
CHAPTER 31
 Servlets are small programs that execute on the
server side of a web connection.
 servlets dynamically extend the functionality of a
web server.
 How is a web page loaded?

 A user enters a Uniform Resource Locator (URL) into a

browser.
 The browser generates an HTTP request to the appropriate
web server.
 The web server maps this request to a specific file.
 That file is returned in an HTTP response to the browser.
 The HTTP header in the response indicates the type of the
content.
 The Multipurpose Internet Mail Extensions (MIME) are used
for this purpose.
 For example, ordinary ASCII text has a MIME type of text/plain.
 The Hypertext Markup Language (HTML) source code of a web page
has a MIME type of text/html.
 How do dynamic pages work?

 In the early days of the Web, a server could dynamically

construct a page by creating a separate process to handle
each client request.
 The process would open connections to one or more
databases in order to obtain the necessary information.
 It communicated with the web server via an interface
known as the Common Gateway Interface (CGI). CGI
allowed the separate process to read data from the HTTP
request and write data to the HTTP response.
 A variety of different languages were used to build CGI
programs.(C,C++,Perl)
 Problems with CGI

 It was expensive in terms of processor and memory

resources to create a separate process for each client
request.
 It was also expensive to open and close database
connections for each client request.
 the CGI programs were not platform-independent.
 Advantages of using Servlets

 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.
 the Java security manager on the server enforces a set of
restrictions to protect the resources on a server machine.
 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.
 The Life Cycle of a Servlet
• First, assume that a user enters a
Uniform Resource Locator (URL) to a
These are
web browser. The browser then generates init()
implemented by
an HTTP request for this URL. This
every servlet and
request is then sent to the appropriate
are invoked at
server.
specific times by
• Second, this HTTP request is received by
the server
the web server. The server maps this
request to a particular servlet. The servlet
is dynamically retrieved and loaded into Lifecycle
the address space of the server.
• Third, the server invokes the init( )
method of the servlet. This method is
invoked only when the servlet is first
loaded into memory. It is possible to pass
initialization parameters to the servlet so service() destroy()
it may configure itself.
• Fourth, the server invokes the service( ) method of the servlet. This method is
called to process the HTTP request. the servlet reads data that has been provided
in the HTTP request. It may also formulate an HTTP response for the client.
• The servlet remains in the server’s address space and is available to process any
other HTTP requests received from clients. The service( ) method is called for
each HTTP request.
• Finally, the server may decide to unload the servlet from its memory. The
algorithms by which this determination is made are specific to each server. The
server calls the destroy( ) method to relinquish any resources such as file
handles that are allocated for the servlet. Important data may be saved to a
persistent store. The memory allocated for the servlet and its objects can then be
garbage collected.
 A Simple Servlet

import java.io.*;
import javax.servlet.*;
public class HelloServlet extends GenericServlet {
public void service(ServletRequest request,
ServletResponse response) throws ServletException, IOException
{
response.setContentType("text/html");
PrintWriter pw = response.getWriter();
pw.println("<B>Hello!");
pw.close();
}
}
 A Simple Servlet

 The basic steps are the following:

 Create and compile the servlet source code. Then, copy the
servlet’s class file to the proper directory, and add the servlet’s
name and mappings to the proper web.xml file.
 To compile
 javac HelloServlet.java -classpath "C:\Program Files\Apache
Software Foundation\Tomcat 5.5\common\lib\servlet-api.jar"
 Start Tomcat.
 Start a web browser and request the servlet.
 The javax.servlet Package

Interface
Classes
 The Servlet Interface

 All servlets must implement the Servlet interface.

 It declares the init( ), service( ), and destroy( )
methods that are called by the server during the life
cycle of a servlet.
 Methods defined are
 The ServletConfig Interface

 The ServletConfig interface allows a servlet to

obtain configuration data when it is loaded.
 The methods declared by this interface are
summarized here
 The ServletContext Interface

 The ServletContext interface enables servlets to

obtain information about their environment.
 Several of its methods are summarized
 The ServletRequest Interface

 The ServletRequest interface enables a servlet to

obtain information about a client request.
 Several of its methods are summarized
 The ServletResponse Interface

 The ServletResponse interface enables a servlet to

formulate a response for a client. Several of its
methods are summarized
 GenericServlet Class

 The GenericServlet class provides implementations of

the basic life cycle methods for a servlet.
 GenericServlet implements the Servlet and
ServletConfig interfaces.
 a method to append a string to the server log file is
available.
 The signatures of this method are shown here:
 void log(String s)
 void log(String s, Throwable e)
 Here, s is the string to be appended to the log, and e is an exception
that occurred.
 CIE 3 - Reading Servlet Parameters

 The ServletRequest interface includes methods that allow

you to read the names and values of parameters that are
included in a client request.
 There are two files in the following program
 PostParameters.html – A web page
 It defines a table that contains two labels and two text fields.
 One of the labels is Employee and the other is Phone.
 There is also a submit button.
 The URL identifies the servlet to process the HTTP POST request.
 PostParametersServlet.java – a servlet program
 The service( ) method is overridden to process client requests.
 The getParameterNames( ) method returns an enumeration of the
parameter names. These are processed in a loop.
 The parameter name and value are output to the client. The parameter
value is obtained via the getParameter( ) method.
 PostParameters.html
<html>
<body>
<center>
<form name="Form1"
method="post"
action="http://localhost:8080/servlets-examples/servlet/PostParametersServlet">
<table>
<tr>
<td><B>Employee</td>
<td><input type=textbox name="e" size="25" value=""></td>
</tr>
<tr>
<td><B>Phone</td>
<td><input type=textbox name="p" size="25" value=""></td>
</tr>
</table>
<input type=submit value="Submit">
</body>
</html>
 PostParametersServlet.java
import java.io.*;
import java.util.*;
import javax.servlet.*;
public class PostParametersServlet extends GenericServlet {
public void service(ServletRequest request, ServletResponse response) throws ServletException,
IOException {
// Get print writer.
PrintWriter pw = response.getWriter();
// Get enumeration of parameter names.
Enumeration e = request.getParameterNames();
// Display parameter names and values.
while(e.hasMoreElements()) {
String pname = (String)e.nextElement();
pw.print(pname + " = ");
String pvalue = request.getParameter(pname);
pw.println(pvalue);
}
pw.close();
}}
 The javax.servlet.http Package

 Interfaces defined in this package are

 Classes defined in this package are

 Handling HTTP Requests and Responses

 The HttpServlet class provides specialized methods that

handle the various types of HTTP requests.
 A servlet developer typically overrides one of these methods.
These methods are
 doDelete( ) - Called by servlet service() method to handle the DELETE
request from client that allows a client to delete a document, webpage or
information from the server.
 doGet( ) - This method is called by servlet service method to handle the
HTTP GET request from client. When overriding this method, read the
request data, write the response headers, get the response’s writer or
output stream object, and finally, write the response data.
 doHead( ) - This method is called by servlet service method to handle
the HTTP HEAD request from client. The client sends a HEAD request
when it wants to see only the headers of a response, such as Content-
Type or Content-Length

 doOptions( ) - Called by the service method to allow a servlet to
handle a OPTIONS request. The OPTIONS request determines which
HTTP methods the server supports and returns an appropriate
header.
 doPost( ) - this method is called by servlet service method to handle
the POST request from client. The HTTP POST method allows the
client to send data of unlimited length to the Web server a single
time and is useful when posting information to the server. Unlike,
doGet where we get information from the sever this method is used
when we are transferring information from client to the server.
 doPut( ) - This method is called by servlet service method to handle
the PUT request from client. This method is similar to doPost
method but unlike doPost method where we send information to the
server, this method sends file to the server, this is similar to the FTP
operation from client to server.
 doTrace( ) - This method is called by service() method for handling
TRACE request. Used for debugging purposes.
 Handling HTTP GET Requests

 Two files
 ColorGet.html - A web page
 ColorGetServlet.java - a servlet
<html>
<body>
<center>
<form name="Form1"
action="http://localhost:8080/servlets-examples/servlet/ColorGetServlet">
<B>Color:</B>
<select name="color" size="1">
<option value="Red">Red</option> • It defines a form that
<option value="Green">Green</option> contains a select element
<option value="Blue">Blue</option> and a submit button.
</select> • Notice that the action
<br><br>
<input type=submit value="Submit">
parameter of the form tag
</form> specifies a URL.
</body> • The URL identifies a servlet
</html> to process the HTTP GET
request.
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*; • The doGet( ) method is
public class ColorGetServlet extends HttpServlet { overridden to process any
public void doGet(HttpServletRequest request, HTTP GET requests that
HttpServletResponse response) are sent to this servlet.
throws ServletException, IOException { • It uses the
String color = request.getParameter("color"); getParameter() method
of HttpServletRequest
response.setContentType("text/html");
to obtain the selection
PrintWriter pw = response.getWriter();
that was made by the
pw.println("<B>The selected color is: ");
user.
pw.println(color); • A response is then
pw.close(); formulated.
}
}
 Handling HTTP POST Requests

 Two files
 ColorPost.html - A web page
 ColorPostServlet.java - a servlet
<html>
<body>
<center>
<form name="Form1"
method="post"
action="http://localhost:8080/servlets-examples/servlet/ColorPostServlet">
<B>Color:</B>
<select name="color" size="1"> • It is identical to ColorGet.htm except
<option value="Red">Red</option>
<option value="Green">Green</option> that the method parameter for the form
<option value="Blue">Blue</option> tag explicitly specifies that the POST
</select> method should be used, and the action
<br><br> parameter for the form tag specifies a
<input type=submit value="Submit"> different servlet.
</form>
</body>
</html>
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class ColorPostServlet extends HttpServlet {
public void doPost(HttpServletRequest request,
HttpServletResponse response) • The doPost( ) method is
throws ServletException, IOException { overridden to process any
String color = request.getParameter("color");
HTTP POST requests that are
response.setContentType("text/html"); sent to this servlet.
PrintWriter pw = response.getWriter(); • It uses the getParameter( )
pw.println("<B>The selected color is: "); method of
HttpServletRequest to
pw.println(color); obtain the selection that was
pw.close(); made
} • by the user.
} • A response is then formulated.
 Using Cookies

 a servlet that illustrates how to use cookies.

 The program includes three files.
 AddCookie.htm - Allows a user to specify a value for the cookie
named MyCookie.
 AddCookieServlet.java - Processes the submission of
AddCookie.htm.
 GetCookiesServlet.java - Displays cookie values.
 AddCookie.html
This page contains a text field
<html> in which a value can be
<body> entered. There is also a
<center> submit button on the
page. When this button is
<form name="Form1" pressed, the value in the text
method="post" field is sent to
action="http://localhost:8080/servlets-AddCookieServlet
examples/servlet/AddCookieServlet"> via an HTTP POST request.
<B>Enter a value for MyCookie:</B>
<input type=textbox name="data" size=25 value="">
<input type=submit value="Submit">
</form>
</body>
</html>
 AddCookieServlet.java
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class AddCookieServlet extends HttpServlet {
public void doPosHttpServletResponse response) throws ServletException, IOException {
// Get parameter from HTTP request.
String data = request.getParameter("data");
// Create cookie.
Cookie cookie = new Cookie("MyCookie", data);
It gets the value of the parameter
named “data”. It then creates a
// Add cookie to HTTP response.
Cookie object that has the name
response.addCookie(cookie);
“MyCookie” and contains the value
// Write output to browser.
of the “data” parameter. The cookie
response.setContentType("text/html"); is then added to the header of the
PrintWriter pw = response.getWriter(); HTTP response via the
pw.println("<B>MyCookie has been set to"); addCookie( ) method. A feedback
pw.println(data); message is then written to the
pw.close(); browser.
}}
 GetCookiesServlet.java
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class GetCookiesServlet extends HttpServlet {
public void doGet(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException { It invokes the getCookies( )
// Get cookies from header of HTTP request. method to read any cookies that
Cookie[] cookies = request.getCookies(); are included in the HTTP GET
// Display these cookies. request. The names and values
response.setContentType("text/html"); of these cookies are then
PrintWriter pw = response.getWriter(); written to the HTTP response.
pw.println("<B>"); Observe that the getName( )
for(int i = 0; i < cookies.length; i++) { and getValue( ) methods are
String name = cookies[i].getName();
called to obtain this
String value = cookies[i].getValue();
information.
pw.println("name = " + name +
"; value = " + value);
}
pw.close();
}
}
 Session Tracking

 HTTP is a stateless protocol.(Each request is independent of the

previous one.)
 it is necessary to save state information so that information can be
collected from several interactions between a browser and a server.
 Sessions provide such a mechanism.
 A session can be created via the getSession( ) method of
HttpServletRequest. An HttpSession object is returned. This
object can store a set of bindings that associate names with objects.
 The setAttribute( ), getAttribute( ), getAttributeNames( ),
and removeAttribute( ) methods of HttpSession manage these
bindings. It is important to note that session state is shared among
all the servlets that are associated with a particular client.
 Program to illustrate the use of sessions
import java.io.*;
import java.util.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class DateServlet extends HttpServlet {  The getSession( ) method
public void doGet(HttpServletRequest request, gets the current session.
HttpServletResponse response)  A new session is created if one
throws ServletException, IOException { does not already exist.
// Get the HttpSession object.  The getAttribute( ) method
HttpSession hs = request.getSession(true); is called to obtain the object
// Get writer.
that is bound to the name
response.setContentType("text/html");
“date”. That object is a Date
PrintWriter pw = response.getWriter();
object that encapsulates the
pw.print("<B>");
// Display date/time of last access.
date and time when this page
Date date = (Date)hs.getAttribute("date");
was last accessed. A Date
if(date != null) { object encapsulating the
pw.print("Last access: " + date + "<br>"); current date and time is then
} created.
// Display current date/time.  The setAttribute( ) method
date = new Date(); is called to bind the name
hs.setAttribute("date", date); “date” to this object.
pw.println("Current date: " + date);
}}