A Java Web Application Without a web.xml

A Java Web Application Without a web.xml

Learn how to use the Java Servlet 3.0 annotations instead of a web.xml file...

1. Overview

In this tutorial, we’re creating a Java web application using Servlet 3.0+.

We’ll take a look at three annotations – @WebServlet@WebFilter, and @WebListener – that can help us nix our web.xml files.

2. The Maven Dependency

In order to use these new annotations, we need to include the javax.servlet-api dependency:


3. XML Based Configuration

Before Servlet 3.0, we’d configure a Java web application in a web.xml file:

<web-app xmlns="http://java.sun.com/xml/ns/javaee"

Let’s start replacing each configuration section with the respective annotations introduced in Servlet 3.0.

4. Servlets

JEE 6 shipped with Servlet 3.0 which enables us to use annotations for servlet definitions, minimizing the use of a web.xml file for a web application.

For example, we can define a servlet and expose it with the *@WebServlet annotation*

Let’s define one servlet for the URL pattern /uppercase. It will transform the value of the input request parameter to uppercase:

@WebServlet(urlPatterns = "/uppercase", name = "uppercaseServlet")
public class UppercaseServlet extends HttpServlet {
    public void doGet(HttpServletRequest request, HttpServletResponse response) 
      throws IOException {
        String inputString = request.getParameter("input").toUpperCase();
        PrintWriter out = response.getWriter();

Note that we defined a name for the servlet (*uppercaseServlet) that we can now reference.* We’ll make use of this in the next section.

With the @WebServlet annotation, we’re replacing the servlet and servlet-mapping sections from the web.xml file.

5. Filters

Filter is an object used to intercept requests or responses, performing pre- or post-processing tasks.

We can define a filter with the *@WebFilter annotation.*

Let’s create a filter to check if the input request parameter is present:

@WebFilter(urlPatterns = "/uppercase")
public class EmptyParamFilter implements Filter {
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse,
      FilterChain filterChain) throws IOException, ServletException {
        String inputString = servletRequest.getParameter("input");
        if (inputString != null && inputString.matches("[A-Za-z0-9]+")) {
            filterChain.doFilter(servletRequest, servletResponse);
        } else {
            servletResponse.getWriter().println("Missing input parameter");
    // implementations for other methods

With the @WebFilter annotation, we’re replacing the filter and filter-mapping sections from the web.xml file.

6. Listeners

We’ll often need to trigger actions based on certain events. This is where listeners come to the rescue. These objects will listen for an event and execute the behavior we specify.

Like previously, we can define a listener with the *@WebListener annotation.*

Let’s create a listener that counts each time we perform a request to the server. We’ll implement ServletRequestListener, listening for _ServletRequestEvent_s:

public class RequestListener implements ServletRequestListener {
    public void requestDestroyed(ServletRequestEvent event) {
        HttpServletRequest request = (HttpServletRequest)event.getServletRequest();
        if (!request.getServletPath().equals("/counter")) {
            ServletContext context = event.getServletContext();
            context.setAttribute("counter", (int) context.getAttribute("counter") + 1);
    // implementations for other methods

Note that we are excluding the requests to the URL pattern /counter.

With the @WebListener annotation, we’re replacing the listener section from the web.xml file.

7. Build and Run

For those following along, note that for testing, there’s a second servlet we’ve added for the /counter endpoint that simply returns the counter servlet context attribute.

So, let’s use Tomcat as the application server.

If we are using a version of maven-war-plugin prior to 3.1.0, we’ll need to set the property failOnMissingWebXml to false.

Now, we can deploy our .war file to Tomcat, and access to our servlets.

Let’s try out our /uppercase endpoint:

curl http://localhost:8080/spring-mvc-java/uppercase?input=texttouppercase

And we should also see how our error handling looks:

curl http://localhost:8080/spring-mvc-java/uppercase
Missing input parameter

And finally, a quick test of our listener:

curl http://localhost:8080/spring-mvc-java/counter
Request counter: 2

8. XML Still Needed

Even, with all the features introduced in Servlet 3.0, there are some use cases where we’ll still need a web.xml file, among them:

  • We can’t define the filter order with annotations – we still need the section if we have multiple filters that we need to be applied in a particular order
  • To define a session timeout, we still need to use the section
  • We still need the element for container-based authorization
  • And to specify welcome files, we’ll still need a section

Or, Servlet 3.0 also introduced some programmatic support via ServletContainerInitializer, too, which can also fill in some of these gaps.

9. Conclusion

In this tutorial, we configured a Java web Application without using the web.xml file by exercising the equivalent annotations.

As always, the source code for this tutorial can be found on GitHub. Additionally, an application using the traditional web.xml file can also be found on GitHub.

For a Spring-based approach, head over to our tutorial web.xml vs. Initializer with Spring.

Mobile App Development Company India | Ecommerce Web Development Company India

Mobile App Development Company India | Ecommerce Web Development Company India

Best Mobile App Development Company India, WebClues Global is one of the leading web and mobile app development company. Our team offers complete IT solutions including Cross-Platform App Development, CMS & E-Commerce, and UI/UX Design.

We are custom eCommerce Development Company working with all types of industry verticals and providing them end-to-end solutions for their eCommerce store development.

Know more about Top E-Commerce Web Development Company

.NET or Java for Web Development

.NET or Java for Web Development

Developers are often in a dilemma when trying to choose between technologies for their projects. Comparing two or more is quite daunting and confusing at times. In this article, we will focus on comparing .NET and Java.

Thinking of adopting one of these technologies for your next web development project? Read on for a basic overview.

Developers are often in a dilemma when trying to choose between technologies for their projects. Comparing two or more is quite daunting and confusing at times. In this article, we will focus on comparing .NET and Java.

The two are quite different in structure but are predisposed to comparison because of their demand when there is a call for complex and large-scale applications.

While .NET is a framework that can use several languages, Java, on the other hand, is a programming language itself.

A debate is often sparked during comparison among business owners and developers when it comes to choosing between the two. In fact, it is common for people to switch between the two periodically.

.NET, under the auspices of its framework, encompasses C#, which is basically Java, and here lies the challenge in contrasting between the better of the two. This article describes how the two are different while showing their similarity.

What Is Common to Both Java and .NET?

They Are Developed for Heavy Applications

Heavy execution, complex architecture, systems with high loads, and applications with big data specifications are some of the things that can be executed by both Java and C# in the .NET framework. This accords them the high adoption rates in technologies in the enterprise level which proves their scalability and reliability.

They Are Multipurpose

Ranging from subtle to overt, both Java and the .NET framework can be run on desktops, mobile applications, and servers. They are both widely used in the enterprise market. Both Java and C# are 'write one run anywhere' type languages.

They Are Similar in Their Syntax

C# in the .NET framework is derived from the Java language. This proves that the syntaxes of Java and C# are the same except for some basic modifications that were made. A basic syntax is common between the two since Java uses syntax from C++ and C# uses a variety of C languages and style including C, C++, and Java.

Both Are Object-Oriented

A common standard, object-oriented programming, is a basic principle of software development. Having their structure in modules, both Java and .NET are flexible and allow for code reuse while having good troubleshooting expansions.

Garbage Collection

Common to low-level languages, recalling is necessary if you have to free up space during memory administration which makes it a repetitive process. However, in .NET and Java there are no memory spills since objects that are not in use are evacuated.

Single Inheritance

Both C# and Java reinforce single inheritance. This means that a single path is always available from a base class to an inferred class.


Whenever methods are unique in an interface for a dynamic class, it defines an interface. A dynamic method on the other and is one that does not encompass its usage point of interest. Any interface characterization, in terms of the property, has code overseeing it, which is provided for actualization based on a specified class for its actualization.

Some of the Differences

Both Are Portable but One Exceeds the Other

Migrating between Java platforms is easy compared to the .NET framework, which is time-consuming and difficult.

Both Have Fundamental Data Types but One Exceeds the Other

.NET incorporates more fundamental data types than Java. It also allows for more extension of these value types.

They Interact Well With Different Languages

Both Java and .NET have their own languages, which they can easily integrate and work with. Examples for Java include Clojure and Groovy while .NET includes visual basic, F# and C#, among others.

Choosing .NET Core or Java for your web development project is really dependent on the type of project, the resources you have, and many other factors.

Happy web developing!