org.springframework.web.servlet.mvc.support
Class ControllerClassNameHandlerMapping

java.lang.Object
  org.springframework.context.support.ApplicationObjectSupport
      org.springframework.web.context.support.WebApplicationObjectSupport
          org.springframework.web.servlet.handler.AbstractHandlerMapping
              org.springframework.web.servlet.handler.AbstractUrlHandlerMapping
                  org.springframework.web.servlet.mvc.support.ControllerClassNameHandlerMapping

All Implemented Interfaces:

ApplicationContextAware, Ordered, ServletContextAware, HandlerMapping

public class ControllerClassNameHandlerMapping
extends AbstractUrlHandlerMapping
implements HandlerMapping

Implementation of HandlerMapping that follows a simple convention for generating URL path mappings from the class names of registered Controller and ThrowawayController beans.

For simple Controller implementations (those that handle a single request type), the convention is to take the short name of the Class, remove the 'Controller' suffix if it exists and return the remaining text, lowercased, as the mapping, with a leading /. For example:

• WelcomeController -> /welcome*
• HomeController -> /home*

For MultiActionControllers then a similar mapping is registered, except that all sub-paths are registed using the trailing wildcard pattern /*. For example:

• WelcomeController -> /welcome/*
• CatalogController -> /catalog/*

For MultiActionController it is often useful to use this mapping strategy in conjunction with the InternalPathMethodNameResolver.

Thanks to Warren Oliver for suggesting the "caseSensitive", "pathPrefix" and "basePackage" properties which have been added in Spring 2.5.

Since:

2.0

Author:

Rob Harrop, Juergen Hoeller

See Also:

Controller, ThrowawayController, MultiActionController

Field Summary

Fields inherited from class org.springframework.context.support.ApplicationObjectSupport

logger

Fields inherited from interface org.springframework.web.servlet.HandlerMapping

PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE

Fields inherited from interface org.springframework.core.Ordered

HIGHEST_PRECEDENCE, LOWEST_PRECEDENCE

Constructor Summary

ControllerClassNameHandlerMapping()

Method Summary

protected void	detectControllers() Detect all the Controller and ThrowawayController beans registered in the ApplicationContext and register a URL path mapping for each one based on rules defined here.
protected String	generatePathMapping(Class beanClass) Generate the actual URL path for the given controller class.
protected void	initApplicationContext() Calls the detectControllers() method in addition to the superclass's initialization.
protected boolean	isEligibleForMapping(String beanName, Class beanClass) Determine whether the specified controller is excluded from this mapping.
protected void	registerController(String beanName, Class beanClass) Register the controller with the given name, as defined in the current application context.
protected void	registerControllers(Class controllerType) Register all controllers of the given type, searching the current DispatcherServlet's ApplicationContext for matching beans.
void	setBasePackage(String basePackage) Set the base package to be used for generating path mappings, including all subpackages underneath this packages as path elements.
void	setCaseSensitive(boolean caseSensitive) Set whether to apply case sensitivity to the generated paths, e.g. turning the class name "BuyForm" into "buyForm".
void	setExcludedClasses(Class[] excludedClasses) Specify controller classes that should be excluded from this mapping.
void	setExcludedPackages(String[] excludedPackages) Specify Java packages that should be excluded from this mapping.
void	setPathPrefix(String prefixPath) Specify a prefix to prepend to the path generated from the controller name.

Methods inherited from class org.springframework.web.servlet.handler.AbstractUrlHandlerMapping

buildPathExposingHandler, exposePathWithinMapping, getHandlerInternal, getHandlerMap, getRootHandler, lookupHandler, registerHandler, registerHandler, setAlwaysUseFullPath, setLazyInitHandlers, setPathMatcher, setRootHandler, setUrlDecode, setUrlPathHelper

Methods inherited from class org.springframework.web.servlet.handler.AbstractHandlerMapping

adaptInterceptor, extendInterceptors, getAdaptedInterceptors, getDefaultHandler, getHandler, getHandlerExecutionChain, getOrder, initInterceptors, setDefaultHandler, setInterceptors, setOrder

Methods inherited from class org.springframework.web.context.support.WebApplicationObjectSupport

getServletContext, getTempDir, getWebApplicationContext, 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

Methods inherited from interface org.springframework.web.servlet.HandlerMapping

getHandler

Constructor Detail

ControllerClassNameHandlerMapping

public ControllerClassNameHandlerMapping()

Method Detail

setExcludedPackages

public void setExcludedPackages(String[] excludedPackages)

Specify Java packages that should be excluded from this mapping. Any classes in such a package (or any of its subpackages) will be ignored by this HandlerMapping.

Default is to exclude the entire "org.springframework.web.servlet.mvc" package, including its subpackages, since none of Spring's out-of-the-box Controller implementations is a reasonable candidate for this mapping strategy. Such controllers are typically handled by a separate HandlerMapping, e.g. a BeanNameUrlHandlerMapping, alongside this ControllerClassNameHandlerMapping for application controllers.

setExcludedClasses

public void setExcludedClasses(Class[] excludedClasses)

Specify controller classes that should be excluded from this mapping. Any such classes will simply be ignored by this HandlerMapping.

setCaseSensitive

public void setCaseSensitive(boolean caseSensitive)

Set whether to apply case sensitivity to the generated paths, e.g. turning the class name "BuyForm" into "buyForm".

Default is "false", using pure lower case paths, e.g. turning the class name "BuyForm" into "buyform".

setPathPrefix

public void setPathPrefix(String prefixPath)

Specify a prefix to prepend to the path generated from the controller name.

Default is a plain slash ("/"). A path like "/mymodule" can be specified in order to have controller path mappings prefixed with that path, e.g. "/mymodule/buyform" instead of "/buyform" for the class name "BuyForm".

setBasePackage

public void setBasePackage(String basePackage)

Set the base package to be used for generating path mappings, including all subpackages underneath this packages as path elements.

Default is null, using the short class name for the generated path, with the controller's package not represented in the path. Specify a base package like "com.mycompany.myapp" to include subpackages within that base package as path elements, e.g. generating the path "/mymodule/buyform" for the class name "com.mycompany.myapp.mymodule.BuyForm". Subpackage hierarchies are represented as individual path elements, e.g. "/mymodule/mysubmodule/buyform" for the class name "com.mycompany.myapp.mymodule.mysubmodule.BuyForm".

initApplicationContext

protected void initApplicationContext()

Calls the detectControllers() method in addition to the superclass's initialization.

Overrides:

initApplicationContext in class AbstractHandlerMapping

See Also:

AbstractHandlerMapping.extendInterceptors(java.util.List), AbstractHandlerMapping.initInterceptors()

detectControllers

protected void detectControllers()
                          throws BeansException

Detect all the Controller and ThrowawayController beans registered in the ApplicationContext and register a URL path mapping for each one based on rules defined here.

Throws:

BeansException - if the controllers couldn't be obtained or registered

See Also:

generatePathMapping(Class)

registerControllers

protected void registerControllers(Class controllerType)
                            throws BeansException

Register all controllers of the given type, searching the current DispatcherServlet's ApplicationContext for matching beans.

Parameters:

controllerType - the type of controller to search for

Throws:

BeansException - if the controllers couldn't be obtained or registered

isEligibleForMapping

protected boolean isEligibleForMapping(String beanName,
                                       Class beanClass)

Determine whether the specified controller is excluded from this mapping.

Parameters:

beanName - the name of the controller bean

beanClass - the concrete class of the controller bean

Returns:

whether the specified class is excluded

See Also:

setExcludedPackages(java.lang.String[]), setExcludedClasses(java.lang.Class[])

registerController

protected void registerController(String beanName,
                                  Class beanClass)
                           throws BeansException,
                                  IllegalStateException

Register the controller with the given name, as defined in the current application context.

Parameters:

beanName - the name of the controller bean

beanClass - the concrete class of the controller bean

Throws:

BeansException - if the controller couldn't be registered

IllegalStateException - if there is a conflicting handler registered

See Also:

ApplicationObjectSupport.getApplicationContext()

generatePathMapping

protected String generatePathMapping(Class beanClass)

Generate the actual URL path for the given controller class.

Subclasses may choose to customize the paths that are generated by overriding this method.

Parameters:

beanClass - the controller bean class to generate a mapping for

Returns:

the URL path mapping for the given controller