Anintroductiontojavawebtechnology 090324184240-phpapp01

24/03/2009 @JECRC,JODHPUR 1
An
Introduction to
Java Web Technology
(Java Servlet)
Presented At:
JECRC, Faculty of E&T,
Jodhpur National University,
Jodhpur, Rajasthan
India -342001

HTTP
HTTP stands for HyperText Transport Protocol, and is the network protocol used over the web. It runs over
TCP/IP.
HTTP uses a request/response model.Client sends an HTTP request, then the server gives back the HTTP
response that the browser will display (depending on the content type of the answer).
If the response is an HTML file, then the HTML file is added to the HTTP response body.
An HTTP response includes : status code, the content-type (MIME type), and actual content of the response.
A MIME type tells the browser what kind of data the response is holding.
URL stands for Uniform Resource Locator: starts with a protocol, then a server name, optionally followed by a
port number, then the path to the resource followed by the resource name. Parameters may appear at the end,
separated from the rest by a ? .

HTTP METHODS
METHOD DESCRIPTION
HEAD Asks for the response identical to the one that would correspond to a GET request, but
without the response body. This is useful for retrieving meta-information written in
response headers, without having to transport the entire content.
GET means retrieve whatever data is identified by the URI
POST Submits data to be processed (e.g., from an HTML form) to the identified resource. The
data is included in the body of the request.
DELETE Deletes the specified resource.
TRACE Echoes back the received request, so that a client can see what intermediate servers are
adding or changing in the request.
OPTIONS Returns the HTTP methods that the server supports for specified URL. This can be used
to check the functionality of a web server by requesting '*' instead of a specific
resource.
CONNECT Converts the request connection to a transparent TCP/IP tunnel, usually to facilitate SSL-
encrypted communication (HTTPS) through an unencrypted HTTP proxy.[3]
PUT Uploads a representation of the specified resource.

HTTP METHODS
HTTP servers are required to implement at least the GET and HEAD methods [4] and, whenever
possible, also the OPTIONS method
Safe methods
Some methods (for example, HEAD, GET, OPTIONS and TRACE) are defined as safe, which means
they are intended only for information retrieval and should not change the state of the server.
Idempotent methods
Some http methods are defined to be idempotent, meaning that multiple identical requests should have
the same effect as a single request. Methods PUT, DELETE, GET, HEAD, OPTIONS and TRACE,
being prescribed as safe, should also be idempotent. HTTP is a stateless protocol.
By contrast, the POST method is not necessarily idempotent, and therefore sending an identical POST
request multiple times may further affect state or cause further side effects.(like updating inserting records
in database multiple times).

DIFFERENCE BETWEEN GET AND POST
GET:
GET parameters are passed on the URL line, after a ?. The URL size is limited.
The parameters appear in the browser URL field, hence showing any password to the world...
GET is supposed to be used to GET things (only retrieval, no modification on the server).
GET processing must be idempotent.
A click on a hyperlink always sends a GET request.
GET is the default method used by HTML forms. Use the method=”POST” to change it.
POST:
POST has a body.
In POST requests, the parameters are passed in the body of the request, after the header. There
is no size-limit. Parameters are not visible from the user.
POST is supposed to be used to send data to be processed.
POST may not be idempotent and is the only one.
IDEMPOTENT : Can do the same thing over and over again, with no negative side effect.

WHAT IS WEB CONTAINER?
A Web application runs within a Web container of a Web server. The Web container
provides the runtime environment through components that provide naming context
and life cycle management. Some Web servers may also provide additional services
such as security and concurrency control.
Web applications are composed of web components and other data such as HTML pages.
Web components can be servlets, JSP pages created with the JavaServer Pages™
technology, web filters, and web event listeners. These components typically execute
in a web server and may respond to HTTP requests from web clients. Servlets, JSP
pages, and filters may be used to generate HTML pages that are an application’s user
interface.

WHAT IS JAVA SERVLET?
Servlets are Java classes that process the request dynamically and generate response independent of the
protocol. Servlets are defined in Java Servlet API specification. Latest Servlet API specification
available is 2.5.
Servlets are server side Java programs which extends the functionality of web server. Servlet are
protocol independent that means it can be used virtually with any protocol to process the request
and generate the response. However in practice Servlets are used to process the HTTP requests
and generate the HTML response.

STRUCTURE OF A WEB APPLICATION
Web Applications use a standard directory structure defined in the Servlet
specification. When developing web applications on J2EE platform, you
must follow this structure so that application can be deployed in any J2EE
compliant web server.
A web application has the directory structure as shown in figure.
The root directory of the application is called the document root. Root
directory is mapped to the context path.
Root directory contains a directory named WEB-INF. Anything under the
root directory excepting the WEB-INF directory is publically available,
and can be accessed by URL from browser.
WEB-INF directory is a private area of the web application, any files under
WEB-INF directory cannot be accessed directly from browser by
specifying the URL like http://somesite/WEB-INF/someresource.html.
Web container will not serve the content of this directory. However the
content of the WEB-INF directory is accessible by the classes within the
application.

WEB-INF DIRECTORY
WEB-INF directory contains
 WEB-INF/web.xml deployment descriptor
 WEB-INF/classes directory
 WEB-INF/lib directory
CLASSES- directory is used to store compiled servlet and other classes of the application.
LIB - directory is used to store the jar files. If application has any bundled jar files, or if application
uses any third party libraries such as log4j which is packaged in jar file, than these jar files should
be placed in lib directory.
All unpacked classes and resources in the /WEB-INF/classes directory, plus classes and resources in
JAR files under the /WEB-INF/lib directory, are made visible to the containing web application.

SERVLET LIFE CYCLE
Servlets are managed components. They are managed by web container. Of the various responsibilities
of web container, servlet life cycle management is the most important one.
A servlet is managed through a well defined life cycle that defines how it is loaded, instantiated ad
initialized, handles requests from clients and how it is taken out of service.
The servlet life cycle methods are defined in the javax.servlet.Servlet interface of the Servlet API that
all Servlets must implement directly or indirectly by extending GenericServlet or HttpServlet
abstract classes. Most of the servlet you develop will implement it by extending HttpServlet class.
The servlet life cycle methods defined in Servlet interface are init(), service() and destroy().
The signature of this methods are shown below.
public void init(ServletConfig config) throws ServletException
public void service(ServletRequest req, ServletResponse res) throws ServletException,
IOException
public void destroy()

SERVLET LIFE CYCLE - STEPS
The servlet life cycle consists of four steps, instantiation, initialization, request handling and end of
service.
Loading and instantiation
During this step, web container loads the servlet class and creates a new instance of the servlet. The
container can create a servlet instance at container startup or it can delay it until the servlet is
needed to service a request.
Initialization
During initialization stage of the Servlet life cycle, the web container initializes the servlet instance by
calling the init() method. The container passes an object implementing the ServletConfig interface
via the init() method. This configuration object allows the servlet to access name-value
initialization parameters from the web application’s deployment descriptor (web.xml) file. The
container guarantees that the init() method will be called before the service() method is called.
The init() method is typically used to perform servlet initialization, creating or loading objects that are
used by the servlet in the handling of its requests.
The init() method is commonly used to perform one time activity. One of the most common use of
init() method is to setup the database connection or connection pool.

SERVLET LIFE CYCLE - STEPS
Request handling
After a servlet is properly initialized, it is ready to handle the client requests. If the container has a
request for the servlet, it calls the servlet instance’s service() method. The request and response
information is wrapped in ServletRequest and ServletResponse objects respectively, which are
then passed to the servlet's service() method. In the case of an HTTP request, the objects
provided by the container are of types HttpServletRequest and HttpServletResponse.
Service() method is responsible for processing the incoming requests and generating the response.
End of service
When the servlet container determines that a servlet should be removed from service, it calls the
destroy () method of the Servlet instance to allow the servlet to release any resources it is using.
The servlet container can destroy a servlet because it wants to conserve some memory or server
itself is shutting down.
Destroy() method is used to release any resources it is using. The most common use of destroy()
method is to close the database connections.

SETTING UP SERVLET DEVELOPMENT ENVIRONMENT
List of required softwares:
 JAVA 1.5 or 1.6
 Tomcat 5.5.16
First of all you need the Java software development kit 1.5 or 1.6 (JAVA SDK) installed.
Checking if JAVA is already installed in your system

Set up the JAVA_HOME environment variable
Once the JAVA SDK is installed follow this step to set the JAVA_HOME environment
variable. If JAVA_HOME variable is already set, you can skip this step.

In the variable name filed, enter JAVA_HOME. Specify the path to root directory of JAVA
installation in variable value field and click OK button. Now JAVA_HOME will appear under
user variables.
Next you need to add bin directory under the root directory of JAVA installation in PATH
environment variable.Select the PATH variable from System variables and click on Edit button.
Add: ;%JAVA_HOME%bin; at the end of variable value field and click OK button.

INSTALLING TOMCAT
Tomcat is an opensource web container. it is also web container reference implementation.
Download the latest version of tomcat from this URL . Download the jakarta-tomcat-
5.0.28.tar.gz and extract it to the directory of your choice.
Note: This directory is referred as TOMCAT_HOME in other tutorials.
That’s all, tomcat is installed.
Starting and shutting down Tomcat
To start the tomcat server, open the command prompt, change the directory to TOMCAT
HOME/bin and run the startup.bat file. It will start the server.
>startup To shut down the tomcat server, run the shutdown.bat file. It will stop the server.
>shutdown Verifying Tomcat installation
To verify that tomcat is installed properly, start the server as explained above, open the web
browser and access the following URL.
http://localhost:8080/index.jsp
It should show the tomcat welcome page, if tomcat is installed properly and server is running.

INSTALLING TOMCAT
Setting up the CLASSPATH
Now you need to create a new environment variable CLASSPATH if it is not already set. We
need to add the servlet-api.jar into the CLASSPATH to compile the Servlets. Follow the same
steps as you did to create the JAVA_HOME variable. Create a new variable CLASSPATH under
system variables. Add TOMCAT_HOME/lib/servlet-api.jar in variable value field.
Note: here TOMCAT_HOME refers to the tomcat installation directory.

SERVLET API CLASSES AND INTERFACES
Servlet API is specified in two packages: javax.servlet and javax.servlet.http. The classes and
interfaces in javax.servlet are protocol independent, while the classes and interface in
javax.servlet.http deals with specialized HTTP Servlets.
Some of the classes and interfaces in the javax.servlet.http package extend those specified in
javax.servlet package.
The javax.servlet package
The javax.servlet package defines the contract between container and the servlet class. It provides the
flexibility to container vendor to implement the API the way they want so long as they follow the
specification. To the developers, it provides the library to develop the servlet based applications.
the javax.servlet Interfaces
The javax.servlet package is composed of 14 interfaces.
Servlet interface
The Servlet Interface is the central abstraction of the Java Servlet API. It defines the life cycle methods
of a servlet. All the servlet implementations must implement it either directly or indirectly by
extending a class which implements the Servlet interface. The two classes in the servlet API that
implement the Servlet interface are GenericServlet and HttpServlet. For most purposes,
developers will extend HttpServlet to implement their Servlets while implementing web
applications employing the HTTP protocol.

ServletRequest interface
 ServletRequest interface provides an abstraction of client request.
 The object of ServletRequest is used to obtain the client request information such as request
parameters, content type and length, locale of the client, request protocol etc.
 Developers don’t need to implement this interface. The web container provides the
implementation this interface. The web container creates an instance of the implementation class
and passes it as an argument when calling the service() method.
ServletResponse interface
 The ServletResponse interface assists a servlet in sending a response to the client.
 Developers don’t need to implement this interface. Servlet container creates the ServletResponse
object and passes it as an argument to the servlet’s service() method.

ServletConfig interface
 The servlet container uses a ServletConfig object to pass initialization information to the
servlet.
 ServletConfig object is most commonly used to read the initialization parameters.
 Servlet intialialization parameters are specified in deployment descriptor (web.xml) file.
 Servlet container passes the ServletConfig object as an argument when calling servlet’s init()
method.
ServletContext interface
 ServletContext object is used to communicate with the servlet container.
 There is only one ServletContext object per web application (per JVM).
 This is initialized when the web application is started and destroyed only when the web application is
being shutdown.
 ServletContext object is most commonly used to obtain the MIME type of a file, dispatching a request,
writing to server’s log file, share the data across application, obtain URL references to resources etc

SingleThreadModel Interface
 SingleThreadModel is a marker interface. It is used to ensure that servlet handle only one request at a
time.
 Servlets can implement SingleThreadModel interface to inform the container that it should make sure
that only one thread is executing the servlet’s service() method at any given moment.
RequestDispatcher Interface
 The RequestDispatcher interface is used to dispatch requests to other resources such a
servlet, HTML file or a JSP file.
Filter Interface
 Filter interface declares life cycle methods of a filter. The life cycle methods include, init()
doFilter() and destroy().
FilterChain Interface
 The FilterChain object provides the filter with a handle to invoke the rest of the filter chain.
Each filter gets access to a FilterChain object when its doFilter() method is invoked. Using
this object, the filter can invoke the next filter in the chain.

FilterConfig interface
 The FilterConfig interface is similar to ServletConfig interface. It is used to get the initialization
parameters.
ServletContextAttributeListner
 Implementation of this interface receives notification whenever an attribute is added, removed or
replaced in ServletContext. To receive the notifications, the implementation class must be
configured in the deployment descriptor (web.xml file).
ServletContextListner Interface
 Implementation of this interface receives notification when the context is created and destroyed.
ServletRequestAttributeListner Interface
 Implementation of this interface receives notification whenever an attribute is added, removed or
replaced in ServletRequest.
ServletRequestListner Interface
 Implementation of this interface receives notification whenever the request is coming in and out
of scope. A request is defined as coming into scope when it is about to enter the first servlet or
filter in each web application, as going out of scope when it exits the last servlet or the first filter
in the chain.

The javax.servlet Classes
The javax.servlet package contains 9 classes.
GenericServlet class
 The GenericServlet abstract class defines the generic protocol independent servlet. It can be
extended to develop our own protocol-based servlet.
ServletContextEvent class
 This is the event class for notifications about changes to the servlet context of a web application.
ServletInputStream class
 Provides an input stream for reading binary data from a client request.
ServletOutputStream class
 Provides an output stream for sending binary data to the client.
javax.servlet Exception classes
The javax.servlet package defines 2 exception classes.
ServletException class
 Defines a general exception a servlet can throw when it encounters difficulty.
UnavailableException class
 Defines an exception that a servlet or filter throws to indicate that it is permanently or temporarily
unavailable.

Understanding the GenericServlet class
GenericServlet class defines a generic protocol independent servlet. It is protocol independent in the sense
it can be extended to provide implementation of any protocol like FTP, SMTP etc.
Servlet API comes with HttpServlet class which implements HTTP protocol.
Generally when developing web application, you will never need to write a servlet that extends
GenericServlet. Most of the Servlets in your application will extend HttpServlet class to handle web
requests.
GenericServlet class provides implementation of Servlet Interface. This is an abstract class, all the subclasses
must implement service () method.
Public abstract class GenericServlet implements Servlet,ServletConfig,Serializable
In addition to those methods defined in Servlet Interface, GenericServlet defines following additional
methods.
Public void init()
Public void log(String message)
Public void log(String message, Throwable t)

Initializing the Servlet
Public void init(ServletConfig config)
Public void init()
Public void init(ServletConfig config) method is an implementation of init(ServletConfig config)
method defined in Servlet interface, it stores the ServletConfig object in private transient instance
variable.
getServletConfig() method can be used to get the reference of this object. If you override this
method, you should include a class to super.init(config) method. Alternatively, you can override
no-argument init() method.
Handling requests
Public abstract void service (ServletRequest request, ServletResponse response)
This is an abstract method, and you must override this method in your subclass to handle requests. All
the code related to request processing and response generation goes here.
Destroying the Servlet
Public void destroy()
This method provides default implementation of destroy () method defined in the Servlet interface.
You can override this method in your subclasses to do some cleanup tasks when servlet is taken
out of service.

Accessing the environment
GenericServlet class also implements ServletConfig interface so all the methods of ServletConfig
interface can be called directly without first obtaining reference to ServletConfig instance.
Public String getInitParameter(String name) : used to obtaing value of servlet initialization
parameter.
public String getInitParameterNames() : returns names of all initialization parameters.
Public ServletContext getServletContext() : returns reference to ServletContext object.
String getServletName() : used to obtain name of the servlet.
Writing to server log file
Public void log(String message)
Public void log(String message, Throwable t)
GenericServlet class provides two utility methods for writing to server log file. log(String message)
method writes servlet name and message to web containers log file. the other method log(string
message, Throwable t), writes servlet name, string message and the exception stack trace of the
given Throwable exception to web containers log file.

GenericServlet Example
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.GenericServlet;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
public class GenericServletExample extends GenericServlet {
public void init() {
log("inside init() method");
}
public void service(ServletRequest request, ServletResponse response) throws
ServletException, IOException {
log("Handling request");
response.setContentType("text/html");
PrintWriter out = response.getWriter();
out.write("<html><head><title>GenericServle
example</title></head>");
out.write("<body><h1>GenericServlet: Hallo world
</h1></body></html>");
out.close();
}

GenericServlet Example
public void destroy() {
log("inside destroy() method");
}
}
--------------------------------------------------------------------------
Web.xml deployment descriptor
<?xml version="1.0" encoding="ISO-8859-1"?>
<web-app xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
version="2.5">
<servlet>
<servlet-name>GenericServlet</servlet-name>
<servlet-class>com.jsptube.servlet.GenericServletExample</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>GenericServlet</servlet-name>
<url-pattern>/exampleservlet</url-pattern>
</servlet-mapping>
</web-app>

A VERY SIMPLE SERVLET EXAMPLE
What is covered in this Servlet example
 How to write the servlet class.
 How to compile the Servlet class.
 How to extract the HTML form parameters from HttpServletRequest.
 web.xml deployment descriptor file.
 How to create the war (web application archive) file.
 How to deploy and run the sample web application in tomcat web container.
This is a very simple web application containing a HTML file and a servlet. The HTML document has
a form which allows the user to enter the name, when the form is submitted application
displays the welcome message to the user.

Create the HTML file.
Copy the following code into form.html file and save it under servlet-example/pages directory.
<html>
<head>
<title>The servlet example </title>
</head>
<body>
<h1>A simple web application</h1>
<form method="POST" action="/WelcomeServlet">
<label for="name">Enter your name </label>
<input type="text" id="name" name="name"/><br><br>
<input type="submit" value="Submit Form"/>
<input type="reset" value="Reset Form"/>
</form>
</body>
</html>

The welcome Servlet class
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class WelcomeServlet extends HttpServlet {
@Override
public void init (ServletConfig config) throws ServletException {
super.init(config);
}
protected void doPost (HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
/* Get the value of form parameter */
String name = request.getParameter("name");
String welcomeMessage = "Welcome "+name;
/* Set the content type(MIME Type) of the response.*/
response.setContentType("text/html");
PrintWriter out = response.getWriter();

/*
* Write the HTML to the response
*/
out. println ("<html>");
out. println ("<head>");
out. println ("<title> A very simple servlet example</title>");
out. println ("</head>");
out. println ("<body>");
out. println ("<h1>"+welcomeMessage+"</h1>");
out. println ("<a href="/servletexample/pages/form.html">"+"Click here to go back
to input page "+"</a>");
out. println ("</body>");
out. println ("</html>");
out. close ();
}
public void destroy() { }
}
Compile the WelcomeServlet.java using the following command.
>javac WelcomeServlet.java
It will create the file WelcomeServlet.class in the same directory. Copy the class file to classes
directory. All the Servlets and other classes used in a web application must be kept under WEB-
INF/classes directory.
Note: to compile a servlet you need to have servlet-api.jar file in the class path.

The deployment descriptor (web.xml) file.
Copy the following code into web.xml file and save it directly under servlet-example/WEB-INF
directory.
<web-app version="2.4"
xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
<servlet>
<servlet-name>WelcomeServlet</servlet-name>
<servlet-class>jsptube.tutorials.servletexample.WelcomeServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>WelcomeServlet</servlet-name>
<url-pattern>/WelcomeServlet</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file>
/pages/form.html
</welcome-file>
</welcome-file-list>
</web-app>

Create the WAR (Web application archive) file.
Web applications are packaged into a WAR (web application archive). There are many different ways
to create a WAR file. You can use jar command, ant or an IDE like Eclipse. This tutorial
explains how to create the WAR file using jar tool.
Open the command prompt and change the directory to the servlet-example directory, and execute
the following command.
>jar cvf servletexample.war *
This command packs all the contents under servlet-example directory, including subdirectories, into
an archive file called servletexample.war.
We used following command-line options:
-c option to create new WAR file.
-v option to generate verbose output.
-f option to specify target WAR file name.
You can use following command to view the content of servletexample.war file.
>Jar –tvf servletexample.war.
This command lists the content of the WAR file.

Deploying the application to tomcat web container.
Deployment steps are different for different J2EE servers. This tutorial explains how to deploy the
sample web application to tomcat web container. If you are using any other J2EE server,
consult the documentation of the server.
A web application can be deployed in tomcat server simply by copying the war file to
<TOMCAT_HOME>/webapp directory.
Copy servletexample.war to <TOMCAT_HOME>/webapp directory. That’s it! You have
successfully deployed the application to tomcat web server. Once you start the server, tomcat
will extract the war file into the directory with the same name as the war file.
To start the server, open the command prompt and change the directory to
<TOMCAT_HOME/bin> directory and run the startup.bat file.
Our sample application can be accessed at http://localhost:8080/servletexample/. If tomcat server is
running on port other than 8080 than you need to change the URL accordingly.
If the application has been deployed properly, you should see the screen similar to below when you
open the application in browser.

How the application works.
When you access the application by navigating to URL http://localhost:8080/servletexample/
the web server serves the form.html file.
“pagesform.html” file is specified as welcome file in web.xml file so web server serves this file by
default.
When you fill the form field and click on submit form button, browser sends the HTTP POST
request with name parameter.
Based on the servlet mapping in web.xml, the web container delegates the request to WelcomeServlet
class.
When the request is received by WelcomeServlet it performs following tasks.
 Extract the name parameter from HttpServletRequest object.
 Generate the welcome message.
 Generate the HTML document and write the response to HttpServletResponse object.
Browser receives the HTML document as response and displays in browser window.
The next step is to understand the code.

Anintroductiontojavawebtechnology 090324184240-phpapp01

More Related Content

What's hot (20)

Similar to Anintroductiontojavawebtechnology 090324184240-phpapp01 (20)

Recently uploaded (20)

Anintroductiontojavawebtechnology 090324184240-phpapp01