diff --git a/spring-core/src/main/java/org/springframework/util/InvalidMimeTypeException.java b/spring-core/src/main/java/org/springframework/util/InvalidMimeTypeException.java new file mode 100644 index 00000000000..f616b99fbf8 --- /dev/null +++ b/spring-core/src/main/java/org/springframework/util/InvalidMimeTypeException.java @@ -0,0 +1,52 @@ +/* + * Copyright 2002-2013 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.springframework.util; + +/** + * Exception thrown from {@link MediaType#parseMimeType(String)} in case of + * encountering an invalid content type specification String. + * + * @author Juergen Hoeller + * @author Rossen Stoyanchev + * @since 4.0 + */ +@SuppressWarnings("serial") +public class InvalidMimeTypeException extends IllegalArgumentException { + + private String mimeType; + + + /** + * Create a new InvalidContentTypeException for the given content type. + * @param mimeType the offending media type + * @param message a detail message indicating the invalid part + */ + public InvalidMimeTypeException(String mimeType, String message) { + super("Invalid mime type \"" + mimeType + "\": " + message); + this.mimeType = mimeType; + + } + + + /** + * Return the offending content type. + */ + public String getMimeType() { + return this.mimeType; + } + +} diff --git a/spring-core/src/main/java/org/springframework/util/MimeType.java b/spring-core/src/main/java/org/springframework/util/MimeType.java new file mode 100644 index 00000000000..4b6652598a5 --- /dev/null +++ b/spring-core/src/main/java/org/springframework/util/MimeType.java @@ -0,0 +1,502 @@ +/* + * Copyright 2002-2013 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.springframework.util; + +import java.nio.charset.Charset; +import java.util.BitSet; +import java.util.Collections; +import java.util.Comparator; +import java.util.Iterator; +import java.util.List; +import java.util.Locale; +import java.util.Map; +import java.util.TreeSet; + + +/** + * 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 + * the q-parameters used in HTTP content negotiation. Those can be found in the sub-class + * {@code org.springframework.http.MediaType} in the {@code spring-web} module. + *

+ * Consists of a {@linkplain #getType() type} and a {@linkplain #getSubtype() subtype}. + * Also has functionality to parse media types from a string using + * {@link #parseMimeType(String)}, or multiple comma-separated media types using + * {@link #parseMimeTypes(String)}. + * + * @author Arjen Poutsma + * @author Juergen Hoeller + * @author Rossen Stoyanchev + * @since 4.0 + * + * @see MimeTypeUtils + */ +public class MimeType implements Comparable { + + protected static final String WILDCARD_TYPE = "*"; + + private static final BitSet TOKEN; + + private static final String PARAM_CHARSET = "charset"; + + + private final String type; + + private final String subtype; + + private final Map parameters; + + + static { + // variable names refer to RFC 2616, section 2.2 + BitSet ctl = new BitSet(128); + for (int i=0; i <= 31; i++) { + ctl.set(i); + } + ctl.set(127); + + BitSet separators = new BitSet(128); + separators.set('('); + separators.set(')'); + separators.set('<'); + separators.set('>'); + separators.set('@'); + separators.set(','); + separators.set(';'); + separators.set(':'); + separators.set('\\'); + separators.set('\"'); + separators.set('/'); + separators.set('['); + separators.set(']'); + separators.set('?'); + separators.set('='); + separators.set('{'); + separators.set('}'); + separators.set(' '); + separators.set('\t'); + + TOKEN = new BitSet(128); + TOKEN.set(0, 128); + TOKEN.andNot(ctl); + TOKEN.andNot(separators); + } + + + /** + * Create a new {@code MimeType} for the given primary type. + *

The {@linkplain #getSubtype() subtype} is set to "*", parameters empty. + * @param type the primary type + * @throws IllegalArgumentException if any of the parameters contain illegal characters + */ + public MimeType(String type) { + this(type, WILDCARD_TYPE); + } + + /** + * Create a new {@code MimeType} for the given primary type and subtype. + *

The parameters are empty. + * @param type the primary type + * @param subtype the subtype + * @throws IllegalArgumentException if any of the parameters contain illegal characters + */ + public MimeType(String type, String subtype) { + this(type, subtype, Collections.emptyMap()); + } + + /** + * Create a new {@code MimeType} for the given type, subtype, and character set. + * @param type the primary type + * @param subtype the subtype + * @param charSet the character set + * @throws IllegalArgumentException if any of the parameters contain illegal characters + */ + public MimeType(String type, String subtype, Charset charSet) { + this(type, subtype, Collections.singletonMap(PARAM_CHARSET, charSet.name())); + } + + /** + * Copy-constructor that copies the type and subtype of the given {@code MimeType}, + * and allows for different parameter. + * @param other the other media type + * @param parameters the parameters, may be {@code null} + * @throws IllegalArgumentException if any of the parameters contain illegal characters + */ + public MimeType(MimeType other, Map parameters) { + this(other.getType(), other.getSubtype(), parameters); + } + + /** + * Create a new {@code MimeType} for the given type, subtype, and parameters. + * @param type the primary type + * @param subtype the subtype + * @param parameters the parameters, may be {@code null} + * @throws IllegalArgumentException if any of the parameters contain illegal characters + */ + public MimeType(String type, String subtype, Map parameters) { + Assert.hasLength(type, "type must not be empty"); + Assert.hasLength(subtype, "subtype must not be empty"); + checkToken(type); + checkToken(subtype); + this.type = type.toLowerCase(Locale.ENGLISH); + this.subtype = subtype.toLowerCase(Locale.ENGLISH); + if (!CollectionUtils.isEmpty(parameters)) { + Map m = new LinkedCaseInsensitiveMap(parameters.size(), Locale.ENGLISH); + for (Map.Entry entry : parameters.entrySet()) { + String attribute = entry.getKey(); + String value = entry.getValue(); + checkParameters(attribute, value); + m.put(attribute, value); + } + this.parameters = Collections.unmodifiableMap(m); + } + else { + this.parameters = Collections.emptyMap(); + } + } + + /** + * Checks the given token string for illegal characters, as defined in RFC 2616, section 2.2. + * @throws IllegalArgumentException in case of illegal characters + * @see HTTP 1.1, section 2.2 + */ + private void checkToken(String token) { + for (int i=0; i < token.length(); i++ ) { + char ch = token.charAt(i); + if (!TOKEN.get(ch)) { + throw new IllegalArgumentException("Invalid token character '" + ch + "' in token \"" + token + "\""); + } + } + } + + protected void checkParameters(String attribute, String value) { + Assert.hasLength(attribute, "parameter attribute must not be empty"); + Assert.hasLength(value, "parameter value must not be empty"); + checkToken(attribute); + if (PARAM_CHARSET.equals(attribute)) { + value = unquote(value); + Charset.forName(value); + } + else if (!isQuotedString(value)) { + checkToken(value); + } + } + + private boolean isQuotedString(String s) { + if (s.length() < 2) { + return false; + } + else { + return ((s.startsWith("\"") && s.endsWith("\"")) || (s.startsWith("'") && s.endsWith("'"))); + } + } + + protected String unquote(String s) { + if (s == null) { + return null; + } + return isQuotedString(s) ? s.substring(1, s.length() - 1) : s; + } + + /** + * Indicates whether the {@linkplain #getType() type} is the wildcard character {@code *} or not. + */ + public boolean isWildcardType() { + return WILDCARD_TYPE.equals(getType()); + } + + /** + * Indicates whether the {@linkplain #getSubtype() subtype} is the wildcard character {@code *} + * or the wildcard character followed by a sufiix (e.g. {@code *+xml}), or not. + * @return whether the subtype is {@code *} + */ + public boolean isWildcardSubtype() { + return WILDCARD_TYPE.equals(getSubtype()) || getSubtype().startsWith("*+"); + } + + /** + * Indicates whether this media type is concrete, i.e. whether neither the type or subtype is a wildcard + * character {@code *}. + * @return whether this media type is concrete + */ + public boolean isConcrete() { + return !isWildcardType() && !isWildcardSubtype(); + } + + /** + * Return the primary type. + */ + public String getType() { + return this.type; + } + + /** + * Return the subtype. + */ + public String getSubtype() { + return this.subtype; + } + + /** + * Return the character set, as indicated by a {@code charset} parameter, if any. + * @return the character set; or {@code null} if not available + */ + public Charset getCharSet() { + String charSet = getParameter(PARAM_CHARSET); + return (charSet != null ? Charset.forName(unquote(charSet)) : null); + } + + /** + * Return a generic parameter value, given a parameter name. + * @param name the parameter name + * @return the parameter value; or {@code null} if not present + */ + public String getParameter(String name) { + return this.parameters.get(name); + } + + /** + * Return all generic parameter values. + * @return a read-only map, possibly empty, never {@code null} + */ + public Map getParameters() { + return parameters; + } + + /** + * Indicate whether this {@code MediaType} includes the given media type. + *

For instance, {@code text/*} includes {@code text/plain} and {@code text/html}, and {@code application/*+xml} + * includes {@code application/soap+xml}, etc. This method is not symmetric. + * @param other the reference media type with which to compare + * @return {@code true} if this media type includes the given media type; {@code false} otherwise + */ + public boolean includes(MimeType other) { + if (other == null) { + return false; + } + if (this.isWildcardType()) { + // */* includes anything + return true; + } + else if (getType().equals(other.getType())) { + if (getSubtype().equals(other.getSubtype())) { + return true; + } + if (this.isWildcardSubtype()) { + // wildcard with suffix, e.g. application/*+xml + int thisPlusIdx = getSubtype().indexOf('+'); + if (thisPlusIdx == -1) { + return true; + } + else { + // application/*+xml includes application/soap+xml + int otherPlusIdx = other.getSubtype().indexOf('+'); + if (otherPlusIdx != -1) { + String thisSubtypeNoSuffix = getSubtype().substring(0, thisPlusIdx); + String thisSubtypeSuffix = getSubtype().substring(thisPlusIdx + 1); + String otherSubtypeSuffix = other.getSubtype().substring(otherPlusIdx + 1); + if (thisSubtypeSuffix.equals(otherSubtypeSuffix) && WILDCARD_TYPE.equals(thisSubtypeNoSuffix)) { + return true; + } + } + } + } + } + return false; + } + + /** + * Indicate whether this {@code MediaType} is compatible with the given media type. + *

For instance, {@code text/*} is compatible with {@code text/plain}, {@code text/html}, and vice versa. + * In effect, this method is similar to {@link #includes(MediaType)}, except that it is symmetric. + * @param other the reference media type with which to compare + * @return {@code true} if this media type is compatible with the given media type; {@code false} otherwise + */ + public boolean isCompatibleWith(MimeType other) { + if (other == null) { + return false; + } + if (isWildcardType() || other.isWildcardType()) { + return true; + } + else if (getType().equals(other.getType())) { + if (getSubtype().equals(other.getSubtype())) { + return true; + } + // wildcard with suffix? e.g. application/*+xml + if (this.isWildcardSubtype() || other.isWildcardSubtype()) { + + int thisPlusIdx = getSubtype().indexOf('+'); + int otherPlusIdx = other.getSubtype().indexOf('+'); + + if (thisPlusIdx == -1 && otherPlusIdx == -1) { + return true; + } + else if (thisPlusIdx != -1 && otherPlusIdx != -1) { + String thisSubtypeNoSuffix = getSubtype().substring(0, thisPlusIdx); + String otherSubtypeNoSuffix = other.getSubtype().substring(0, otherPlusIdx); + + String thisSubtypeSuffix = getSubtype().substring(thisPlusIdx + 1); + String otherSubtypeSuffix = other.getSubtype().substring(otherPlusIdx + 1); + + if (thisSubtypeSuffix.equals(otherSubtypeSuffix) && + (WILDCARD_TYPE.equals(thisSubtypeNoSuffix) || WILDCARD_TYPE.equals(otherSubtypeNoSuffix))) { + return true; + } + } + } + } + return false; + } + + /** + * Compares this {@code MediaType} to another alphabetically. + * @param other media type to compare to + * @see #sortBySpecificity(List) + */ + @Override + public int compareTo(MimeType other) { + int comp = getType().compareToIgnoreCase(other.getType()); + if (comp != 0) { + return comp; + } + comp = getSubtype().compareToIgnoreCase(other.getSubtype()); + if (comp != 0) { + return comp; + } + comp = getParameters().size() - other.getParameters().size(); + if (comp != 0) { + return comp; + } + TreeSet thisAttributes = new TreeSet(String.CASE_INSENSITIVE_ORDER); + thisAttributes.addAll(getParameters().keySet()); + TreeSet otherAttributes = new TreeSet(String.CASE_INSENSITIVE_ORDER); + otherAttributes.addAll(other.getParameters().keySet()); + Iterator thisAttributesIterator = thisAttributes.iterator(); + Iterator otherAttributesIterator = otherAttributes.iterator(); + while (thisAttributesIterator.hasNext()) { + String thisAttribute = thisAttributesIterator.next(); + String otherAttribute = otherAttributesIterator.next(); + comp = thisAttribute.compareToIgnoreCase(otherAttribute); + if (comp != 0) { + return comp; + } + String thisValue = getParameters().get(thisAttribute); + String otherValue = other.getParameters().get(otherAttribute); + if (otherValue == null) { + otherValue = ""; + } + comp = thisValue.compareTo(otherValue); + if (comp != 0) { + return comp; + } + } + return 0; + } + + @Override + public boolean equals(Object other) { + if (this == other) { + return true; + } + if (!(other instanceof MimeType)) { + return false; + } + MimeType otherType = (MimeType) other; + return (this.type.equalsIgnoreCase(otherType.type) && this.subtype.equalsIgnoreCase(otherType.subtype) && + this.parameters.equals(otherType.parameters)); + } + + @Override + public int hashCode() { + int result = this.type.hashCode(); + result = 31 * result + this.subtype.hashCode(); + result = 31 * result + this.parameters.hashCode(); + return result; + } + + @Override + public String toString() { + StringBuilder builder = new StringBuilder(); + appendTo(builder); + return builder.toString(); + } + + protected void appendTo(StringBuilder builder) { + builder.append(this.type); + builder.append('/'); + builder.append(this.subtype); + appendTo(this.parameters, builder); + } + + private void appendTo(Map map, StringBuilder builder) { + for (Map.Entry entry : map.entrySet()) { + builder.append(';'); + builder.append(entry.getKey()); + builder.append('='); + builder.append(entry.getValue()); + } + } + + /** + * Parse the given String value into a {@code MimeType} object, + * with this method name following the 'valueOf' naming convention + * (as supported by {@link org.springframework.core.convert.ConversionService}. + * @see #parseMimeType(String) + */ + public static MimeType valueOf(String value) { + return MimeTypeUtils.parseMimeType(value); + } + + + public static class SpecificityComparator implements Comparator { + + @Override + public int compare(T mimeType1, T mimeType2) { + if (mimeType1.isWildcardType() && !mimeType2.isWildcardType()) { // */* < audio/* + return 1; + } + else if (mimeType2.isWildcardType() && !mimeType1.isWildcardType()) { // audio/* > */* + return -1; + } + else if (!mimeType1.getType().equals(mimeType2.getType())) { // audio/basic == text/html + return 0; + } + else { // mediaType1.getType().equals(mediaType2.getType()) + if (mimeType1.isWildcardSubtype() && !mimeType2.isWildcardSubtype()) { // audio/* < audio/basic + return 1; + } + else if (mimeType2.isWildcardSubtype() && !mimeType1.isWildcardSubtype()) { // audio/basic > audio/* + return -1; + } + else if (!mimeType1.getSubtype().equals(mimeType2.getSubtype())) { // audio/basic == audio/wave + return 0; + } + else { // mediaType2.getSubtype().equals(mediaType2.getSubtype()) + return compareParameters(mimeType1, mimeType2); + } + } + } + + protected int compareParameters(T mimeType1, T mimeType2) { + int paramsSize1 = mimeType1.getParameters().size(); + int paramsSize2 = mimeType2.getParameters().size(); + return (paramsSize2 < paramsSize1 ? -1 : (paramsSize2 == paramsSize1 ? 0 : 1)); // audio/basic;level=1 < audio/basic + } + } + +} diff --git a/spring-core/src/main/java/org/springframework/util/MimeTypeUtils.java b/spring-core/src/main/java/org/springframework/util/MimeTypeUtils.java new file mode 100644 index 00000000000..a57d59cb699 --- /dev/null +++ b/spring-core/src/main/java/org/springframework/util/MimeTypeUtils.java @@ -0,0 +1,332 @@ +/* + * Copyright 2002-2013 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.springframework.util; + +import java.nio.charset.UnsupportedCharsetException; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.Comparator; +import java.util.Iterator; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; + +import org.springframework.util.MimeType.SpecificityComparator; + + + +/** + * + * @author Arjen Poutsma + * @author Rossen Stoyanchev + * @since 4.0 + */ +public class MimeTypeUtils { + + /** + * Public constant mime type that includes all media ranges (i.e. "*/*"). + */ + public static final MimeType ALL; + + /** + * A String equivalent of {@link MediaType#ALL}. + */ + public static final String ALL_VALUE = "*/*"; + + /** + * Public constant mime type for {@code application/atom+xml}. + */ + public final static MimeType APPLICATION_ATOM_XML; + + /** + * A String equivalent of {@link MimeType#APPLICATION_ATOM_XML}. + */ + public final static String APPLICATION_ATOM_XML_VALUE = "application/atom+xml"; + + /** + * Public constant mime type for {@code application/x-www-form-urlencoded}. + * */ + public final static MimeType APPLICATION_FORM_URLENCODED; + + /** + * A String equivalent of {@link MimeType#APPLICATION_FORM_URLENCODED}. + */ + public final static String APPLICATION_FORM_URLENCODED_VALUE = "application/x-www-form-urlencoded"; + + /** + * Public constant mime type for {@code application/json}. + * */ + public final static MimeType APPLICATION_JSON; + + /** + * A String equivalent of {@link MimeType#APPLICATION_JSON}. + */ + public final static String APPLICATION_JSON_VALUE = "application/json"; + + /** + * Public constant mime type for {@code application/octet-stream}. + * */ + public final static MimeType APPLICATION_OCTET_STREAM; + + /** + * A String equivalent of {@link MimeType#APPLICATION_OCTET_STREAM}. + */ + public final static String APPLICATION_OCTET_STREAM_VALUE = "application/octet-stream"; + + /** + * Public constant mime type for {@code application/xhtml+xml}. + * */ + public final static MimeType APPLICATION_XHTML_XML; + + /** + * A String equivalent of {@link MimeType#APPLICATION_XHTML_XML}. + */ + public final static String APPLICATION_XHTML_XML_VALUE = "application/xhtml+xml"; + + /** + * Public constant mime type for {@code application/xml}. + */ + public final static MimeType APPLICATION_XML; + + /** + * A String equivalent of {@link MimeType#APPLICATION_XML}. + */ + public final static String APPLICATION_XML_VALUE = "application/xml"; + + /** + * Public constant mime type for {@code image/gif}. + */ + public final static MimeType IMAGE_GIF; + + /** + * A String equivalent of {@link MimeType#IMAGE_GIF}. + */ + public final static String IMAGE_GIF_VALUE = "image/gif"; + + /** + * Public constant mime type for {@code image/jpeg}. + */ + public final static MimeType IMAGE_JPEG; + + /** + * A String equivalent of {@link MimeType#IMAGE_JPEG}. + */ + public final static String IMAGE_JPEG_VALUE = "image/jpeg"; + + /** + * Public constant mime type for {@code image/png}. + */ + public final static MimeType IMAGE_PNG; + + /** + * A String equivalent of {@link MimeType#IMAGE_PNG}. + */ + public final static String IMAGE_PNG_VALUE = "image/png"; + + /** + * Public constant mime type for {@code multipart/form-data}. + * */ + public final static MimeType MULTIPART_FORM_DATA; + + /** + * A String equivalent of {@link MimeType#MULTIPART_FORM_DATA}. + */ + public final static String MULTIPART_FORM_DATA_VALUE = "multipart/form-data"; + + /** + * Public constant mime type for {@code text/html}. + * */ + public final static MimeType TEXT_HTML; + + /** + * A String equivalent of {@link MimeType#TEXT_HTML}. + */ + public final static String TEXT_HTML_VALUE = "text/html"; + + /** + * Public constant mime type for {@code text/plain}. + * */ + public final static MimeType TEXT_PLAIN; + + /** + * A String equivalent of {@link MimeType#TEXT_PLAIN}. + */ + public final static String TEXT_PLAIN_VALUE = "text/plain"; + + /** + * Public constant mime type for {@code text/xml}. + * */ + public final static MimeType TEXT_XML; + + /** + * A String equivalent of {@link MimeType#TEXT_XML}. + */ + public final static String TEXT_XML_VALUE = "text/xml"; + + + static { + ALL = MimeType.valueOf(ALL_VALUE); + APPLICATION_ATOM_XML = MimeType.valueOf(APPLICATION_ATOM_XML_VALUE); + APPLICATION_FORM_URLENCODED = MimeType.valueOf(APPLICATION_FORM_URLENCODED_VALUE); + APPLICATION_JSON = MimeType.valueOf(APPLICATION_JSON_VALUE); + APPLICATION_OCTET_STREAM = MimeType.valueOf(APPLICATION_OCTET_STREAM_VALUE); + APPLICATION_XHTML_XML = MimeType.valueOf(APPLICATION_XHTML_XML_VALUE); + APPLICATION_XML = MimeType.valueOf(APPLICATION_XML_VALUE); + IMAGE_GIF = MimeType.valueOf(IMAGE_GIF_VALUE); + IMAGE_JPEG = MimeType.valueOf(IMAGE_JPEG_VALUE); + IMAGE_PNG = MimeType.valueOf(IMAGE_PNG_VALUE); + MULTIPART_FORM_DATA = MimeType.valueOf(MULTIPART_FORM_DATA_VALUE); + TEXT_HTML = MimeType.valueOf(TEXT_HTML_VALUE); + TEXT_PLAIN = MimeType.valueOf(TEXT_PLAIN_VALUE); + TEXT_XML = MimeType.valueOf(TEXT_XML_VALUE); + } + + + /** + * Parse the given String into a single {@code MimeType}. + * @param mimeType the string to parse + * @return the mime type + * @throws InvalidMimeTypeException if the string cannot be parsed + */ + public static MimeType parseMimeType(String mimeType) { + if (!StringUtils.hasLength(mimeType)) { + throw new InvalidMimeTypeException(mimeType, "'mimeType' must not be empty"); + } + String[] parts = StringUtils.tokenizeToStringArray(mimeType, ";"); + + String fullType = parts[0].trim(); + // java.net.HttpURLConnection returns a *; q=.2 Accept header + if (MimeType.WILDCARD_TYPE.equals(fullType)) { + fullType = "*/*"; + } + int subIndex = fullType.indexOf('/'); + if (subIndex == -1) { + throw new InvalidMimeTypeException(mimeType, "does not contain '/'"); + } + if (subIndex == fullType.length() - 1) { + throw new InvalidMimeTypeException(mimeType, "does not contain subtype after '/'"); + } + String type = fullType.substring(0, subIndex); + String subtype = fullType.substring(subIndex + 1, fullType.length()); + if (MimeType.WILDCARD_TYPE.equals(type) && !MimeType.WILDCARD_TYPE.equals(subtype)) { + throw new InvalidMimeTypeException(mimeType, "wildcard type is legal only in '*/*' (all mime types)"); + } + + Map parameters = null; + if (parts.length > 1) { + parameters = new LinkedHashMap(parts.length - 1); + for (int i = 1; i < parts.length; i++) { + String parameter = parts[i]; + int eqIndex = parameter.indexOf('='); + if (eqIndex != -1) { + String attribute = parameter.substring(0, eqIndex); + String value = parameter.substring(eqIndex + 1, parameter.length()); + parameters.put(attribute, value); + } + } + } + + try { + return new MimeType(type, subtype, parameters); + } + catch (UnsupportedCharsetException ex) { + throw new InvalidMimeTypeException(mimeType, "unsupported charset '" + ex.getCharsetName() + "'"); + } + catch (IllegalArgumentException ex) { + throw new InvalidMimeTypeException(mimeType, ex.getMessage()); + } + } + + /** + * Parse the given, comma-separated string into a list of {@code MimeType} objects. + * @param mimeTypes the string to parse + * @return the list of mime types + * @throws IllegalArgumentException if the string cannot be parsed + */ + public static List parseMimeTypes(String mimeTypes) { + if (!StringUtils.hasLength(mimeTypes)) { + return Collections.emptyList(); + } + String[] tokens = mimeTypes.split(",\\s*"); + List result = new ArrayList(tokens.length); + for (String token : tokens) { + result.add(parseMimeType(token)); + } + return result; + } + + /** + * Return a string representation of the given list of {@code MimeType} objects. + * @param mimeTypes the string to parse + * @return the list of mime types + * @throws IllegalArgumentException if the String cannot be parsed + */ + public static String toString(Collection mimeTypes) { + StringBuilder builder = new StringBuilder(); + for (Iterator iterator = mimeTypes.iterator(); iterator.hasNext();) { + MimeType mimeType = iterator.next(); + mimeType.appendTo(builder); + if (iterator.hasNext()) { + builder.append(", "); + } + } + return builder.toString(); + } + + + /** + * Sorts the given list of {@code MimeType} objects by specificity. + *

+ * Given two mime types: + *

    + *
  1. if either mime type has a {@linkplain #isWildcardType() wildcard type}, then + * the mime type without the wildcard is ordered before the other.
    2. + *
  2. if the two mime types have different {@linkplain #getType() types}, then + * they are considered equal and remain their current order.
    3. + *
  3. if either mime type has a {@linkplain #isWildcardSubtype() wildcard subtype} + * , then the mime type without the wildcard is sorted before the other.
    4. + *
  4. if the two mime types have different {@linkplain #getSubtype() subtypes}, + * then they are considered equal and remain their current order.
    5. + *
  5. if the two mime types have a different amount of + * {@linkplain #getParameter(String) parameters}, then the mime type with the most + * parameters is ordered before the other.
    6. + *
+ *

+ * For example:

audio/basic < audio/* < */*
+ *
audio/basic;level=1 < audio/basic
+ *
audio/basic == text/html
audio/basic == + * audio/wave
+ * + * @param mimeTypes the list of mime types to be sorted + * @see HTTP 1.1, section + * 14.1 + */ + public static void sortBySpecificity(List mimeTypes) { + Assert.notNull(mimeTypes, "'mimeTypes' must not be null"); + if (mimeTypes.size() > 1) { + Collections.sort(mimeTypes, SPECIFICITY_COMPARATOR); + } + } + + + /** + * Comparator used by {@link #sortBySpecificity(List)}. + */ + public static final Comparator SPECIFICITY_COMPARATOR = new SpecificityComparator(); + +} diff --git a/spring-core/src/test/java/org/springframework/util/MimeTypeTests.java b/spring-core/src/test/java/org/springframework/util/MimeTypeTests.java new file mode 100644 index 00000000000..f8d767a1978 --- /dev/null +++ b/spring-core/src/test/java/org/springframework/util/MimeTypeTests.java @@ -0,0 +1,299 @@ +/* + * Copyright 2002-2013 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.springframework.util; + +import java.nio.charset.Charset; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.Random; + +import org.junit.Test; +import org.springframework.core.convert.ConversionService; +import org.springframework.core.convert.support.DefaultConversionService; + +import static org.junit.Assert.*; + + +/** + * @author Arjen Poutsma + * @author Juergen Hoeller + */ +public class MimeTypeTests { + + + @Test(expected = IllegalArgumentException.class) + public void slashInSubtype() { + new MimeType("text", "/"); + } + + @Test(expected = InvalidMimeTypeException.class) + public void valueOfNoSubtype() { + MimeType.valueOf("audio"); + } + + @Test(expected = InvalidMimeTypeException.class) + public void valueOfNoSubtypeSlash() { + MimeType.valueOf("audio/"); + } + + @Test(expected = InvalidMimeTypeException.class) + public void valueOfIllegalType() { + MimeType.valueOf("audio(/basic"); + } + + @Test(expected = InvalidMimeTypeException.class) + public void valueOfIllegalSubtype() { + MimeType.valueOf("audio/basic)"); + } + + @Test(expected = InvalidMimeTypeException.class) + public void valueOfIllegalCharset() { + MimeType.valueOf("text/html; charset=foo-bar"); + } + + @Test + public void parseCharset() throws Exception { + String s = "text/html; charset=iso-8859-1"; + MimeType mimeType = MimeType.valueOf(s); + assertEquals("Invalid type", "text", mimeType.getType()); + assertEquals("Invalid subtype", "html", mimeType.getSubtype()); + assertEquals("Invalid charset", Charset.forName("ISO-8859-1"), mimeType.getCharSet()); + } + + @Test + public void parseQuotedCharset() { + String s = "application/xml;charset=\"utf-8\""; + MimeType mimeType = MimeType.valueOf(s); + assertEquals("Invalid type", "application", mimeType.getType()); + assertEquals("Invalid subtype", "xml", mimeType.getSubtype()); + assertEquals("Invalid charset", Charset.forName("UTF-8"), mimeType.getCharSet()); + } + + @Test + public void testWithConversionService() { + ConversionService conversionService = new DefaultConversionService(); + assertTrue(conversionService.canConvert(String.class, MimeType.class)); + MimeType mimeType = MimeType.valueOf("application/xml"); + assertEquals(mimeType, conversionService.convert("application/xml", MimeType.class)); + } + + @Test + public void includes() throws Exception { + MimeType textPlain = MimeTypeUtils.TEXT_PLAIN; + assertTrue("Equal types is not inclusive", textPlain.includes(textPlain)); + MimeType allText = new MimeType("text"); + + assertTrue("All subtypes is not inclusive", allText.includes(textPlain)); + assertFalse("All subtypes is inclusive", textPlain.includes(allText)); + + assertTrue("All types is not inclusive", MimeTypeUtils.ALL.includes(textPlain)); + assertFalse("All types is inclusive", textPlain.includes(MimeTypeUtils.ALL)); + + assertTrue("All types is not inclusive", MimeTypeUtils.ALL.includes(textPlain)); + assertFalse("All types is inclusive", textPlain.includes(MimeTypeUtils.ALL)); + + MimeType applicationSoapXml = new MimeType("application", "soap+xml"); + MimeType applicationWildcardXml = new MimeType("application", "*+xml"); + + assertTrue(applicationSoapXml.includes(applicationSoapXml)); + assertTrue(applicationWildcardXml.includes(applicationWildcardXml)); + + assertTrue(applicationWildcardXml.includes(applicationSoapXml)); + assertFalse(applicationSoapXml.includes(applicationWildcardXml)); + + assertFalse(applicationWildcardXml.includes(MimeTypeUtils.APPLICATION_JSON)); + } + + @Test + public void isCompatible() throws Exception { + MimeType textPlain = MimeTypeUtils.TEXT_PLAIN; + assertTrue("Equal types is not compatible", textPlain.isCompatibleWith(textPlain)); + MimeType allText = new MimeType("text"); + + assertTrue("All subtypes is not compatible", allText.isCompatibleWith(textPlain)); + assertTrue("All subtypes is not compatible", textPlain.isCompatibleWith(allText)); + + assertTrue("All types is not compatible", MimeTypeUtils.ALL.isCompatibleWith(textPlain)); + assertTrue("All types is not compatible", textPlain.isCompatibleWith(MimeTypeUtils.ALL)); + + assertTrue("All types is not compatible", MimeTypeUtils.ALL.isCompatibleWith(textPlain)); + assertTrue("All types is compatible", textPlain.isCompatibleWith(MimeTypeUtils.ALL)); + + MimeType applicationSoapXml = new MimeType("application", "soap+xml"); + MimeType applicationWildcardXml = new MimeType("application", "*+xml"); + + assertTrue(applicationSoapXml.isCompatibleWith(applicationSoapXml)); + assertTrue(applicationWildcardXml.isCompatibleWith(applicationWildcardXml)); + + assertTrue(applicationWildcardXml.isCompatibleWith(applicationSoapXml)); + assertTrue(applicationSoapXml.isCompatibleWith(applicationWildcardXml)); + + assertFalse(applicationWildcardXml.isCompatibleWith(MimeTypeUtils.APPLICATION_JSON)); + } + + @Test + public void testToString() throws Exception { + MimeType mimeType = new MimeType("text", "plain"); + String result = mimeType.toString(); + assertEquals("Invalid toString() returned", "text/plain", result); + } + + @Test + public void parseMimeType() throws Exception { + String s = "audio/*"; + MimeType mimeType = MimeTypeUtils.parseMimeType(s); + assertEquals("Invalid type", "audio", mimeType.getType()); + assertEquals("Invalid subtype", "*", mimeType.getSubtype()); + } + + @Test(expected = InvalidMimeTypeException.class) + public void parseMimeTypeNoSubtype() { + MimeTypeUtils.parseMimeType("audio"); + } + + @Test(expected = InvalidMimeTypeException.class) + public void parseMimeTypeNoSubtypeSlash() { + MimeTypeUtils.parseMimeType("audio/"); + } + + @Test(expected = InvalidMimeTypeException.class) + public void parseMimeTypeTypeRange() { + MimeTypeUtils.parseMimeType("*/json"); + } + + @Test(expected = InvalidMimeTypeException.class) + public void parseMimeTypeIllegalType() { + MimeTypeUtils.parseMimeType("audio(/basic"); + } + + @Test(expected = InvalidMimeTypeException.class) + public void parseMimeTypeIllegalSubtype() { + MimeTypeUtils.parseMimeType("audio/basic)"); + } + + @Test(expected = InvalidMimeTypeException.class) + public void parseMimeTypeEmptyParameterAttribute() { + MimeTypeUtils.parseMimeType("audio/*;=value"); + } + + @Test(expected = InvalidMimeTypeException.class) + public void parseMimeTypeEmptyParameterValue() { + MimeTypeUtils.parseMimeType("audio/*;attr="); + } + + @Test(expected = InvalidMimeTypeException.class) + public void parseMimeTypeIllegalParameterAttribute() { + MimeTypeUtils.parseMimeType("audio/*;attr<=value"); + } + + @Test(expected = InvalidMimeTypeException.class) + public void parseMimeTypeIllegalParameterValue() { + MimeTypeUtils.parseMimeType("audio/*;attr=v>alue"); + } + + @Test(expected = InvalidMimeTypeException.class) + public void parseMimeTypeIllegalCharset() { + MimeTypeUtils.parseMimeType("text/html; charset=foo-bar"); + } + + // SPR-8917 + + @Test + public void parseMimeTypeQuotedParameterValue() { + MimeType mimeType = MimeTypeUtils.parseMimeType("audio/*;attr=\"v>alue\""); + assertEquals("\"v>alue\"", mimeType.getParameter("attr")); + } + + // SPR-8917 + + @Test + public void parseMimeTypeSingleQuotedParameterValue() { + MimeType mimeType = MimeTypeUtils.parseMimeType("audio/*;attr='v>alue'"); + assertEquals("'v>alue'", mimeType.getParameter("attr")); + } + + @Test(expected = InvalidMimeTypeException.class) + public void parseMimeTypeIllegalQuotedParameterValue() { + MimeTypeUtils.parseMimeType("audio/*;attr=\""); + } + + @Test + public void parseMimeTypes() throws Exception { + String s = "text/plain, text/html, text/x-dvi, text/x-c"; + List mimeTypes = MimeTypeUtils.parseMimeTypes(s); + assertNotNull("No mime types returned", mimeTypes); + assertEquals("Invalid amount of mime types", 4, mimeTypes.size()); + + mimeTypes = MimeTypeUtils.parseMimeTypes(null); + assertNotNull("No mime types returned", mimeTypes); + assertEquals("Invalid amount of mime types", 0, mimeTypes.size()); + } + + @Test + public void compareTo() { + MimeType audioBasic = new MimeType("audio", "basic"); + MimeType audio = new MimeType("audio"); + MimeType audioWave = new MimeType("audio", "wave"); + MimeType audioBasicLevel = new MimeType("audio", "basic", Collections.singletonMap("level", "1")); + + // equal + assertEquals("Invalid comparison result", 0, audioBasic.compareTo(audioBasic)); + assertEquals("Invalid comparison result", 0, audio.compareTo(audio)); + assertEquals("Invalid comparison result", 0, audioBasicLevel.compareTo(audioBasicLevel)); + + assertTrue("Invalid comparison result", audioBasicLevel.compareTo(audio) > 0); + + List expected = new ArrayList(); + expected.add(audio); + expected.add(audioBasic); + expected.add(audioBasicLevel); + expected.add(audioWave); + + List result = new ArrayList(expected); + Random rnd = new Random(); + // shuffle & sort 10 times + for (int i = 0; i < 10; i++) { + Collections.shuffle(result, rnd); + Collections.sort(result); + + for (int j = 0; j < result.size(); j++) { + assertSame("Invalid media type at " + j + ", run " + i, expected.get(j), result.get(j)); + } + } + } + + @Test + public void compareToCaseSensitivity() { + MimeType m1 = new MimeType("audio", "basic"); + MimeType m2 = new MimeType("Audio", "Basic"); + assertEquals("Invalid comparison result", 0, m1.compareTo(m2)); + assertEquals("Invalid comparison result", 0, m2.compareTo(m1)); + + m1 = new MimeType("audio", "basic", Collections.singletonMap("foo", "bar")); + m2 = new MimeType("audio", "basic", Collections.singletonMap("Foo", "bar")); + assertEquals("Invalid comparison result", 0, m1.compareTo(m2)); + assertEquals("Invalid comparison result", 0, m2.compareTo(m1)); + + m1 = new MimeType("audio", "basic", Collections.singletonMap("foo", "bar")); + m2 = new MimeType("audio", "basic", Collections.singletonMap("foo", "Bar")); + assertTrue("Invalid comparison result", m1.compareTo(m2) != 0); + assertTrue("Invalid comparison result", m2.compareTo(m1) != 0); + } + + +} diff --git a/spring-web/src/main/java/org/springframework/http/InvalidMediaTypeException.java b/spring-web/src/main/java/org/springframework/http/InvalidMediaTypeException.java index 358c9c8226a..e62f2377fb0 100644 --- a/spring-web/src/main/java/org/springframework/http/InvalidMediaTypeException.java +++ b/spring-web/src/main/java/org/springframework/http/InvalidMediaTypeException.java @@ -16,6 +16,8 @@ package org.springframework.http; +import org.springframework.util.InvalidMimeTypeException; + /** * Exception thrown from {@link MediaType#parseMediaType(String)} in case of * encountering an invalid media type specification String. @@ -32,12 +34,19 @@ public class InvalidMediaTypeException extends IllegalArgumentException { /** * Create a new InvalidMediaTypeException for the given media type. * @param mediaType the offending media type - * @param msg a detail message indicating the invalid part + * @param message a detail message indicating the invalid part */ - public InvalidMediaTypeException(String mediaType, String msg) { - super("Invalid media type \"" + mediaType + "\": " + msg); + public InvalidMediaTypeException(String mediaType, String message) { + super("Invalid media type \"" + mediaType + "\": " + message); this.mediaType = mediaType; + } + /** + * Constructor that allows wrapping {@link InvalidMimeTypeException}. + */ + InvalidMediaTypeException(InvalidMimeTypeException ex) { + super(ex.getMessage(), ex); + this.mediaType = ex.getMimeType(); } diff --git a/spring-web/src/main/java/org/springframework/http/MediaType.java b/spring-web/src/main/java/org/springframework/http/MediaType.java index 222db739de7..4e1c8d3826a 100644 --- a/spring-web/src/main/java/org/springframework/http/MediaType.java +++ b/spring-web/src/main/java/org/springframework/http/MediaType.java @@ -17,31 +17,24 @@ package org.springframework.http; import java.nio.charset.Charset; -import java.nio.charset.UnsupportedCharsetException; import java.util.ArrayList; -import java.util.BitSet; import java.util.Collection; import java.util.Collections; import java.util.Comparator; -import java.util.Iterator; import java.util.LinkedHashMap; import java.util.List; -import java.util.Locale; import java.util.Map; -import java.util.TreeSet; import org.springframework.util.Assert; -import org.springframework.util.CollectionUtils; -import org.springframework.util.LinkedCaseInsensitiveMap; +import org.springframework.util.InvalidMimeTypeException; +import org.springframework.util.MimeType; +import org.springframework.util.MimeTypeUtils; import org.springframework.util.StringUtils; import org.springframework.util.comparator.CompoundComparator; /** - * Represents an Internet Media Type, as defined in the HTTP specification. - * - *

Consists of a {@linkplain #getType() type} and a {@linkplain #getSubtype() subtype}. - * Also has functionality to parse media types from a string using {@link #parseMediaType(String)}, - * or multiple comma-separated media types using {@link #parseMediaTypes(String)}. + * A sub-class of {@link MimeType} that adds support for quality parameters as defined + * in the HTTP specification. * * @author Arjen Poutsma * @author Juergen Hoeller @@ -49,10 +42,10 @@ import org.springframework.util.comparator.CompoundComparator; * @since 3.0 * @see HTTP 1.1, section 3.7 */ -public class MediaType implements Comparable { +public class MediaType extends MimeType { /** - * Public constant media type that includes all media ranges (i.e. {@code */*}). + * Public constant media type that includes all media ranges (i.e. "*/*"). */ public static final MediaType ALL; @@ -192,81 +185,35 @@ public class MediaType implements Comparable { public final static String TEXT_XML_VALUE = "text/xml"; - private static final BitSet TOKEN; - - private static final String WILDCARD_TYPE = "*"; - private static final String PARAM_QUALITY_FACTOR = "q"; - private static final String PARAM_CHARSET = "charset"; - - - private final String type; - - private final String subtype; - - private final Map parameters; - static { - // variable names refer to RFC 2616, section 2.2 - BitSet ctl = new BitSet(128); - for (int i=0; i <= 31; i++) { - ctl.set(i); - } - ctl.set(127); - - BitSet separators = new BitSet(128); - separators.set('('); - separators.set(')'); - separators.set('<'); - separators.set('>'); - separators.set('@'); - separators.set(','); - separators.set(';'); - separators.set(':'); - separators.set('\\'); - separators.set('\"'); - separators.set('/'); - separators.set('['); - separators.set(']'); - separators.set('?'); - separators.set('='); - separators.set('{'); - separators.set('}'); - separators.set(' '); - separators.set('\t'); - - TOKEN = new BitSet(128); - TOKEN.set(0, 128); - TOKEN.andNot(ctl); - TOKEN.andNot(separators); - - ALL = MediaType.valueOf(ALL_VALUE); - APPLICATION_ATOM_XML = MediaType.valueOf(APPLICATION_ATOM_XML_VALUE); - APPLICATION_FORM_URLENCODED = MediaType.valueOf(APPLICATION_FORM_URLENCODED_VALUE); - APPLICATION_JSON = MediaType.valueOf(APPLICATION_JSON_VALUE); - APPLICATION_OCTET_STREAM = MediaType.valueOf(APPLICATION_OCTET_STREAM_VALUE); - APPLICATION_XHTML_XML = MediaType.valueOf(APPLICATION_XHTML_XML_VALUE); - APPLICATION_XML = MediaType.valueOf(APPLICATION_XML_VALUE); - IMAGE_GIF = MediaType.valueOf(IMAGE_GIF_VALUE); - IMAGE_JPEG = MediaType.valueOf(IMAGE_JPEG_VALUE); - IMAGE_PNG = MediaType.valueOf(IMAGE_PNG_VALUE); - MULTIPART_FORM_DATA = MediaType.valueOf(MULTIPART_FORM_DATA_VALUE); - TEXT_HTML = MediaType.valueOf(TEXT_HTML_VALUE); - TEXT_PLAIN = MediaType.valueOf(TEXT_PLAIN_VALUE); - TEXT_XML = MediaType.valueOf(TEXT_XML_VALUE); + ALL = valueOf(ALL_VALUE); + APPLICATION_ATOM_XML = valueOf(APPLICATION_ATOM_XML_VALUE); + APPLICATION_FORM_URLENCODED = valueOf(APPLICATION_FORM_URLENCODED_VALUE); + APPLICATION_JSON = valueOf(APPLICATION_JSON_VALUE); + APPLICATION_OCTET_STREAM = valueOf(APPLICATION_OCTET_STREAM_VALUE); + APPLICATION_XHTML_XML = valueOf(APPLICATION_XHTML_XML_VALUE); + APPLICATION_XML = valueOf(APPLICATION_XML_VALUE); + IMAGE_GIF = valueOf(IMAGE_GIF_VALUE); + IMAGE_JPEG = valueOf(IMAGE_JPEG_VALUE); + IMAGE_PNG = valueOf(IMAGE_PNG_VALUE); + MULTIPART_FORM_DATA = valueOf(MULTIPART_FORM_DATA_VALUE); + TEXT_HTML = valueOf(TEXT_HTML_VALUE); + TEXT_PLAIN = valueOf(TEXT_PLAIN_VALUE); + TEXT_XML = valueOf(TEXT_XML_VALUE); } /** * Create a new {@code MediaType} for the given primary type. - *

The {@linkplain #getSubtype() subtype} is set to {@code *}, parameters empty. + *

The {@linkplain #getSubtype() subtype} is set to "*", parameters empty. * @param type the primary type * @throws IllegalArgumentException if any of the parameters contain illegal characters */ public MediaType(String type) { - this(type, WILDCARD_TYPE); + super(type); } /** @@ -277,7 +224,7 @@ public class MediaType implements Comparable { * @throws IllegalArgumentException if any of the parameters contain illegal characters */ public MediaType(String type, String subtype) { - this(type, subtype, Collections.emptyMap()); + super(type, subtype, Collections.emptyMap()); } /** @@ -288,7 +235,7 @@ public class MediaType implements Comparable { * @throws IllegalArgumentException if any of the parameters contain illegal characters */ public MediaType(String type, String subtype, Charset charSet) { - this(type, subtype, Collections.singletonMap(PARAM_CHARSET, charSet.name())); + super(type, subtype, charSet); } /** @@ -311,7 +258,7 @@ public class MediaType implements Comparable { * @throws IllegalArgumentException if any of the parameters contain illegal characters */ public MediaType(MediaType other, Map parameters) { - this(other.getType(), other.getSubtype(), parameters); + super(other.getType(), other.getSubtype(), parameters); } /** @@ -322,122 +269,17 @@ public class MediaType implements Comparable { * @throws IllegalArgumentException if any of the parameters contain illegal characters */ public MediaType(String type, String subtype, Map parameters) { - Assert.hasLength(type, "type must not be empty"); - Assert.hasLength(subtype, "subtype must not be empty"); - checkToken(type); - checkToken(subtype); - this.type = type.toLowerCase(Locale.ENGLISH); - this.subtype = subtype.toLowerCase(Locale.ENGLISH); - if (!CollectionUtils.isEmpty(parameters)) { - Map m = new LinkedCaseInsensitiveMap(parameters.size(), Locale.ENGLISH); - for (Map.Entry entry : parameters.entrySet()) { - String attribute = entry.getKey(); - String value = entry.getValue(); - checkParameters(attribute, value); - m.put(attribute, value); - } - this.parameters = Collections.unmodifiableMap(m); - } - else { - this.parameters = Collections.emptyMap(); - } + super(type, subtype, parameters); } - /** - * Checks the given token string for illegal characters, as defined in RFC 2616, section 2.2. - * @throws IllegalArgumentException in case of illegal characters - * @see HTTP 1.1, section 2.2 - */ - private void checkToken(String token) { - for (int i=0; i < token.length(); i++ ) { - char ch = token.charAt(i); - if (!TOKEN.get(ch)) { - throw new IllegalArgumentException("Invalid token character '" + ch + "' in token \"" + token + "\""); - } - } - } - - private void checkParameters(String attribute, String value) { - Assert.hasLength(attribute, "parameter attribute must not be empty"); - Assert.hasLength(value, "parameter value must not be empty"); - checkToken(attribute); + protected void checkParameters(String attribute, String value) { + super.checkParameters(attribute, value); if (PARAM_QUALITY_FACTOR.equals(attribute)) { value = unquote(value); double d = Double.parseDouble(value); Assert.isTrue(d >= 0D && d <= 1D, "Invalid quality value \"" + value + "\": should be between 0.0 and 1.0"); } - else if (PARAM_CHARSET.equals(attribute)) { - value = unquote(value); - Charset.forName(value); - } - else if (!isQuotedString(value)) { - checkToken(value); - } - } - - private boolean isQuotedString(String s) { - if (s.length() < 2) { - return false; - } - else { - return ((s.startsWith("\"") && s.endsWith("\"")) || (s.startsWith("'") && s.endsWith("'"))); - } - } - - private String unquote(String s) { - if (s == null) { - return null; - } - return isQuotedString(s) ? s.substring(1, s.length() - 1) : s; - } - - /** - * Return the primary type. - */ - public String getType() { - return this.type; - } - - /** - * Indicates whether the {@linkplain #getType() type} is the wildcard character {@code *} or not. - */ - public boolean isWildcardType() { - return WILDCARD_TYPE.equals(this.type); - } - - /** - * Return the subtype. - */ - public String getSubtype() { - return this.subtype; - } - - /** - * Indicates whether the {@linkplain #getSubtype() subtype} is the wildcard character {@code *} - * or the wildcard character followed by a sufiix (e.g. {@code *+xml}), or not. - * @return whether the subtype is {@code *} - */ - public boolean isWildcardSubtype() { - return WILDCARD_TYPE.equals(this.subtype) || this.subtype.startsWith("*+"); - } - - /** - * Indicates whether this media type is concrete, i.e. whether neither the type or subtype is a wildcard - * character {@code *}. - * @return whether this media type is concrete - */ - public boolean isConcrete() { - return !isWildcardType() && !isWildcardSubtype(); - } - - /** - * Return the character set, as indicated by a {@code charset} parameter, if any. - * @return the character set; or {@code null} if not available - */ - public Charset getCharSet() { - String charSet = getParameter(PARAM_CHARSET); - return (charSet != null ? Charset.forName(unquote(charSet)) : null); } /** @@ -450,119 +292,16 @@ public class MediaType implements Comparable { return (qualityFactory != null ? Double.parseDouble(unquote(qualityFactory)) : 1D); } - /** - * Return a generic parameter value, given a parameter name. - * @param name the parameter name - * @return the parameter value; or {@code null} if not present - */ - public String getParameter(String name) { - return this.parameters.get(name); - } - - /** - * Return all generic parameter values. - * @return a read-only map, possibly empty, never {@code null} - */ - public Map getParameters() { - return parameters; - } - - /** - * Indicate whether this {@code MediaType} includes the given media type. - *

For instance, {@code text/*} includes {@code text/plain} and {@code text/html}, and {@code application/*+xml} - * includes {@code application/soap+xml}, etc. This method is not symmetric. - * @param other the reference media type with which to compare - * @return {@code true} if this media type includes the given media type; {@code false} otherwise - */ - public boolean includes(MediaType other) { - if (other == null) { - return false; - } - if (this.isWildcardType()) { - // */* includes anything - return true; - } - else if (this.type.equals(other.type)) { - if (this.subtype.equals(other.subtype)) { - return true; - } - if (this.isWildcardSubtype()) { - // wildcard with suffix, e.g. application/*+xml - int thisPlusIdx = this.subtype.indexOf('+'); - if (thisPlusIdx == -1) { - return true; - } - else { - // application/*+xml includes application/soap+xml - int otherPlusIdx = other.subtype.indexOf('+'); - if (otherPlusIdx != -1) { - String thisSubtypeNoSuffix = this.subtype.substring(0, thisPlusIdx); - String thisSubtypeSuffix = this.subtype.substring(thisPlusIdx + 1); - String otherSubtypeSuffix = other.subtype.substring(otherPlusIdx + 1); - if (thisSubtypeSuffix.equals(otherSubtypeSuffix) && WILDCARD_TYPE.equals(thisSubtypeNoSuffix)) { - return true; - } - } - } - } - } - return false; - } - - /** - * Indicate whether this {@code MediaType} is compatible with the given media type. - *

For instance, {@code text/*} is compatible with {@code text/plain}, {@code text/html}, and vice versa. - * In effect, this method is similar to {@link #includes(MediaType)}, except that it is symmetric. - * @param other the reference media type with which to compare - * @return {@code true} if this media type is compatible with the given media type; {@code false} otherwise - */ - public boolean isCompatibleWith(MediaType other) { - if (other == null) { - return false; - } - if (isWildcardType() || other.isWildcardType()) { - return true; - } - else if (this.type.equals(other.type)) { - if (this.subtype.equals(other.subtype)) { - return true; - } - // wildcard with suffix? e.g. application/*+xml - if (this.isWildcardSubtype() || other.isWildcardSubtype()) { - - int thisPlusIdx = this.subtype.indexOf('+'); - int otherPlusIdx = other.subtype.indexOf('+'); - - if (thisPlusIdx == -1 && otherPlusIdx == -1) { - return true; - } - else if (thisPlusIdx != -1 && otherPlusIdx != -1) { - String thisSubtypeNoSuffix = this.subtype.substring(0, thisPlusIdx); - String otherSubtypeNoSuffix = other.subtype.substring(0, otherPlusIdx); - - String thisSubtypeSuffix = this.subtype.substring(thisPlusIdx + 1); - String otherSubtypeSuffix = other.subtype.substring(otherPlusIdx + 1); - - if (thisSubtypeSuffix.equals(otherSubtypeSuffix) && - (WILDCARD_TYPE.equals(thisSubtypeNoSuffix) || WILDCARD_TYPE.equals(otherSubtypeNoSuffix))) { - return true; - } - } - } - } - return false; - } - /** * Return a replica of this instance with the quality value of the given MediaType. * @return the same instance if the given MediaType doesn't have a quality value, or a new one otherwise */ public MediaType copyQualityValue(MediaType mediaType) { - if (!mediaType.parameters.containsKey(PARAM_QUALITY_FACTOR)) { + if (!mediaType.getParameters().containsKey(PARAM_QUALITY_FACTOR)) { return this; } - Map params = new LinkedHashMap(this.parameters); - params.put(PARAM_QUALITY_FACTOR, mediaType.parameters.get(PARAM_QUALITY_FACTOR)); + Map params = new LinkedHashMap(getParameters()); + params.put(PARAM_QUALITY_FACTOR, mediaType.getParameters().get(PARAM_QUALITY_FACTOR)); return new MediaType(this, params); } @@ -571,104 +310,14 @@ public class MediaType implements Comparable { * @return the same instance if the media type doesn't contain a quality value, or a new one otherwise */ public MediaType removeQualityValue() { - if (!this.parameters.containsKey(PARAM_QUALITY_FACTOR)) { + if (!getParameters().containsKey(PARAM_QUALITY_FACTOR)) { return this; } - Map params = new LinkedHashMap(this.parameters); + Map params = new LinkedHashMap(getParameters()); params.remove(PARAM_QUALITY_FACTOR); return new MediaType(this, params); } - /** - * Compares this {@code MediaType} to another alphabetically. - * @param other media type to compare to - * @see #sortBySpecificity(List) - */ - @Override - public int compareTo(MediaType other) { - int comp = this.type.compareToIgnoreCase(other.type); - if (comp != 0) { - return comp; - } - comp = this.subtype.compareToIgnoreCase(other.subtype); - if (comp != 0) { - return comp; - } - comp = this.parameters.size() - other.parameters.size(); - if (comp != 0) { - return comp; - } - TreeSet thisAttributes = new TreeSet(String.CASE_INSENSITIVE_ORDER); - thisAttributes.addAll(this.parameters.keySet()); - TreeSet otherAttributes = new TreeSet(String.CASE_INSENSITIVE_ORDER); - otherAttributes.addAll(other.parameters.keySet()); - Iterator thisAttributesIterator = thisAttributes.iterator(); - Iterator otherAttributesIterator = otherAttributes.iterator(); - while (thisAttributesIterator.hasNext()) { - String thisAttribute = thisAttributesIterator.next(); - String otherAttribute = otherAttributesIterator.next(); - comp = thisAttribute.compareToIgnoreCase(otherAttribute); - if (comp != 0) { - return comp; - } - String thisValue = this.parameters.get(thisAttribute); - String otherValue = other.parameters.get(otherAttribute); - if (otherValue == null) { - otherValue = ""; - } - comp = thisValue.compareTo(otherValue); - if (comp != 0) { - return comp; - } - } - return 0; - } - - @Override - public boolean equals(Object other) { - if (this == other) { - return true; - } - if (!(other instanceof MediaType)) { - return false; - } - MediaType otherType = (MediaType) other; - return (this.type.equalsIgnoreCase(otherType.type) && this.subtype.equalsIgnoreCase(otherType.subtype) && - this.parameters.equals(otherType.parameters)); - } - - @Override - public int hashCode() { - int result = this.type.hashCode(); - result = 31 * result + this.subtype.hashCode(); - result = 31 * result + this.parameters.hashCode(); - return result; - } - - @Override - public String toString() { - StringBuilder builder = new StringBuilder(); - appendTo(builder); - return builder.toString(); - } - - private void appendTo(StringBuilder builder) { - builder.append(this.type); - builder.append('/'); - builder.append(this.subtype); - appendTo(this.parameters, builder); - } - - private void appendTo(Map map, StringBuilder builder) { - for (Map.Entry entry : map.entrySet()) { - builder.append(';'); - builder.append(entry.getKey()); - builder.append('='); - builder.append(entry.getValue()); - } - } - - /** * Parse the given String value into a {@code MediaType} object, * with this method name following the 'valueOf' naming convention @@ -686,48 +335,17 @@ public class MediaType implements Comparable { * @throws InvalidMediaTypeException if the string cannot be parsed */ public static MediaType parseMediaType(String mediaType) { - if (!StringUtils.hasLength(mediaType)) { - throw new InvalidMediaTypeException(mediaType, "'mediaType' must not be empty"); - } - String[] parts = StringUtils.tokenizeToStringArray(mediaType, ";"); - String fullType = parts[0].trim(); - // java.net.HttpURLConnection returns a *; q=.2 Accept header - if (WILDCARD_TYPE.equals(fullType)) { - fullType = "*/*"; + MimeType type; + try { + type = MimeTypeUtils.parseMimeType(mediaType); } - int subIndex = fullType.indexOf('/'); - if (subIndex == -1) { - throw new InvalidMediaTypeException(mediaType, "does not contain '/'"); - } - if (subIndex == fullType.length() - 1) { - throw new InvalidMediaTypeException(mediaType, "does not contain subtype after '/'"); - } - String type = fullType.substring(0, subIndex); - String subtype = fullType.substring(subIndex + 1, fullType.length()); - if (WILDCARD_TYPE.equals(type) && !WILDCARD_TYPE.equals(subtype)) { - throw new InvalidMediaTypeException(mediaType, "wildcard type is legal only in '*/*' (all media types)"); - } - - Map parameters = null; - if (parts.length > 1) { - parameters = new LinkedHashMap(parts.length - 1); - for (int i = 1; i < parts.length; i++) { - String parameter = parts[i]; - int eqIndex = parameter.indexOf('='); - if (eqIndex != -1) { - String attribute = parameter.substring(0, eqIndex); - String value = parameter.substring(eqIndex + 1, parameter.length()); - parameters.put(attribute, value); - } - } + catch (InvalidMimeTypeException ex) { + throw new InvalidMediaTypeException(ex); } try { - return new MediaType(type, subtype, parameters); - } - catch (UnsupportedCharsetException ex) { - throw new InvalidMediaTypeException(mediaType, "unsupported charset '" + ex.getCharsetName() + "'"); + return new MediaType(type.getType(), type.getSubtype(), type.getParameters()); } catch (IllegalArgumentException ex) { throw new InvalidMediaTypeException(mediaType, ex.getMessage()); @@ -762,15 +380,7 @@ public class MediaType implements Comparable { * @throws IllegalArgumentException if the String cannot be parsed */ public static String toString(Collection mediaTypes) { - StringBuilder builder = new StringBuilder(); - for (Iterator iterator = mediaTypes.iterator(); iterator.hasNext();) { - MediaType mediaType = iterator.next(); - mediaType.appendTo(builder); - if (iterator.hasNext()) { - builder.append(", "); - } - } - return builder.toString(); + return MimeTypeUtils.toString(mediaTypes); } /** @@ -848,50 +458,6 @@ public class MediaType implements Comparable { } - /** - * Comparator used by {@link #sortBySpecificity(List)}. - */ - public static final Comparator SPECIFICITY_COMPARATOR = new Comparator() { - - @Override - public int compare(MediaType mediaType1, MediaType mediaType2) { - if (mediaType1.isWildcardType() && !mediaType2.isWildcardType()) { // */* < audio/* - return 1; - } - else if (mediaType2.isWildcardType() && !mediaType1.isWildcardType()) { // audio/* > */* - return -1; - } - else if (!mediaType1.getType().equals(mediaType2.getType())) { // audio/basic == text/html - return 0; - } - else { // mediaType1.getType().equals(mediaType2.getType()) - if (mediaType1.isWildcardSubtype() && !mediaType2.isWildcardSubtype()) { // audio/* < audio/basic - return 1; - } - else if (mediaType2.isWildcardSubtype() && !mediaType1.isWildcardSubtype()) { // audio/basic > audio/* - return -1; - } - else if (!mediaType1.getSubtype().equals(mediaType2.getSubtype())) { // audio/basic == audio/wave - return 0; - } - else { // mediaType2.getSubtype().equals(mediaType2.getSubtype()) - double quality1 = mediaType1.getQualityValue(); - double quality2 = mediaType2.getQualityValue(); - int qualityComparison = Double.compare(quality2, quality1); - if (qualityComparison != 0) { - return qualityComparison; // audio/*;q=0.7 < audio/*;q=0.3 - } - else { - int paramsSize1 = mediaType1.parameters.size(); - int paramsSize2 = mediaType2.parameters.size(); - return (paramsSize2 < paramsSize1 ? -1 : (paramsSize2 == paramsSize1 ? 0 : 1)); // audio/basic;level=1 < audio/basic - } - } - } - } - }; - - /** * Comparator used by {@link #sortByQualityValue(List)}. */ @@ -925,12 +491,29 @@ public class MediaType implements Comparable { return 0; } else { - int paramsSize1 = mediaType1.parameters.size(); - int paramsSize2 = mediaType2.parameters.size(); + int paramsSize1 = mediaType1.getParameters().size(); + int paramsSize2 = mediaType2.getParameters().size(); return (paramsSize2 < paramsSize1 ? -1 : (paramsSize2 == paramsSize1 ? 0 : 1)); // audio/basic;level=1 < audio/basic } } } }; + /** + * Comparator used by {@link #sortBySpecificity(List)}. + */ + public static final Comparator SPECIFICITY_COMPARATOR = new SpecificityComparator() { + + @Override + protected int compareParameters(MediaType mediaType1, MediaType mediaType2) { + double quality1 = mediaType1.getQualityValue(); + double quality2 = mediaType2.getQualityValue(); + int qualityComparison = Double.compare(quality2, quality1); + if (qualityComparison != 0) { + return qualityComparison; // audio/*;q=0.7 < audio/*;q=0.3 + } + return super.compareParameters(mediaType1, mediaType2); + } + }; + } diff --git a/spring-web/src/main/java/org/springframework/web/accept/HeaderContentNegotiationStrategy.java b/spring-web/src/main/java/org/springframework/web/accept/HeaderContentNegotiationStrategy.java index 1cfcd67e5db..7ed825846e8 100644 --- a/spring-web/src/main/java/org/springframework/web/accept/HeaderContentNegotiationStrategy.java +++ b/spring-web/src/main/java/org/springframework/web/accept/HeaderContentNegotiationStrategy.java @@ -19,6 +19,7 @@ package org.springframework.web.accept; import java.util.Collections; import java.util.List; +import org.springframework.http.InvalidMediaTypeException; import org.springframework.http.MediaType; import org.springframework.util.StringUtils; import org.springframework.web.HttpMediaTypeNotAcceptableException; @@ -48,7 +49,7 @@ public class HeaderContentNegotiationStrategy implements ContentNegotiationStrat return mediaTypes; } } - catch (IllegalArgumentException ex) { + catch (InvalidMediaTypeException ex) { throw new HttpMediaTypeNotAcceptableException( "Could not parse accept header [" + acceptHeader + "]: " + ex.getMessage()); } diff --git a/spring-web/src/test/java/org/springframework/http/MediaTypeTests.java b/spring-web/src/test/java/org/springframework/http/MediaTypeTests.java index d5657d199e7..a69ff8c46d5 100644 --- a/spring-web/src/test/java/org/springframework/http/MediaTypeTests.java +++ b/spring-web/src/test/java/org/springframework/http/MediaTypeTests.java @@ -16,7 +16,6 @@ package org.springframework.http; -import java.nio.charset.Charset; import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; @@ -24,7 +23,6 @@ import java.util.List; import java.util.Random; import org.junit.Test; - import org.springframework.core.convert.ConversionService; import org.springframework.core.convert.support.DefaultConversionService; @@ -36,60 +34,6 @@ import static org.junit.Assert.*; */ public class MediaTypeTests { - @Test - public void includes() throws Exception { - MediaType textPlain = MediaType.TEXT_PLAIN; - assertTrue("Equal types is not inclusive", textPlain.includes(textPlain)); - MediaType allText = new MediaType("text"); - - assertTrue("All subtypes is not inclusive", allText.includes(textPlain)); - assertFalse("All subtypes is inclusive", textPlain.includes(allText)); - - assertTrue("All types is not inclusive", MediaType.ALL.includes(textPlain)); - assertFalse("All types is inclusive", textPlain.includes(MediaType.ALL)); - - assertTrue("All types is not inclusive", MediaType.ALL.includes(textPlain)); - assertFalse("All types is inclusive", textPlain.includes(MediaType.ALL)); - - MediaType applicationSoapXml = new MediaType("application", "soap+xml"); - MediaType applicationWildcardXml = new MediaType("application", "*+xml"); - - assertTrue(applicationSoapXml.includes(applicationSoapXml)); - assertTrue(applicationWildcardXml.includes(applicationWildcardXml)); - - assertTrue(applicationWildcardXml.includes(applicationSoapXml)); - assertFalse(applicationSoapXml.includes(applicationWildcardXml)); - - assertFalse(applicationWildcardXml.includes(MediaType.APPLICATION_JSON)); - } - - @Test - public void isCompatible() throws Exception { - MediaType textPlain = MediaType.TEXT_PLAIN; - assertTrue("Equal types is not compatible", textPlain.isCompatibleWith(textPlain)); - MediaType allText = new MediaType("text"); - - assertTrue("All subtypes is not compatible", allText.isCompatibleWith(textPlain)); - assertTrue("All subtypes is not compatible", textPlain.isCompatibleWith(allText)); - - assertTrue("All types is not compatible", MediaType.ALL.isCompatibleWith(textPlain)); - assertTrue("All types is not compatible", textPlain.isCompatibleWith(MediaType.ALL)); - - assertTrue("All types is not compatible", MediaType.ALL.isCompatibleWith(textPlain)); - assertTrue("All types is compatible", textPlain.isCompatibleWith(MediaType.ALL)); - - MediaType applicationSoapXml = new MediaType("application", "soap+xml"); - MediaType applicationWildcardXml = new MediaType("application", "*+xml"); - - assertTrue(applicationSoapXml.isCompatibleWith(applicationSoapXml)); - assertTrue(applicationWildcardXml.isCompatibleWith(applicationWildcardXml)); - - assertTrue(applicationWildcardXml.isCompatibleWith(applicationSoapXml)); - assertTrue(applicationSoapXml.isCompatibleWith(applicationWildcardXml)); - - assertFalse(applicationWildcardXml.isCompatibleWith(MediaType.APPLICATION_JSON)); - } - @Test public void testToString() throws Exception { MediaType mediaType = new MediaType("text", "plain", 0.7); @@ -177,45 +121,6 @@ public class MediaTypeTests { MediaType.parseMediaType("text/html; charset=foo-bar"); } - // SPR-8917 - - @Test - public void parseMediaTypeQuotedParameterValue() { - MediaType mediaType = MediaType.parseMediaType("audio/*;attr=\"v>alue\""); - assertEquals("\"v>alue\"", mediaType.getParameter("attr")); - } - - // SPR-8917 - - @Test - public void parseMediaTypeSingleQuotedParameterValue() { - MediaType mediaType = MediaType.parseMediaType("audio/*;attr='v>alue'"); - assertEquals("'v>alue'", mediaType.getParameter("attr")); - } - - @Test(expected = InvalidMediaTypeException.class) - public void parseMediaTypeIllegalQuotedParameterValue() { - MediaType.parseMediaType("audio/*;attr=\""); - } - - @Test - public void parseCharset() throws Exception { - String s = "text/html; charset=iso-8859-1"; - MediaType mediaType = MediaType.parseMediaType(s); - assertEquals("Invalid type", "text", mediaType.getType()); - assertEquals("Invalid subtype", "html", mediaType.getSubtype()); - assertEquals("Invalid charset", Charset.forName("ISO-8859-1"), mediaType.getCharSet()); - } - - @Test - public void parseQuotedCharset() { - String s = "application/xml;charset=\"utf-8\""; - MediaType mediaType = MediaType.parseMediaType(s); - assertEquals("Invalid type", "application", mediaType.getType()); - assertEquals("Invalid subtype", "xml", mediaType.getSubtype()); - assertEquals("Invalid charset", Charset.forName("UTF-8"), mediaType.getCharSet()); - } - @Test public void parseURLConnectionMediaType() throws Exception { String s = "*; q=.2"; diff --git a/spring-webmvc/src/main/java/org/springframework/web/servlet/mvc/condition/ConsumesRequestCondition.java b/spring-webmvc/src/main/java/org/springframework/web/servlet/mvc/condition/ConsumesRequestCondition.java index 39f46205013..545ff8c362b 100644 --- a/spring-webmvc/src/main/java/org/springframework/web/servlet/mvc/condition/ConsumesRequestCondition.java +++ b/spring-webmvc/src/main/java/org/springframework/web/servlet/mvc/condition/ConsumesRequestCondition.java @@ -26,6 +26,7 @@ import java.util.Set; import javax.servlet.http.HttpServletRequest; +import org.springframework.http.InvalidMediaTypeException; import org.springframework.http.MediaType; import org.springframework.util.StringUtils; import org.springframework.web.HttpMediaTypeNotSupportedException; @@ -221,7 +222,7 @@ public final class ConsumesRequestCondition extends AbstractRequestCondition