Servlet Listener is used for listening to events in a web container, such as when you create a session or place an attribute in a session or if you passivate and activate in another container, to subscribe to these events you can configure listener in web.xml, for example, HttpSessionListener.

Listeners get triggered for an actual physical request that can be attached to events in your app server .With listeners, you can track application-level, session-level, life-cycle changes, attribute changes etc.

You can monitor and react to events in a servlet’s life cycle by defining listener objects whose methods get invoked when lifecycle events occur. 

Event

Event is the occurrence of something, an event can be the initialization of the application, destroying an application, request from the client, creating/destroying a session, attribute modification in session etc.

Servlet API

This provides different types of Listener interfaces that we can implement and configure in web.xml.

Servlet API provides following event objects.

Servlet API provides following Listener interfaces :-

Example : Counting logged in users Using HttpSessionEvent and HttpSessionListener

<form action="login">

Name:<input type="text" name="userName"><br>

Password:<input type="password" name="password"><br>

<input type="submit" value="Login"/>

</form>

import java.io.IOException;

import java.io.PrintWriter;

import javax.servlet.ServletContext;

import javax.servlet.ServletException;

import javax.servlet.http.HttpServlet;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import javax.servlet.http.HttpSession;

public class First extends HttpServlet {

 public void doGet(HttpServletRequest request,

       HttpServletResponse response)

throws ServletException, IOException {

    response.setContentType("text/html");

    PrintWriter out = response.getWriter();

  String username =request.getParameter("userName");

    out.print("Welcome "+ userName);

    HttpSession session=request.getSession();

    session.setAttribute("userName",userName);

    ServletContext ctx=getServletContext();

    int loggedInUsers=(Integer)ctx.getAttribute("loggedInUsers");

out.print("<br>Total logged in users= "+loggedInUsers);

    out.close();

  }

}

import javax.servlet.annotation.WebListener;

import javax.servlet.http.HttpSessionEvent;

import javax.servlet.http.HttpSessionListener;

@WebListener

publicclassMyListenerimplementsHttpSessionListener{

ServletContext ctx=null;

static int loggedInUsers=0;

publicvoid sessionCreated(HttpSessionEvent sessionEvent){

loggedInUsers++;

 ctx=e.getSession().getServletContext();

 ctx.setAttribute("loggedInUsers", loggedInUsers);

}

publicvoid sessionDestroyed(HttpSessionEvent sessionEvent){

loggedInUsers--;

      ctx.setAttribute("loggedInUsers",loggedInUsers);

}

}

Reference :-

http://www.journaldev.com/1945/servletcontextlistener-servlet-listener-example

http://www.javatpoint.com/Event-and-Listener-in-Servlet

A filter is an object that dynamically intercepts requests and responses to transform or use the information contained in the requests or responses.

Filters typically do not themselves create responses but instead provide universal functions that can be “attached” to any type of servlet or JSP page.

The filter is run before rendering view but after controller rendered response.

A Filter is used in the web layer only as it is defined in web.xml.

Filters are more suitable when treating your request/response as a black box system. They’ll work regardless of how the servlet is implemented.

Filters are used to perform filtering tasks such as login authentication ,auditing of incoming requests from web pages, conversion, logging, compression, encryption and decryption, input validation etc.

A Servlet Filter is used in the web layer only, you can’t use it outside of a
web context.

Filter Interface methods :-

import javax.servlet.*;
import java.io.IOException;

public class MyFilter implements Filter {

    public void init(FilterConfig filterConfig) throws ServletException {
    }

    public void doFilter(ServletRequest request, ServletResponse response,
                         FilterChain filterChain)
    throws IOException, ServletException {
      // your code goes here
    }

    public void destroy() {
    }
}

import java.io.IOException;  
import java.io.PrintWriter;  
  
import javax.servlet.ServletException;  
import javax.servlet.http.*;  
  
public class HelloServlet extends HttpServlet {  
    public void doGet(HttpServletRequest request, HttpServletResponse response)  
            throws ServletException, IOException {  
  
        response.setContentType("text/html");  
        PrintWriter out = response.getWriter();  
      
        out.print("<br>Hello from servlet<br>");  
          
    }  
  
}

<web-app>  
  <servlet>  
    <servlet-name>Servlet1</servlet-name>  
    <servlet-class>HelloServlet</servlet-class>  
  </servlet>               
  <servlet-mapping>  
    <servlet-name>Servlet1</servlet-name>  
    <url-pattern>/servlet1</url-pattern>  
  </servlet-mapping>  
   
 <filter>  
   <filter-name>Filter1</filter-name>  
   <filter-class>MyFilter</filter-class>  
 </filter>  
   
 <filter-mapping>  
   <filter-name>Filter1</filter-name>  
   <url-pattern>/servlet1</url-pattern>  
 </filter-mapping>  
</web-app>

Servlets are programs that run on a Web or Application server and act as a middle layer between a request coming from a Web browser or other HTTP client and databases or applications on the HTTP server.

A servlet is simply a class which responds to a particular type of network request – most commonly an HTTP request.

Basically, servlets are usually used to implement web applications – but there are also various frameworks which operate on top of servlets (e.g. Struts) to give a higher-level abstraction than the “here’s an HTTP request, write to this HTTP response” level which servlets provide.

Servlets run in a servlet container which handles the networking side (e.g. parsing an HTTP request, connection handling etc). One of the best-known open source servlet containers is Tomcat.

The container will take care of things like wrapping the whole thing in a HTTP response object and send it over to the client (say a browser).

The javax.servlet and javax.servlet.http packages provide interfaces and classes for writing servlets. All servlets must implement the Servlet interface, which defines life-cycle methods. When implementing a generic service, you can use or extend the GenericServlet class provided with the Java Servlet API. The HttpServlet class provides methods, such as doGet and doPost, for handling HTTP-specific services.

Lifecycle

Servlets are now java classes whose lifecycle will be maintained by the container but their reaction to incoming HTTP requests will be decided by you.

You do that by writing what-you-want-to-do in the pre-defined methods like init(), doGet(), doPost() etc.

When a Servlet is requested for the first time or when the web app starts up, the servlet container will create an instance of it and keep it in memory during the web app’s lifetime.

The same instance will be reused for every incoming request whose URL matches the servlet’s URL pattern. You can access the requested data by HttpServletRequest and handle the response by HttpServletResponse. Both objects are available as method arguments inside of any of the overridden methods of HttpServlet, such as doGet() to preprocess a request and doPost() to post-process a request. See also How do servlets work? Instantiation, sessions, shared variables and multithreading.