Servlet:

• Java Servlets are the Java programs that run on the Java-enabled web
server or application server.
• They are used to handle the request obtained from the web server,
process the request, produce the response, and then send a response
back to the web server.
• Servlet technology is robust and scalable because of java language.
Before Servlet, CGI (Common Gateway Interface) scripting language
was common as a server-side programming language
• Servlet can be described in many ways, depending on the context.

• Servlet is a technology which is used to create a web application.

• Servlet is an API that provides many interfaces and classes including

documentation.

• Servlet is an interface that must be implemented for creating any

Servlet.

• Servlet is a class that extends the capabilities of the servers and

responds to the incoming requests. It can respond to any requests.

• Servlet is a web component that is deployed on the server to create a

dynamic web page.
Properties of Java Servlet
• The properties of Servlets are as follows:
• Servlets work on the server side.
• Servlets are capable of handling complex requests obtained from the
web server.

Execution of Servlets basically involves Six basic steps:

1.The Clients send the request to the Web Server.
2.The Web Server receives the request.
3.The Web Server passes the request to the corresponding servlet.
4.The Servlet processes the request and generates the response in the
form of output.
5.The Servlet sends the response back to the webserver.
6.The Web Server sends the response back to the client and the client
Need of Server-Side Extensions

• The Server-Side Extensions are nothing but technologies used to

create dynamic Web pages.

• To provide the facility of dynamic Web pages, Web pages need a

container or Web server. To meet this requirement, independent web
server providers offer proprietary solutions in the form of
API. These APIs allow us to build programs running with a Web server.

• In this case, Java Servlet is also one of the component APIs of Java
Platform Enterprise Edition (nowadays known as – ‘Jakarta
EE’) which sets standards for creating dynamic Web applications in
Java.

• The Servlet technology is similar to web server extensions such

as Common Gateway Interface (CGI) scripts and Hypertext
 • In CGI application, when a client
CGI (Common Gateway makes a request to access
Interface) dynamic Web pages, the Web
CGI is actually an external server performs the following
application that is written by operations:
using any of the programming 1. It first locates the requested web
languages like C or C++ and page i.e the required CGI
this is responsible for application using URL.
processing client requests and 2. It then creates a new process to
generating dynamic content. service the client’s request.
3. Invokes the CGI application
within the process and passes
the request information to the
application.
4. Collects the response from the
CGI application.
5. Destroys the process, prepares
the HTTP response, and sends it
• So, in CGI server has to create and destroy the process for every
request. It’s easy to understand that this approach is applicable for
handling a few clients .
• But as the number of clients increases, the workload on the server
increases and so the time taken to process requests increases.

Disadvantages of CGI:
There are many problems in CGI technology:
1.If the number of clients increases, it takes more time to send the
response.
2.For each request, it starts a process, and the web server is limited to
start processes.
3.It uses platform dependent language e.g. C, C++, perl.
Servlets APIs
Servlets are built from two
packages:
• javax.servlet(Basic)
• javax.servlet.http(Advance)

• The web container creates

threads for handling the
multiple requests to the
Servlet.
• Threads have many
benefits over the Processes
such as they share a
common memory area,
lightweight, cost of
communication between
the threads are low.
The Servlet Container
• Servlet container, also known as Servlet engine, is an integrated set of
objects that provide a run time environment for Java Servlet components. In
simple words, it is a system that manages Java Servlet components on top of
the Web server to handle the Web client requests.
Services provided by the Servlet container:
• Network Services: Loads a Servlet class. The loading may be from a local file
system, a remote file system or other network services. The Servlet container
provides the network services over which the request and response are sent.
• Decode and Encode MIME-based messages: Provides the service of
decoding and encoding MIME-based messages.
• Manage Servlet container: Manages the lifecycle of a Servlet.
• Resource management Manages the static and dynamic resources, such as
HTML files, Servlets, and JSP pages.
• Security Service: Handles authorization and authentication of resource
access.
• Session Management: Maintains a session by appending a session ID to
the URL path.
The advantages of Servlet are as follows:
1.Better performance: because it creates a thread for
each request, not process.
2.Portability: because it uses Java language.
3.Robust: JVM manages Servlets, so we don't need to
worry about the memory leak, garbage collection, etc.
4.Secure: because it uses java language.
Various classes and interfaces present in these packages are:

Component Type Package

Servlet Interface javax.servlet.*
ServletRequest Interface javax.servlet.*
ServletResponse Interface javax.servlet.*
GenericServlet Class javax.servlet.*
HttpServlet Class javax.servlet.http.*
HttpServletRequest Interface javax.servlet.http.*
HttpServletResponse Interface javax.servlet.http.*
Filter Interface javax.servlet.*
ServletConfig Interface javax.servlet.*
• Difference between Java Servlets and CGI
Servlet API

• Servlets are the Java programs that run on the Java-enabled web
server or application server.
• They are used to handle the request obtained from the webserver,
process the request, produce the response, then send a response
back to the webserver.
• In Java, to create web applications we use Servlets. To create Java
Servlets, we need to use Servlet API which contains all the necessary
interfaces and classes.
• Servlet API has 2 packages namely,
• javax.servlet
• javax.servlet.http

javax.servlet
• This package provides the number of interfaces and classes to
• These interfaces and classes describe and define the contracts
between a servlet class and the runtime environment provided
by a servlet container.
Class Name Description

GenericServlet To define a generic and protocol-independent servlet.

To generate notifications about changes to the attributes of the servlet

ServletContextAttributeEvent
context of a web application.

To generate notifications about changes to the servlet context of a web

ServletContextEvent
application.

This class provides an input stream to read binary data from a client
ServletInputStream
request.

ServletOutputStream This class provides an output stream for sending binary data to the client.

To generate notifications about changes to the attributes of the servlet

ServletRequestAttributeEvent
request in an application.

ServletRequestEvent To indicate lifecycle events for a ServletRequest.

This class provides the implementation of the ServletRequest interface

ServletRequestWrapper
that can be subclassed by developers to adapt the request to a Servlet.

This class provides the implementation of the ServletResponse interface

ServletResponseWrapper that can be subclassed by developers to adapt the response from a
Servlet.
• Interfaces available in javax.servlet. package:
Interface Name Description

To perform filtering tasks on either the request to a resource, or on the response from a
Filter
resource, or both.

To provide a view into the invocation chain of a filtered request for a resource to the developer
FilterChain
by the servlet container.

FilterConfig To pass information to a filter during initialization used by a servlet container.

RequestDispatche It defines an object to dispatch the request and response to any other resource, means it
r receives requests from the client and sends them to a servlet/HTML file/JSP file on the server.

This is the main interface that defines the methods in which all the servlets must implement. To
Servlet implement this interface, write a generic servlet that extends javax.servlet.GenericServlet or an
HTTP servlet that extends javax.servlet.http.HttpServlet.

It defines an object created by a servlet container at the time of servlet instantiation and to
ServletConfig
pass information to the servlet during initialization.

It defines a set of methods that a servlet uses to communicate with its servlet container. The
ServletContext information related to the web application available in web.xml file is stored in ServletContext
object created by container.

ServletContextAttr The classes that implement this interface receive notifications of changes to the attribute list on
ibuteListener the servlet context of a web application.
 The classes that implement this interface receive notifications about changes to the
ServletContextListener
servlet context of the web application they are part of.

It defines an object that is created by servlet container to pass client request

ServletRequest
information to a servlet.

ServletRequestAttributeLis To generate the notifications of request attribute changes while the request is within
tener the scope of the web application in which the listener is registered.

To generate the notifications of requests coming in and out of scope in a web

ServletRequestListener
component.

It defines an object created by servlet container to assist a servlet in sending a

ServletResponse
response to the client.

Exceptions in javax.servlet
package:
Exception Name Description

ServletException A general exception thrown by a servlet when it encounters difficulty.

UnavailableExceptio Thrown by a servlet or filter to indicate that it is permanently or

n temporarily unavailable.
 javax.servlet.http

• This package provides the number of interfaces and classes to support

HTTP servlet which is HTTP protocol dependent.
• These interfaces and classes describe and define the contracts between a
servlet class running under HTTP protocol and the runtime environment
provided by a servlet container. Classes available in
javax.servlet.http package:
Class Name Description

Creates a cookie object. It is a small amount of information sent by a servlet to a Web browser, saved by the
Cookie
browser, and later sent back to the server used for session management.

HttpServlet Provides an abstract class that defines methods to create an HTTP suitable servlet for a web application.

HttpServletRequestWra This class provides implementation of the HttpServletRequest interface that can be subclassed to adapt the
pper request to a Servlet.

HttpServletResponseWr This class provides implementation of the HttpServletResponse interface that can be subclassed to adapt the
apper response from a Servlet.

This events are either sent to an object that implements HttpSessionBindingListener when it is bound or
HttpSessionBindingEven
unbound from a session, or to a HttpSessionAttributeListener that has been configured in the deployment
t
descriptor when any attribute is bound, unbound or replaced in a session.

HttpSessionEvent To represent event notifications for changes to sessions within a web application.
• Interfaces available in javax.servlet.http package:
• Interface Name Description

To provide client HTTP request information for servlets. It

HttpServletRequest
extends the ServletRequest interface.

To provide HTTP-specific functionality in sending a

HttpServletResponse response to client. It extends
the ServletResponse interface.

It provides a way to identify a user across web

HttpSession application/web site pages and to store information about
that user.

Container to notify all the objects that are bound to a

HttpSessionActivationListen
session that sessions will be passivated and that session
er
will be activated.

To get notifications of changes to the attribute lists of

HttpSessionAttributeListener sessions within this web application, this listener interface
can be implemented.

It causes an object to be notified by an

HttpSessionBindingListener HttpSessionBindingEvent object, when it is bound to or
unbound from a session.
GenericServlet Class:
• Servlet API provide GenericServlet class in javax.servlet package.
• public abstract class GenericServlet
• extends java.lang.Object
• implements Servlet, ServletConfig, java.io.Serializable
• An abstract class that implements most of the servlet basic
methods.
• Implements the Servlet, ServletConfig, and Serializable
interfaces.
•Makes writing servlets easier by
• providing
Protocol-independent
simple versionsservlet.
of the
lifecycle methods init() and
destroy().

•To write a generic servlet, you

need to
extend javax.servlet.GenericSer
vlet class and need to override
HttpServlet Class
• Servlet API provides HttpServlet class in javax.servlet.http package.
• public abstract class HttpServlet
• extends GenericServlet
• implements java.io.Serializable
• in abstract class to be subclassed to create an HTTP-specific servlet that is suitable
for a Web site/Web application.
• Extends Generic Servlet class and implements Serializable interface.
• HTTP Protocol-dependent servlet.
• To write a Http servlet, you need to extend javax.servlet.http.HttpServlet class and
must override at least one of the below methods,
• doGet() – to support HTTP GET requests by the servlet.
• doPost() – to support HTTP POST requests by the servlet.
• doPut() – to support HTTP PUT requests by the servlet.
• doDelete() – to support HTTP DELETE requests by the servlet.
• init() and destroy() – to manage resources held in the life of the servlet.
• getServletInfo() – To provide information about the servlet itself like the author of
servlet or version of it etc.
Servlet API Package
Hierarchy
• Below is the package hierarchy of
Generic Servlet and HTTP Servlet.
• Servlet API provides all the
required interfaces, classes, and
methods to develop a web
application.
• we need to add the servlet-
api.jar file in our web application
to use the servlet functionality.
 Life Cycle of a Servlet

• The entire life cycle of a Servlet is managed by the Servlet container which
uses the javax.servlet.Servlet interface to understand the Servlet object and
manage it.
• Stages of the Servlet Life Cycle:
• The Servlet life cycle mainly goes through four stages,
1. Loading a Servlet.
2. Initializing the Servlet.
3. Request handling.
4. Destroying the Servlet.
• Let’s look at each of these stages in details:
1.Loading a Servlet: The first stage of the Servlet lifecycle involves loading and
initializing the Servlet by the Servlet container. The Web container or Servlet
Container can load the Servlet at either of the following two stages :
1. Initializing the context, on configuring the Servlet with a zero or positive
integer value.
2. If the Servlet is not preceding stage, it may delay the loading process until the
Web container determines that this Servlet is needed to service a request.
• The Servlet container • Loading : Loads the Servlet class.
performs two operations in • Instantiation : Creates an instance of the
Servlet. To create a new instance of the
this stage : Servlet, the container uses the no-argument
constructor.
1.Initializing a Servlet: After the Servlet is
instantiated successfully, the Servlet
container initializes the instantiated Servlet
object. The container initializes the Servlet
object by invoking
the Servlet.init(ServletConfig) method
which accepts ServletConfig object reference
as parameter.The Servlet container invokes
the Servlet.init(ServletConfig) method
only once, immediately after
the Servlet.init(ServletConfig) object is
instantiated successfully. This method is used
to initialize the resources, such as JDBC
datasource.
2.Now, if the Servlet fails to initialize, then it
informs the Servlet container by throwing
the ServletException or UnavailableExcep
tion.
3 Handling request: After initialization, the Servlet instance is ready to serve the
client requests. The Servlet container performs the following operations when the
Servlet instance is located to service a request :
1. It creates the ServletRequest and ServletResponse objects. In this case, if
this is a HTTP request, then the Web container
creates HttpServletRequest and HttpServletResponse objects which are
subtypes of the ServletRequest and ServletResponse objects respectively.
2. After creating the request and response objects it invokes the
Servlet.service(ServletRequest, ServletResponse) method by passing the
request and response objects.
The service() method while processing the request may throw
the ServletException or UnavailableException or IOException.
4 Destroying a Servlet: When a Servlet container decides to destroy the Servlet,
it performs the following operations,
3. It allows all the threads currently running in the service method of the Servlet
instance to complete their jobs and get released.
4. After currently running threads have completed their jobs, the Servlet
container calls the destroy() method on the Servlet instance.
After the destroy() method is executed, the Servlet container releases all the
references of this Servlet instance so that it becomes eligible for garbage
collection.
 Servlet Life Cycle Methods
• There are three life cycle methods of a Servlet :
• init()
• service()
• destroy()
1 init() method: 2 service() method:
• The Servlet container calls the The service() method of the Servlet is
invoked to inform the Servlet about the
Servlet.init() method to indicate client requests.
that this Servlet instance is • This method uses ServletRequest object
instantiated successfully and is to collect the data requested by the
about to put into service. client.
• //init() method • This method uses ServletResponse
object to generate the output content.
• // service() method
public class MyServlet implements
Servlet{ public class MyServlet implements
public void init(ServletConfig Servlet{
config) throws ServletException { public void service(ServletRequest res,
ServletResponse res)
//initialization code
throws ServletException, IOException {
} // request handling code
//rest of code }
} // rest of code
}
 // Extend HttpServlet class
3 destroy() method: public class AdvanceJavaConcepts extends
The destroy() method runs only HttpServlet
{
once during a Servlet's lifetime private String output;
and signals the Servlet // Initializing servlet
instance's end public void init() throws ServletException
{
output = "Advance Java Concepts";
• //destroy() method }
// Requesting and printing the output
public void destroy() public void doGet(HttpServletRequest req,
HttpServletResponse resp)
throws ServletException, IOException
• As soon as the destroy() {
method is activated, the resp.setContentType("text/html");
Servlet container releases the PrintWriter out = resp.getWriter();
out.println(output);
Servlet instance. }

• // Java program to show servlet example public void destroy()

// Importing required Java libraries {
import java.io.*; System.out.println("Over");
import javax.servlet.*; }
import javax.servlet.http.*;
Steps to create a servlet example
• There are given 6 steps to create a servlet example. These steps are required
for all the servers.
• Three ways can create the servlet example:
1. By implementing Servlet interface,
2. By inheriting GenericServlet class, (or)
3. By inheriting HttpServlet class
• The mostly used approach is by extending HttpServlet because it provides
http request specific method such as doGet(), doPost(), doHead() etc.

• Here, we are going to use apache tomcat server in this example. The steps
are as follows:
1. Create a directory structure
2. Create a Servlet
3. Compile the Servlet
4. Create a deployment descriptor
5. Start the server and deploy the project
6. Access the servlet
• 1)Create a directory structures
• The directory structure defines that where to put the different
types of files so that web container may get the information
and respond to the client.
• The Sun Microsystem defines a unique standard to be
followed by all the server vendors. Let's see the directory
structure that must be followed to create the servlet.
• As you can see
that the servlet
class file must be
in the classes
folder.

• The web.xml file

must be under
the WEB-INF
2)Create a Servlet 3)Compile the servlet

• There are three ways to create the • For compiling the Servlet, jar file is
servlet. required to be loaded. Different Servers
1. By implementing the Servlet interface provide different jar files:
2. By inheriting the GenericServlet class Jar file Server
3. By inheriting the HttpServlet class 1) servlet-api.jar Apache Tomcat
2) weblogic.jar Weblogic
• The HttpServlet class is widely used to 3) javaee.jar Glassfish
create the servlet because it provides
methods to handle http requests such 4) javaee.jar JBoss
as doGet(), doPost, doHead() etc.

• Two ways to load the jar file

• In this example we are going to create a
servlet that extends the HttpServlet • set classpath
class. In this example, we are inheriting • paste the jar file in JRE/lib/ext folder
the HttpServlet class and providing the • Put the java file in any folder. After
implementation of the doGet() method.
compiling the java file, paste the class file
Notice that get request is the default
of servlet in WEB-INF/classes directory.
request.
4)Create the deployment
descriptor (web.xml file)
• The deployment descriptor is an
xml file, from which Web Container
gets the information about the
servet to be invoked.
• The web container uses the Parser
to get the information from the
web.xml file. There are many xml
parsers such as SAX, DOM and
Pull.
• There are many elements in the
web.xml file. Here is given some
necessary elements to run the
simple servlet program.
 5)Start the Server and deploy the project
Description of the elements • To start Apache Tomcat server, double
of web.xml file click on the startup.bat file under apache-
tomcat/bin directory.
• There are too many elements in the • One Time Configuration for Apache Tomcat
web.xml file. Here is the illustration of Server
some elements that is used in the above
web.xml file. The elements are as follows:
• You need to perform 2 tasks:
• <web-app> represents the whole
application. • set JAVA_HOME or JRE_HOME in
environment variable (It is required to start
• <servlet> is sub element of <web-app> server).
and represents the servlet. • Change the port number of tomcat
• <servlet-name> is sub element of (optional). It is required if another server is
<servlet> represents the name of the running on same port (8080).
servlet.
1) How to set JAVA_HOME in environment variable?
• <servlet-class> is sub element of
• To start Apache Tomcat server JAVA_HOME and
<servlet> represents the class of the JRE_HOME must be set in Environment
servlet. variables.
• <servlet-mapping> is sub element of • Go to My Computer properties -> Click on
<web-app>. It is used to map the servlet. advanced tab then environment variables ->
Click on the new tab of user variable -> Write
• <url-pattern> is sub element of <servlet- JAVA_HOME in variable name and paste the path
mapping>. This pattern is used at client of jdk folder in variable value -> ok -> ok -> ok.
• Go to My Computer properties:
• Click on advanced system settings tab then environment
variables:
• Click on the new tab of user variable or system variable:
• Write JAVA_HOME in variable name and paste the path of jdk folder in
variable value:
• There must not be semicolon (;) at the end of the path.
• After setting the JAVA_HOME double click on the startup.bat file in
apache tomcat/bin.
• Apache tomcat that needs to install
• It is the example of apache tomcat that needs to extract only.
Now server is started successfully.
2) How to change port number of apache tomcat
• Changing the port number is required if there is another
server running on the same system with same port
number.Suppose you have installed oracle, you need to
change the port number of apache tomcat because both
have the default port number 8080.

• Open server.xml file in notepad. It is located inside the

apache-tomcat/conf directory . Change the Connector
port = 8080 and replace 8080 by any four digit number
instead of 8080. Let us replace it by 9999 and save this
file.
• 5) How to deploy the servlet project
• Copy the project and paste it in the webapps folder under
apache tomcat.
• But there are several ways to deploy the project.
They are as follows:
• By copying the context(project) folder into the webapps
directory
• By copying the war folder into the webapps directory
• By selecting the folder path from the server
• By selecting the war file from the server
• Here, we are using the first approach.
• You can also create war file, and paste it inside the
webapps directory. To do so, you need to use jar tool to
create the war file. Go inside the project directory (before
the WEB-INF), then write:
1.projectfolder> jar cvf myproject.war *
• Creating war file has an advantage that moving the
project from one location to another takes less time.
6) How to access the servlet
• Open broser and write
http://hostname:portno/contextroot/urlpatternofservlet. For
example:
 Handling requests using form parameters:
• Servlets are the Java programs that run on the Java-enabled web server
or application server.
• They are used to handle the request obtained from the webserver,
process the request, produce the response, then send a response back
to the webserver.
Properties of Servlets are as follows:
• Servlets work on the server-side.
• Servlets are capable of handling complex requests obtained from the
webserver.

• ‘handling the client data‘:

• Let us consider a situations where we need to fill a form with our data
to access some application. In this situation, you need to handle that
data or information to pass from the browser to the web/application
server and finally to your backend program to process that request
HttpServlet Class
• Java provides HttpServlet class which extends the GenericServlet class to process
HTTP-specific request/response for a website.
• It provides HTTP specific methods such as doGet(), doPost(), doPut(), doDelete()
etc. If we are extending the HttpServlet in our class, we must override at least one
of these methods to process the request and send the response.
• We need to use either doGet() or doPost() method in the servlet class to get the
information from the browser based on the method specified in the form.

GET method type and doGet() method

• The doGet() method in servlets is used to process the HTTP GET requests. the
HTTP GET method should be used to get the data from the server to the browser.
• Although in some requests, the GET method is used to send data from the browser
to the server also.
• The data that is being submitted to the server will be visible in the URL using
query parameters like this “http://localhost:8080/HelloServlet/hello?
myParam=myValue”.
• So, if you are sending any sensitive information like passwords, you should not
use the GET method as the data entered can be clearly visible in the browser URL.
POST method type and doPost() method
• The doPost() method in servlets is used to process the HTTP POST
requests. It is used to submit the data from the browser to the server for
processing. The data submitted with POST method type is sent in the
message body so it is secure and cannot be seen in the URL.
• And there is no limit on the data that can be sent through the POST
method. we need to use the POST method, to send the form data to the
webserver. To achieve this, Java provides ServletRequest interface.

HttpServletRequest(I):
• HttpServletRequest interface extends the ServletRequest interface to
provide the Http-specific request information for Servlets.
• The servlet container creates an HttpServletRequest object and passes it
as an argument to the servlet’s service methods – doPost(), doGet(), etc.,
• The object provides data like parameter name and values, attributes, and
an input stream. And it has various methods to work with the client data.
getParameter() method:
• The method returns the value of a field/parameter from the request which
is specified by the given name, as a String. If the specified parameter
name does not exist, it returns null.
• This method should be used on the parameter that has only one value. If
multiple values are there, then it returns only the first value.
• Syntax:
• java.lang.String getParameter(java.lang.String name)

getParameterValues() method:
• The method returns an array of String objects containing all of the values
of the given field/parameter from the request. If the specified parameter
name does not exist, it returns null.
• Syntax:
• java.lang.String[] getParameterValues(java.lang.String name)
Steps to create the application:

1. Create an HTML to take the input data from the client.

2. Create a Servlet to handle the data, process the request, and
generate the response.
3. Run the application.