Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| The Spring Framework
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## 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

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| The Spring Framework
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2002-2007 The Spring Framework.