Common Interview Questions for Servlets in 2023 - IQCode

Simplified Introduction to Servlet:

A servlet is a Java class that is loaded into a server to enhance its functionality. It enables dynamic responses and data persistence, making it useful for web servers as a replacement for CGI scripts. Servlets run inside a Java Virtual Machine (JVM), making them safe and portable. They work exclusively within the domain of the server, and no Java support is required for web browsers.

Sun Microsystems developed the first servlet specification in June 1997, providing Internet functionality to Java. Servlets were developed under the Java Community Process beginning with version 2.3. They are a more efficient architecture than the previous CGI standard.

Servlet Interview Questions for Freshers:

1. What is a servlet?

Writing a Servlet for a Web Application

To write a servlet for a web application, you need to follow these steps:

  1. Create a Java class that extends the javax.servlet.http.HttpServlet class.
  2. Override the doPost and doGet methods to handle HTTP POST and GET requests.
  3. Map the servlet to a URL in the web.xml file or by using annotations.
  4. Compile the servlet class and package it in a WAR file.
  5. Deploy the WAR file to a web server or a servlet container such as Tomcat or Jetty.

public class MyServlet extends HttpServlet {
  public void doGet(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
    // Handle GET request	  
  public void doPost(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
    // Handle POST request

Advantages of Servlets

Servlets have several advantages:

  • They can handle multiple requests and generate dynamic content for each request.
  • They can be easily integrated with existing enterprise systems and applications.
  • They offer better performance and scalability compared to traditional CGI scripts.
  • They provide a robust, secure, and consistent environment for developing web applications.
  • They offer a wide range of APIs for handling HTTP requests and responses, session management, cookie handling, and more.
// Example of a simple servlet
public class MyServlet extends HttpServlet {
   protected void doGet(HttpServletRequest request, HttpServletResponse response)
         throws ServletException, IOException {
      PrintWriter out = response.getWriter();
      out.println("<h1>Hello World!</h1>");

Explanation of the Servlet API

The Servlet API is a library of classes and interfaces that provides the framework for creating Java web applications that serve HTTP requests and responses. This API defines the Servlet container, which is responsible for receiving requests and sending responses, and includes methods for handling request parameters, session management, and other web programming tasks.

The API consists of several packages, including javax.servlet and javax.servlet.http, that contain the classes and interfaces needed to write servlets and filters. The javax.servlet package contains the Servlet interface, which defines the methods that handle requests and responses, while the javax.servlet.http package extends this API to include HTTP-specific methods and servlets.

In addition, the Servlet API includes annotations, such as @WebServlet and @WebFilter, which can be used to configure servlets and filters without the need for a deployment descriptor.

Overall, the Servlet API provides a powerful and flexible framework for building scalable and reliable web applications in Java.

Understanding Server-Side Include (SSI) Functionality in Servlets

In Servlets, Server-Side Include (SSI) functionality is used to include the content of one file into another. This means that the content of a file can be dynamically included in another file during runtime.

SSI can be used to include headers, footers or navigation menus in all pages of a website by storing them in separate files and then including them in each page using server-side includes. This reduces the redundancy of code and makes it easier to update the website.

To enable SSI functionality, the servlet container must be configured to allow SSI. The following code can be added to the web.xml file to enable SSI:



Once enabled, SSI can be used in Servlets by adding the following code to include a file:

<!--#include file="header.html" -->

Overall, SSI functionality is a useful feature in Servlets that can simplify the development and maintenance of websites.

Explanation of Server-Side Include Expansion

When a web server receives a request for a webpage containing server-side include (SSI) directives, it processes the directives. SSI directives instruct the server to provide additional content from external sources.

Server-side include expansion involves the inclusion of external files into HTML documents server-side. Server-Side Includes (SSI) is a type of HTML injection method that allows the web developer to add dynamic content to a web page.

SSI can include several types of dynamic content, such as the current date and time, environment variables, and other functions, which are often used for server maintenance purposes.

When the server encounters an SSI tag in the HTML file, it reads the command, performs any requested actions, and inserts the result into the HTML document before sending it to the requesting client. This allows the server to cache or reuse pre-built HTML fragments, which can improve site response times.

Defining 'init' and 'destroy' Methods in Servlets

In servlets, the `init()` and `destroy()` methods are used to initialize and clean up servlet resources, respectively.

The `init()` method is called when a servlet is first loaded into the server's memory. This method is used to perform all the initialization tasks, like setting up a database connection, initializing variables, creating data structures, etc.

The `destroy()` method is called when a servlet is about to be removed from the server's memory. It is used to perform all the clean-up tasks, like closing database connections, freeing up resources, etc.

Here's an example of how to define these methods in a servlet:

public class MyServlet extends HttpServlet {

  public void init() throws ServletException {
    // Initialization tasks go here

  public void destroy() {
    // Clean-up tasks go here
  // other servlet methods go here

Differences in Retrieving Information between Servlets and CGI

In Servlets, information can be retrieved using the methods provided by the Servlet API, such as getRequestParameter() or getAttribute(). These methods allow for efficient retrieval of specific data and can handle larger amounts of information.

On the other hand, in CGI, information is retrieved primarily through environment variables and standard input. This process can be slower and less efficient, especially when dealing with large amounts of data.

Additionally, Servlets have the advantage of being able to maintain state information between requests, which is not possible with CGI. This allows for more robust and dynamic applications.

Comparison of CGI Environment Variables and Corresponding Servlet Methods

When developing web applications, it is important to understand the differences between CGI and servlets. One major difference is the way environment variables are handled.

// example CGI environment variable
String queryString = System.getenv("QUERY_STRING"); 

// example servlet method
String parameter = request.getParameter("parameterName"); 

In CGI, environment variables are accessed through the System.getenv() method. For example, the QUERY_STRING environment variable can be accessed using System.getenv("QUERY_STRING").

In contrast, servlets provide methods to access environment variables. For instance, the getParameter() method can be used to retrieve the value of a parameter passed in a request URI.

In summary, while CGI applications use environment variables to store and retrieve information, servlets provide a set of methods to handle incoming requests and access the corresponding data.

How can a Servlet access its initialization parameters?

A Servlet can access its initialization parameters using the `getInitParameter()` method of the `javax.servlet.ServletConfig` interface. This method takes the parameter name as a string argument and returns the value of the parameter as a string object. Here's an example:


public class MyServlet extends HttpServlet {
  private String username;

  public void init(ServletConfig config) throws ServletException {
    username = config.getInitParameter("username");

  public void doGet(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
    // use the username parameter

In this example, the `init()` method obtains the value of the `username` parameter using the `getInitParameter()` method and stores it in a class variable. The `doGet()` method can then use this variable as needed.

How can a Servlet access all of its initialization parameters?

A Servlet can retrieve its initialization parameters by calling the


method of the ServletConfig object. This method returns an enumeration of all the initialization parameters contained in the Servlet's configuration. The Servlet can then iterate through this enumeration and retrieve the value of each initialization parameter using the


method, passing in the parameter name as a parameter.

Servet Chaining in Java: Interview Question for Experienced Developers

In Java, servlet chaining is a technique where multiple servlets are combined to perform a single task. The output of one servlet is used as input to another servlet in a chain-like structure. The servlets are executed in the order in which they are chained.

This technique is useful for modularizing complex operations and dividing them into multiple simpler operations. It also promotes code reuse and makes it easier to maintain code.

To implement servlet chaining, the web.xml file can be configured to map a servlet output to the input of another servlet. This can be done using the


tag in the web.xml file.

Overall, servlet chaining is a powerful tool in Java for creating complex web applications and streamlining complex tasks.

Understanding Servlet Filtering

Filtering in Servlets refers to the process of intercepting and processing requests and responses before they are sent to the intended servlet or to the client. Servlet Filters are Java classes that can be executed automatically before or after a servlet is invoked, providing a convenient way of modifying the request or response, or even blocking them altogether.

Filters can be used to perform several tasks such as logging user activity, authentication and authorization, compression of responses, modifying request parameters, and more. They can also be chained together to execute more than one filter in a specified order.

Overall, Servlet Filtering is a powerful feature that enables developers to perform operations on requests and responses more efficiently, enhancing the functionality and security of web applications.

Uses of Servlet Chaining

Servlet chaining is a technique used in Java web development where two or more servlets can collaborate in processing a single request. It is useful in the following scenarios:

1. Security: Several servlets can be chained together to implement a multi-layer security mechanism. Each servlet in the chain can authenticate and authorize the user, ensuring that sensitive resources are protected.

2. Processing: Servlet chaining can be used to divide the processing of a request among different servlets. Each servlet can perform a specific task and then pass the request to the next servlet in the chain. This can help optimize the overall performance of the application.

3. Extensibility: Servlet chaining can be used to create modular and extensible web applications. New servlets can be added to the chain without affecting the existing functionality.

In order to implement servlet chaining, the RequestDispatcher object is used to forward the request from one servlet to the next servlet in the chain. The forward() method of the RequestDispatcher object is called to accomplish this.

Advantages of Servlet Chains

A servlet chain allows multiple servlets to be invoked in a specific order, which provides several advantages:

1. Improved modularity and reusability of code: Servlet chains allow developers to break down complex tasks into smaller, modular components that can be reused in different parts of the application.

2. Clear separation of concerns: Each servlet in the chain can focus on a specific concern, such as authentication or logging, without having to worry about the other tasks in the application.

3. Better control over request processing: With servlet chains, developers can control the order in which servlets are invoked, allowing for more precise handling of requests.

4. Improved performance: By breaking down tasks into smaller, more focused servlets, applications can be designed to run more efficiently and with less overhead.

Overall, servlet chains provide a flexible and powerful tool for developing scalable, modular, and efficient web applications. Code: `



Servant Life Cycle

A servlet is a Java programming language class that is used to extend the capabilities of servers that host web applications. The following are the stages of the servlet life cycle:

1. Loading: When a servlet container receives a request for a servlet, it first checks whether the servlet class has already been loaded into the memory or not. If the servlet class has not been loaded, it loads the servlet class. Otherwise, the servlet container moves on to the next stage.

2. Instantiation: Once the servlet class is loaded, an instance of the servlet is created using the no-argument constructor of the servlet class.

3. Initialization: The init() method is called by the servlet container to initialize the servlet. This method is called only once during the lifecycle of the servlet.

4. Request Handling: Once the servlet is initialized, it can handle requests from clients. Each request is handled in a separate thread.

5. Destruction: When the servlet container shuts down, it destroys all the servlets it has created. The destroy() method is called by the servlet container to give the servlet an opportunity to release any resources it has been holding.

6. Unloading: After the servlet has been destroyed, the servlet container unloads the servlet class from the memory.

It is important for a servlet developer to understand these stages of the life cycle in order to write efficient and effective servlets.

What is the lifecycle contract that a Servlet engine must conform to?

In the Java Servlet API, a Servlet engine must follow a specific lifecycle contract in order to properly manage Servlet objects. This contract defines a set of methods for initializing, servicing, and destroying Servlets.

The lifecycle of a Servlet object begins when it is first created and ends when it is either destroyed or the Servlet engine is shut down. The following are the methods that a Servlet engine must provide to conform to this lifecycle contract:

1. `init(ServletConfig config)`: This method is called once, right after the Servlet engine creates the Servlet object. This is where the Servlet can perform any initialization it needs to do.

2. `service(ServletRequest request, ServletResponse response)`: This method is called for each request that is handled by the Servlet. This is where the Servlet processes the request and generates a response.

3. `destroy()`: This method is called once, right before the Servlet object is destroyed. This is where the Servlet can perform any cleanup it needs to do.

By following this lifecycle contract, a Servlet engine can ensure that Servlets are properly initialized, serviced, and destroyed throughout their lifetime.

Understanding Servlet Reloading

Servlet reloading refers to the process of restarting or reloading a servlet container to apply any changes made to servlet code or configuration. During development, it is often necessary to modify servlet code and test the changes, which requires restarting the servlet container.

Reloading can be done manually by stopping and starting the servlet container, or it can be automated using tools such as JRebel. However, it is important to note that frequent reloading can impact the performance of the server and affect the overall user experience.

Therefore, it is recommended to use reloading judiciously and only when necessary, while also optimizing the code for maximum efficiency.

Methods for a Servlet to Obtain Server Information

A servlet can make use of the following methods to obtain information about the server:

  • getRealPath(String path)

    - This method returns a String containing the real path for the given context-relative virtual path.

  • getServerName()

    - This method returns the server's hostname.

  • getServerPort()

    - This method returns the port number on which the server is listening.

  • getServletContext().getServerInfo()

    - This method returns the server software and version.

By using these methods, a servlet can obtain a variety of server information required for its processing.

How a Servlet can Retrieve Server Name and Port Number for a Specific Request

In a Servlet, we can use the methods of the HttpServletRequest object to retrieve the name of the server and port number for a particular request.

To obtain the server name, we can use the getServerName() method. Here is an example:

// getting the server name
String serverName = request.getServerName();

To retrieve the port number, we can use the getServerPort() method, like this:

// getting the port number
int portNumber = request.getServerPort();

By using these methods, a Servlet can obtain the name of the server and the port number for the incoming requests.

Retrieving Client Machine Information in Servlets

In a Servlet, client machine information can be retrieved using the request object. The request object contains information such as the client's IP address, browser type, and request headers.

To retrieve the client's IP address, use the `getRemoteAddr` method of the request object:

String ipAddress = request.getRemoteAddr();

To retrieve the browser type, use the `getHeader` method of the request object:

String browserType = request.getHeader("User-Agent");

To retrieve other request headers, use the `getHeader` method and provide the header name:

String acceptLanguage = request.getHeader("Accept-Language");

With this information, a Servlet can make decisions on how to handle requests from different clients or browsers.

Explanation of Single-Thread Model in Servlets

The Single-Thread model in servlets refers to the process where the web server uses only one thread per request. This means that each request is processed by only one thread at a time. Once a request is received, the web server assigns a thread to process it. The thread remains busy while processing the request and is not available to process any other requests until it is finished.

This model is useful in situations where the servlet code cannot be run concurrently. For example, if a servlet modifies a shared static variable, using the single-thread model ensures that only one request can access this variable at a time, guaranteeing thread safety.

However, this model is not suitable for high-traffic websites or applications that require a large number of simultaneous requests to be processed. In such cases, the multi-threaded model is used, where each request is assigned to a separate thread to maximize the use of system resources and ensure scalability.

Background Processing in Servlets

In servlets, background processing takes place using multithreading. When a request is received by the server, a new thread is created to handle that request. This allows the server to handle multiple requests simultaneously, improving its efficiency and overall performance.

To implement background processing in a servlet, you can use the `javax.servlet.AsyncContext` class. This class allows you to start a new thread to handle a long-running task, while the main thread is free to continue handling other requests.

Here's an example of how you can use the `AsyncContext` class to perform background processing in a servlet:

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    final AsyncContext asyncContext = request.startAsync();
    // Start a new thread to handle the long-running task
    new Thread() {
        public void run() {
            // Perform some long-running task here...
            // ...
            // Once the task is complete, dispatch the response

In this example, we start a new thread to perform a long-running task, such as fetching data from a database or performing complex calculations. Once the task is complete, we call the `dispatch()` method on the `AsyncContext` object to send the response back to the client.

Overall, multithreading using the `AsyncContext` class is a powerful technique for implementing background processing in servlets. It allows you to handle multiple requests simultaneously without slowing down the server's performance.

Servlet Collaboration: How Does it Work?

When multiple servlets need to work together to provide a response to a client's request, servlet collaboration takes place. This can be achieved through several techniques, such as:

1. Using RequestDispatcher interface: This interface allows a servlet to pass the request and response objects to another servlet or JSP page through the forward() or include() methods.

2. Using session object: A session object can be shared among multiple servlets, allowing them to store and retrieve attributes associated with a particular user.

3. Using a shared database: Servlets can interact with a common database, allowing them to share data and information.

4. Using cookies: Cookies can be used to maintain client-specific information across multiple servlets.

In summary, servlet collaboration is a critical aspect of building complex and dynamic web applications that provide users with a seamless experience.

Request Parameters in Servlets

In web applications, a client sends a request to the server to perform some operation. The request parameters are used to send extra information to the server with the request.

ServletRequest object is used to retrieve request parameters, which are submitted by the user in the request URL or in a web form. The following methods of the ServletRequest object are used to retrieve request parameters:

  • getParameter(String name)

    – retrieves the value of a parameter

  • getParameterNames()

    – retrieves a list of parameter names

  • getParameterValues(String name)

    – retrieves an array of parameter values

For example, if a client sends a GET request with the URL "", then the Servlet can retrieve the values of these parameters using the


method as follows:

String name = request.getParameter("name"); 
int age = Integer.parseInt(request.getParameter("age"));

In the case of a POST request, web forms can be used to collect request parameters. The values submitted in the form are passed as POST data to the server. The same


method can be used to retrieve these values.

<form method="post" action="/exampleServlet">
  Name: <input type="text" name="name"><br>
  Age: <input type="text" name="age"><br>
  <input type="submit" value="Submit">
String name = request.getParameter("name");
int age = Integer.parseInt(request.getParameter("age"));

In summary, request parameters are used in servlets to send extra information to the server from a client. These parameters can be retrieved using the


object and its methods.

Three Methods of Inter-servlet Communication

In Java Servlets, there are three ways for servlets to communicate with each other:

  1. Using request dispatcher.
  2. Using shared session data.
  3. Using ServletContext attributes.

These methods allow for efficient and effective communication between servlets, allowing them to exchange data and interact with each other in various ways.

Reasons for Using Inter-Servlet Communication

Inter-servlet communication is used in web applications for several reasons, including:

1. Sharing data between servlets: When different servlets in a web application need to access the same data or resource, inter-servlet communication allows them to share this data without duplicating it.

2. Modularization: Dividing an application into smaller, more manageable modules makes it easier to develop, test, and maintain. Inter-servlet communication enables communication between these modules, promoting modularity.

3. Collaboration between servlets: When servlets need to collaborate and work together to complete a task, such as handling a single HTTP request, inter-servlet communication facilitates this collaboration.

4. Improved performance: By using inter-servlet communication to share resources instead of duplicating data, web applications can save memory and processing power, resulting in improved performance.

In conclusion, inter-servlet communication is a crucial aspect of web application development that allows servlets to work together efficiently and effectively.

Understanding Servlet Manipulation

Servlet manipulation refers to the process of modifying or transforming the content of a servlet HTTP response before it is sent back to the client. It involves intercepting the response stream and performing some action on it based on certain criteria. This technique is commonly used for tasks such as modifying headers, compressing content, or adding additional content to the response. The Servlet API provides several mechanisms for implementing servlet manipulation, including filters and servlet listeners. By leveraging these features, developers can easily modify the behavior of their servlets and enhance the functionality of their web applications.

Explanation of the javax.servlet Package

The javax.servlet package is a part of the Java Servlet API that provides classes and interfaces to create web application servers. It contains the classes and interfaces required to create Servlets and manage their lifecycle. Servlets are Java classes that can process HTTP requests from clients and generate HTTP responses accordingly. The javax.servlet package also includes classes to manage sessions, cookies, and filters that can be used to intercept and modify requests and responses. This package is an essential component of Java web development.

Technical Interview Guides

Here are guides for technical interviews, categorized from introductory to advanced levels.

View All

Best MCQ

As part of their written examination, numerous tech companies necessitate candidates to complete multiple-choice questions (MCQs) assessing their technical aptitude.

View MCQ's
Made with love
This website uses cookies to make IQCode work for you. By using this site, you agree to our cookie policy

Welcome Back!

Sign up to unlock all of IQCode features:
  • Test your skills and track progress
  • Engage in comprehensive interactive courses
  • Commit to daily skill-enhancing challenges
  • Solve practical, real-world issues
  • Share your insights and learnings
Create an account
Sign in
Recover lost password
Or log in with

Create a Free Account

Sign up to unlock all of IQCode features:
  • Test your skills and track progress
  • Engage in comprehensive interactive courses
  • Commit to daily skill-enhancing challenges
  • Solve practical, real-world issues
  • Share your insights and learnings
Create an account
Sign up
Or sign up with
By signing up, you agree to the Terms and Conditions and Privacy Policy. You also agree to receive product-related marketing emails from IQCode, which you can unsubscribe from at any time.