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 sub-classes 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 Description
protected Log logger
- Fields inherited from interface org.springframework.web.accept.ContentNegotiationStrategy
  MEDIA_TYPE_ALL_LIST

Constructor Summary
Constructors
Constructor 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	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). Sub-classes 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

Class AbstractMappingContentNegotiationStrategy

Field Summary

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

Constructor Summary

Method Summary

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

Methods inherited from class java.lang.Object

Field Detail

logger

Constructor Detail

AbstractMappingContentNegotiationStrategy

Method Detail

setUseRegisteredExtensionsOnly

isUseRegisteredExtensionsOnly

setIgnoreUnknownExtensions

isIgnoreUnknownExtensions

resolveMediaTypes

resolveMediaTypeKey

getMediaTypeKey

handleMatch

handleNoMatch