public interface HandlerMapping {

  // ...
  // 其他常量定义

  /**
  * Return a handler and any interceptors for this request. The choice may be made
  * on request URL, session state, or any factor the implementing class chooses.
  * <p>The returned HandlerExecutionChain contains a handler Object, rather than
  * even a tag interface, so that handlers are not constrained in any way.
  * For example, a HandlerAdapter could be written to allow another framework's
  * handler objects to be used.
  * <p>Returns {@code null} if no match was found. This is not an error.
  * The DispatcherServlet will query all registered HandlerMapping beans to find
  * a match, and only decide there is an error if none can find a handler.
  * @param request current HTTP request
  * @return a HandlerExecutionChain instance containing handler object and
  * any interceptors, or {@code null} if no mapping found
  * @throws Exception if there is an internal error
  */
  HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception;

}

<beans>
    <bean id="handlerMapping"
          class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMap
        <property name="interceptors">
            <list>
                <ref bean="officeHoursInterceptor"/>
            </list>
        </property>
      <property name="interceptors">
                    <list>
                <ref bean="officeHoursInterceptor"/>
            </list>
        </property>
    </bean>
    <bean id="officeHoursInterceptor"
          class="samples.TimeBasedAccessInterceptor">
        <property name="openingTime" value="9"/>
        <property name="closingTime" value="18"/>
    </bean>
<beans>

<mvc:interceptors>
  <bean class="my.MyInterceptor"/>
  <ref bean="interceptorRef"/>
  <mvc:interceptor>
      <mvc:mapping path="/interceptor/*"/>
      <bean class="my.MyInterceptor1"/>
  </mvc:interceptor>
</mvc:interceptors>

public interface HandlerAdapter {

  /**
  * Given a handler instance, return whether or not this {@code HandlerAdapter}
  * can support it. Typical HandlerAdapters will base the decision on the handler
  * type. HandlerAdapters will usually only support one handler type each.
  * <p>A typical implementation:
  * <p>{@code
  * return (handler instanceof MyHandler);
  * }
  * @param handler handler object to check
  * @return whether or not this object can use the given handler
  */
  boolean supports(Object handler);

  /**
  * Use the given handler to handle this request.
  * The workflow that is required may vary widely.
  * @param request current HTTP request
  * @param response current HTTP response
  * @param handler handler to use. This object must have previously been passed
  * to the {@code supports} method of this interface, which must have
  * returned {@code true}.
  * @throws Exception in case of errors
  * @return ModelAndView object with the name of the view and the required
  * model data, or {@code null} if the request has been handled directly
  */
  ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception;

  /**
  * Same contract as for HttpServlet's {@code getLastModified} method.
  * Can simply return -1 if there's no support in the handler class.
  * @param request current HTTP request
  * @param handler handler to use
  * @return the lastModified value for the given handler
  * @see javax.servlet.http.HttpServlet#getLastModified
  * @see org.springframework.web.servlet.mvc.LastModified#getLastModified
  */
  long getLastModified(HttpServletRequest request, Object handler);

}

protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
  for (HandlerAdapter ha : this.handlerAdapters) {
      if (logger.isTraceEnabled()) {
          logger.trace("Testing handler adapter [" + ha + "]");
      }
      if (ha.supports(handler)) {
          return ha;
      }
  }
  throw new ServletException("No adapter for handler [" + handler +
          "]: The DispatcherServlet configuration needs to include a HandlerAdapter that supports this handler");
}

public class SimpleControllerHandlerAdapter implements HandlerAdapter {

  @Override
  public boolean supports(Object handler) {
      return (handler instanceof Controller);
  }

  @Override
  public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
          throws Exception {

      return ((Controller) handler).handleRequest(request, response);
  }

  @Override
  public long getLastModified(HttpServletRequest request, Object handler) {
      if (handler instanceof LastModified) {
          return ((LastModified) handler).getLastModified(request);
      }
      return -1L;
  }

}