Package org.springframework.util

# Class MimeType

java.lang.Object
org.springframework.util.MimeType

All Implemented Interfaces:
  `Serializable`, `Comparable<MimeType>`

public class MimeType extends Object implements Comparable<MimeType>, Serializable
Represents a MIME Type, as originally defined in RFC 2046 and subsequently used in other Internet protocols including HTTP.

This class, however, does not contain support for the q-parameters used in HTTP content negotiation. Those can be found in the subclass `org.springframework.http.MediaType` in the `spring-web` module.

Consists of a type and a subtype. Also has functionality to parse MIME Type values from a `String` using `valueOf(String)`. For more parsing options see `MimeTypeUtils`.

Since:
  4.0
Author:
  Arjen Poutsma, Juergen Hoeller, Rossen Stoyanchev, Sam Brannen
See Also:
  - `MimeTypeUtils`
  - Serialized Form

## Nested Class Summary

Nested Classes
Modifier and Type
Class
Description
`static class`
`MimeType.SpecificityComparator<T extends MimeType>`
Deprecated, for removal: This API element is subject to removal in a future version.
As of 6.0, with no direct replacement

## Field Summary

Fields
Modifier and Type
Field
Description
`protected static final String`
`WILDCARD_TYPE`

## Constructor Summary

Constructors
Modifier
Constructor
Description
``
`MimeType(String type)`
Create a new `MimeType` for the given primary type.
``
`MimeType(String type, String subtype)`
Create a new `MimeType` for the given primary type and subtype.
``
`MimeType(String type, String subtype, Charset charset)`
Create a new `MimeType` for the given type, subtype, and character set.
``
`MimeType(String type, String subtype, Map<String,String> parameters)`
Create a new `MimeType` for the given type, subtype, and parameters.
`protected`
`MimeType(MimeType other)`
Copy-constructor that copies the type, subtype and parameters of the given `MimeType`, skipping checks performed in other constructors.
``
`MimeType(MimeType other, Charset charset)`
Copy-constructor that copies the type, subtype, parameters of the given `MimeType`, and allows to set the specified character set.
``
`MimeType(MimeType other, Map<String,String> parameters)`
Copy-constructor that copies the type and subtype of the given `MimeType`, and allows for different parameter.

## Method Summary

Modifier and Type
Method
Description
`protected void`
`appendTo(StringBuilder builder)`
`protected void`
`checkParameters(String parameter, String value)`
`int`
`compareTo(MimeType other)`
Compares this MIME Type to another alphabetically.
`boolean`
`equals(Object other)`
`boolean`
`equalsTypeAndSubtype(MimeType other)`
Similar to `equals(Object)` but based on the type and subtype only, i.e.
`Charset`
`getCharset()`
Return the character set, as indicated by a `charset` parameter, if any.
`String`
`getParameter(String name)`
Return a generic parameter value, given a parameter name.
`Map<String,String>`
`getParameters()`
Return all generic parameter values.
`String`
`getSubtype()`
Return the subtype.
`String`
`getSubtypeSuffix()`
Return the subtype suffix as defined in RFC 6839.
`String`
`getType()`
Return the primary type.
`int`
`hashCode()`
`boolean`
`includes(MimeType other)`
Indicate whether this MIME Type includes the given MIME Type.
`boolean`
`isCompatibleWith(MimeType other)`
Indicate whether this MIME Type is compatible with the given MIME Type.
`boolean`
`isConcrete()`
Indicates whether this MIME Type is concrete, i.e.
`boolean`
`isLessSpecific(MimeType other)`
Indicates whether this `MimeType` is less specific than the given type.
`boolean`
`isMoreSpecific(MimeType other)`
Indicates whether this `MimeType` is more specific than the given type.
`boolean`
`isPresentIn(Collection<? extends MimeType> mimeTypes)`
Unlike `Collection.contains(Object)` which relies on `equals(Object)`, this method only checks the type and the subtype, but otherwise ignores parameters.
`boolean`
`isWildcardSubtype()`
Indicates whether the subtype is the wildcard character `*` or the wildcard character followed by a suffix (for example, `*+xml`).
`boolean`
`isWildcardType()`
Indicates whether the type is the wildcard character `*` or not.
`String`
`toString()`
`protected String`
`unquote(String s)`
`static MimeType`
`valueOf(String value)`
Parse the given String value into a `MimeType` object, with this method name following the 'valueOf' naming convention (as supported by `ConversionService`).

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

`clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

## Field Details

### WILDCARD_TYPE

protected static final String WILDCARD_TYPE

See Also:
  - Constant Field Values

## Constructor Details

### MimeType

public MimeType(String type)
Create a new `MimeType` for the given primary type.

The subtype is set to `"*"`, and the parameters are empty.

Parameters:
  `type` - the primary type
Throws:
  `IllegalArgumentException` - if any of the parameters contains illegal characters

### MimeType

public MimeType(String type, String subtype)
Create a new `MimeType` for the given primary type and subtype.

The parameters are empty.

Parameters:
  `type` - the primary type
  `subtype` - the subtype
Throws:
  `IllegalArgumentException` - if any of the parameters contains illegal characters

### MimeType

public MimeType(String type, String subtype, Charset charset)
Create a new `MimeType` for the given type, subtype, and character set.

Parameters:
  `type` - the primary type
  `subtype` - the subtype
  `charset` - the character set
Throws:
  `IllegalArgumentException` - if any of the parameters contains illegal characters

### MimeType

public MimeType(MimeType other, Charset charset)
Copy-constructor that copies the type, subtype, parameters of the given `MimeType`, and allows to set the specified character set.

Parameters:
  `other` - the other MimeType
  `charset` - the character set
Throws:
  `IllegalArgumentException` - if any of the parameters contains illegal characters
Since:
  4.3

### MimeType

public MimeType(MimeType other, @Nullable Map<String,String> parameters)
Copy-constructor that copies the type and subtype of the given `MimeType`, and allows for different parameter.

Parameters:
  `other` - the other MimeType
  `parameters` - the parameters (may be `null`)
Throws:
  `IllegalArgumentException` - if any of the parameters contains illegal characters

### MimeType

public MimeType(String type, String subtype, @Nullable Map<String,String> parameters)
Create a new `MimeType` for the given type, subtype, and parameters.

Parameters:
  `type` - the primary type
  `subtype` - the subtype
  `parameters` - the parameters (may be `null`)
Throws:
  `IllegalArgumentException` - if any of the parameters contains illegal characters

### MimeType

protected MimeType(MimeType other)
Copy-constructor that copies the type, subtype and parameters of the given `MimeType`, skipping checks performed in other constructors.

Parameters:
  `other` - the other MimeType
Since:
  5.3

## Method Details

### checkParameters

protected void checkParameters(String parameter, String value)

### unquote

protected String unquote(String s)

### isWildcardType

public boolean isWildcardType()
Indicates whether the type is the wildcard character `*` or not.

### isWildcardSubtype

public boolean isWildcardSubtype()
Indicates whether the subtype is the wildcard character `*` or the wildcard character followed by a suffix (for example, `*+xml`).

Returns:
  whether the subtype is a wildcard

### isConcrete

public boolean isConcrete()
Indicates whether this MIME Type is concrete, i.e. whether neither the type nor the subtype is a wildcard character `*`.

Returns:
  whether this MIME Type is concrete

### getType

public String getType()
Return the primary type.

### getSubtype

public String getSubtype()
Return the subtype.

### getSubtypeSuffix

@Nullable public String getSubtypeSuffix()
Return the subtype suffix as defined in RFC 6839.

Since:
  5.3

### getCharset

@Nullable public Charset getCharset()
Return the character set, as indicated by a `charset` parameter, if any.

Returns:
  the character set, or `null` if not available
Since:
  4.3

### getParameter

@Nullable public String getParameter(String name)
Return a generic parameter value, given a parameter name.

Parameters:
  `name` - the parameter name
Returns:
  the parameter value, or `null` if not present

### getParameters

public Map<String,String> getParameters()
Return all generic parameter values.

Returns:
  a read-only map (possibly empty, never `null`)

### includes

public boolean includes(@Nullable MimeType other)
Indicate whether this MIME Type includes the given MIME Type.

For instance, `text/*` includes `text/plain` and `text/html`, and `application/*+xml` includes `application/soap+xml`, etc. This method is not symmetric.

Parameters:
  `other` - the reference MIME Type with which to compare
Returns:
  `true` if this MIME Type includes the given MIME Type; `false` otherwise

### isCompatibleWith

public boolean isCompatibleWith(@Nullable MimeType other)
Indicate whether this MIME Type is compatible with the given MIME Type.

For instance, `text/*` is compatible with `text/plain`, `text/html`, and vice versa. In effect, this method is similar to `includes(org.springframework.util.MimeType)`, except that it is symmetric.

Parameters:
  `other` - the reference MIME Type with which to compare
Returns:
  `true` if this MIME Type is compatible with the given MIME Type; `false` otherwise

### equalsTypeAndSubtype

public boolean equalsTypeAndSubtype(@Nullable MimeType other)
Similar to `equals(Object)` but based on the type and subtype only, i.e. ignoring parameters.

Parameters:
  `other` - the other mime type to compare to
Returns:
  whether the two mime types have the same type and subtype
Since:
  5.1.4

### isPresentIn

public boolean isPresentIn(Collection<? extends MimeType> mimeTypes)
Unlike `Collection.contains(Object)` which relies on `equals(Object)`, this method only checks the type and the subtype, but otherwise ignores parameters.

Parameters:
  `mimeTypes` - the list of mime types to perform the check against
Returns:
  whether the list contains the given mime type
Since:
  5.1.4

### equals

public boolean equals(@Nullable Object other)

Overrides:
  `equals` in class `Object`

### hashCode

public int hashCode()

Overrides:
  `hashCode` in class `Object`

### toString

public String toString()

Overrides:
  `toString` in class `Object`

### appendTo

protected void appendTo(StringBuilder builder)

### compareTo

public int compareTo(MimeType other)
Compares this MIME Type to another alphabetically.

Specified by:
  `compareTo` in interface `Comparable<MimeType>`
Parameters:
  `other` - the MIME Type to compare to

### isMoreSpecific

public boolean isMoreSpecific(MimeType other)
Indicates whether this `MimeType` is more specific than the given type.

1. if this mime type has a wildcard type, and the other does not, then this method returns `false`.
2. if this mime type does not have a wildcard type, and the other does, then this method returns `true`.
3. if this mime type has a wildcard type, and the other does not, then this method returns `false`.
4. if this mime type does not have a wildcard type, and the other does, then this method returns `true`.
5. if the two mime types have identical type and subtype, then the mime type with the most parameters is more specific than the other.
6. Otherwise, this method returns `false`.

Parameters:
  `other` - the `MimeType` to be compared
Returns:
  the result of the comparison
Since:
  6.0
See Also:
  - `isLessSpecific(MimeType)`
  - HTTP 1.1: Semantics and Content, section 5.3.2

### isLessSpecific

public boolean isLessSpecific(MimeType other)
Indicates whether this `MimeType` is less specific than the given type.

1. if this mime type has a wildcard type, and the other does not, then this method returns `true`.
2. if this mime type does not have a wildcard type, and the other does, then this method returns `false`.
3. if this mime type has a wildcard type, and the other does not, then this method returns `true`.
4. if this mime type does not have a wildcard type, and the other does, then this method returns `false`.
5. if the two mime types have identical type and subtype, then the mime type with the least parameters is less specific than the other.
6. Otherwise, this method returns `false`.

Parameters:
  `other` - the `MimeType` to be compared
Returns:
  the result of the comparison
Since:
  6.0
See Also:
  - `isMoreSpecific(MimeType)`
  - HTTP 1.1: Semantics and Content, section 5.3.2

### valueOf

public static MimeType valueOf(String value)
Parse the given String value into a `MimeType` object, with this method name following the 'valueOf' naming convention (as supported by `ConversionService`).

See Also:
  - `MimeTypeUtils.parseMimeType(String)`