Different Ways to Get Servlet Context

1. Introduction

When building web applications with Java Servlets, we often need a way to share information or resources across the entire application. We can do so by accessing the ServletContext object.

In this tutorial, we’ll explore different ways to retrieve the ServletContext inside a servlet. We’ll implement a simple servlet and examine different approaches, showing that they all return the same shared object.

2. What’s a ServletContext?

Let’s start by explaining the ServletContext. It’s an interface that defines a set of methods that a servlet can use to communicate with the servlet container.

There’s one ServletContext per web application, and the container creates it when it deploys the application. All servlets, filters, and listeners within the same application in a non-distributed environment share this single object. On the other hand, in a distributed environment, each node has its own ServletContext.

3. Accessing the ServletContext Inside a Servlet

Let’s now implement a simple servlet. We also need to add a required dependency and configure a Servlet container. With the setup in place, we can use the @WebServlet annotation to map the servlet to the /context URL:

@WebServlet("/context")
public class ContextServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) 
      throws IOException, ServletException {}
}

Inside the doGet() method, we’ll demonstrate the different ways of retrieving the ServletContext.

3.1. Direct Access From the Servlet

The simplest way to access the ServletContext is by calling the getServletContext() method directly on the servlet instance:

@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) 
  throws IOException, ServletException {
  
    ServletContext contextFromServlet = this.getServletContext();
    resp.getWriter().println("1) From HttpServlet: " + contextFromServlet);
}

To verify the reference, we can use the HttpServletResponse object. Calling getWriter() gives us a PrintWriter, which we can use to write text into the response body and display it in the browser or console. If we run the application and access the specified URL, the output, which contains the hexadecimal version of the object’s hash code, will be displayed:

1) From HttpServlet: org.apache.catalina.core.ApplicationContextFacade@437620e9

The servlet container injects the ServletContext into the servlet during initialization. Calling the getServletContext() retrieves that reference. This is the most direct and common approach when working inside a servlet.

3.2. Accessing Through the ServletConfig

Alternatively, we can access the ServletContext through a servlet configuration object. A servlet container creates and uses the ServletConfig to pass information to a servlet during initialization. We can obtain the context by first calling getServletConfig() and then getServletContext():

@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) 
  throws IOException, ServletException {
    ServletConfig config = this.getServletConfig();
    ServletContext contextFromConfig = config.getServletContext();
    resp.getWriter().println("2) From ServletConfig: " + contextFromConfig);
}

Let’s check what the servlet produces:

2) From ServletConfig: org.apache.catalina.core.ApplicationContextFacade@437620e9

The approach is practical when we’re already working with the servlet’s configuration. It’s also useful if we need to interact with the context during servlet initialization.

3.3. Getting the Context From the Request

Next, we can obtain the ServletContext from the HttpServletRequest. Since Servlet 3.0, the HttpServletRequest interface provides a dedicated getServletContext() method:

@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) 
  throws IOException, ServletException {
    ServletContext contextFromRequest = req.getServletContext();
    resp.getWriter().println("3) From HttpServletRequest: " + contextFromRequest);
}

This is useful in helper classes or filters, where we often only have access to the request object rather than the servlet itself. Similar to the previous approaches, the output displays the same object:

3) From HttpServletRequest: org.apache.catalina.core.ApplicationContextFacade@437620e9

3.4. Retrieving Through the Session Object

Finally, we can also reach the ServletContext through the HttpSession object. Every session is associated with the same application context, so calling getServletContext() on the session returns the same instance:

@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException, ServletException {
    ServletContext contextFromSession = req.getSession().getServletContext();
    resp.getWriter().println("4) From HttpSession: " + contextFromSession);
}

Although this works, it’s more indirect and less common than the other approaches. Additionally, the getSession() method will implicitly create the HTTP session object if one doesn’t exist. Nevertheless, the output confirms that the ServletContext is the same regardless of the retrieval method:

4) From HttpSession: org.apache.catalina.core.ApplicationContextFacade@437620e9

4. Conclusion

In this article, we explored the different ways to obtain the ServletContext inside a servlet. We retrieved it directly from the HttpServlet, through the ServletConfig, from the HttpServletRequest, and indirectly via the HttpSession.

As the comparisons showed, all of these approaches return the same ServletContext instance, since there’s only one per web application. When working inside a servlet, the most straightforward approach is to call getServletContext() directly. The other options are helpful in scenarios where we might already be dealing with configuration, request, or session objects.