Implement Custom Filters and OnePageFilter in Spring for Efficient Request Handling

1. Introduction to Spring Filters

Spring filters operate at a lower level than controllers. They allow you to intercept HTTP requests and responses, modify them if needed, or even terminate requests before reaching the controller. Filters are ideal for cross-cutting concerns like logging, security, and CORS handling.

1.1 What is a Custom Filter?

A custom filter in Spring is a class that implements the javax.servlet.Filter interface and is capable of modifying both the request and the response. You define this filter in the Spring context and then map it to specific URL patterns.

1.2 Example of a Basic Custom Filter

Below is a simple example of a custom logging filter. This filter logs incoming requests and outgoing responses:

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebFilter;
import java.io.IOException;

@WebFilter(urlPatterns = "/*")
public class LoggingFilter implements Filter {

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        // Initialize the filter
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        System.out.println("Incoming request: " + request.getRemoteAddr());
        chain.doFilter(request, response);
        System.out.println("Outgoing response: " + response.getContentType());
    }

    @Override
    public void destroy() {
        // Cleanup
    }
}

1.3 Registering the Custom Filter in Spring

The next step is to register this filter in the Spring context, ensuring that it is part of the filter chain:

import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class FilterConfig {

    @Bean
    public FilterRegistrationBean<LoggingFilter> loggingFilter() {
        FilterRegistrationBean<LoggingFilter> registrationBean = new FilterRegistrationBean<>();
        registrationBean.setFilter(new LoggingFilter());
        registrationBean.addUrlPatterns("/*");
        return registrationBean;
    }
}

In this example, the LoggingFilter is applied to all URLs (/*), meaning every request will pass through the filter before reaching the controller.

1.4 Demo Result of the Custom Filter

Once implemented, the application will log the remote address of each incoming request and the content type of the outgoing response. You can observe this behavior by running the application and making requests via Postman or a browser.

Demo Output:

Incoming request: 127.0.0.1
Outgoing response: application/json

2. Implementing a OnePageFilter for Efficient Request Handling

The OnePageFilter is a specialized custom filter used to manage how multiple requests to the same page are handled. This filter helps ensure that requests from a single user to a specific page are not processed multiple times unnecessarily, thus optimizing performance and security.

2.1 What is a OnePageFilter?

The OnePageFilter ensures that once a user accesses a certain page, subsequent requests to the same page are blocked or processed differently. This is particularly useful for pages like checkout pages in e-commerce platforms, where double submissions can lead to problems like duplicate orders.

2.2 Example of a OnePageFilter

Here is a practical implementation of the OnePageFilter. In this example, it blocks multiple submissions from the same user to a checkout page:

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebFilter;
import java.io.IOException;

@WebFilter(urlPatterns = "/checkout")
public class OnePageFilter implements Filter {

    private boolean isPageAccessed = false;

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        if (isPageAccessed) {
            System.out.println("Page already accessed. Blocking request.");
            return;
        } else {
            isPageAccessed = true;
            chain.doFilter(request, response);
        }
    }

    @Override
    public void destroy() {
    }
}

2.3 Resetting Access for Future Requests

To reset the access flag (i.e., to allow access after a session expires or once a purchase is completed), you can hook into events like session destruction or request completion:

import org.springframework.context.event.EventListener;
import org.springframework.session.events.SessionDestroyedEvent;
import org.springframework.stereotype.Component;

@Component
public class SessionListener {

    private final OnePageFilter onePageFilter;

    public SessionListener(OnePageFilter onePageFilter) {
        this.onePageFilter = onePageFilter;
    }

    @EventListener
    public void handleSessionDestroyed(SessionDestroyedEvent event) {
        // Reset flag when the session is destroyed
        onePageFilter.resetAccess();
    }
}

2.4 Demo Result of the OnePageFilter

The OnePageFilter will block any subsequent requests to the checkout page once the first request is processed. The following output can be observed in the logs:

Demo Output:

Page already accessed. Blocking request.

This prevents issues like double orders or multiple form submissions on sensitive pages.

3. Conclusion

By using custom filters and OnePageFilter in Spring, you can efficiently handle various request scenarios. Custom filters give you the flexibility to preprocess or post-process requests for cross-cutting concerns, while the OnePageFilter ensures that requests to critical pages are managed safely and efficiently.

If you have any questions or need further clarifications on this topic, feel free to leave a comment below!

Read posts more at : Implement Custom Filters and OnePageFilter in Spring for Efficient Request Handling