protected  void detectAndCreateHandlers(ConfigurableListableBeanFactory beanFactory) throws BeansException 
{
		try {
			Class[] handlerClasses = getClassesWithPathMapAttributes();
			if (logger.isDebugEnabled()) {
				logger.debug("Found " + handlerClasses.length + " attribute-targeted handlers");
			}
			// for each Class returned by the Commons Attribute indexer
			for (int i = 0; i <  handlerClasses.length; i++) {
				Class handlerClass = handlerClasses[i];
				// Autowire the given handler class via AutowireCapableBeanFactory.
				// Either autowires a constructor or by type, depending on the
				// constructors available in the given class.
				Object handler = beanFactory.createBean(handlerClass, this.autowireMode, this.dependencyCheck);
				// We now have an "autowired" handler, that may reference beans in the
				// application context. We now add the new handler to the factory.
				// This isn't necessary for the handler to work, but is useful if we want
				// to enumerate controllers in the factory etc.
				beanFactory.registerSingleton(handlerClass.getName(), handler);
				// There may be multiple paths mapped to this handler.
				PathMap[] pathMaps = getPathMapAttributes(handlerClass);
				registerHandler(pathMaps, handler);
			}
		}
		catch (BeansException ex) {
			throw ex;
		}
		catch (Exception ex) {
			throw new BeanInitializationException("Could not retrieve PathMap attributes", ex);
		}
}

Look for all classes with a PathMap class attribute, instantiate them in the owning ApplicationContext, and register them as MVC handlers usable by the current DispatcherServlet.

 abstract protected Class[] getClassesWithPathMapAttributes() throws Exception       Deprecated!
Use an attribute index to get a Collection of Class objects
with the required PathMap attribute.

 abstract protected PathMap[] getPathMapAttributes(Class handlerClass) throws Exception       Deprecated!
Use Attributes API to find PathMap attributes for the given handler class.
We know there's at least one, as the getClassNamesWithPathMapAttributes
method return this class name.

 public  void initApplicationContext() throws BeansException 
{
		super.initApplicationContext();
		if (!(getApplicationContext() instanceof ConfigurableApplicationContext)) {
			throw new IllegalStateException(
					"[" + getClass().getName() + "] needs to run in a ConfigurableApplicationContext");
		}
		ConfigurableListableBeanFactory beanFactory =
				((ConfigurableApplicationContext) getApplicationContext()).getBeanFactory();
		detectAndCreateHandlers(beanFactory);
}

Calls the detectAndCreateHandlers method in addition to the superclass's initialization.

 protected  void registerHandler(PathMap[] pathMaps,
    Object handler) throws IllegalStateException, BeansException 
{
		for (int j = 0; j <  pathMaps.length; j++) {
			PathMap pathMap = pathMaps[j];
			String path = pathMap.getUrl();
			if (!path.startsWith("/")) {
				path = "/" + path;
			}
			registerHandler(path, handler);
		}
}

Register the given handler for the URL paths indicated by the given PathMaps.

 public  void setAutowireMode(int autowireMode) 
{
		this.autowireMode = autowireMode;
}

Set the autowire mode for handlers. This determines whether any automagical detection and setting of bean references will happen.

Default is AUTOWIRE_AUTODETECT, which means either constructor autowiring or autowiring by type (depending on the constructors available in the class).

 public  void setAutowireModeName(String constantName) throws IllegalArgumentException 
{
	                                           	 
		setAutowireMode(constants.asNumber(constantName).intValue());
}

Set the autowire mode for handlers, by the name of the corresponding constant in the AutowireCapableBeanFactory interface, e.g. "AUTOWIRE_BY_NAME".

 public  void setDependencyCheck(boolean dependencyCheck) 
{
		this.dependencyCheck = dependencyCheck;
}

Set whether to perform a dependency check for objects on autowired handlers. Not applicable to autowiring a constructor, thus ignored there.

Default is "true".