org.springframework.http.HttpMethod Maven / Gradle / Ivy
/*
* Copyright 2002-2022 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
*
* https://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.http;
import java.io.Serializable;
import java.util.Arrays;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;
import org.springframework.lang.Nullable;
import org.springframework.util.Assert;
/**
* Represents an HTTP request method. Intended for use
* with {@link org.springframework.http.client.ClientHttpRequest}
* and {@link org.springframework.web.client.RestTemplate}.
*
* @author Arjen Poutsma
* @author Juergen Hoeller
* @since 3.0
*/
public final class HttpMethod implements Comparable, Serializable {
private static final long serialVersionUID = -70133475680645360L;
/**
* The HTTP method {@code GET}.
* @see HTTP 1.1, section 9.3
*/
public static final HttpMethod GET = new HttpMethod("GET");
/**
* The HTTP method {@code HEAD}.
* @see HTTP 1.1, section 9.4
*/
public static final HttpMethod HEAD = new HttpMethod("HEAD");
/**
* The HTTP method {@code POST}.
* @see HTTP 1.1, section 9.5
*/
public static final HttpMethod POST = new HttpMethod("POST");
/**
* The HTTP method {@code PUT}.
* @see HTTP 1.1, section 9.6
*/
public static final HttpMethod PUT = new HttpMethod("PUT");
/**
* The HTTP method {@code PATCH}.
* @see RFC 5789
*/
public static final HttpMethod PATCH = new HttpMethod("PATCH");
/**
* The HTTP method {@code DELETE}.
* @see HTTP 1.1, section 9.7
*/
public static final HttpMethod DELETE = new HttpMethod("DELETE");
/**
* The HTTP method {@code OPTIONS}.
* @see HTTP 1.1, section 9.2
*/
public static final HttpMethod OPTIONS = new HttpMethod("OPTIONS");
/**
* The HTTP method {@code TRACE}.
* @see HTTP 1.1, section 9.8
*/
public static final HttpMethod TRACE = new HttpMethod("TRACE");
private static final HttpMethod[] values = new HttpMethod[] { GET, HEAD, POST, PUT, PATCH, DELETE, OPTIONS, TRACE };
private static final Map mappings = Arrays.stream(values)
.collect(Collectors.toUnmodifiableMap(HttpMethod::name, Function.identity()));
private final String name;
private HttpMethod(String name) {
this.name = name;
}
/**
* Returns an array containing the standard HTTP methods. Specifically,
* this method returns an array containing {@link #GET}, {@link #HEAD},
* {@link #POST}, {@link #PUT}, {@link #PATCH}, {@link #DELETE},
* {@link #OPTIONS}, and {@link #TRACE}.
*
* Note that the returned value does not include any HTTP methods defined
* in WebDav.
*/
public static HttpMethod[] values() {
HttpMethod[] copy = new HttpMethod[values.length];
System.arraycopy(values, 0, copy, 0, values.length);
return copy;
}
/**
* Return an {@code HttpMethod} object for the given value.
* @param method the method value as a String
* @return the corresponding {@code HttpMethod}
*/
public static HttpMethod valueOf(String method) {
Assert.notNull(method, "Method must not be null");
HttpMethod result = mappings.get(method);
if (result != null) {
return result;
}
else {
return new HttpMethod(method);
}
}
/**
* Resolve the given method value to an {@code HttpMethod}.
* @param method the method value as a String
* @return the corresponding {@code HttpMethod}, or {@code null} if not found
* @since 4.2.4
* @deprecated in favor of {@link #valueOf(String)}
*/
@Nullable
@Deprecated(since = "6.0", forRemoval = true)
public static HttpMethod resolve(@Nullable String method) {
return (method != null ? valueOf(method) : null);
}
/**
* Return the name of this method, e.g. "GET", "POST".
*/
public String name() {
return this.name;
}
/**
* Determine whether this {@code HttpMethod} matches the given method value.
* @param method the HTTP method as a String
* @return {@code true} if it matches, {@code false} otherwise
* @since 4.2.4
*/
public boolean matches(String method) {
return name().equals(method);
}
@Override
public int compareTo(HttpMethod other) {
return this.name.compareTo(other.name);
}
@Override
public int hashCode() {
return this.name.hashCode();
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
else if (o instanceof HttpMethod otherMethod) {
return this.name.equals(otherMethod.name);
}
return false;
}
@Override
public String toString() {
return this.name;
}
}