/**

      * Calls the {@link #registerHandlers} method in addition to the

      * superclass's initialization.

      */

     @Override

     public void initApplicationContext() throws BeansException {

         super.initApplicationContext();

         registerHandlers(this.urlMap);

     }

     /**

      * Initializes the interceptors.

      * @see #extendInterceptors(java.util.List)

      * @see #initInterceptors()

      */

     @Override

     protected void initApplicationContext() throws BeansException {

         extendInterceptors(this.interceptors);

         detectMappedInterceptors(this.mappedInterceptors);

         initInterceptors();

     }

     /**

      * Extension hook that subclasses can override to register additional interceptors,

      * given the configured interceptors (see {@link #setInterceptors}).

      * <p>Will be invoked before {@link #initInterceptors()} adapts the specified

      * interceptors into {@link HandlerInterceptor} instances.

      * <p>The default implementation is empty.

      * @param interceptors the configured interceptor List (never {@code null}),

      * allowing to add further interceptors before as well as after the existing

      * interceptors

      */

     protected void extendInterceptors(List<Object> interceptors) {

     }

     /**

      * Detects beans of type {@link MappedInterceptor} and adds them to the list of mapped interceptors.

      * This is done in addition to any {@link MappedInterceptor}s that may have been provided via

      * {@link #setInterceptors(Object[])}. Subclasses can override this method to change that.

      *

      * @param mappedInterceptors an empty list to add MappedInterceptor types to

      */

     protected void detectMappedInterceptors(List<MappedInterceptor> mappedInterceptors) {

         mappedInterceptors.addAll(

                 BeanFactoryUtils.beansOfTypeIncludingAncestors(

                         getApplicationContext(),MappedInterceptor.class, true, false).values());

     }

     /**

      * Initialize the specified interceptors, checking for {@link MappedInterceptor}s and adapting

      * HandlerInterceptors where necessary.

      * @see #setInterceptors

      * @see #adaptInterceptor

      */

     protected void initInterceptors() {

         if (!this.interceptors.isEmpty()) {

             for (int i = 0; i < this.interceptors.size(); i++) {

                 Object interceptor = this.interceptors.get(i);

                 if (interceptor == null) {

                     throw new IllegalArgumentException("Entry number " + i + " in interceptors array is null");

                 }

                 if (interceptor instanceof MappedInterceptor) {

                     mappedInterceptors.add((MappedInterceptor) interceptor);

                 }

                 else {

                     adaptedInterceptors.add(adaptInterceptor(interceptor));

                 }

             }

         }

     }

     /**

      * Adapt the given interceptor object to the HandlerInterceptor interface.

      * <p>Supported interceptor types are HandlerInterceptor and WebRequestInterceptor.

      * Each given WebRequestInterceptor will be wrapped in a WebRequestHandlerInterceptorAdapter.

      * Can be overridden in subclasses.

      * @param interceptor the specified interceptor object

      * @return the interceptor wrapped as HandlerInterceptor

      * @see org.springframework.web.servlet.HandlerInterceptor

      * @see org.springframework.web.context.request.WebRequestInterceptor

      * @see WebRequestHandlerInterceptorAdapter

      */

     protected HandlerInterceptor adaptInterceptor(Object interceptor) {

         if (interceptor instanceof HandlerInterceptor) {

             return (HandlerInterceptor) interceptor;

         }

         else if (interceptor instanceof WebRequestInterceptor) {

             return new WebRequestHandlerInterceptorAdapter((WebRequestInterceptor) interceptor);

         }

         else {

             throw new IllegalArgumentException("Interceptor type not supported: " + interceptor.getClass().getName());

         }

     }

     /**

      * Register all handlers specified in the URL map for the corresponding paths.

      * @param urlMap Map with URL paths as keys and handler beans or bean names as values

      * @throws BeansException if a handler couldn't be registered

      * @throws IllegalStateException if there is a conflicting handler registered

      */

     protected void registerHandlers(Map<String, Object> urlMap) throws BeansException {

         if (urlMap.isEmpty()) {

             logger.warn("Neither 'urlMap' nor 'mappings' set on SimpleUrlHandlerMapping");

         }

         else {

             for (Map.Entry<String, Object> entry : urlMap.entrySet()) {

                 String url = entry.getKey();

                 Object handler = entry.getValue();

                 // Prepend with slash if not already present.

                 if (!url.startsWith("/")) {

                     url = "/" + url;

                 }

                 // Remove whitespace from handler bean name.

                 if (handler instanceof String) {

                     handler = ((String) handler).trim();

                 }

                 registerHandler(url, handler);

             }

         }

     }

 /**

      * Register the specified handler for the given URL path.

      * @param urlPath the URL the bean should be mapped to

      * @param 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

      * @throws IllegalStateException if there is a conflicting handler registered

      */

     protected void registerHandler(String urlPath, Object handler) throws BeansException, IllegalStateException {

         Assert.notNull(urlPath, "URL path must not be null");

         Assert.notNull(handler, "Handler object must not be null");

         Object resolvedHandler = handler;

         // Eagerly resolve handler if referencing singleton via name.不是单例同时不是懒加载

         if (!this.lazyInitHandlers && handler instanceof String) {

             String handlerName = (String) handler;

             if (getApplicationContext().isSingleton(handlerName)) {

                 resolvedHandler = getApplicationContext().getBean(handlerName);

             }

         }

         Object mappedHandler = this.handlerMap.get(urlPath);// 获取之前已经匹配的Handler

         if (mappedHandler != null) {

             if (mappedHandler != resolvedHandler) {// 如果新匹配得到的跟之前已解析到的handler不一致,则抛异常

                 throw new IllegalStateException(

                         "Cannot map " + getHandlerDescription(handler) + " to URL path [" + urlPath +

                         "]: There is already " + getHandlerDescription(mappedHandler) + " mapped.");

             }

         }

         else {

             if (urlPath.equals("/")) {// 设置rootHandler

                 if (logger.isInfoEnabled()) {

                     logger.info("Root mapping to " + getHandlerDescription(handler));

                 }

                 setRootHandler(resolvedHandler);

             }

             else if (urlPath.equals("/*")) {// 设置默认的defaultHandler

                 if (logger.isInfoEnabled()) {

                     logger.info("Default mapping to " + getHandlerDescription(handler));

                 }

                 setDefaultHandler(resolvedHandler);

             }

             else {// 最后才是普通handler的设置

                 this.handlerMap.put(urlPath, resolvedHandler);

                 if (logger.isInfoEnabled()) {

                     logger.info("Mapped URL path [" + urlPath + "] onto " + getHandlerDescription(handler));

                 }

             }

         }

     }