Creating a custom handler mapping Object
The first thing to do is, is to create a custom handler mapping Object. This Object can extend the Spring DefaultAnnotationHandlerMapping. This handler mapping won’t overwrite the DefaultAnnotationHandlerMapping. But we will just use this one to test for our REST url patterns. If no match is found. Then the method getHandlerInternal will return null. When null is returned, this means that Spring will go on and try to do this request in any of the other handler mappings configured. How this is configured in Spring comes up a little bit later in this post.

The code for the new RestHandlerMapping is as follows:

package com.radikalfx.demo.handler;
 
import javax.servlet.http.HttpServletRequest;
import org.springframework.beans.factory.annotation.Required;
import org.springframework.web.servlet.HandlerExecutionChain;
import org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping;
 
public class RestHandlerMapping extends DefaultAnnotationHandlerMapping {
 
	private String[] requestNames;
 
	@Override
	public HandlerExecutionChain getHandlerInternal(HttpServletRequest request) throws Exception {
 
		String uri = request.getRequestURI();
 
		for (String requestName : requestNames) {
			if (uri.startsWith(requestName)) {
				return new HandlerExecutionChain(this.getHandlerMap().get(requestName));
			}
		}
		return null;
	}
 
	@Required
	public void setRequestNames(String[] requestNames) {
		this.requestNames = requestNames;
	}
}

This RestHandlerMapping Object has the option to set one or more request names. This was we can just have this one Handler to set up multiple different URL patterns for different Controllers.

The Controller

Next is the controller. There is not much special that needs to happen to the controller. The only thing that we need to do, is make sure that we place a request mapping similar to that provided to the handler. And that this request mapping is placed on the class and not on the method.

package com.radikalfx.demo.controller;
 
import javax.servlet.http.HttpServletRequest;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
 
@Controller
@RequestMapping("/action/")
public class ActionController {
 
	@RequestMapping
	public ModelAndView getAction(HttpServletRequest request) {
		return new ModelAndView("action");
	}
}

Spring configuration
Next thing we need to do, is that we need to change the Spring configuration a little bit. Normally when using annotated Web MVC you would probably use the DefaultAnnotationHandlerMapping, with this hack, we are still doing that. But creating an own handler mapping to be used before this one. In you configuration, this would become:

<bean class="com.radikalfx.demo.handler.RestHandlerMapping">
    <property name="requestNames">
        <list>
            <value>/action/</value>
        </list>
    </property>
</bean>
<bean class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping"/>
<bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter"/>

Don’t forget to also include in the Controller in the Spring configuration!

Changing web.xml
The final thing that you need to do, to get this working, is change the web.xml so that the DispatcherServlet gets the requests for the URL pattern that we want to use:

<url-pattern>/action/*</url-pattern>

And that’s it. Of course you probably want to have some service that can handle the HttpServletRequest in the controller and extract the proper information from the request URI. But basically this is all you need to use wild cards in URL patterns with Spring 2.5 and annotations.

Make sure your web server supports the If-Modified-Since HTTP header. This feature allows your web server to tell Google whether your content has changed since we last crawled your site. Supporting this feature saves you bandwidth and overhead

Because Tomcat’s default is to let the browser / crawler know that it doesn’t cache pages, GoogleBot will go and download the page every time it visits that page. In general this doesn’t have to be bad, but because the website I am working on contains a lot of pages in google (>500.000) it might be wise to sometimes give this if-modified-since header back to Google and thereby spare some bandwidth and server load.

So then we need to take a look if GoogleBot gives back this header and then compare it and see if the information should be re crawled by Google. For this example I will be taking a period of 7 days. Of course, you could also let this depend on the data in your system. But the website I am working on makes it a bit difficult to do this, because looking up if there is new data, will slowdown the entire load process of the website (for each request), which is something I would like to avoid.

So how does the code look, to get this done:

<%
String ifModifiedSince = request.getHeader("if-modified-since");
if (ifModifiedSince != null && !ifModifiedSince.equals("")) {
  try {
    // Format should be something like this: Thu, 10 Jan 2008 09:20:50 GMT
    SimpleDateFormat sdf = new SimpleDateFormat("EEE, d MMMM yyyy HH:mm:ss z");
    Date modifiedDate = sdf.parse(ifModifiedSince);
 
    Calendar modifiedCal = Calendar.getInstance();
    modifiedCal.setTime(modifiedDate);
    Calendar nowCal = Calendar.getInstance();
    long sevenDays = 604800000;
    if (modifiedCal.getTime().getTime() + sevenDays > nowCal.getTime().getTime()) {
      response.sendError(HttpServletResponse.SC_NOT_MODIFIED);
    }
  } catch (Exception e) {
    e.printStackTrace();
  }
}
response.setHeader ("Cache-Control", "max-age=604800"); // 7 days in seconds
response.setDateHeader("Expires",
System.currentTimeMillis()+604800000); // 7 days in milliseconds
response.setDateHeader("Last-Modified", System.currentTimeMillis()); // Now
%>

The code above should be enough to get the job done. But if you feel that this can be done better or easier, feel free to comment on this post.