How to add filters to servlet without modifying web.xml

Question

I'd like the ability to modify/configure filters in a different way than web.xml. Here is a static configuration of 2 filters. I'd like the ability to have one filter statically configured and allow that filter to load additional filters. I just wanted to know if anyone knows of lib that already has this.

Using Servlet API 2.5

<web-app>
  ...
  <filter>
    <filter-name>MyFilter1</filter-name>
    <filter-class>com.me.MyFilter1</filter-class>
  </filter>
  <filter-mapping>
    <filter-name>MyFilter1</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>
  ...
  <filter>
    <filter-name>MyFilter2</filter-name>
    <filter-class>com.me.MyFilter2</filter-class>
  </filter>
  <filter-mapping>
    <filter-name>MyFilter2</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>
  ...
</web-app>

I've seen this done in Guice with GuiceFilter where the Filters are configured at runtime.

Septicidal

It would be dependent of the servlet container, so you should tell us which one you are using – Yerkovich

Must it be dependent? Is GuiceFilter dependent on the container? – Septicidal

Guice rolls its own mapping mechanism that behaves just like web.xml mappings -- for the web container, all requests end at GuiceFilter. If you want Guice, just use it :) – Vidar

Answer 1

Just do the same job as the container already does. I.e. reinvent the wheel of the chain of responsibility design pattern as is under the covers been used by servlet filters.

public class GodFilter implements Filter {

    private Map<Pattern, Filter> filters = new LinkedHashMap<Pattern, Filter>();

    @Override
    public void init(FilterConfig config) throws ServletException {
        Filter1 filter1 = new Filter1();
        filter1.init(config);
        filters.put(new Pattern("/foo/*"), filter1);

        Filter2 filter2 = new Filter2();
        filter2.init(config);
        filters.put(new Pattern("*.bar"), filter2);

        // ...
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws ServletException, IOException {
        HttpServletRequest hsr = (HttpServletRequest) request;
        String path = hsr.getRequestURI().substring(hsr.getContextPath().length());
        GodFilterChain godChain = new GodFilterChain(chain);

        for (Entry<Pattern, Filter> entry : filters.entrySet()) {
            if (entry.getKey().matches(path)) {
                godChain.addFilter(entry.getValue());
            }
        }

        godChain.doFilter(request, response);
    }

    @Override
    public void destroy() {
        for (Filter filter : filters.values()) {
            filter.destroy();
        }
    }

}

with those little helper classes (which can if necessary be made private static nested classes of the above GodFilter):

public class Pattern {

    private int position;
    private String url;

    public Pattern(String url) {
        this.position = url.startsWith("*") ? 1
                      : url.endsWith("*") ? -1
                      : 0;
        this.url = url.replaceAll("/?\\*", "");
    }

    public boolean matches(String path) {
        return (position == -1) ? path.startsWith(url)
             : (position == 1) ? path.endsWith(url)
             : path.equals(url);
    }

}

and

public class GodFilterChain implements FilterChain {

    private FilterChain chain;
    private List<Filter> filters = new ArrayList<Filter>();
    private Iterator<Filter> iterator;

    public GodFilterChain(FilterChain chain) {
        this.chain = chain;
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response) throws IOException, ServletException {
        if (iterator == null) {
            iterator = filters.iterator();
        }

        if (iterator.hasNext()) {
            iterator.next().doFilter(request, response, this);
        } else {
            chain.doFilter(request, response);
        }
    }

    public void addFilter(Filter filter) {
        if (iterator != null) {
            throw new IllegalStateException();
        }

        filters.add(filter);
    }

}

You could if necessary also feed a XML config file with all possible filters so that you end up with easier configuration. You could use reflection to create filters in init() of your GodFilter.

Oh nevermind, that's what the web.xml and the container already is doing...

Adkison

Shouldn't GodFilterChain.doFilter() loop over all added filters than only use the first? – Cant

@MRalwasser: Uh, no. Perhaps you're missing how "Chain of responsibility" design pattern works? The chain.doFilter() call in the filter's implementation would invoke the GodFilterChain#doFilter() again (because it's as this been passed as FilterChain argument) and then the iterator would advance to the next element, etcetera. – Adkison

ah, I totally missed that subsequent iterator.next() invocations will be done inside deeper "chain levels". Thanks, for pointing this out. – Cant

It works great! But could you please explain a use of Pattern? Why we need replace /* and hold position? – Ettie

@user99560: so that the very same code doesn't unnecessarily need to be executed everytime. The result is the same everytime, so it's logically more efficient to calculate it once and get hold of it for reuse. – Adkison

these are the reasons you have 629k. this is impressive and clean. +1 – Anglophobia

@BalusC, this might be another question to post, but is there a way to configure filters in a different xml file other than defining them in web.xml? – Kass

Answer 2

Servlet 3.0 has the @WebFilter annotation to define a filter. No need to declare it in web.xml anymore.

But loading a filter from a filter is not supported. You could implement it yourself: it's "just" the chain of responsibility pattern, but why would you?

Alvord

Deleted my answer, beat me to it by 30 seconds >:| – Homology

@JB Nizet : TJR is not asking for version servlet 3.0, he is specific with servlet 2.5 – Cattle

@JB, I've added to the question that I'm using 2.5. That 3.0 feature does make me happy though. – Septicidal

What is was looking for @WebFilter(filterName = "customFilter", urlPatterns = { "/*" }) public class CustomFilter implements Filter .... does it – Oyler

Answer 3

It can be achieved in easy steps, even for pre-3.0 Servlet spec:

1. Add a filter containing a static & ordered collection of Classes (chain).
2. Map the filter to intercept every traffic.
3. Manipulate the order & existence of your helper classes (those will be called privately by your filter upon interception of traffic) in the chain.

Ref: Xstream uses same kind of pattern for Serializer, well not with Servlet/Filter though. :)

League

Answer 4

I personally like the @WebFilter annotation to register servlet filters.
But another solution is to add the filter at runtime using the ServletContext's addFilter function.

Implement ServletContextListener; something like:

public class MyContextListener implements ServletContextListener {

    @Override
    public void contextInitialized(ServletContextEvent ce) {
        ServletContext servletContext = ce.getServletContext();
    
        // you can even conditionally add this
        servletContext.addFilter("My filter 1", MyFilter1.class)
                .addMappingForUrlPatterns(allOf(DispatcherType.class), false, "/*");
    }
}

Register listener:

<listener>
    <listener-class>com.me.MyContextListener</listener-class>
</listener>   

And of course you need to implement a Filter. But in your question you already refer to an example filter 'MyFilter1'.

Responsory