org.springframework.web.accept

## Class AbstractMappingContentNegotiationStrategy

- java.lang.Object
- - org.springframework.web.accept.MappingMediaTypeFileExtensionResolver
  - - org.springframework.web.accept.AbstractMappingContentNegotiationStrategy

- All Implemented Interfaces:
    ContentNegotiationStrategy, MediaTypeFileExtensionResolver
  Direct Known Subclasses:
    ParameterContentNegotiationStrategy, PathExtensionContentNegotiationStrategy

      public abstract class AbstractMappingContentNegotiationStrategy
      extends MappingMediaTypeFileExtensionResolver
      implements ContentNegotiationStrategy

  Base class for `ContentNegotiationStrategy` implementations with the steps to resolve a request to media types.

  First a key (e.g. "json", "pdf") must be extracted from the request (e.g. file extension, query param). The key must then be resolved to media type(s) through the base class `MappingMediaTypeFileExtensionResolver` which stores such mappings.

  The method `handleNoMatch(org.springframework.web.context.request.NativeWebRequest, java.lang.String)` allow subclasses to plug in additional ways of looking up media types (e.g. through the Java Activation framework, or `ServletContext.getMimeType(java.lang.String)`). Media types resolved via base classes are then added to the base class `MappingMediaTypeFileExtensionResolver`, i.e. cached for new lookups.

  Since:
    3.2
  Author:
    Rossen Stoyanchev

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | `logger`

    - ### Fields inherited from interface org.springframework.web.accept.ContentNegotiationStrategy

      `MEDIA_TYPE_ALL_LIST`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `AbstractMappingContentNegotiationStrategy(Map<String,MediaType> mediaTypes)` Create an instance with the given map of file extensions and media types.

  - ### Method Summary

    All Methods Instance Methods Abstract Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected abstract String` | `getMediaTypeKey(NativeWebRequest request)` Extract a key from the request to use to look up media types.
    `protected void` | `handleMatch(String key, MediaType mediaType)` Override to provide handling when a key is successfully resolved via `MappingMediaTypeFileExtensionResolver.lookupMediaType(java.lang.String)`.
    `protected MediaType` | `handleNoMatch(NativeWebRequest request, String key)` Override to provide handling when a key is not resolved via.
    `boolean` | `isIgnoreUnknownExtensions()`
    `boolean` | `isUseRegisteredExtensionsOnly()`
    `List<MediaType>` | `resolveMediaTypeKey(NativeWebRequest webRequest, String key)` An alternative to `resolveMediaTypes(NativeWebRequest)` that accepts an already extracted key.
    `List<MediaType>` | `resolveMediaTypes(NativeWebRequest webRequest)` Resolve the given request to a list of media types.
    `void` | `setIgnoreUnknownExtensions(boolean ignoreUnknownExtensions)` Whether to ignore requests with unknown file extension.
    `void` | `setUseRegisteredExtensionsOnly(boolean useRegisteredExtensionsOnly)` Whether to only use the registered mappings to look up file extensions, or also to use dynamic resolution (e.g.

    - ### Methods inherited from class org.springframework.web.accept.MappingMediaTypeFileExtensionResolver

      `addMapping, getAllFileExtensions, getAllMediaTypes, getMediaTypes, lookupMediaType, resolveFileExtensions`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### logger

          protected final Log logger

  - ### Constructor Detail

    - #### AbstractMappingContentNegotiationStrategy

          public AbstractMappingContentNegotiationStrategy(@Nullable
                                                           Map<String,MediaType> mediaTypes)

      Create an instance with the given map of file extensions and media types.

  - ### Method Detail

    - #### setUseRegisteredExtensionsOnly

          public void setUseRegisteredExtensionsOnly(boolean useRegisteredExtensionsOnly)

      Whether to only use the registered mappings to look up file extensions, or also to use dynamic resolution (e.g. via `MediaTypeFactory`.

      By default this is set to `false`.

    - #### isUseRegisteredExtensionsOnly

          public boolean isUseRegisteredExtensionsOnly()

    - #### setIgnoreUnknownExtensions

          public void setIgnoreUnknownExtensions(boolean ignoreUnknownExtensions)

      Whether to ignore requests with unknown file extension. Setting this to `false` results in `HttpMediaTypeNotAcceptableException`.

      By default this is set to false but is overridden in `PathExtensionContentNegotiationStrategy` to true.

    - #### isIgnoreUnknownExtensions

          public boolean isIgnoreUnknownExtensions()

    - #### resolveMediaTypes

          public List<MediaType> resolveMediaTypes(NativeWebRequest webRequest)
                                            throws HttpMediaTypeNotAcceptableException

      Description copied from interface: `ContentNegotiationStrategy`
      Resolve the given request to a list of media types. The returned list is ordered by specificity first and by quality parameter second.
      Specified by:
        `resolveMediaTypes` in interface `ContentNegotiationStrategy`
      Parameters:
        `webRequest` - the current request
      Returns:
        the requested media types, or `ContentNegotiationStrategy.MEDIA_TYPE_ALL_LIST` if none were requested.
      Throws:
        `HttpMediaTypeNotAcceptableException` - if the requested media types cannot be parsed

    - #### resolveMediaTypeKey

          public List<MediaType> resolveMediaTypeKey(NativeWebRequest webRequest,
                                                     @Nullable
                                                     String key)
                                              throws HttpMediaTypeNotAcceptableException

      An alternative to `resolveMediaTypes(NativeWebRequest)` that accepts an already extracted key.
      Throws:
        `HttpMediaTypeNotAcceptableException`
      Since:
        3.2.16

    - #### getMediaTypeKey

          @Nullable
          protected abstract String getMediaTypeKey(NativeWebRequest request)

      Extract a key from the request to use to look up media types.
      Returns:
        the lookup key, or `null` if none

    - #### handleMatch

          protected void handleMatch(String key,
                                     MediaType mediaType)

      Override to provide handling when a key is successfully resolved via `MappingMediaTypeFileExtensionResolver.lookupMediaType(java.lang.String)`.

    - #### handleNoMatch

          @Nullable
          protected MediaType handleNoMatch(NativeWebRequest request,
                                                      String key)
                                               throws HttpMediaTypeNotAcceptableException

      Override to provide handling when a key is not resolved via. `MappingMediaTypeFileExtensionResolver.lookupMediaType(java.lang.String)`. Subclasses can take further steps to determine the media type(s). If a MediaType is returned from this method it will be added to the cache in the base class.
      Throws:
        `HttpMediaTypeNotAcceptableException`