servlet ppt by vikas jagtap
TRANSCRIPT
BY Vikas p Jagtap
Servlet Concept
Server side programs can be written using different server-side technologies , such as Common Gateway Interface (CGI) , Active Server Pages (ASP) and Servlets.
CGI scripts are written in C , C++ or perl programming languages .
In case of an application server using CGI script to process client request , the server creates a separate instance of the CGI script to process the request.
As a result, the efficiency of the server is affected when there is large number of concurrent requests.
ASP is a server –side technology that enables a developer to combine both HTML and scripting language in the same page.
ASP objects are multithreading and can therefore concurrently service multiple requests.
The limitation of the ASP is that it is not compatible with all the commercial Web servers.
Servlets are server side programs written in Java.
Unlike CGI scripts ,the servlet initialization code is executed only once.
Moreover , separate thread in the server handle each client-request.
In addition, servlets inherit all the features of the Java programming language.
Web containersWeb containers provide various services required by web
application , such as :
Managing various stages in the life cycle of the servlet, such as initializing a servlet instance, processing the client request , and removing the servlet instance from service.
Defining the security constraints that specifies only authorized users can access the deployed servlets.
Managing database transactions when a servlet needs to read and write data from a database , such as SQL Server 2000.
Creating and removing servlet instances from an instance pool to serve multiple requests.
Tasks performed by the Web container
Loads the Servlet class
Instantiates the Servlet
Initializes the Servlet Instance
Passes Request to the Servlet
Instance
Sends Response
First Client Request
Request
Response
The Servlet Class Hierarchy
Servlet ServletConfig Serializable
GenericServlet
HttpServlet
UserDefinedServlet
Interfaces
Built-in classes
User defines class
The Servlet Life Cycle Methods
The javax.servlet.Servlet interface defines the life cycle methods of the servlet such as init() , service() , and destroy().
The Web container invokes the init() , service(), and destroy() methods of a servlet during its life cycle.
The sequence in which the Web container calls the life cycle methods of a servlet is as follows :
1. The Web container loads the servlet class and creates instance of the servlet class.
2. The Web container invokes the init() method of the servlet instance during initialization of the Servlet. The init() method is invoked only once in the servlet life cycle .
3. The Web container invokes the service() method to allow a servlet to process a client request.
4. The service() method processes the request and returns the response back to the Web container.
5. The servlet then waits to receive and process subsequent requests as explained in steps 3 and 4.
6. The Web container calls the destroy() method before removing the servlet instance from the service. The destroy() method is also invoked only once in the a servlet life cycle.
The init() method
The init() method is called during the initialization phase of the servlet life cycle.
The Web container first maps the requested URL to the corresponding servlet available in the Web container and then instantiates the servlet.
The Web container then creates an object of the ServletConfig interface, which contains the startup configuration information, such as initialization parameters of the servlet.
The Web container then calls the init() method of the servlet and passes the ServletConfig object to it.
The init() method ……..
The init() method throws a ServletException if the Web container cannot initialize the servlet resources .
The servlet initialization completes before any client requests are accepted.
The following code snippet shows the init() method:
public void init (ServletConfig config) throws ServletException
The service() MethodThe service() method processes the client requests.
Each time the Web container receives a client request, it invokes the service() method.
The service() method is invoked only after the initialization of the servlet is complete.
When the Web container calls the service() method, it passes an object of the ServletRequest interface and an object of the ServletResponse interface.
The ServletRequest object contains information about the service request made by the client.
The ServletResponse object contains the information returned by the servlet to the client.
The service() Method…….The following code snippet shows the service() method:
public void service(ServletRequest req , ServletResponse res) throws ServletException , IOException
The service() method dispatches a client request to one of the request handler methods of the HttpServlet interface ,such as the doGet() , doPost() , doHead() , or doPut().
The request handler methods accepts the objects of the HttpServletRequest and HttpServletResponse as parameters from the service() method.
service() method is not overridden in the HttpServlet as the Web container automatically invokes the service() method.
The servlet functionality of the HTTP Servlets is written in doGet() or doPost() methods.
The destroy() method The destroy() method marks the end of the life cycle of a servlet.
The Web container calls the destroy() method before removing a servlet instance from the service.
The Web container calls the destroy() method when :
1. The time period specified for the servlet has elapsed. The time period of a servlet is the period for which the servlet is kept in the active state by the Web container to service the client request.
2. The Web container needs to release servlet instances to conserve memory.
3. The Web container is about to shut down.
The destroy() method……..
In the destroy() method you can write the code to release the resources occupied by the servlet.
The following code snippet shows the code of the destroy() method:
public void destroy();
Summary
The classes and interfaces , which are used to develop a servlet, are packages in the javax.servlet and javax.servlet.http packages of the Servlet API.
The javax.servlet.Servlet interface defines methods that are used to manage the servlet life cycle.
The javax.servlet.ServletConfig interface is implemented by a Web container to pass configuration information to the servlet.
The HttpServletRequest object represents a request sent by a client using HTTP.
The HttpServletResponse object represents a response sent by a servlet to a client using HTTP.
Assignment
Smart Software Developers wants to develop a web application that will use servlets to display employee infromation stored in the Employee table.
The application needs to have a user interface in which a user can specify an employee id to view the data of the employee.
The interface should also display the number of times this site has been visited.
Employee details are : Name , Address , Age , Designation.
The commonly used interfaces of javax.servlet package are :
1. ServletRequest Interface
2. ServletResponse Interface
3. ServletContext Interface
The ServletRequest Interface The ServletRequest interface contains various methods to
handle client requests to access a servlet.
The following describes various methods of the ServletRequest interface:
1. public String getParameter (String paramName) -> Returns a String object that specifies the value of a particular
request parameter.
2. public String[] getParameterValues (String paramName) -> Returns an array of String objects that contains all the values
of the request parameter.
3. public Enumeration getParameterNames () -> Returns an Enumeration containing all the parameter
names as String objects that a servlet request contains.
4. public String getRemoteHost () -> Returns a String that specifies the full-qualified name of the computer from which the request is sent.
5. public Sring getRemoteAddr () -> Returns a String that specifies the IP address of the
computer from which the request is sent.
The ServletResponse InterfaceThe ServletResponse interface contains various methods that
enable a servlet to respond to the client requests.
A servlet can send the response either as character or binary data.
The PrintWriter stream can be used to send character data as servlet response and ServletOutputStream stream to send to binary data as servlet response.
The following describes various methods of the ServletResponse interface:
1. public ServletOutputStream getOutputstream() throws IOException -> Returns an object of the ServletOutputStream class that
represents an output stream to send binary data as response.
2. public PrintWriter getWriter () throws IOException -> Returns an object of the PrintWriter class that servlet uses to
send character data as response.
3. public void setContentType(String type)
-> Sets the Multipurpose Internet Mail Extensions (MIME) type for the servlet response. Some of the MIME types are text/plain , image/jpeg , and text/html.
The ServletContext interfaceThe ServletContext interface provides information to servlets
regarding the environment in which they are running.
The context is also called as servlet context or Web context and is created by the Web container as an object of the ServletContext interface.
The Web container creates a ServletContext object for each deployed Web application.
You can also use the ServletContext object to set attributes that other servlet of your application can access.
The following describes various methods of the ServletContext interface :
1. public void setAttribute (String , Object) -> binds the object with a name and stores the name/value pair as an
attribute of the ServletContext object .If an attribute already exists, then this method replaces the existing attribute.
2. public Object getAttribute (String attrname) -> Returns the object stored in the ServletContext object with the name
passed as a parameter.
3. public Enumeration getAttributeNames () -> Returns an Enumeration of String object that contain names of all
the context attributes.
4. public Enumeration getInitParameter (String pname) -> Returns the value of the initialization parameter with the name
passed as a parameter.
5. public Enumeration getInitParameterNames () -> Returns an Enumeration of String object that contain names
of all the initialization parameters.
6. public int getMajorVersion () -> Returns an integer value that specifies the major version of
the Servlet API that the Web container suports. If your Web container support the version 2.4 of the Servlet API, this method will return 2.
7. public int getMinorVersion() -> Returns an integer value that specifies the minor version of the
Servlet API that the Web Container supports. If your Web container supports the version 2.4 of the Servlet API , this method will return 4.
The classes and interfaces of javax.servlet.http package handle servlets that communicates using HTTP.
These servlets are also called as HTTP servlets.
The following are the commonly used interfaces of the javax.servlet.http package:
1. HttpServletRequest Interface 2. HttpServletResponse Interface 3. HttpSession Interface
HttpServletRequest Interface
The HttpServletRequest interface extends the ServletRequest interface to represent the request information being sent by an HTTP client.
HTTP requests have number of associated headers.
These headers provide extra information about the client ,such as the name and version of browser sending the request.
Some of the important HTTP request headers are :
1. Accept: Specifies the MIME type that the client prefers to accept. 2. Accept-Language : Specifies the language in which the client prefers to receive the request. 3. User-Agent : Specifies the name and version of the browser sending the request.
The following describes various methods of HttpservletRequest
1. public String getHeader (String fieldname) -> Returns the value of the request header field ,such as Cache-
control and Accept-Langauge specified in parameter.
2. public Enumeration getHeaders (String sname) -> Returns all the values associated with a specific request
haeader as an Enumeration of String objects.
3. public Enumeration getHeaderNames() -> Returns the names of all the request headers that a servlet can
access as an Enumeration of the String Objects.
Assignment
Write a servlet code to retrieve the header information of a request.
The HttpServletResponse interface
The HttpServletResponse interface extends the ServletResponse interface and provides method to handle response, status codes ,and response headers for servlets that communicates using HTTP.
The following describes various methods of the HttpServletResponse interface.
1. void setHeader (String hname, String hvalue)
-> Sets the value of header , hname to hvalue. If the header has already been set, the new value overwrites the existing value.
2. void setIntHeader (String hname ,int hvalue)
-> Sets the value of the header, hname to the int value, hvalue. If the header has already been set , the new value overwrites the
existing value.
3. void setDateHeader (String hname,long datev)
->Sets the value of the header, hname with a long value datev. The datev represents the number of milliseconds since the midnight of January 1, 1970 , GMT.
4. void addHeader (String hname , String hvalue) -> Adds a header , hname with value , hvalue.This method adds a
new header if the header already exists.
5. void addIntHeader (String hname , int hvalue) -> Adds a header , hname with an integer value , hvalue
6. void addDateHeader (String hname , long datev) -> Adds a header named hname with value equal to given date ,
datev. The value of the datev must be in milliseconds , which starts since midnight , January 1, 1970 , GMT.
7. boolean containsHeader (String hname) -> Returns true if the header , hname has already been set with a
specific value and false , if not.
8. void sendRediect (String url)
-> Redirects a request to the specified URL
The HttpSession Interface
The HttpSession interface contains methods to maintain the state of an end user across a Web application.
An object of the HttpSession interface provides support for tracking and managing the session of an end user.
The following describes various methods of the HttpSession interface:
1. public void setAttribute (String name, Object value)
-> Binds the object with a name and stores the name/value pair as an attribute of the HttpSession object. If an attribute already exists , then this method replaces the existing attribute.
2. public Object getAttribute(String name)
-> Retrieves the String object specified in the parameter ,from the session object . If no object is found for the specified attribute , then the getAttribute() method returns null.
3. public Enumeration getAttributeNames ()
-> Returns an Enumeration that contains the name of the all the objects that are bound as attribute to the session object
Session Management
Session management is the process of keeping track of the activities of a user across Web pages.
Consider an example of an online shopping mall.
The user can choose a product and add it to the shopping cart.
When the user moves to a different page , the details in the shopping cart are still retained ,so that the user can check the items in the shopping cart and then place the order.
Session Management TechniquesHTTP is a stateless protocol and therefore cannot store the
information about the user activities across Web pages.
However , there are certain techniques that helps store the user information across Web pages using HTTP protocol.
The techniques that you can use to maintain the session information are :
1. Hidden form field 2. URL rewriting 3. Cookies 4. Servlet session API
Hidden Form FieldYou can use hidden form fields to maintain the session
information of a user while the user interacts with the web application.
A hidden form field is embedded in an HTML page and is not visible when viewed in a browser.
The following code snippet shows a hidden form field in an HTML page :
<html> <form method=“get” action=“ ”> <input type=“hidden” name=“id” value=“L234”>
------------- ---------------
</html>
URL Rewriting
URL rewriting is a session management techniques that manages user session by modifying a URL .
Usually ,this techniques is used when information that is to be transferred is not very critical because the URL can be intercepted easily during transfer.
For example , in an online shopping portal, servlet can modify a URL to include user information , such as a username.
Using cookiesCookies are small text files that are stored by an application server
in the client browser to keep track of all the users.
A cookie has values in the form of name/value pairs.
For example , a cookie can have a name , user with the value, Peace.
They are created by the server and are sent to the client with the HTTP response headers.
The client saves the cookies in the local hard disk and sends them along with the HTTP request headers to the server.
A Web browser is expected to support 20 cookies per host and the size of each cookies can be a maximum of 4 bytes each.
Various characteristics of cookies are :
1. Cookies can only be read by the application server that had written them in the client browser.
2. Cookies can be used by the server to find out the computer name , IP address or any other details of the client computer by retrieving the remote host address of the client where the cookies are stored.
The Cookie class of javax.servlet.http package represents a cookie.
The Cookie class provides a constructor that accepts the name and value to create a cookie.
The following code snippet shows the constructor for creating a cookie with name , cname , and value , cvalue:
public Cookie(String cname , String cvalue);
The HttpServletResponse interface provides the addCookie() method to add a cookie to the response object, for sending it to the client.
The following code snippet shows ho to add a cookie:
resp.addCookie(Cookie cookie);
The HttpServletRequest provides the getCookies() method that returns an array of cookies that the request object contains.
The following code snippet shows how to retrieve cookies:
Cookie cookie [ ] = req.getCookies();
The Cookie class provides several methods to set and retrieve various properties of a cookie.
The following describes the various methods of the Cookie class :
1. public String getName() -> Returns the name of the cookie.
2. public void setMaxAge(int expiry) -> Sets the maximum time for which the client browser retains
the cookie value.
3. public int getMaxAge() -> Returns the maximum age of the cookie in seconds.
4. public void setValue(String value) -> Sets a new value to the cookie
5. public String getValue() -> Returns the value of the cookie
An application server can store cookies in the client machine only when the cookie are enabled in the client browser
Servlet Session API
You can use the classes and interfaces defined int the Servlet Session API to create and manage user sessions.
Various interfaces provided by the Servlet Session API to create and manage user session are ,
javax.servlet.http.httpSession
javax.servlet.http.HttpSessionListener , and
javax.servlet.http.HttpSessionBindingListener
The javax.servlet.http.HttpSession interface provides methods for tracking the session of a user.
You can create an object of HttpSession interface to store session information as name/value pairs.
You can later retrieve this information to manage user sessions.
The following describes the various methods defined in the HttpSession interface.
1. public void setAttribute (String name , Object value)
-> Binds an attribute to a session object with a unique name and stores the name/value pair in the current session. If an object is already bound with the same attribute, then the new object replaces the existing.
2. public getAttribute(String name)
-> Retrieves the object bound with the attribute name specified in the method , from the session object. If no object is found for the specified attribute, then the getAttribute() method returns null.
3. public Enumeration getAttributeNames()
-> Returns the name of all the objects that are bound to the session object.
4. public void removeAttribute (String name)
-> Unbinds the session object from the attribute , name specified in the method.
5. public void setMaxInactiveInterval (int interval) -> Sets the maximum time for which the session will remain active. The
time is specified in seconds. If there is no client request during this time , then the server invalidates the session. A negative value in this method signifies that the session should always remain active.
6. public int getMaxInactiveInterval () -> Returns the maximum time in seconds for which the server will not
invalidate the session even if there is no client request.
7. public String getId ()
->Returns a string that contains the unique identifier associated with the session.
8. public void invalidate()
->Invalidates a session. All the objects bound to the session are automatically unbound.
AssignmentLarry Williams is in charge of the garments section of Countryside
Markets. He receives information stating that the total in the bill is wrong.
Larry visits the Web site of his company and does an online shopping. He finds that the bill includes information of only those shirts that he selected on the last Web page he visited. The information of shirts that he selected in the earlier Web pages was lost.
Larry asks John, the developer of the company’s Web site , to modify the Web site such that the shirts selected by a user should be tracked and the bill should get updated accordingly.
John develops a test application for the customer, Mike to test the functionality
Handling Errors and Exception in servlets
You can perform exception handling in a servlet to handle exceptions thrown by the servlet.
You can also create customized error pages to display exceptions and error messages and log these messages to the application server log file.
Servlet Exceptions
The Servlet API defines two exception classes that are defined in the javax.servlet package.
The two exceptions classes are ServletException and UnavailableException.
The UnavailableException class is a subclass of the ServletException
The javax.servlet.ServletException Class
The javax.servlet.ServletException class is defined in the javax.servlet package and is subclass of the java.lang,Exception class.
It defines a servlet exception that a servlet throws while processing the client request.
This class contains the getRootCause () method , which returns an object of type java,lang.Throwable that represents the root cause of the exception
The javax.servlet.UnavailableException Class
The javax.servlet.UnavailableException exception class is thrown by a servlet when the servlet is either temporarily or permanently unavailable.
The methods provided by the UnavailableException class are : 1. public boolean isPermanent() -> Returns a boolean value that describes whether a servlet is
permanently unavailable or not .If the servlet is permanently unavailable , this method returns true.
2. public int getUnavailableSeconds () -> Returns the time , in seconds , for which the servlet will
remain unavailable
Handling Errors
Servlets in the Web application can generate errors and throws exceptions.
You can provide information to users regarding these errors and exception by sending errors messages and status codes that represents various types of errors.
You can create customized error pages to format and display information on the type of error and exception that occurs.
You can also log the error messages and the exceptions to the web server log file to keep track of the errors and the exceptions occurring in your Web application.
Error Messages and Status CodesA status code is the information that the application server sends
to the client about the success or failure of a client request.
When the application server services a client request , it returns the status code to the client browser through the response object.
The HttpServletResponse of javax.servlet.http package defines various fields that represent status codes.
You can these fields to send status codes from your servlet.
The status codes are logically grouped into following five categories:
1 . Information :
Information code group represent messages about the receipt of a request and that the application server is processing the request .
Some of the HttpServletResponse fields that represent information codes are :
a] SC_SWITCHING_PROTOCOLS : Represents 101 status code and indicates switching of protocols by the application server.
b] SC_CONTINUE : Represents 100 status code and indicates that the client can continue its interaction with the application server.
2. Success
Success code group represents a success message which indicates that the request is successful .
Some of the HttpServletResponse fields that represent success
codes are : a] SC_OK : Represents 200 status code and indicates that the request is
successfully received.
b] SC_ACCEPTED : Represents 202 status code and indicates that the server has accepted the request and is processing the request.
3. Redirection Redirection code group represents a redirection message, which
indicates that the request is redirected to another page for processing and service.
Some of the HttpServletResponse fields that represent redirection codes are :
a] SC_MOVED_PERMANENTLY : Represents 301 status code and indicates that the resource is moved permanently.
b] SC_MOVED_TEMPORARILY : Represents 302 status code and indicates that the resource is moved temporarily.
4. Client errorClient error code group represents a client error, which indicates
that the request has some error and cannot be serviced.
Some of the HttpServletResponse fields that represent client error codes are :
a] SC_BAD_REQUEST : Represents 400 status code and indicates that the syntax of the client request is not correct.
b] SC_NOT_FOUND : Represents 404 status code and indicates that the resource requested by the client is not available.
c] SC_GONE : Represents 410 status code and indicates that the resource is not available any longer.
5. Server errorServer error code group represents a server error, which indicates
that the server is unable to fulfill the client request.
Some of the HttpServletResponse fields that represents server code are :
a] SC_INTERNAL_SERVER_ERROR : Represents 500 status code and indicates that there is an error in the server that prohibits it to fulfill the request.
b] SC_NOT_IMPLEMENTED: Represents 501 status code and indicates that the server does not provide the functionality to fulfill the request.
You can send an error response or status response to the client whenever an error is generated during the processing of a Web application.
The sendError() and setStatus() are the two methods of the HttpServletResponse object that you can use to send error and status messages to a client
The sendError() methodThe sendError () method is defined in the HttpServletResponse.You can use this method to send error messages to client.The following describes the signatures of the overloaded
sendError () method:
a] public void sendError (int status) -> Accepts an integer field of HttpServletResponse as argument that
describes the type of error that occurs and sends the error response to the client.
b] public void sendError (int status , String message) -> Accepts an additional String argument that describes the error and sends
the error response to the client.
The sendError () methods throws an exception , IllegalStateException if it is called after a response is committted.
You can use the following code snippet to send an error messages to the client:
public void doPost (HttpServletRequest req , HttpServletResponse resp){ PrintWriter pw = null ; try { pw = resp.getWriter(); pw.println(“This page is going to give an Error”); resp.sendError(HttpServletResponse.SC_NOT_FOUND , “Sorry the source you
have requested is not available”);
} catch (Exception ex) { pw.println( ex.printStackTrace() ) ; }
The setStatus () methodThe setStatus () method defined in the HttpServletResponse ,
sets the status information about a servlet.The following describes the signatures of the overloaded setStaus
() method:
a] public void setStatus (int status) -> Accept an integer field of HttpServletResponse as argument that
represents the status information and sets the information to the response.
b] public void setStatus (int status, String message) -> Accepts an additional String argument that describes the status of the
servelt.
The setStatus () method throws an exception, IllegalStateException , if it is called after a response is committed.
You can use the following code snippet to use the setStaus () method to send an error response to the client:
public void doPost(HttpServletRequest req , HttpServletResponse resp){ PrintWriter pw = null ; try { pw = resp.getWriter (); pw.println(“This page is going to display a status code”);
resp.setStatus (HttpServletResponse.SC_GONE); } catch (Exception ex) { pw.println( ex.printStackTrace() ); } }
Writing an Exception and Error to the Server Log File
You can log error massages and exceptions in the server log file to keep a track of the kind of errors thrown by the application.
Logging the errors and exceptions helps you to identify the errors that occur in you r Web application.
The ServletContext interface provides the log() method to log error messages and exceptions.
You can use the following code to create a servlet that throws an exception and logs the exception details in the server log file:
public class LogDemo extends HttpServlet{ public void doGet (HttpServletRequest req,HttpServletResponse resp) throws ServletException , IOException { ServletContext sc = getServletContext () ; PrintWriter pw = resp.getWriter (); pw.println(“<B>Writing an exception to the server log file</B>”); try { int x = 9; int y = x/0; } catch (ArithmeticException ae) { sc.log(“dividing an intrger by zero will not give result”, ae); } }} // server.log
Assignment
A user while using an online calculator applications enters a non-numeric characters to adds the numbers.
When a servlet tries to convert the value entered by the user into an integer type ,it throws an exception of type NumberFormatException.
Create a Web Application that handles the exception using a customized error page .
The customized error page needs to provide information on the user and log the exception to the server log file.
AssignmentInfoSuper Corp . has created a dynamic Web site .
Whenever an error occurs , the stack trace displayed in the browser is difficult to understand .
David Wong , the System Analyst of the company asks Don Allen , the software programmer of the company to create a customized error page .
Whenever an exception is thrown by a servlet , the servlet dispatches the request to the customized error page.
The error page then displays the error in the browser is more understandable format
Inter-Servlet Communication In a Web application, various components of the application, such as servlet
might need to communicate with each other to process client requests.
For example, consider a servlet that displays copyright information of an organization in a Web application.
You can you use various inter-servlet communication techniques to include the contents of this servlet in all the other servlets of the application that need to display the copyright information.
Similarly, a servlet in a web application can forward a request to another servlet if any exception occurs while processing the request.
You can implement inter-servlet communication techniques in your Web application in the following two ways:
1] Using Request Dispatcher 2] Using servlet Request Object
Request DispatcherA Request Dispatcher is an object of the javax.servlet.RequestDispatcher
interface that allows inter-servlet communication.
You can use Request Dispatcher in your servlet to forward a request to another resource that can be a static page or another servlet.
You can also use the RequestDispatcher object to include the contents of another resource in your servlet.
The ServletContext interface provides the getRequestDispatcher (String path) method that returns the RequestDispatcher object.
The path argument of the method specifies the path relative to the context root of the target resource.
Once you obtain the RequestDispatcher object, you canperform the following two functions.
1] Include contents of another servlet 2] Forward request to another servlet.
Including Contents of Another Servlet
The RequestDispatcher interface provides the include () method you can use to include the content of another servlet.
For this , you need to first obtain an object of RequestDispatcher interface and then invoke the include () .
For example, consider the servlet , CopyrightServlet that displays copyright information about ABC Inc., in the Web site of the organisation.
import javax.servlet.*;import javax.servlet.http.*;Import java.io.*;
public class CopyrightServlet extends HttpSservlet{
public void doGet (HttpServletRequest req , HttpServletResponse resp) throws ServletException , IOException {
PrintWriter pw = resp.getWriter (); pw.println(“Copyright 2000-2004 ABC , Inc. All Rights Reserved.<br>”);
}}
To include the contents of CopyrightServlet in the servlet , IncludeServlet , you need to first call the getRequestDispatcher() method of the ServletContext interface by passing the path of CopyrightServlet as a parameter.
This returns a RequestDispatcher object.
You can then call the include() method to include the content of CopyrightServlet.
import javax.servlet.*;import javax.servlet.http.*;import java.io.*;
public class IncludeServlet extends HttpServletp{ public void doGet(HttpServletRequest req , HttpServletResponse resp) throws ServletException , IOException { RequestDispatcher dispatch = getServletContext().getRequestDispatcher(“/servlet/CopyrightServlet”); PrintWriter pw = resp.getWriter (); pw.println(“<b>The Copyright information included form copyright servlet
is: <b><br>”); /* Use the include () of RequestDispatcher to include the content */
dispatch.include (req , resp) ; } }
Forwarding Request to Other ServletsYou can use a RequestDispatcher objects to forward requests to
other servlets in your application.
For example , consider ABC , Inc. that provides tour packages for vacations.
You need to create the Web site of ABC.. where users can request for information, such as details of available flights , airport transfers , and hotel accommodations.
You can create a main servlet to process all these requests and send back the responses.
However, doing this will increase the request processing time of the main servlet.
Instead , you can develop different servlets to process specific client requests.
For example, the HotelInformation servlet can process the requests for hotel accommodation while a FlightInformation servlet can process requests pertaining to flight information.
The main servlet of the Web application can receive all requests of corrresponding servlet.
The following code snippet shows how you can use RequestDispatcher in the deGet() method to forward requests to different servlets of your application.
public void doGet (HttpServletRequest req , HttpServletResponse resp) throws ServletException , IOException{ String requestType = req.getParameter (“Type”); if ( requestType.equals(“hotel”) ) { RequestDispatcher disp = getServletContext().getRequestDispatcher(“/servlet/HotelInformation”) ; disp.forward(req , resp); } if ( requestType.equals(“cab”) ) { RequestDispatcher disp = getServletContext().getRequestDispatcher(“/servlet/CabInformation”) ; disp.forward(req , resp); } ……..}
Using the Request Object
You have learned how the RequestDispatcher object allows inter-servlet communications by forwarding request to another servlet and including response from another servlet.
However , the RequestDispatcher objects does not allow servlets to share data.
To share data between servlets, you can use the request object in your servlets that needs to communicate.
You can use the setAttribute () method of the javax.servlet.ServletRequest interface to set values of data in the request object.
Other servlets of the application can use the getAttribute () method of the javax.servlet.ServletRequest interface to retrieve the value of the data.
For example , considers a Web application in which CalculatorServlet performs arithmetic calculations.
Another servlet of the Web application will display the calculation result.
To send the calculated result to the second servlet , CalculatorServlet can perform the following steps :
1. Store the calculated data as attribute to the request object in the first servlet.
2. Forward the request to the second servlet using RequestDispatcher.
The second servlet then retrieved the data form the request object and displays the result.
You can use the following code to create the CalculatorServlet servlet that adds two numbers specified by the user and stores the result as an attribute of the request object.
The servlet then forwards the request to the DisplayServlet servlet:
Import java.io.*;Import javax.servlet.*;Import javax.servet.http.*; public class CalculatorServlet extends HttpServlet { public void doGet (HttpServletRequest req , HttpServletReponse resp) throws ServletException , IOExceptiion { int num1 = Interger.parseInt (req.getParameter (“number1”) ) ; int num2 = Interger.parseInt (req.getParameter (“number2”) ) ; int sum = num1 + num2 ;
req.setAttribute (“result” , new Integer(sum)); ServletContext contx = getServletConfig () . getServletContext() ; RequestDispatcher disp = contx.getRequestDispatcher(“/servlet/DisplayServlet”);
disp.forward(req , resp); }}
public class DisplayServlet extends HttpServlet {
public void doGet ( HttpServletRequest req , HttpServletResponse resp) throws SevletException , IOException {
Integer res = (Integer) req.getAttribute (“result”);
PrintWriter pw = rep.getWriter() ;
pw .println(“the result of the calculation is :” + res.toString() ) ;
}
}
