JAVA EE: HttpSessionListener

Showing posts with label HttpSessionListener. Show all posts

Saturday, 21 June 2014

Servlets : HttpSession Listener Demo [Count logged in Users]

Master Core Java & Servlets!

Subscribe to Ram N Java for beginner-friendly coding walkthroughs, web architecture lessons, and hands-on Java guides!

🔔 Subscribe to Ram N Java

Tracking Logged-In Users with HttpSessionListener

In Java web applications, tracking the number of active sessions or concurrent logged-in users is a common requirement for dashboards, system monitoring, and session management. The standard, cleanest way to achieve this is by implementing the HttpSessionListener interface.

The web container automatically triggers callback methods on HttpSessionListener whenever a new HTTP session is created or an existing session is invalidated or times out. By updating a counter stored in the application-wide ServletContext, you can maintain an accurate, real-time count of active users.

How the Listener Works

The HttpSessionListener interface defines two primary lifecycle methods:

sessionCreated(HttpSessionEvent se): Invoked automatically when a new user session is initiated. Here, you increment the active user counter.
sessionDestroyed(HttpSessionEvent se): Invoked when a user logs out (session invalidated) or when the session expires due to inactivity. Here, you decrement the counter.

@WebListener

    public class UserCounterListener implements HttpSessionListener {

        private static int activeUsers = 0;


        public void sessionCreated(HttpSessionEvent se) {

            activeUsers++;

            se.getSession().getServletContext().setAttribute("activeUsers", activeUsers);

        }


        public void sessionDestroyed(HttpSessionEvent se) {

            activeUsers--;

            se.getSession().getServletContext().setAttribute("activeUsers", activeUsers);

        }

    }

Key Advantages of Using HttpSessionListener

Automatic Session Lifecycle Management: No manual tracking or polling needed; the servlet container notifies the listener on lifecycle transitions.
Clean Separation: Decouples session analytics and user counting from individual business servlets.
Global Availability: Storing the count inside ServletContext makes it effortlessly accessible across all servlets, JSPs, and controllers.

Recommended Related Tutorials

Continue exploring servlet listeners and session handling with these tutorials from Ram N Java:

Click here to watch in Youtube : https://www.youtube.com/watch?v=fv8Idtevcg0

Click the below Image to Enlarge

HttpSessionListenerDemo Project Dir Structure

LoginServlet.java

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 LoginServlet extends HttpServlet
{
    
    private static final long serialVersionUID = 1L;

    public void init() throws ServletException
    {
        System.out.println("-----------------------------------------");
        System.out.println(" Init method is called in "
                + this.getClass().getName());
        System.out.println("--------------------------------------");
    }
    
    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("uname", userName);

        ServletContext ctx = getServletContext();
        int totalUsers = (Integer) ctx.getAttribute("totalusers");
        int currentUsers = (Integer) ctx.getAttribute("currentusers");
        
        out.print("<br>total users= " + totalUsers);
        out.print("<br>current users= " + currentUsers);

        out.print("<br><a href='logout'>logout</a>");

        out.close();
    }
    
    public void destroy()
    {
        System.out.println("-----------------------------------------");
        System.out.println(" destroy method is called in "
                + this.getClass().getName());
        System.out.println("-----------------------------------------");
    }

}

LogoutServlet.java

import java.io.IOException;
import java.io.PrintWriter;

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 LogoutServlet extends HttpServlet
{

    private static final long serialVersionUID = 1L;

    public void doGet( HttpServletRequest request, HttpServletResponse response )
            throws ServletException, IOException
    {

        response.setContentType("text/html");
        PrintWriter out = response.getWriter();

        HttpSession session = request.getSession(false);
        session.invalidate();

        out.print("You are successfully logged out");

        out.close();
    }

}

CountUserListener.java

import javax.servlet.ServletContext;
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;

public class CountUserListener implements HttpSessionListener
{
    ServletContext ctx = null;
    static int     totalUserCount = 0, currentUserCount = 0;

    public void sessionCreated( HttpSessionEvent httpSessionEvent )
    {
        System.out.println("sessionCreated method has been called in "
                + this.getClass().getName());

        
        totalUserCount++;
        currentUserCount++;

        ctx = httpSessionEvent.getSession().getServletContext();
        
        ctx.setAttribute("totalusers", totalUserCount);
        ctx.setAttribute("currentusers", currentUserCount);

    }

    public void sessionDestroyed( HttpSessionEvent httpSessionEvent )
    {
        
        System.out.println("sessionDestroyed method has been called in "
                + this.getClass().getName());       
        currentUserCount--;
        ctx.setAttribute("currentusers", currentUserCount);
    }

}

web.xml

<?xml version="1.0" encoding="ISO-8859-1"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns="http://java.sun.com/xml/ns/javaee"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
    metadata-complete="true" version="3.0">
    <display-name>HttpSessionListenerDemo</display-name>
    <description>
        This is a simple web application with a source code organization
        based on the recommendations of the Application Developer's Guide.
    </description>


    <servlet>
        <servlet-name>LoginServlet</servlet-name>
        <servlet-class>LoginServlet</servlet-class>
    </servlet>
    
    <servlet>
        <servlet-name>LogoutServlet</servlet-name>
        <servlet-class>LogoutServlet</servlet-class>
    </servlet>


    <servlet-mapping>
        <servlet-name>LoginServlet</servlet-name>
        <url-pattern>/login</url-pattern>
    </servlet-mapping>
    
    <servlet-mapping>
        <servlet-name>LogoutServlet</servlet-name>
        <url-pattern>/logout</url-pattern>
    </servlet-mapping>


    <listener>
        <listener-class>CountUserListener</listener-class>
    </listener>
    
</web-app>

index.html

<form action="login">
    Name:<input type="text" name="username"><br> 
    
    Password:<input type="password" name="password"><br> 
    
    <input type="submit" value="login" />
    
</form>

Environment Used

JDK version :1.7.0_51
Tomcat version : 7.0.50

To Download HttpSessionListenerCountUserDemoApp Project Click the below link

https://sites.google.com/site/javaee4321/servlets/HttpSessionListenerCountUserDemoApp.zip?attredirects=0&d=1

See also:

Servlets Tutorial

All Design Patterns Links

Servlets Listeners

Master Core Java & Servlets!

Subscribe to Ram N Java for beginner-friendly coding walkthroughs, web architecture lessons, and hands-on Java guides!

🔔 Subscribe to Ram N Java

What Are Servlet Listeners?

In Java web applications, a Servlet Listener is a special Java class designed to monitor and respond to lifecycle events and state changes occurring in the web container. Built on the classic Observer design pattern, listeners automatically run custom code when specific events occur.

Instead of manually polling or handling setup logic inside servlets, listeners allow you to automatically execute initialization routines, clean up system resources, track active user sessions, or react whenever attributes are added, updated, or removed across different servlet scopes.

Major Types of Servlet Listeners

Servlet listeners in Java EE / Jakarta EE are broadly divided into three main categories based on the scope they monitor:

ServletContext Listeners: Monitor application-wide lifecycle events and attributes.
Examples: ServletContextListener (monitors startup and shutdown) and ServletContextAttributeListener (tracks context attribute changes).
HttpSession Listeners: Track user session creation, expiration, and attribute management.
Examples: HttpSessionListener (tracks active sessions/logged-in users) and HttpSessionAttributeListener (detects session data modifications).
ServletRequest Listeners: Intercept individual client HTTP request lifecycles.
Examples: ServletRequestListener (runs code on request creation/destruction) and ServletRequestAttributeListener.

Why Use Servlet Listeners?

Application Startup & Teardown: Ideal for initializing shared database connection pools or background tasks when the web app starts, and safely releasing them on shutdown.
Session Tracking & Analytics: Track the total count of active sessions or concurrent users logged into the platform in real time.
Loose Coupling: Decouple event-driven logic and monitoring tasks completely from your core business servlets.
Simple Configuration: Easily configure listeners in web.xml using the <listener> tag or by annotating the class with @WebListener.

Friday, 13 June 2014

Servlets : HttpSessionListener Introduction

Master Core Java & Servlets!

Subscribe to Ram N Java for beginner-friendly coding walkthroughs, session management tutorials, and hands-on Java guides!

🔔 Subscribe to Ram N Java

What is HttpSessionListener?

In Java web applications, managing user sessions effectively is essential for authentication, state preservation, and analytics. The HttpSessionListener interface (belonging to the javax.servlet.http package) provides a callback mechanism that enables an application to respond whenever an HttpSession is created or destroyed.

Whenever a client accesses a web application and a session is instantiated by the servlet container, or when a session times out or gets invalidated upon user logout, the container dispatches notifications to any registered HttpSessionListener. This makes it an ideal tool for monitoring active user sessions, initializing session-scoped settings, or cleaning up resources.

Key Lifecycle Methods

The HttpSessionListener interface defines two primary lifecycle callback methods:

sessionCreated(HttpSessionEvent se): Triggered automatically by the servlet container when a new session is created. You can retrieve the session instance via se.getSession() to initialize default user state or increment active user counts.
sessionDestroyed(HttpSessionEvent se): Triggered when a session is invalidated explicitly via session.invalidate() or expires automatically after reaching its configured timeout threshold.

@WebListener

    public class MySessionListener implements HttpSessionListener {


        @Override

        public void sessionCreated(HttpSessionEvent se) {

            System.out.println("New session created with ID: " + se.getSession().getId());

        }


        @Override

        public void sessionDestroyed(HttpSessionEvent se) {

            System.out.println("Session destroyed with ID: " + se.getSession().getId());

        }

    }

Why Use HttpSessionListener?

Active User Tracking: Effortlessly maintain an accurate count of concurrently logged-in users across the entire web application.
Resource Cleanup: Safely release allocated resources or invalidate locks when user sessions expire unexpectedly.
Centralized Lifecycle Management: Separates session lifecycle telemetry from individual business servlets, keeping application code modular and maintainable.

Hands-On with HttpSessionListener

In Java web applications, managing session state and observing lifecycle transitions is vital for security, auditing, and user analytics. The HttpSessionListener interface allows your application to intercept and respond to session creation and destruction events in real time.

Whenever a user initiates a request that starts a new session (e.g., calling request.getSession()), or when a session is explicitly invalidated or times out due to inactivity, the servlet container notifies all registered listeners. This hands-on tutorial demonstrates how to implement and test this listener in an Apache Tomcat environment.

Implementing the Lifecycle Callback Methods

To create an active session listener, implement the HttpSessionListener interface and annotate the class with @WebListener (or configure it inside web.xml):

sessionCreated(HttpSessionEvent se): Executes when a new session instance is created. You can retrieve session attributes, print session IDs, or increment total session metrics.
sessionDestroyed(HttpSessionEvent se): Executes when session.invalidate() is called or when the session reaches its max inactive interval timeout.

@WebListener

    public class SessionLifecycleDemoListener implements HttpSessionListener {


        @Override

        public void sessionCreated(HttpSessionEvent se) {

            HttpSession session = se.getSession();

            System.out.println("Session Created: " + session.getId());

        }


        @Override

        public void sessionDestroyed(HttpSessionEvent se) {

            HttpSession session = se.getSession();

            System.out.println("Session Destroyed: " + session.getId());

        }

    }

Key Takeaways & Practical Use Cases

Automatic Invocation: No need to invoke listener methods manually; the servlet engine triggers them across the entire application automatically.
Clean Decoupling: Session logging and lifecycle operations remain decoupled from individual business servlets.
Session Timeout Handling: Allows applications to run custom cleanup logic even when users do not click an explicit "Logout" button.

Saturday, 21 June 2014

Servlets : HttpSession Listener Demo [Count logged in Users]

Master Core Java & Servlets!

Tracking Logged-In Users with HttpSessionListener

How the Listener Works

Key Advantages of Using HttpSessionListener

Recommended Related Tutorials

Servlets Listeners

Master Core Java & Servlets!

What Are Servlet Listeners?

Major Types of Servlet Listeners

Why Use Servlet Listeners?

Recommended Related Tutorials

Friday, 13 June 2014

Servlets : HttpSessionListener Introduction

Master Core Java & Servlets!

What is HttpSessionListener?

Key Lifecycle Methods

Why Use HttpSessionListener?

Recommended Related Tutorials

Servlets : HttpSessionListener Demo

Master Core Java & Servlets!

Hands-On with HttpSessionListener

Implementing the Lifecycle Callback Methods

Key Takeaways & Practical Use Cases

Recommended Related Tutorials

Tutorials