anchor.diff:    information about multipart handling.
   * An appropriate handler is searched for. If a handler is found, the execution chain
     associated with the handler (preprocessors, postprocessors, and controllers) is
  -  executed in order to prepare a model or rendering.
  +  executed in order to prepare a model or rendering. Or alternatively for annotated
  +  controllers, the response may be rendered (within the `HandlerAdapter`) instead of
  +  returning a view.
   * If a model is returned, the view is rendered. If no model is returned, (may be due to
     a preprocessor or postprocessor intercepting the request, perhaps for security
     reasons), no view is rendered, because the request could already have been fulfilled.
   
  -Handler exception resolvers that are declared in the `WebApplicationContext` pick up
  -exceptions that are thrown during processing of the request. Using these exception
  -resolvers allows you to define custom behaviors to address exceptions.
  +The `HandlerExceptionResolver` beans declared in the `WebApplicationContext` are used to
  +resolve exceptions thrown during request processing. Those exception resolvers allow
  +customizing the logic to address exceptions. See <<mvc-exceptionhandlers>> for more details.
   
   The Spring `DispatcherServlet` also supports the return of the
   __last-modification-date__, as specified by the Servlet API. The process of determining
  
positive.code: | Bean type| Explanation
  
  | <<mvc-handlermapping,HandlerMapping>>
  | Maps incoming requests to handlers and a list of pre- and post-processors (handler
    interceptors) based on some criteria the details of which vary by `HandlerMapping`
    implementation. The most popular implementation supports annotated controllers but
    other implementations exists as well.
  
  | HandlerAdapter
  | Helps the `DispatcherServlet` to invoke a handler mapped to a request regardless of
    the handler is actually invoked. For example, invoking an annotated controller
    requires resolving various annotations. Thus the main purpose of a `HandlerAdapter` is
    to shield the `DispatcherServlet` from such details.
  
  | <<mvc-exceptionhandlers,HandlerExceptionResolver>>
  | Maps exceptions to views also allowing for more complex exception handling code.
  
  | <<mvc-viewresolver,ViewResolver>>
  | Resolves logical String-based view names to actual `View` types.
  
  | <<mvc-localeresolver,LocaleResolver>> & <<mvc-timezone,LocaleContextResolver>>
  | Resolves the locale a client is using and possibly their time zone, in order to be able
    to offer internationalized views
  
  | <<mvc-themeresolver,ThemeResolver>>
  | Resolves themes your web application can use, for example, to offer personalized layouts
  
  | <<mvc-multipart,MultipartResolver>>
  | Parses multi-part requests for example to support processing file uploads from HTML
    forms.
  
  | <<mvc-flash-attributes,FlashMapManager>>
  | Stores and retrieves the "input" and the "output" `FlashMap` that can be used to pass
  
negative.code: 
  
  [[mvc-servlet-config]]
  === `DispatcherServlet` Configuration
  There are more than one ways to actually configure the `DispatcherServlet` with the special
  bean types listed in the previous section.
  
  If there are no beans of a given type in the `WebApplicationContext` by default the
  `DispatcherServlet` will refer to a list of default implementations to use in the file
  https://github.com/spring-projects/spring-framework/blob/master/spring-webmvc/src/main/resources/org/springframework/web/servlet/DispatcherServlet.properties[DispatcherServlet.properties].
  
  Applications can explicitly declare the special beans to use to take over the defaults.
  However for most applications the MVC Java config or the MVC XML namespace are the
  best starting point. Each creates the necessary Spring configuration for the
  `DispatcherServlet` and also provide a higher-level API to configure Spring MVC without
  having to understand all the details. See <<mvc-config>> for more details.
  
  [NOTE]
  ====
  Spring Boot uses the MVC Java config to configure Spring MVC and provides many
  extra options and conveniences on top.
  ====
  
  
  
  [[mvc-servlet-sequence]]
  === DispatcherServlet Processing Sequence
  The `DispatcherServlet` processes requests as follows:
  
  * The `WebApplicationContext` is searched for and bound in the request as an attribute
    that the controller and other elements in the process can use. It is bound by default
  