public  void afterCompletion(HttpServletRequest request,
    HttpServletResponse response,
    Object handler,
    Exception ex) throws Exception 
{

}

This implementation is empty.

 protected Integer lookupCacheSeconds(String urlPath) 
{
		// direct match?
		Integer cacheSeconds = (Integer) this.cacheMappings.get(urlPath);
		if (cacheSeconds == null) {
			// pattern match?
			for (Iterator it = this.cacheMappings.keySet().iterator(); it.hasNext();) {
				String registeredPath = (String) it.next();
				if (this.pathMatcher.match(registeredPath, urlPath)) {
					cacheSeconds = (Integer) this.cacheMappings.get(registeredPath);
				}
			}
		}
		return cacheSeconds;
}

Look up a cache seconds value for the given URL path.

Supports direct matches, e.g. a registered "/test" matches "/test", and various Ant-style pattern matches, e.g. a registered "/t*" matches both "/test" and "/team". For details, see the AntPathMatcher class.

 public  void postHandle(HttpServletRequest request,
    HttpServletResponse response,
    Object handler,
    ModelAndView modelAndView) throws Exception 
{

}

This implementation is empty.

 public boolean preHandle(HttpServletRequest request,
    HttpServletResponse response,
    Object handler) throws ServletException 
{
		String lookupPath = this.urlPathHelper.getLookupPathForRequest(request);
		if (logger.isDebugEnabled()) {
			logger.debug("Looking up cache seconds for [" + lookupPath + "]");
		}
		Integer cacheSeconds = lookupCacheSeconds(lookupPath);
		if (cacheSeconds != null) {
			if (logger.isDebugEnabled()) {
				logger.debug("Applying " + cacheSeconds + " cache seconds to [" + lookupPath + "]");
			}
			checkAndPrepare(request, response, cacheSeconds.intValue(), handler instanceof LastModified);
		}
		else {
			if (logger.isDebugEnabled()) {
				logger.debug("Applying default cache seconds to [" + lookupPath + "]");
			}
			checkAndPrepare(request, response, handler instanceof LastModified);
		}
		return true;
}

 public  void setAlwaysUseFullPath(boolean alwaysUseFullPath) 
{
	                                                 	 
		this.urlPathHelper.setAlwaysUseFullPath(alwaysUseFullPath);
}

Set if URL lookup should always use full path within current servlet context. Else, the path within the current servlet mapping is used if applicable (i.e. in the case of a ".../*" servlet mapping in web.xml). Default is "false".

Only relevant for the "cacheMappings" setting.

 public  void setCacheMappings(Properties cacheMappings) 
{
		this.cacheMappings.clear();
		for (Iterator it = cacheMappings.keySet().iterator(); it.hasNext();) {
			String path = (String) it.next();
			this.cacheMappings.put(path, Integer.valueOf(cacheMappings.getProperty(path)));
		}
}

Map specific URL paths to specific cache seconds.

Overrides the default cache seconds setting of this interceptor. Can specify "-1" to exclude a URL path from default caching.

Supports direct matches, e.g. a registered "/test" matches "/test", and a various Ant-style pattern matches, e.g. a registered "/t*" matches both "/test" and "/team". For details, see the AntPathMatcher javadoc.

 public  void setPathMatcher(PathMatcher pathMatcher) 
{
		Assert.notNull(pathMatcher, "PathMatcher must not be null");
		this.pathMatcher = pathMatcher;
}

Set the PathMatcher implementation to use for matching URL paths against registered URL patterns, for determining cache mappings. Default is AntPathMatcher.

 public  void setUrlDecode(boolean urlDecode) 
{
		this.urlPathHelper.setUrlDecode(urlDecode);
}

Set if context path and request URI should be URL-decoded. Both are returned undecoded by the Servlet API, in contrast to the servlet path.

Uses either the request encoding or the default encoding according to the Servlet spec (ISO-8859-1).

Only relevant for the "cacheMappings" setting.

 public  void setUrlPathHelper(UrlPathHelper urlPathHelper) 
{
		Assert.notNull(urlPathHelper, "UrlPathHelper must not be null");
		this.urlPathHelper = urlPathHelper;
}

Set the UrlPathHelper to use for resolution of lookup paths.

Use this to override the default UrlPathHelper with a custom subclass, or to share common UrlPathHelper settings across multiple HandlerMappings and MethodNameResolvers.

Only relevant for the "cacheMappings" setting.