org.springframework.web.servlet.handler
Class AbstractUrlHandlerMapping

java.lang.Object
  extended by org.springframework.context.support.ApplicationObjectSupport
      extended by org.springframework.web.context.support.WebApplicationObjectSupport
          extended by org.springframework.web.servlet.handler.AbstractHandlerMapping
              extended by org.springframework.web.servlet.handler.AbstractUrlHandlerMapping
All Implemented Interfaces:
Aware, ApplicationContextAware, Ordered, ServletContextAware, HandlerMapping
Direct Known Subclasses:
AbstractDetectingUrlHandlerMapping, SimpleUrlHandlerMapping

public abstract class AbstractUrlHandlerMapping
extends AbstractHandlerMapping

Abstract base class for URL-mapped HandlerMapping implementations. Provides infrastructure for mapping handlers to URLs and configurable URL lookup. For information on the latter, see "alwaysUseFullPath" property.

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

Will search all path patterns to find the most exact match for the current request path. The most exact match is defined as the longest path pattern that matches the current request path.

Since:
16.04.2003
Author:
Juergen Hoeller, Arjen Poutsma

Field Summary
 
Fields inherited from class org.springframework.context.support.ApplicationObjectSupport
logger
 
Fields inherited from interface org.springframework.web.servlet.HandlerMapping
BEST_MATCHING_PATTERN_ATTRIBUTE, INTROSPECT_TYPE_LEVEL_MAPPING, PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE, PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE, URI_TEMPLATE_VARIABLES_ATTRIBUTE
 
Fields inherited from interface org.springframework.core.Ordered
HIGHEST_PRECEDENCE, LOWEST_PRECEDENCE
 
Constructor Summary
AbstractUrlHandlerMapping()
           
 
Method Summary
protected  Object buildPathExposingHandler(Object rawHandler, String bestMatchingPattern, String pathWithinMapping, Map<String,String> uriTemplateVariables)
          Build a handler object for the given raw handler, exposing the actual handler, the HandlerMapping.PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE, as well as the HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE before executing the handler.
protected  void exposePathWithinMapping(String bestMatchingPattern, String pathWithinMapping, HttpServletRequest request)
          Expose the path within the current mapping as request attribute.
protected  void exposeUriTemplateVariables(Map<String,String> uriTemplateVariables, HttpServletRequest request)
          Expose the URI templates variables as request attribute.
protected  Object getHandlerInternal(HttpServletRequest request)
          Look up a handler for the URL path of the given request.
 Map<String,Object> getHandlerMap()
          Return the registered handlers as an unmodifiable Map, with the registered path as key and the handler object (or handler bean name in case of a lazy-init handler) as value.
 Object getRootHandler()
          Return the root handler for this handler mapping (registered for "/"), or null if none.
protected  Object lookupHandler(String urlPath, HttpServletRequest request)
          Look up a handler instance for the given URL path.
protected  void registerHandler(String[] urlPaths, String beanName)
          Register the specified handler for the given URL paths.
protected  void registerHandler(String urlPath, Object handler)
          Register the specified handler for the given URL path.
 void setLazyInitHandlers(boolean lazyInitHandlers)
          Set whether to lazily initialize handlers.
 void setRootHandler(Object rootHandler)
          Set the root handler for this handler mapping, that is, the handler to be registered for the root path ("/").
protected  boolean supportsTypeLevelMappings()
          Indicates whether this handler mapping support type-level mappings.
protected  void validateHandler(Object handler, HttpServletRequest request)
          Validate the given handler against the current request.
 
Methods inherited from class org.springframework.web.servlet.handler.AbstractHandlerMapping
adaptInterceptor, detectMappedInterceptors, extendInterceptors, getAdaptedInterceptors, getDefaultHandler, getHandler, getHandlerExecutionChain, getMappedInterceptors, getOrder, getPathMatcher, getUrlPathHelper, initApplicationContext, initInterceptors, setAlwaysUseFullPath, setDefaultHandler, setInterceptors, setOrder, setPathMatcher, setUrlDecode, setUrlPathHelper
 
Methods inherited from class org.springframework.web.context.support.WebApplicationObjectSupport
getServletContext, getTempDir, getWebApplicationContext, initApplicationContext, initServletContext, isContextRequired, setServletContext
 
Methods inherited from class org.springframework.context.support.ApplicationObjectSupport
getApplicationContext, getMessageSourceAccessor, requiredContextClass, setApplicationContext
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Constructor Detail

AbstractUrlHandlerMapping

public AbstractUrlHandlerMapping()
Method Detail

setRootHandler

public void setRootHandler(Object rootHandler)
Set the root handler for this handler mapping, that is, the handler to be registered for the root path ("/").

Default is null, indicating no root handler.


getRootHandler

public Object getRootHandler()
Return the root handler for this handler mapping (registered for "/"), or null if none.


setLazyInitHandlers

public void setLazyInitHandlers(boolean lazyInitHandlers)
Set whether to lazily initialize handlers. Only applicable to singleton handlers, as prototypes are always lazily initialized. Default is "false", as eager initialization allows for more efficiency through referencing the controller objects directly.

If you want to allow your controllers to be lazily initialized, make them "lazy-init" and set this flag to true. Just making them "lazy-init" will not work, as they are initialized through the references from the handler mapping in this case.


getHandlerInternal

protected Object getHandlerInternal(HttpServletRequest request)
                             throws Exception
Look up a handler for the URL path of the given request.

Specified by:
getHandlerInternal in class AbstractHandlerMapping
Parameters:
request - current HTTP request
Returns:
the handler instance, or null if none found
Throws:
Exception - if there is an internal error

lookupHandler

protected Object lookupHandler(String urlPath,
                               HttpServletRequest request)
                        throws Exception
Look up a handler instance 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.

Looks for the most exact pattern, where most exact is defined as the longest path pattern.

Parameters:
urlPath - URL the bean is mapped to
request - current HTTP request (to expose the path within the mapping to)
Returns:
the associated handler instance, or null if not found
Throws:
Exception
See Also:
exposePathWithinMapping(java.lang.String, java.lang.String, javax.servlet.http.HttpServletRequest), AntPathMatcher

validateHandler

protected void validateHandler(Object handler,
                               HttpServletRequest request)
                        throws Exception
Validate the given handler against the current request.

The default implementation is empty. Can be overridden in subclasses, for example to enforce specific preconditions expressed in URL mappings.

Parameters:
handler - the handler object to validate
request - current HTTP request
Throws:
Exception - if validation failed

buildPathExposingHandler

protected Object buildPathExposingHandler(Object rawHandler,
                                          String bestMatchingPattern,
                                          String pathWithinMapping,
                                          Map<String,String> uriTemplateVariables)
Build a handler object for the given raw handler, exposing the actual handler, the HandlerMapping.PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE, as well as the HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE before executing the handler.

The default implementation builds a HandlerExecutionChain with a special interceptor that exposes the path attribute and uri template variables

Parameters:
rawHandler - the raw handler to expose
pathWithinMapping - the path to expose before executing the handler
uriTemplateVariables - the URI template variables, can be null if no variables found
Returns:
the final handler object

exposePathWithinMapping

protected void exposePathWithinMapping(String bestMatchingPattern,
                                       String pathWithinMapping,
                                       HttpServletRequest request)
Expose the path within the current mapping as request attribute.

Parameters:
pathWithinMapping - the path within the current mapping
request - the request to expose the path to
See Also:
HandlerMapping.PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE

exposeUriTemplateVariables

protected void exposeUriTemplateVariables(Map<String,String> uriTemplateVariables,
                                          HttpServletRequest request)
Expose the URI templates variables as request attribute.

Parameters:
uriTemplateVariables - the URI template variables
request - the request to expose the path to
See Also:
HandlerMapping.PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE

registerHandler

protected void registerHandler(String[] urlPaths,
                               String beanName)
                        throws BeansException,
                               IllegalStateException
Register the specified handler for the given URL paths.

Parameters:
urlPaths - the URLs that the bean should be mapped to
beanName - the name of the handler bean
Throws:
BeansException - if the handler couldn't be registered
IllegalStateException - if there is a conflicting handler registered

registerHandler

protected void registerHandler(String urlPath,
                               Object handler)
                        throws BeansException,
                               IllegalStateException
Register the specified handler for the given URL path.

Parameters:
urlPath - the URL the bean should be mapped to
handler - the handler instance or handler bean name String (a bean name will automatically be resolved into the corresponding handler bean)
Throws:
BeansException - if the handler couldn't be registered
IllegalStateException - if there is a conflicting handler registered

getHandlerMap

public final Map<String,Object> getHandlerMap()
Return the registered handlers as an unmodifiable Map, with the registered path as key and the handler object (or handler bean name in case of a lazy-init handler) as value.

See Also:
AbstractHandlerMapping.getDefaultHandler()

supportsTypeLevelMappings

protected boolean supportsTypeLevelMappings()
Indicates whether this handler mapping support type-level mappings. Default to false.