ServletContext

01 July 2023 19:46

In Java EE, the ServletContext represents the context of a web application and provides a way to interact
with the application's environment. It serves as a communication channel between the web container
(such as Apache Tomcat) and the servlets running within the container.

The ServletContext object is created by the web container when the application is deployed and is made
available to all servlets and other web components within the application. It provides various methods
to access information about the application, manage resources, and communicate with the container.

Now, let's dive into a step-by-step example of using the ServletContext object within a web application.

Step 1: Create a new dynamic web project:

Set up your development environment with an IDE (Integrated Development Environment) like Eclipse
or IntelliJ.
Create a new dynamic web project in your IDE.
Step 2: Define a servlet:

Create a new Java class that extends the HttpServlet class.

Override the doGet() method to handle GET requests.
Step 3: Access the ServletContext object:

Within the doGet() method of your servlet, obtain the ServletContext object using the
getServletContext() method inherited from the HttpServlet class.

public class MyServlet extends HttpServlet {

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws

ServletException, IOException {
// Obtain the ServletContext object
ServletContext servletContext = getServletContext();

// Access and utilize the ServletContext

String appName = servletContext.getServletContextName();
String contextPath = servletContext.getContextPath();

// Perform further operations with the ServletContext

// ...
}
}
Step 4: Utilize the ServletContext:

Once you have the ServletContext object, you can use its methods to access information about the
application or perform specific tasks. Here are a few examples:
Retrieve the application name:

String appName = servletContext.getServletContextName();

Retrieve the context path:

String contextPath = servletContext.getContextPath();

Get the absolute path of a resource within the application:

String imagePath = servletContext.getRealPath("/images/logo.png");

Set and retrieve attributes shared across servlets:

servletContext.setAttribute("attributeName", attributeValue);
Object attributeValue = servletContext.getAttribute("attributeName");
These are just a few examples of how you can utilize the ServletContext object. It provides many more
methods to interact with the application's environment, manage resources, handle file uploads, and
more.

Remember to configure your web.xml deployment descriptor or use annotations to map your servlet to
a URL pattern so that the doGet() method gets invoked when the corresponding URL is requested.

HttpServletRequest

In J2EE, the HttpServletRequest interface represents an HTTP request made by a client (usually a web
browser) to a web application. It provides methods to access information about the request, such as
request parameters, headers, cookies, and session attributes. It is an essential component in the servlet
API for handling and processing client requests.

Now, let's dive into a step-by-step example of using the HttpServletRequest interface in a servlet.

Step 1: Create a new dynamic web project:

Set up your development environment with an IDE (Integrated Development Environment) like Eclipse
or IntelliJ.
Create a new dynamic web project in your IDE.
Step 2: Define a servlet:

Create a new Java class that extends the HttpServlet class.

Override the doGet() or doPost() method to handle GET or POST requests, respectively.
Step 3: Access the HttpServletRequest object:

Within the doGet() or doPost() method of your servlet, obtain the HttpServletRequest object as a
parameter.
Example code snippet:

public class MyServlet extends HttpServlet {

 protected void doGet(HttpServletRequest request, HttpServletResponse response) throws
ServletException, IOException {
// Access the HttpServletRequest object
// ...
}
}
Step 4: Utilize the HttpServletRequest:

Once you have the HttpServletRequest object, you can use its methods to access various details about
the request.
Example code snippet:

public class MyServlet extends HttpServlet {

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws

ServletException, IOException {
// Access the request URL
String requestURL = request.getRequestURL().toString();

// Access request parameters

String name = request.getParameter("name");
String age = request.getParameter("age");

// Access request headers

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

// Access request cookies

Cookie[] cookies = request.getCookies();
// ...

// Perform further operations with the HttpServletRequest

// ...
}
}
In this example, we have a servlet called MyServlet with the doGet() method overridden. We obtain the
HttpServletRequest object as a parameter. Then, we utilize various methods of the HttpServletRequest
to access information about the request:

getRequestURL() retrieves the URL of the request.

getParameter() retrieves the values of request parameters.
getHeader() retrieves the value of a request header.
getCookies() retrieves an array of cookies included in the request.
You can access many more details and attributes of the HttpServletRequest object, such as the request
method, session, and attributes, among others.

Remember, the actual request details will depend on the client's request and the parameters passed.

HttpServletResponse

In J2EE, the HttpServletResponse interface represents the HTTP response that a web server sends back
to the client (usually a web browser) after receiving an HTTP request. It provides methods to manipulate
the response, set response headers, write content, and control the behavior of the response. It is an
essential component in the servlet API for handling and processing server responses.

Now, let's dive into a step-by-step example of using the HttpServletResponse interface in a servlet.

Step 1: Create a new dynamic web project:

Set up your development environment with an IDE (Integrated Development Environment) like Eclipse
or IntelliJ.
Create a new dynamic web project in your IDE.
Step 2: Define a servlet:

Create a new Java class that extends the HttpServlet class.

Override the doGet() or doPost() method to handle GET or POST requests, respectively.
Step 3: Access the HttpServletResponse object:

Within the doGet() or doPost() method of your servlet, obtain the HttpServletResponse object as a
parameter.
Example code snippet:

public class MyServlet extends HttpServlet {

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws

ServletException, IOException {
// Access the HttpServletResponse object
// ...
}
}
Step 4: Utilize the HttpServletResponse:

Once you have the HttpServletResponse object, you can use its methods to manipulate the response
and control its behavior.
Example code snippet:

public class MyServlet extends HttpServlet {

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws

ServletException, IOException {
// Set response content type
response.setContentType("text/html");

// Set response status code

response.setStatus(HttpServletResponse.SC_OK);

// Set response headers

response.setHeader("Cache-Control", "no-cache");
response.setHeader("Expires", "0");

// Write response content

PrintWriter out = response.getWriter();
out.println("<html>");
out.println("<body>");
 out.println("<h1>Hello, World!</h1>");
out.println("</body>");
out.println("</html>");

// Perform further operations with the HttpServletResponse

// ...
}
}
In this example, we have a servlet called MyServlet with the doGet() method overridden. We obtain the
HttpServletResponse object as a parameter. Then, we utilize various methods of the
HttpServletResponse to manipulate the response:

setContentType() sets the content type of the response.

setStatus() sets the HTTP status code of the response.
setHeader() sets the value of a response header.
getWriter() obtains a PrintWriter object to write response content.
We use the PrintWriter to write an HTML response content, including a simple "Hello, World!" message.

You can also use other methods of the HttpServletResponse object, such as sendRedirect() to redirect
the client to a different URL, sendError() to send an error response, and more.

Remember, the actual response details and content will depend on the specific requirements of your
web application.

HttpSession

In J2EE, the HttpSession interface represents a session object that allows you to store and retrieve
session-specific information between multiple requests from the same client. It provides methods to
manage session attributes and control the session's behavior. HttpSession is an essential component in
the servlet API for handling user sessions in web applications.

Now, let's dive into a step-by-step example of using the HttpSession interface in a servlet.

Step 1: Create a new dynamic web project:

Set up your development environment with an IDE (Integrated Development Environment) like Eclipse
or IntelliJ.
Create a new dynamic web project in your IDE.
Step 2: Define a servlet:

Create a new Java class that extends the HttpServlet class.

Override the doGet() or doPost() method to handle GET or POST requests, respectively.
Step 3: Access the HttpSession object:

Within the doGet() or doPost() method of your servlet, obtain the HttpSession object from the
HttpServletRequest.
Example code snippet:

public class MyServlet extends HttpServlet {

 protected void doGet(HttpServletRequest request, HttpServletResponse response) throws
ServletException, IOException {
// Access the HttpSession object
HttpSession session = request.getSession();
// ...
}
}
Step 4: Utilize the HttpSession:

Once you have the HttpSession object, you can use its methods to store, retrieve, and manage session
attributes.
Example code snippet:

public class MyServlet extends HttpServlet {

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws

ServletException, IOException {
// Access the HttpSession object
HttpSession session = request.getSession();

// Store a session attribute

session.setAttribute("username", "John");

// Retrieve a session attribute

String username = (String) session.getAttribute("username");

// Remove a session attribute

session.removeAttribute("username");

// Invalidate the session

session.invalidate();

// Perform further operations with the HttpSession

// ...
}
}
In this example, we have a servlet called MyServlet with the doGet() method overridden. We obtain the
HttpSession object by calling request.getSession(). Then, we utilize various methods of the HttpSession
to manage session attributes:

setAttribute() stores a session attribute with a specified name and value.

getAttribute() retrieves a session attribute value based on the attribute name.
removeAttribute() removes a session attribute based on the attribute name.
invalidate() invalidates the session and removes all session attributes.
You can use HttpSession to store any serializable Java object as a session attribute, such as user
information, shopping cart items, or application-specific data.

Remember, the HttpSession object provides additional methods to control the session's behavior, set
session timeouts, and manage session listeners.

HttpServlet
In J2EE, the HttpServlet class is an abstract class that provides a convenient way to implement servlets
that handle HTTP requests and responses. It extends the GenericServlet class and adds specific methods
to handle different HTTP methods (such as GET, POST, PUT, DELETE) and perform tasks related to HTTP
protocol handling.

Now, let's dive into a step-by-step example of using the HttpServlet class in a servlet.

Step 1: Create a new dynamic web project:

Set up your development environment with an IDE (Integrated Development Environment) like Eclipse
or IntelliJ.
Create a new dynamic web project in your IDE.
Step 2: Define a servlet:

Create a new Java class that extends the HttpServlet class.

Override the doGet() or doPost() method (or other HTTP methods) to handle specific HTTP requests.
Example code snippet:

public class MyServlet extends HttpServlet {

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws

ServletException, IOException {
// Handle GET requests
// ...
}
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws
ServletException, IOException {
// Handle POST requests
// ...
}
}

In this example, we have a servlet called MyServlet that extends the HttpServlet class. We override the
doGet() and doPost() methods to handle GET and POST requests, respectively.

Step 3: Implement request handling logic:

Within the overridden methods, implement the logic to handle the specific HTTP requests.
Example code snippet:

public class MyServlet extends HttpServlet {

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws

ServletException, IOException {
// Handle GET requests
String name = request.getParameter("name");
response.getWriter().println("Hello, " + name);
}
 protected void doPost(HttpServletRequest request, HttpServletResponse response) throws
ServletException, IOException {
// Handle POST requests
String username = request.getParameter("username");
String password = request.getParameter("password");

// Validate user credentials

if (username.equals("admin") && password.equals("password")) {
response.getWriter().println("Login successful!");
} else {
response.getWriter().println("Invalid username or password!");
}
}
}
In this example, we handle GET and POST requests in their respective methods. For a GET request, we
retrieve the "name" parameter from the request and send a response with a personalized greeting. For
a POST request, we retrieve the "username" and "password" parameters, validate them, and send a
response indicating the login status.

Remember, the HttpServlet class provides other methods that you can override to handle additional
HTTP methods, such as doPut(), doDelete(), and more.

RequestDispatcher

In J2EE, the RequestDispatcher interface provides a way to forward requests from one servlet to another
servlet or include the response of another servlet within the current servlet's response. It is used to
achieve servlet collaboration and dynamic content generation.

Now, let's dive into a step-by-step example of using the RequestDispatcher interface in a servlet.

Step 1: Create a new dynamic web project:

Set up your development environment with an IDE (Integrated Development Environment) like Eclipse
or IntelliJ.
Create a new dynamic web project in your IDE.
Step 2: Define a servlet:

Create a new Java class that extends the HttpServlet class.

Override the doGet() or doPost() method to handle GET or POST requests, respectively.
Step 3: Obtain the RequestDispatcher object:

Within the doGet() or doPost() method of your servlet, obtain the RequestDispatcher object from the
HttpServletRequest.
Example code snippet:

public class MyServlet extends HttpServlet {

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws

ServletException, IOException {
// Obtain the RequestDispatcher object
RequestDispatcher dispatcher = request.getRequestDispatcher("targetServlet");
// ...
 }
}
Step 4: Forward or include the request/response:

Use the forward() or include() methods of the RequestDispatcher object to forward or include the
request and response objects to another servlet.
Example code snippet:

public class MyServlet extends HttpServlet {

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws

ServletException, IOException {
// Obtain the RequestDispatcher object
RequestDispatcher dispatcher = request.getRequestDispatcher("targetServlet");

// Forward the request and response objects

dispatcher.forward(request, response);

// Include the response of another servlet

dispatcher.include(request, response);
}
}
In this example, we have a servlet called MyServlet with the doGet() method overridden. We obtain the
RequestDispatcher object by calling request.getRequestDispatcher("targetServlet"), where
"targetServlet" is the URL or servlet path of the servlet to which we want to forward or include the
request.

To forward the request and response objects to the target servlet, we use the forward() method of the
RequestDispatcher object, passing the request and response as parameters.

To include the response of the target servlet within the current servlet's response, we use the include()
method of the RequestDispatcher object, again passing the request and response as parameters.

The target servlet can be another servlet within the same web application or a servlet in a different
application altogether.

Remember, forward() transfers control to the target servlet, and the response generated by the current
servlet is not sent to the client. include() includes the response of the target servlet within the current
servlet's response.

ServletConfig

In J2EE, the ServletConfig interface represents the configuration information of a servlet. It allows you to
retrieve initialization parameters specified in the deployment descriptor (web.xml) and provides a way
to access servlet-related information such as the servlet's name and ServletContext.

Now, let's dive into a step-by-step example of using the ServletConfig interface in a servlet.

Step 1: Create a new dynamic web project:

Set up your development environment with an IDE (Integrated Development Environment) like Eclipse
or IntelliJ.
Create a new dynamic web project in your IDE.
Step 2: Define a servlet:

Create a new Java class that extends the HttpServlet class.

Override the init() method to perform servlet initialization.
Example code snippet:

public class MyServlet extends HttpServlet {

private ServletConfig config;

public void init(ServletConfig config) throws ServletException {

super.init(config);
this.config = config;
}

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws

ServletException, IOException {
// Access the ServletConfig object
String servletName = config.getServletName();
String initParameter = config.getInitParameter("parameterName");

// ...
}
}
In this example, we have a servlet called MyServlet that extends the HttpServlet class. We override the
init() method and call super.init(config) to perform any necessary initialization.

Step 3: Access ServletConfig:

Within the doGet() or doPost() method of your servlet, access the ServletConfig object to retrieve
initialization parameters and other servlet-related information.
Example code snippet:

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws

ServletException, IOException {
// Access the ServletConfig object
String servletName = config.getServletName();
String initParameter = config.getInitParameter("parameterName");

// ...
}
In this example, we access the ServletConfig object stored in the config instance variable. We can use
the getServletName() method to retrieve the name of the servlet defined in the deployment descriptor.

We can also use the getInitParameter() method to retrieve initialization parameters specified in the
deployment descriptor. The parameter name specified as an argument should match the name defined
in the deployment descriptor.

Remember, the ServletConfig object provides other useful methods such as getServletContext() to
obtain the ServletContext object associated with the servlet.
Difference between RequestDispatcher.forward and HttpServletResponse.sendRedirect

RequestDispatcher.forward() and HttpServletResponse.sendRedirect() are two different methods used

in servlets to redirect the request from one resource (servlet, JSP, or HTML page) to another resource.
However, they have different behaviors and use cases.

RequestDispatcher.forward():
The RequestDispatcher.forward() method allows you to forward the request and response objects from
one resource to another resource on the server side. It is performed internally within the server without
the client being aware of it. The client's URL and request parameters remain unchanged.
Step-by-step example:
Suppose you have two servlets, "FirstServlet" and "SecondServlet". In "FirstServlet", you want to process
some information and then forward the request to "SecondServlet".

// FirstServlet
public class FirstServlet extends HttpServlet {

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws

ServletException, IOException {
// Process some information

// Obtain the RequestDispatcher object

RequestDispatcher dispatcher = request.getRequestDispatcher("SecondServlet");

// Forward the request and response objects

dispatcher.forward(request, response);
}
}
// SecondServlet
public class SecondServlet extends HttpServlet {

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws

ServletException, IOException {
// Handle the forwarded request

// ...
}
}
In this example, when the client makes a request to "FirstServlet", the request is forwarded to
"SecondServlet" using the RequestDispatcher.forward() method. The control moves from "FirstServlet"
to "SecondServlet" on the server side, and the response is generated by "SecondServlet".

HttpServletResponse.sendRedirect():

The HttpServletResponse.sendRedirect() method allows you to redirect the client's browser to a

different URL or resource. It sends a response to the client with an HTTP status code of 302 (Found)
along with the new URL. The client's browser then makes a new request to the specified URL, and the
URL changes in the client's browser.
Step-by-step example:
Suppose you want to redirect the client's browser from "FirstServlet" to an external website,
"https://www.example.com".

// FirstServlet
public class FirstServlet extends HttpServlet {

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws

ServletException, IOException {
// Redirect the client's browser
response.sendRedirect("https://www.example.com");
}
}
In this example, when the client makes a request to "FirstServlet", the
HttpServletResponse.sendRedirect() method is used to send a redirect response to the client's browser
with the new URL. The client's browser then makes a new request to "https://www.example.com", and
the URL changes in the client's browser.

In summary, the main difference between RequestDispatcher.forward() and

HttpServletResponse.sendRedirect() is that forward() is a server-side redirect without the client's
involvement, while sendRedirect() is a client-side redirect where the client's browser is redirected to a
new URL.

RequestDispatcher.forward() is commonly used when you want to keep the URL unchanged and
perform server-side processing or invoke another resource internally within the server.

HttpServletResponse.sendRedirect() is commonly used when you want to redirect the client's browser
to a different URL, such as another page within the same web application or an external website.