Autowire Spring Bean in Servlet Filter

Servlet filters provide a powerful way to intercept and manipulate incoming requests. However, accessing Spring-managed beans within these filters can be challenging. Let us delve into understanding how to autowire a Spring bean within a servlet filter.

1. Understanding the Limitations of @Autowired in Servlet Filter

While Spring’s @Autowired annotation is a powerful tool for dependency injection, its direct usage within a Servlet filter comes with certain limitations. Understanding these limitations is crucial for implementing effective and maintainable Spring-based web applications.

1.1 Lifecycle Mismatch

Servlet filters are managed by the servlet container, not by the Spring context. This causes a mismatch in lifecycles:

• Servlet filters are instantiated and managed by the servlet container.
• Spring beans are managed by the Spring IoC container.

Due to this lifecycle mismatch, the Spring context is not automatically available in the filter’s lifecycle, preventing direct usage of @Autowired.

1.2 Initialization Order

The initialization order of servlet filters and the Spring context can lead to issues:

• Servlet filters can be initialized before the Spring context is fully initialized.
• This can result in NullPointerException when accessing Spring beans that are not yet available.

To mitigate this, specific techniques are needed to ensure that the Spring context is available when the filter is initialized.

1.3 Direct Usage of @Autowired

Direct usage of @Autowired in servlet filters is problematic because the servlet container does not support Spring annotations natively:

public class MyFilter implements Filter {

    @Autowired
    private MyService myService;  // This will not work directly

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        // Filter initialization logic
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        myService.performAction();  // This will result in NullPointerException
        chain.doFilter(request, response);
    }

    @Override
    public void destroy() {
    }
}

This code will not work as intended because the servlet container does not process Spring annotations, and myService will remain null.

To address these limitations, alternative approaches are needed to access Spring beans in a Servlet filter. Here are some commonly used techniques:

• SpringBeanAutowiringSupport: Manually triggers the autowiring process within the filter.
• WebApplicationContextUtils: Retrieves the Spring application context and gets beans from it.
• FilterRegistrationBean: Registers the filter with Spring Boot, allowing constructor injection.
• DelegatingFilterProxy: Delegates filter operations to a Spring-managed bean, integrating with Spring’s dependency injection.

2. Obtaining Spring Beans within a Servlet Filter

In Spring-based web applications, it is common to require access to Spring beans within a Servlet filter. Here we explore various approaches to achieve this seamlessly.

2.1 Using SpringBeanAutowiringSupport in Servlet Filter

The SpringBeanAutowiringSupport class can be used to enable the autowiring of Spring beans in a Servlet filter. This approach requires manually calling the autowiring process in the filter’s init method.

import org.springframework.web.context.support.SpringBeanAutowiringSupport;

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 java.io.IOException;

public class MyFilter extends SpringBeanAutowiringSupport implements Filter {

    @Autowired
    private MyService myService;

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        SpringBeanAutowiringSupport.processInjectionBasedOnCurrentContext(this);
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        myService.performAction();
        chain.doFilter(request, response);
    }

    @Override
    public void destroy() {
    }
}

This approach involves:

• Extending SpringBeanAutowiringSupport to support autowiring.
• Calling SpringBeanAutowiringSupport.processInjectionBasedOnCurrentContext(this) in the init method to enable autowiring.
• Using the MyService bean in the doFilter method.

2.2 Using WebApplicationContextUtils in Servlet Filter

The WebApplicationContextUtils class provides a way to retrieve the Spring application context and get beans from it. This method does not require the filter itself to be Spring-managed.

import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;

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 java.io.IOException;

public class MyFilter implements Filter {

    private MyService myService;

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        WebApplicationContext context = WebApplicationContextUtils
                .getRequiredWebApplicationContext(filterConfig.getServletContext());
        myService = context.getBean(MyService.class);
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        myService.performAction();
        chain.doFilter(request, response);
    }

    @Override
    public void destroy() {
    }
}

This approach involves:

• Retrieving the Spring application context using WebApplicationContextUtils.getRequiredWebApplicationContext.
• Getting the MyService bean from the context in the init method.
• Using the MyService bean in the doFilter method.

2.3 Using FilterRegistrationBean in Configuration

The FilterRegistrationBean allows registering a filter in a Spring Boot application, providing a way to inject Spring beans directly into the filter. This approach leverages Spring’s Java configuration capabilities.

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

import javax.servlet.Filter;

@Configuration
public class FilterConfig {

    @Bean
    public FilterRegistrationBean myFilter(MyService myService) {
        FilterRegistrationBean registrationBean = new FilterRegistrationBean();
        MyFilter myFilter = new MyFilter(myService);
        registrationBean.setFilter(myFilter);
        registrationBean.addUrlPatterns("/my-url/*");
        return registrationBean;
    }
}

public class MyFilter implements Filter {

    private final MyService myService;

    public MyFilter(MyService myService) {
        this.myService = myService;
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        myService.performAction();
        chain.doFilter(request, response);
    }

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

    @Override
    public void destroy() {
    }
}

This approach involves:

• Defining a FilterRegistrationBean in a configuration class to register the filter.
• Injecting the MyService bean into the filter through its constructor.
• Using the injected MyService bean in the doFilter method.

2.4 Using DelegatingFilterProxy in Servlet Filter

The DelegatingFilterProxy delegates the filter operations to a Spring-managed bean. This requires defining the filter as a Spring bean and configuring the DelegatingFilterProxy in the web.xml or through Java configuration.

import org.springframework.web.filter.DelegatingFilterProxy;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {

    @Bean
    public MySpringManagedFilter mySpringManagedFilter() {
        return new MySpringManagedFilter();
    }

    @Bean
    public FilterRegistrationBean delegatingFilterProxy() {
        FilterRegistrationBean registrationBean = new FilterRegistrationBean();
        DelegatingFilterProxy delegatingFilterProxy = new DelegatingFilterProxy("mySpringManagedFilter");
        registrationBean.setFilter(delegatingFilterProxy);
        registrationBean.addUrlPatterns("/my-url/*");
        return registrationBean;
    }
}

@Component("mySpringManagedFilter")
public class MySpringManagedFilter implements Filter {

    @Autowired
    private MyService myService;

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        myService.performAction();
        chain.doFilter(request, response);
    }

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

    @Override
    public void destroy() {
    }
}

This approach involves:

• Defining the filter as a Spring bean with the @Component annotation.
• Configuring a DelegatingFilterProxy in a configuration class to delegate the filter operations to the Spring-managed bean.
• Using the injected MyService bean in the doFilter method of the Spring-managed filter bean.

3. Comparing Dependency Injection Approaches in Servlet Filter

4. Conclusion

Understanding the limitations of @Autowired in Servlet filters is essential for developing robust Spring-based web applications. By using the appropriate workarounds, you can effectively integrate Spring’s powerful dependency injection capabilities within servlet filters.

Do you want to know how to develop your skillset to become a Java Rockstar?

Subscribe to our newsletter to start Rocking right now!

To get you started we give you our best selling eBooks for FREE!

1. JPA Mini Book

2. JVM Troubleshooting Guide

3. JUnit Tutorial for Unit Testing

4. Java Annotations Tutorial

5. Java Interview Questions

6. Spring Interview Questions

7. Android UI Design

and many more ....

I agree to the Terms and Privacy Policy

Sign up

Thank you!

We will contact you soon.