public AbstractControllerUrlHandlerMapping() 
{
	            	 
		this.predicate = (JdkVersion.isAtLeastJava15() ?
				instantiateAnnotationPredicate() : new ControllerTypePredicate());
}

Activates detection of annotated controllers when running on JDK 1.5 or higher.

 abstract protected String[] buildUrlsForHandler(String beanName,
    Class beanClass)
Abstract template method to be implemented by subclasses.

 protected String[] determineUrlsForHandler(String beanName) 
{
		Class beanClass = getApplicationContext().getType(beanName);
		if (isEligibleForMapping(beanName, beanClass)) {
			return buildUrlsForHandler(beanName, beanClass);
		}
		else {
			return null;
		}
}

This implementation delegates to #buildUrlsForHandler , provided that #isEligibleForMapping returns true.

 protected boolean isControllerType(Class beanClass) 
{
		return this.predicate.isControllerType(beanClass);
}

Determine whether the given bean class indicates a controller type that is supported by this mapping strategy.

 protected boolean isEligibleForMapping(String beanName,
    Class beanClass) 
{
		if (beanClass == null) {
			if (logger.isDebugEnabled()) {
				logger.debug("Excluding controller bean '" + beanName + "' from class name mapping " +
						"because its bean type could not be determined");
			}
			return false;
		}
		if (this.excludedClasses.contains(beanClass)) {
			if (logger.isDebugEnabled()) {
				logger.debug("Excluding controller bean '" + beanName + "' from class name mapping " +
						"because its bean class is explicitly excluded: " + beanClass.getName());
			}
			return false;
		}
		String beanClassName = beanClass.getName();
		for (Iterator it = this.excludedPackages.iterator(); it.hasNext();) {
			String packageName = (String) it.next();
			if (beanClassName.startsWith(packageName)) {
				if (logger.isDebugEnabled()) {
					logger.debug("Excluding controller bean '" + beanName + "' from class name mapping " +
							"because its bean class is defined in an excluded package: " + beanClass.getName());
				}
				return false;
			}
		}
		return isControllerType(beanClass);
}

Determine whether the specified controller is excluded from this mapping.

 protected boolean isMultiActionControllerType(Class beanClass) 
{
		return this.predicate.isMultiActionControllerType(beanClass);
}

Determine whether the given bean class indicates a controller type that dispatches to multiple action methods.

 public  void setExcludedClasses(Class[] excludedClasses) 
{
		this.excludedClasses =
				(excludedClasses != null ? new HashSet(Arrays.asList(excludedClasses)) : Collections.EMPTY_SET);
}

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

 public  void setExcludedPackages(String[] excludedPackages) 
{
		this.excludedPackages =
				(excludedPackages != null ? new HashSet(Arrays.asList(excludedPackages)) : Collections.EMPTY_SET);
}

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 org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping , alongside this ControllerClassNameHandlerMapping for application controllers.

 public  void setIncludeAnnotatedControllers(boolean includeAnnotatedControllers) 
{
		this.predicate = (includeAnnotatedControllers ?
				instantiateAnnotationPredicate() : new ControllerTypePredicate());
}

Set whether to activate or deactivate detection of annotated controllers.

Annotated controllers will by included by default when runnong on JDK 1.5 or higher.