Add @HttpRequest and HttpServiceProxyFactory

See gh-28386

spring-web/src/main/java/org/springframework/web/service/annotation/GetRequest.java

@@ -0,0 +1,57 @@
+/*
+ * 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.web.service.annotation;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import org.springframework.core.annotation.AliasFor;
+
+
+/**
+ *
+ * @author Rossen Stoyanchev
+ * @since 6.0
+ */
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@HttpRequest(method = "GET")
+public @interface GetRequest {
+
+	/**
+	 * Alias for {@link HttpRequest#value}.
+	 */
+	@AliasFor(annotation = HttpRequest.class)
+	String value() default "";
+
+	/**
+	 * Alias for {@link HttpRequest#url()}.
+	 */
+	@AliasFor(annotation = HttpRequest.class)
+	String url() default "";
+
+	/**
+	 * Alias for {@link HttpRequest#accept()}.
+	 */
+	@AliasFor(annotation = HttpRequest.class)
+	String[] accept() default {};
+
+}

spring-web/src/main/java/org/springframework/web/service/annotation/HttpRequest.java

@@ -0,0 +1,88 @@
+/*
+ * 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.web.service.annotation;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import org.springframework.core.annotation.AliasFor;
+import org.springframework.web.bind.annotation.Mapping;
+
+/**
+ * Supported method parameters:
+ * <ul>
+ * <li>{@link java.net.URI} -- dynamic URL
+ * <li>{@link org.springframework.http.HttpMethod} - dynamic HTTP method
+ * <li>{@link org.springframework.http.HttpHeaders} - request headers
+ * <li>{@link org.springframework.http.HttpCookie} - request headers
+ * <li>...
+ * </ul>
+ *
+ * @author Rossen Stoyanchev
+ * @since 6.0
+ */
+@Target({ElementType.TYPE, ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Mapping
+public @interface HttpRequest {
+
+	/**
+	 * This is an alias for {@link #url}.
+	 */
+	@AliasFor("url")
+	String value() default "";
+
+	/**
+	 * The URL for the request, either a full URL or a path only that is relative
+	 * to a URL declared in a type-level {@code @HttpRequest}, and/or a globally
+	 * configured base URL.
+	 * <p>By default, this is empty.
+	 */
+	@AliasFor("value")
+	String url() default "";
+
+	/**
+	 * The HTTP method to use.
+	 * <p>Supported at the type level as well as at the method level.
+	 * When used at the type level, all method-level mappings inherit this value.
+	 * <p>By default, this is empty.
+	 */
+	String method() default "";
+
+
+	/**
+	 * The media type for the {@code "Content-Type"} header.
+	 * <p>Supported at the type level as well as at the method level, in which
+	 * case the method-level values override type-level values.
+	 * <p>By default, this is empty.
+	 */
+	String contentType() default "";
+
+	/**
+	 * The media types for the {@code "Accept"} header.
+	 * <p>Supported at the type level as well as at the method level, in which
+	 * case the method-level values override type-level values.
+	 * <p>By default, this is empty.
+	 */
+	String[] accept() default {};
+
+
+}

spring-web/src/main/java/org/springframework/web/service/annotation/PostRequest.java

@@ -0,0 +1,62 @@
+/*
+ * 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.web.service.annotation;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import org.springframework.core.annotation.AliasFor;
+
+/**
+ *
+ * @author Rossen Stoyanchev
+ * @since 6.0
+ */
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@HttpRequest(method = "POST")
+public @interface PostRequest {
+
+	/**
+	 * Alias for {@link HttpRequest#value}.
+	 */
+	@AliasFor(annotation = HttpRequest.class)
+	String value() default "";
+
+	/**
+	 * Alias for {@link HttpRequest#url()}.
+	 */
+	@AliasFor(annotation = HttpRequest.class)
+	String url() default "";
+
+	/**
+	 * Alias for {@link HttpRequest#contentType()}.
+	 */
+	@AliasFor(annotation = HttpRequest.class)
+	String contentType() default "";
+
+	/**
+	 * Alias for {@link HttpRequest#accept()}.
+	 */
+	@AliasFor(annotation = HttpRequest.class)
+	String[] accept() default {};
+
+}

spring-web/src/main/java/org/springframework/web/service/annotation/PutRequest.java

@@ -0,0 +1,56 @@
+/*
+ * 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.web.service.annotation;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import org.springframework.core.annotation.AliasFor;
+
+/**
+ *
+ * @author Rossen Stoyanchev
+ * @since 6.0
+ */
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@HttpRequest(method = "PUT")
+public @interface PutRequest {
+
+	/**
+	 * Alias for {@link HttpRequest#value}.
+	 */
+	@AliasFor(annotation = HttpRequest.class)
+	String[] value() default {};
+
+	/**
+	 * Alias for {@link HttpRequest#url()}.
+	 */
+	@AliasFor(annotation = HttpRequest.class)
+	String[] url() default {};
+
+	/**
+	 * Alias for {@link HttpRequest#contentType()}.
+	 */
+	@AliasFor(annotation = HttpRequest.class)
+	String contentType() default "";
+
+}

spring-web/src/main/java/org/springframework/web/service/annotation/package-info.java

@@ -0,0 +1,9 @@
+/**
+ * Annotations to declare HTTP service, request methods.
+ */
+@NonNullApi
+@NonNullFields
+package org.springframework.web.service.annotation;
+
+import org.springframework.lang.NonNullApi;
+import org.springframework.lang.NonNullFields;

spring-web/src/main/java/org/springframework/web/service/invoker/HttpClientAdapter.java

@@ -0,0 +1,50 @@
+/*
+ * 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.web.service.invoker;
+
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import org.springframework.core.ParameterizedTypeReference;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.ResponseEntity;
+
+
+/**
+ * Decouple an {@link HttpServiceProxyFactory#createService(Class) HTTP Service proxy}
+ * from the underlying HTTP client.
+ *
+ * @author Rossen Stoyanchev
+ * @since 6.0
+ */
+public interface HttpClientAdapter {
+
+	Mono<Void> requestToVoid(HttpRequestDefinition requestDefinition);
+
+	Mono<HttpHeaders> requestToHeaders(HttpRequestDefinition requestDefinition);
+
+	<T> Mono<T> requestToBody(HttpRequestDefinition requestDefinition, ParameterizedTypeReference<T> bodyType);
+
+	<T> Flux<T> requestToBodyFlux(HttpRequestDefinition requestDefinition, ParameterizedTypeReference<T> bodyType);
+
+	Mono<ResponseEntity<Void>> requestToBodilessEntity(HttpRequestDefinition requestDefinition);
+
+	<T> Mono<ResponseEntity<T>> requestToEntity(HttpRequestDefinition requestDefinition, ParameterizedTypeReference<T> bodyType);
+
+	<T> Mono<ResponseEntity<Flux<T>>> requestToEntityFlux(HttpRequestDefinition requestDefinition, ParameterizedTypeReference<T> bodyType);
+
+}

spring-web/src/main/java/org/springframework/web/service/invoker/HttpRequestDefinition.java

@@ -0,0 +1,192 @@
+/*
+ * 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.web.service.invoker;
+
+
+import java.net.URI;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.reactivestreams.Publisher;
+
+import org.springframework.core.MethodParameter;
+import org.springframework.core.ParameterizedTypeReference;
+import org.springframework.core.ResolvableType;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.HttpRequest;
+import org.springframework.lang.Nullable;
+import org.springframework.util.Assert;
+import org.springframework.util.CollectionUtils;
+import org.springframework.util.LinkedMultiValueMap;
+import org.springframework.util.MultiValueMap;
+
+
+/**
+ * Container for HTTP request values accumulated from an
+ * {@link HttpRequest @HttpRequest}-annotated method and arguments passed to it.
+ * This allows an {@link HttpClientAdapter} adapt these inputs as it sees fit
+ * to the API of the underlying client.
+ *
+ * @author Rossen Stoyanchev
+ * @since 6.0
+ */
+public class HttpRequestDefinition {
+
+	private static final MultiValueMap<String, String> EMPTY_COOKIES_MAP =
+			CollectionUtils.toMultiValueMap(Collections.emptyMap());
+
+
+	@Nullable
+	private URI uri;
+	
+	@Nullable
+	private String uriTemplate;
+
+	@Nullable
+	private Map<String, String> uriVariables;
+
+	@Nullable
+	private List<String> uriVariablesList;
+
+	@Nullable
+	private HttpMethod httpMethod;
+
+	@Nullable
+	private HttpHeaders headers;
+
+	@Nullable
+	private MultiValueMap<String, String> cookies;
+
+	@Nullable
+	private Object bodyValue;
+
+	@Nullable
+	private Publisher<?> bodyPublisher;
+	
+	@Nullable
+	private ParameterizedTypeReference<?> bodyPublisherElementType;
+
+	private boolean complete;
+
+
+	public void setUri(URI uri) {
+		checkComplete();
+		this.uri = uri;
+	}
+
+	@Nullable
+	public URI getUri() {
+		return this.uri;
+	}
+
+	public void setUriTemplate(String uriTemplate) {
+		checkComplete();
+		this.uriTemplate = uriTemplate;
+	}
+
+	@Nullable
+	public String getUriTemplate() {
+		return this.uriTemplate;
+	}
+
+	public Map<String, String> getUriVariables() {
+		this.uriVariables = (this.uriVariables != null ? this.uriVariables : new LinkedHashMap<>());
+		return this.uriVariables;
+	}
+
+	public List<String> getUriVariableValues() {
+		this.uriVariablesList = (this.uriVariablesList != null ? this.uriVariablesList : new ArrayList<>());
+		return this.uriVariablesList;
+	}
+
+	public void setHttpMethod(HttpMethod httpMethod) {
+		checkComplete();
+		this.httpMethod = httpMethod;
+	}
+
+	@Nullable
+	public HttpMethod getHttpMethod() {
+		return this.httpMethod;
+	}
+
+	public HttpMethod getHttpMethodRequired() {
+		Assert.notNull(this.httpMethod, "No HttpMethod");
+		return this.httpMethod;
+	}
+
+	public HttpHeaders getHeaders() {
+		this.headers = (this.headers != null ? this.headers : new HttpHeaders());
+		return this.headers;
+	}
+
+	public MultiValueMap<String, String> getCookies() {
+		this.cookies = (this.cookies != null ? this.cookies : new LinkedMultiValueMap<>());
+		return this.cookies;
+	}
+
+	public void setBodyValue(Object bodyValue) {
+		checkComplete();
+		this.bodyValue = bodyValue;
+	}
+
+	@Nullable
+	public Object getBodyValue() {
+		return this.bodyValue;
+	}
+
+	public <T, P extends Publisher<T>> void setBodyPublisher(Publisher<P> bodyPublisher, MethodParameter parameter) {
+		checkComplete();
+		// Adapt to Mono/Flux and nest MethodParameter for element type
+		this.bodyPublisher = bodyPublisher;
+		this.bodyPublisherElementType = ParameterizedTypeReference.forType(parameter.nested().getGenericParameterType());
+	}
+
+	@Nullable
+	public Publisher<?> getBodyPublisher() {
+		return this.bodyPublisher;
+	}
+
+	public ParameterizedTypeReference<?> getBodyPublisherElementType() {
+		Assert.state(this.bodyPublisherElementType != null, "No body Publisher");
+		return this.bodyPublisherElementType;
+	}
+
+	private void checkComplete() {
+		Assert.isTrue(!this.complete, "setComplete already called");
+	}
+
+
+	void setComplete() {
+
+		this.uriVariables = (this.uriVariables != null ?
+				Collections.unmodifiableMap(this.uriVariables) : Collections.emptyMap());
+
+		this.uriVariablesList = (this.uriVariablesList != null ?
+				Collections.unmodifiableList(this.uriVariablesList) : Collections.emptyList());
+
+		this.headers = (this.headers != null ?
+				HttpHeaders.readOnlyHttpHeaders(this.headers) : HttpHeaders.EMPTY);
+
+		this.cookies = (this.cookies != null ?
+				CollectionUtils.unmodifiableMultiValueMap(this.cookies) : EMPTY_COOKIES_MAP);
+	}
+
+}

spring-web/src/main/java/org/springframework/web/service/invoker/HttpServiceMethod.java

@@ -0,0 +1,361 @@
+/*
+ * 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.web.service.invoker;
+
+
+import java.lang.reflect.Method;
+import java.time.Duration;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+import java.util.function.Function;
+
+import org.reactivestreams.Publisher;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import org.springframework.core.MethodParameter;
+import org.springframework.core.ParameterizedTypeReference;
+import org.springframework.core.ReactiveAdapter;
+import org.springframework.core.ReactiveAdapterRegistry;
+import org.springframework.core.annotation.AnnotatedElementUtils;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.lang.Nullable;
+import org.springframework.util.Assert;
+import org.springframework.util.ObjectUtils;
+import org.springframework.util.StringUtils;
+import org.springframework.web.service.annotation.HttpRequest;
+
+
+/**
+ * Implements the invocation of an {@link HttpRequest @HttpRequest} annotated,
+ * {@link HttpServiceProxyFactory#createService(Class) HTTP Service proxy} method
+ * by delegating to an {@link HttpClientAdapter} to perform actual requests.
+ *
+ * @author Rossen Stoyanchev
+ * @since 6.0
+ */
+final class HttpServiceMethod {
+
+	private final Method method;
+
+	private final MethodParameter[] parameters;
+
+	private final List<HttpServiceMethodArgumentResolver> argumentResolvers;
+
+	private final HttpRequestDefinitionFactory requestDefinitionFactory;
+
+	private final ResponseFunction responseFunction;
+
+
+	HttpServiceMethod(
+			Method method, Class<?> containingClass, List<HttpServiceMethodArgumentResolver> argumentResolvers,
+			HttpClientAdapter client, ReactiveAdapterRegistry reactiveRegistry,
+			Duration blockTimeout) {
+
+		this.method = method;
+		this.parameters = initMethodParameters(method);
+		this.argumentResolvers = argumentResolvers;
+		this.requestDefinitionFactory = HttpRequestDefinitionFactory.create(method, containingClass);
+		this.responseFunction = ResponseFunction.create(client, method, reactiveRegistry, blockTimeout);
+	}
+
+	private static MethodParameter[] initMethodParameters(Method method) {
+		int count = method.getParameterCount();
+		MethodParameter[] parameters = new MethodParameter[count];
+		for (int i = 0; i < count; i++) {
+			parameters[i] = new MethodParameter(method, i);
+		}
+		return parameters;
+	}
+
+
+	public Method getMethod() {
+		return this.method;
+	}
+
+
+	@Nullable
+	public Object invoke(Object[] arguments) {
+		HttpRequestDefinition requestDefinition = this.requestDefinitionFactory.initializeRequest();
+		applyArguments(requestDefinition, arguments);
+		requestDefinition.setComplete();
+		return this.responseFunction.execute(requestDefinition);
+	}
+
+	private void applyArguments(HttpRequestDefinition requestDefinition, Object[] arguments) {
+		Assert.isTrue(arguments.length == this.parameters.length, "Method argument mismatch");
+		for (int i = 0; i < this.parameters.length; i++) {
+			Object argumentValue = arguments[i];
+			for (HttpServiceMethodArgumentResolver resolver : this.argumentResolvers) {
+				resolver.resolve(argumentValue, this.parameters[i], requestDefinition);
+			}
+		}
+	}
+
+
+	/**
+	 * Factory for an {@link HttpRequestDefinition} with values extracted from
+	 * the type and method-level {@link HttpRequest @HttpRequest} annotations.
+	 */
+	private record HttpRequestDefinitionFactory(
+			@Nullable HttpMethod httpMethod, @Nullable String url,
+			@Nullable MediaType contentType, @Nullable List<MediaType> acceptMediaTypes) {
+
+		private HttpRequestDefinitionFactory(
+				@Nullable HttpMethod httpMethod, @Nullable String url,
+				@Nullable MediaType contentType, @Nullable List<MediaType> acceptMediaTypes) {
+
+			this.url = url;
+			this.httpMethod = httpMethod;
+			this.contentType = contentType;
+			this.acceptMediaTypes = acceptMediaTypes;
+		}
+
+		public HttpRequestDefinition initializeRequest() {
+			HttpRequestDefinition requestDefinition = new HttpRequestDefinition();
+			if (this.httpMethod != null) {
+				requestDefinition.setHttpMethod(this.httpMethod);
+			}
+			if (this.url != null) {
+				requestDefinition.setUriTemplate(this.url);
+			}
+			if (this.contentType != null) {
+				requestDefinition.getHeaders().setContentType(this.contentType);
+			}
+			if (this.acceptMediaTypes != null) {
+				requestDefinition.getHeaders().setAccept(this.acceptMediaTypes);
+			}
+			return requestDefinition;
+		}
+
+
+		/**
+		 * Introspect the method and create the request factory for it.
+		 */
+		public static HttpRequestDefinitionFactory create(Method method, Class<?> containingClass) {
+
+			HttpRequest annot1 = AnnotatedElementUtils.findMergedAnnotation(containingClass, HttpRequest.class);
+			HttpRequest annot2 = AnnotatedElementUtils.findMergedAnnotation(method, HttpRequest.class);
+
+			Assert.notNull(annot2, "Expected HttpRequest annotation");
+
+			HttpMethod httpMethod = initHttpMethod(annot1, annot2);
+			String url = initUrl(annot1, annot2);
+			MediaType contentType = initContentType(annot1, annot2);
+			List<MediaType> acceptableMediaTypes = initAccept(annot1, annot2);
+
+			return new HttpRequestDefinitionFactory(httpMethod, url, contentType, acceptableMediaTypes);
+		}
+
+
+		@Nullable
+		private static HttpMethod initHttpMethod(@Nullable HttpRequest typeAnnot, HttpRequest annot) {
+
+			String value1 = (typeAnnot != null ? typeAnnot.method() : null);
+			String value2 = annot.method();
+
+			if (StringUtils.hasText(value2)) {
+				return HttpMethod.valueOf(value2);
+			}
+
+			if (StringUtils.hasText(value1)) {
+				return HttpMethod.valueOf(value1);
+			}
+
+			return null;
+		}
+
+		@Nullable
+		private static String initUrl(@Nullable HttpRequest typeAnnot, HttpRequest annot) {
+
+			String url1 = (typeAnnot != null ? typeAnnot.url() : null);
+			String url2 = annot.url();
+
+			boolean hasUrl1 = StringUtils.hasText(url1);
+			boolean hasUrl2 = StringUtils.hasText(url2);
+
+			if (hasUrl1 && hasUrl2) {
+				return (url1 + (!url1.endsWith("/") && !url2.startsWith("/") ? "/" : "") + url2);
+			}
+
+			if (!hasUrl1 && !hasUrl2) {
+				return null;
+			}
+
+			return (hasUrl2 ? url2 : url1);
+		}
+
+		@Nullable
+		private static MediaType initContentType(@Nullable HttpRequest typeAnnot, HttpRequest annot) {
+
+			String value1 = (typeAnnot != null ? typeAnnot.contentType() : null);
+			String value2 = annot.contentType();
+
+			if (StringUtils.hasText(value2)) {
+				return MediaType.parseMediaType(value2);
+			}
+
+			if (StringUtils.hasText(value1)) {
+				return MediaType.parseMediaType(value1);
+			}
+
+			return null;
+		}
+
+		@Nullable
+		private static List<MediaType> initAccept(@Nullable HttpRequest typeAnnot, HttpRequest annot) {
+
+			String[] value1 = (typeAnnot != null ? typeAnnot.accept() : null);
+			String[] value2 = annot.accept();
+
+			if (!ObjectUtils.isEmpty(value2)) {
+				return MediaType.parseMediaTypes(Arrays.asList(value2));
+			}
+
+			if (!ObjectUtils.isEmpty(value1)) {
+				return MediaType.parseMediaTypes(Arrays.asList(value1));
+			}
+
+			return null;
+		}
+
+	}
+
+
+	/**
+	 * Function to execute a request, obtain a response, and adapt to the expected
+	 * return type blocking if necessary.
+	 */
+	private record ResponseFunction(
+			Function<HttpRequestDefinition, Publisher<?>> responseFunction,
+			@Nullable ReactiveAdapter returnTypeAdapter,
+			boolean blockForOptional, Duration blockTimeout) {
+
+		private ResponseFunction(
+				Function<HttpRequestDefinition, Publisher<?>> responseFunction,
+				@Nullable ReactiveAdapter returnTypeAdapter,
+				boolean blockForOptional, Duration blockTimeout) {
+
+			this.responseFunction = responseFunction;
+			this.returnTypeAdapter = returnTypeAdapter;
+			this.blockForOptional = blockForOptional;
+			this.blockTimeout = blockTimeout;
+		}
+
+		@Nullable
+		public Object execute(HttpRequestDefinition requestDefinition) {
+
+			Publisher<?> responsePublisher = this.responseFunction.apply(requestDefinition);
+
+			if (this.returnTypeAdapter != null) {
+				return this.returnTypeAdapter.fromPublisher(responsePublisher);
+			}
+
+			return (this.blockForOptional ?
+					((Mono<?>) responsePublisher).blockOptional(this.blockTimeout) :
+					((Mono<?>) responsePublisher).block(this.blockTimeout));
+		}
+
+
+		/**
+		 * Create the {@code ResponseFunction} that matches method return type.
+		 */
+		public static ResponseFunction create(
+				HttpClientAdapter client, Method method, ReactiveAdapterRegistry reactiveRegistry,
+				Duration blockTimeout) {
+
+			MethodParameter returnParam = new MethodParameter(method, -1);
+			Class<?> returnType = returnParam.getParameterType();
+			ReactiveAdapter reactiveAdapter = reactiveRegistry.getAdapter(returnType);
+
+			MethodParameter actualParam = (reactiveAdapter != null ? returnParam.nested() : returnParam.nestedIfOptional());
+			Class<?> actualType = actualParam.getNestedParameterType();
+
+			Function<HttpRequestDefinition, Publisher<?>> responseFunction;
+			if (actualType.equals(void.class) || actualType.equals(Void.class)) {
+				responseFunction = client::requestToVoid;
+			}
+			else if (reactiveAdapter != null && reactiveAdapter.isNoValue()) {
+				responseFunction = client::requestToVoid;
+			}
+			else if (actualType.equals(HttpHeaders.class)) {
+				responseFunction = client::requestToHeaders;
+			}
+			else if (actualType.equals(ResponseEntity.class)) {
+				MethodParameter bodyParam = actualParam.nested();
+				Class<?> bodyType = bodyParam.getNestedParameterType();
+				if (bodyType.equals(Void.class)) {
+					responseFunction = client::requestToBodilessEntity;
+				}
+				else {
+					ReactiveAdapter bodyAdapter = reactiveRegistry.getAdapter(bodyType);
+					responseFunction = initResponseEntityFunction(client, bodyParam, bodyAdapter);
+				}
+			}
+			else {
+				responseFunction = initBodyFunction(client, actualParam, reactiveAdapter);
+			}
+
+			boolean blockForOptional = actualType.equals(Optional.class);
+			return new ResponseFunction(responseFunction, reactiveAdapter, blockForOptional, blockTimeout);
+		}
+
+		@SuppressWarnings("ConstantConditions")
+		private static Function<HttpRequestDefinition, Publisher<?>> initResponseEntityFunction(
+				HttpClientAdapter client, MethodParameter methodParam, @Nullable ReactiveAdapter reactiveAdapter) {
+
+			if (reactiveAdapter == null) {
+				return request -> client.requestToEntity(
+						request, ParameterizedTypeReference.forType(methodParam.getNestedGenericParameterType()));
+			}
+
+			Assert.isTrue(reactiveAdapter.isMultiValue(),
+					"ResponseEntity body must be a concrete value or a multi-value Publisher");
+
+			ParameterizedTypeReference<?> bodyType =
+					ParameterizedTypeReference.forType(methodParam.nested().getNestedGenericParameterType());
+
+			// Shortcut for Flux
+			if (reactiveAdapter.getReactiveType().equals(Flux.class)) {
+				return request -> client.requestToEntityFlux(request, bodyType);
+			}
+
+			return request -> client.requestToEntityFlux(request, bodyType)
+					.map(entity -> {
+						Object body = reactiveAdapter.fromPublisher(entity.getBody());
+						return new ResponseEntity<>(body, entity.getHeaders(), entity.getStatusCode());
+					});
+		}
+
+		private static Function<HttpRequestDefinition, Publisher<?>> initBodyFunction(
+				HttpClientAdapter client, MethodParameter methodParam, @Nullable ReactiveAdapter reactiveAdapter) {
+
+			ParameterizedTypeReference<?> bodyType =
+					ParameterizedTypeReference.forType(methodParam.getNestedGenericParameterType());
+
+			return (reactiveAdapter != null && reactiveAdapter.isMultiValue() ?
+					request -> client.requestToBodyFlux(request, bodyType) :
+					request -> client.requestToBody(request, bodyType));
+		}
+
+	}
+
+}

spring-web/src/main/java/org/springframework/web/service/invoker/HttpServiceMethodArgumentResolver.java

@@ -0,0 +1,41 @@
+/*
+ * 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.web.service.invoker;
+
+import org.springframework.core.MethodParameter;
+import org.springframework.lang.Nullable;
+import org.springframework.web.service.annotation.HttpRequest;
+
+
+/**
+ * Resolve an argument from an {@link HttpRequest @HttpRequest} annotated method
+ * to one or more HTTP request values.
+ *
+ * @author Rossen Stoyanchev
+ * @since 6.0
+ */
+public interface HttpServiceMethodArgumentResolver {
+
+	/**
+	 * Resolve the argument value.
+	 * @param argument the argument value
+	 * @param parameter the method parameter for the argument
+	 * @param requestDefinition container to add HTTP request values to
+	 */
+	void resolve(@Nullable Object argument, MethodParameter parameter, HttpRequestDefinition requestDefinition);
+
+}

spring-web/src/main/java/org/springframework/web/service/invoker/HttpServiceProxyFactory.java

@@ -0,0 +1,115 @@
+/*
+ * 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.web.service.invoker;
+
+
+import java.lang.reflect.Method;
+import java.time.Duration;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.aopalliance.intercept.MethodInterceptor;
+import org.aopalliance.intercept.MethodInvocation;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import org.springframework.aop.framework.ProxyFactory;
+import org.springframework.core.MethodIntrospector;
+import org.springframework.core.ReactiveAdapterRegistry;
+import org.springframework.core.annotation.AnnotatedElementUtils;
+import org.springframework.web.service.annotation.HttpRequest;
+
+
+/**
+ * Factory to create a proxy for an HTTP service with {@link HttpRequest} methods.
+ *
+ * @author Rossen Stoyanchev
+ * @since 6.0
+ */
+public class HttpServiceProxyFactory {
+
+	private final List<HttpServiceMethodArgumentResolver> argumentResolvers;
+
+	private final HttpClientAdapter clientAdapter;
+
+	private final ReactiveAdapterRegistry reactiveAdapterRegistry;
+
+	private final Duration blockTimeout;
+
+
+	public HttpServiceProxyFactory(
+			List<HttpServiceMethodArgumentResolver> argumentResolvers, HttpClientAdapter clientAdapter,
+			ReactiveAdapterRegistry reactiveAdapterRegistry, Duration blockTimeout) {
+
+		this.argumentResolvers = argumentResolvers;
+		this.clientAdapter = clientAdapter;
+		this.reactiveAdapterRegistry = reactiveAdapterRegistry;
+		this.blockTimeout = blockTimeout;
+	}
+
+
+	/**
+	 * Create a proxy for executing requests to the given HTTP service.
+	 * @param serviceType the HTTP service to create a proxy for
+	 * @param <S> the service type
+	 * @return the created proxy
+	 */
+	public <S> S createService(Class<S> serviceType) {
+
+		List<HttpServiceMethod> methods =
+				MethodIntrospector.selectMethods(serviceType, this::isHttpRequestMethod)
+						.stream()
+						.map(method -> initServiceMethod(method, serviceType))
+						.toList();
+
+		return ProxyFactory.getProxy(serviceType, new HttpServiceMethodInterceptor(methods));
+	}
+
+	private boolean isHttpRequestMethod(Method method) {
+		return AnnotatedElementUtils.hasAnnotation(method, HttpRequest.class);
+	}
+
+	private HttpServiceMethod initServiceMethod(Method method, Class<?> serviceType) {
+		return new HttpServiceMethod(
+				method, serviceType, this.argumentResolvers,
+				this.clientAdapter, this.reactiveAdapterRegistry, this.blockTimeout);
+	}
+
+
+	/**
+	 *
+	 */
+	private static final class HttpServiceMethodInterceptor implements MethodInterceptor {
+
+		private final Map<Method, HttpServiceMethod> serviceMethodMap = new HashMap<>();
+
+		private HttpServiceMethodInterceptor(List<HttpServiceMethod> methods) {
+			methods.forEach(serviceMethod -> this.serviceMethodMap.put(serviceMethod.getMethod(), serviceMethod));
+		}
+
+		@Nullable
+		@Override
+		public Object invoke(@NotNull MethodInvocation invocation) throws Throwable {
+			Method method = invocation.getMethod();
+			HttpServiceMethod httpServiceMethod = this.serviceMethodMap.get(method);
+			return httpServiceMethod.invoke(invocation.getArguments());
+		}
+
+	}
+
+}

spring-web/src/main/java/org/springframework/web/service/invoker/package-info.java

@@ -0,0 +1,9 @@
+/**
+ *
+ */
+@NonNullApi
+@NonNullFields
+package org.springframework.web.service.invoker;
+
+import org.springframework.lang.NonNullApi;
+import org.springframework.lang.NonNullFields;

spring-web/src/main/java/org/springframework/web/service/package-info.java

@@ -0,0 +1,10 @@
+/**
+ * Annotations to declare an HTTP service contract with request methods along
+ * with a proxy factory backed by client-driven implementation.
+ */
+@NonNullApi
+@NonNullFields
+package org.springframework.web.service;
+
+import org.springframework.lang.NonNullApi;
+import org.springframework.lang.NonNullFields;

spring-web/src/test/java/org/springframework/web/service/invoker/HttpServiceMethodTests.java

@@ -0,0 +1,378 @@
+/*
+ * 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.web.service.invoker;
+
+
+import java.time.Duration;
+import java.util.Collections;
+
+import io.reactivex.rxjava3.core.Completable;
+import io.reactivex.rxjava3.core.Flowable;
+import io.reactivex.rxjava3.core.Single;
+import org.junit.jupiter.api.Test;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+import reactor.test.StepVerifier;
+
+import org.springframework.core.ParameterizedTypeReference;
+import org.springframework.core.ReactiveAdapterRegistry;
+import org.springframework.http.HttpEntity;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.lang.Nullable;
+import org.springframework.web.service.annotation.GetRequest;
+import org.springframework.web.service.annotation.HttpRequest;
+import org.springframework.web.service.annotation.PostRequest;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.springframework.http.MediaType.APPLICATION_CBOR_VALUE;
+import static org.springframework.http.MediaType.APPLICATION_JSON_VALUE;
+
+
+/**
+ * Tests for {@link HttpServiceMethod} with a test {@link TestHttpClientAdapter}
+ * that stubs the client invocations.
+ *
+ * <p>The tests do not create nor invoke {@code HttpServiceMethod} directly but
+ * rather use {@link HttpServiceProxyFactory} to create a service proxy in order to
+ * use a strongly typed interface without the need for class casts.
+ *
+ * @author Rossen Stoyanchev
+ */
+public class HttpServiceMethodTests {
+
+	private static final ParameterizedTypeReference<String> BODY_TYPE = new ParameterizedTypeReference<>() {};
+
+
+	private final TestHttpClientAdapter clientAdapter = new TestHttpClientAdapter();
+
+
+	@Test
+	void reactorService() {
+
+		ReactorService service = createService(ReactorService.class);
+		
+		Mono<Void> voidMono = service.execute();
+		StepVerifier.create(voidMono).verifyComplete();
+		verifyClientInvocation("requestToVoid", null);
+
+		Mono<HttpHeaders> headersMono = service.getHeaders();
+		StepVerifier.create(headersMono).expectNextCount(1).verifyComplete();
+		verifyClientInvocation("requestToHeaders", null);
+
+		Mono<String> body = service.getBody();
+		StepVerifier.create(body).expectNext("requestToBody").verifyComplete();
+		verifyClientInvocation("requestToBody", BODY_TYPE);
+
+		Flux<String> fluxBody = service.getFluxBody();
+		StepVerifier.create(fluxBody).expectNext("request", "To", "Body", "Flux").verifyComplete();
+		verifyClientInvocation("requestToBodyFlux", BODY_TYPE);
+
+		Mono<ResponseEntity<Void>> voidEntity = service.getVoidEntity();
+		StepVerifier.create(voidEntity).expectNext(ResponseEntity.ok().build()).verifyComplete();
+		verifyClientInvocation("requestToBodilessEntity", null);
+
+		Mono<ResponseEntity<String>> entity = service.getEntity();
+		StepVerifier.create(entity).expectNext(ResponseEntity.ok("requestToEntity"));
+		verifyClientInvocation("requestToEntity", BODY_TYPE);
+
+		Mono<ResponseEntity<Flux<String>>> fluxEntity= service.getFluxEntity();
+		StepVerifier.create(fluxEntity.flatMapMany(HttpEntity::getBody)).expectNext("request", "To", "Entity", "Flux").verifyComplete();
+		verifyClientInvocation("requestToEntityFlux", BODY_TYPE);
+	}
+
+	@Test
+	void rxJavaService() {
+
+		RxJavaService service = createService(RxJavaService.class);
+		
+		Completable completable = service.execute();
+		assertThat(completable).isNotNull();
+
+		Single<HttpHeaders> headersSingle = service.getHeaders();
+		assertThat(headersSingle.blockingGet()).isNotNull();
+
+		Single<String> bodySingle = service.getBody();
+		assertThat(bodySingle.blockingGet()).isEqualTo("requestToBody");
+
+		Flowable<String> bodyFlow = service.getFlowableBody();
+		assertThat(bodyFlow.toList().blockingGet()).asList().containsExactly("request", "To", "Body", "Flux");
+
+		Single<ResponseEntity<Void>> voidEntity = service.getVoidEntity();
+		assertThat(voidEntity.blockingGet().getBody()).isNull();
+
+		Single<ResponseEntity<String>> entitySingle = service.getEntity();
+		assertThat(entitySingle.blockingGet().getBody()).isEqualTo("requestToEntity");
+
+		Single<ResponseEntity<Flowable<String>>> entityFlow = service.getFlowableEntity();
+		Flowable<String> body = (entityFlow.blockingGet()).getBody();
+		assertThat(body.toList().blockingGet()).containsExactly("request", "To", "Entity", "Flux");
+	}
+
+	@Test
+	void blockingService() {
+
+		BlockingService service = createService(BlockingService.class);
+
+		service.execute();
+
+		HttpHeaders headers = service.getHeaders();
+		assertThat(headers).isNotNull();
+
+		String body = service.getBody();
+		assertThat(body).isEqualTo("requestToBody");
+
+		ResponseEntity<String> entity = service.getEntity();
+		assertThat(entity.getBody()).isEqualTo("requestToEntity");
+
+		ResponseEntity<Void> voidEntity = service.getVoidEntity();
+		assertThat(voidEntity.getBody()).isNull();
+	}
+
+	@Test
+	void methodAnnotatedService() {
+
+		MethodAnnotatedService service = createService(MethodAnnotatedService.class);
+
+		service.performGet();
+
+		HttpRequestDefinition request = this.clientAdapter.getRequestDefinition();
+		assertThat(request.getHttpMethod()).isEqualTo(HttpMethod.GET);
+		assertThat(request.getUriTemplate()).isNull();
+		assertThat(request.getHeaders().getContentType()).isNull();
+		assertThat(request.getHeaders().getAccept()).isEmpty();
+
+		service.performPost();
+
+		request = this.clientAdapter.getRequestDefinition();
+		assertThat(request.getHttpMethod()).isEqualTo(HttpMethod.POST);
+		assertThat(request.getUriTemplate()).isEqualTo("/url");
+		assertThat(request.getHeaders().getContentType()).isEqualTo(MediaType.APPLICATION_JSON);
+		assertThat(request.getHeaders().getAccept()).containsExactly(MediaType.APPLICATION_JSON);
+	}
+
+	@Test
+	void typeAndMethodAnnotatedService() {
+
+		MethodAnnotatedService service = createService(TypeAndMethodAnnotatedService.class);
+
+		service.performGet();
+
+		HttpRequestDefinition request = this.clientAdapter.getRequestDefinition();
+		assertThat(request.getHttpMethod()).isEqualTo(HttpMethod.GET);
+		assertThat(request.getUriTemplate()).isEqualTo("/base");
+		assertThat(request.getHeaders().getContentType()).isEqualTo(MediaType.APPLICATION_CBOR);
+		assertThat(request.getHeaders().getAccept()).containsExactly(MediaType.APPLICATION_CBOR);
+
+		service.performPost();
+
+		request = this.clientAdapter.getRequestDefinition();
+		assertThat(request.getHttpMethod()).isEqualTo(HttpMethod.POST);
+		assertThat(request.getUriTemplate()).isEqualTo("/base/url");
+		assertThat(request.getHeaders().getContentType()).isEqualTo(MediaType.APPLICATION_JSON);
+		assertThat(request.getHeaders().getAccept()).containsExactly(MediaType.APPLICATION_JSON);
+	}
+
+	private <S> S createService(Class<S> serviceType) {
+
+		HttpServiceProxyFactory factory = new HttpServiceProxyFactory(
+				Collections.emptyList(), this.clientAdapter, ReactiveAdapterRegistry.getSharedInstance(),
+				Duration.ofSeconds(5));
+
+		return factory.createService(serviceType);
+	}
+
+	private void verifyClientInvocation(String methodName, @Nullable ParameterizedTypeReference<?> expectedBodyType) {
+		assertThat((this.clientAdapter.getMethodName())).isEqualTo(methodName);
+		assertThat(this.clientAdapter.getBodyType()).isEqualTo(expectedBodyType);
+	}
+
+
+	@SuppressWarnings("unused")
+	private interface ReactorService {
+
+		@HttpRequest
+		Mono<Void> execute();
+
+		@GetRequest
+		Mono<HttpHeaders> getHeaders();
+
+		@GetRequest
+		Mono<String> getBody();
+
+		@GetRequest
+		Flux<String> getFluxBody();
+
+		@GetRequest
+		Mono<ResponseEntity<Void>> getVoidEntity();
+
+		@GetRequest
+		Mono<ResponseEntity<String>> getEntity();
+
+		@GetRequest
+		Mono<ResponseEntity<Flux<String>>> getFluxEntity();
+	}
+
+
+	@SuppressWarnings("unused")
+	private interface RxJavaService {
+
+		@HttpRequest
+		Completable execute();
+
+		@GetRequest
+		Single<HttpHeaders> getHeaders();
+
+		@GetRequest
+		Single<String> getBody();
+
+		@GetRequest
+		Flowable<String> getFlowableBody();
+
+		@GetRequest
+		Single<ResponseEntity<Void>> getVoidEntity();
+
+		@GetRequest
+		Single<ResponseEntity<String>> getEntity();
+
+		@GetRequest
+		Single<ResponseEntity<Flowable<String>>> getFlowableEntity();
+	}
+
+
+	@SuppressWarnings("unused")
+	private interface BlockingService {
+
+		@HttpRequest
+		void execute();
+
+		@GetRequest
+		HttpHeaders getHeaders();
+
+		@GetRequest
+		String getBody();
+
+		@GetRequest
+		ResponseEntity<Void> getVoidEntity();
+
+		@GetRequest
+		ResponseEntity<String> getEntity();
+	}
+
+
+	@SuppressWarnings("unused")
+	private interface MethodAnnotatedService {
+
+		@GetRequest
+		void performGet();
+
+		@PostRequest(url = "/url", contentType = APPLICATION_JSON_VALUE, accept = APPLICATION_JSON_VALUE)
+		void performPost();
+
+	}
+
+
+	@SuppressWarnings("unused")
+	@HttpRequest(url = "/base", contentType = APPLICATION_CBOR_VALUE, accept = APPLICATION_CBOR_VALUE)
+	private interface TypeAndMethodAnnotatedService extends MethodAnnotatedService {
+	}
+
+
+	@SuppressWarnings("unchecked")
+	private static class TestHttpClientAdapter implements HttpClientAdapter {
+
+		@Nullable
+		private String methodName;
+
+		@Nullable
+		private HttpRequestDefinition requestDefinition;
+
+		@Nullable
+		private ParameterizedTypeReference<?> bodyType;
+
+
+		public String getMethodName() {
+			assertThat(this.methodName).isNotNull();
+			return this.methodName;
+		}
+
+		public HttpRequestDefinition getRequestDefinition() {
+			assertThat(this.requestDefinition).isNotNull();
+			return this.requestDefinition;
+		}
+
+		@Nullable
+		public ParameterizedTypeReference<?> getBodyType() {
+			return this.bodyType;
+		}
+
+
+		@Override
+		public Mono<Void> requestToVoid(HttpRequestDefinition def) {
+			saveInput("requestToVoid", def, null);
+			return Mono.empty();
+		}
+
+		@Override
+		public Mono<HttpHeaders> requestToHeaders(HttpRequestDefinition def) {
+			saveInput("requestToHeaders", def, null);
+			return Mono.just(new HttpHeaders());
+		}
+
+		@Override
+		public <T> Mono<T> requestToBody(HttpRequestDefinition def, ParameterizedTypeReference<T> bodyType) {
+			saveInput("requestToBody", def, bodyType);
+			return (Mono<T>) Mono.just(getMethodName());
+		}
+
+		@Override
+		public <T> Flux<T> requestToBodyFlux(HttpRequestDefinition def, ParameterizedTypeReference<T> bodyType) {
+			saveInput("requestToBodyFlux", def, bodyType);
+			return (Flux<T>) Flux.just("request", "To", "Body", "Flux");
+		}
+
+		@Override
+		public Mono<ResponseEntity<Void>> requestToBodilessEntity(HttpRequestDefinition def) {
+			saveInput("requestToBodilessEntity", def, null);
+			return Mono.just(ResponseEntity.ok().build());
+		}
+
+		@Override
+		public <T> Mono<ResponseEntity<T>> requestToEntity(HttpRequestDefinition def, ParameterizedTypeReference<T> bodyType) {
+			saveInput("requestToEntity", def, bodyType);
+			return Mono.just((ResponseEntity<T>) ResponseEntity.ok("requestToEntity"));
+		}
+
+		@Override
+		public <T> Mono<ResponseEntity<Flux<T>>> requestToEntityFlux(HttpRequestDefinition def, ParameterizedTypeReference<T> bodyType) {
+			saveInput("requestToEntityFlux", def, bodyType);
+			return Mono.just(ResponseEntity.ok((Flux<T>) Flux.just("request", "To", "Entity", "Flux")));
+		}
+
+		private <T> void saveInput(
+				String methodName, HttpRequestDefinition definition, @Nullable ParameterizedTypeReference<T> bodyType) {
+
+			this.methodName = methodName;
+			this.requestDefinition = definition;
+			this.bodyType = bodyType;
+		}
+
+	}
+
+}

spring-webflux/src/main/java/org/springframework/web/reactive/function/client/support/WebClientAdapter.java

@@ -0,0 +1,116 @@
+/*
+ * 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.web.reactive.function.client.support;
+
+
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import org.springframework.core.ParameterizedTypeReference;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.reactive.function.client.ClientResponse;
+import org.springframework.web.reactive.function.client.WebClient;
+import org.springframework.web.service.invoker.HttpClientAdapter;
+import org.springframework.web.service.invoker.HttpRequestDefinition;
+
+
+/**
+ * {@link HttpClientAdapter} implementation for {@link WebClient}.
+ *
+ * @author Rossen Stoyanchev
+ * @since 6.0
+ */
+public class WebClientAdapter implements HttpClientAdapter {
+
+	private final WebClient webClient;
+
+
+	public WebClientAdapter(WebClient webClient) {
+		this.webClient = webClient;
+	}
+
+
+	@Override
+	public Mono<Void> requestToVoid(HttpRequestDefinition request) {
+		return toBodySpec(request).exchangeToMono(ClientResponse::releaseBody);
+	}
+
+	@Override
+	public Mono<HttpHeaders> requestToHeaders(HttpRequestDefinition request) {
+		return toBodySpec(request).retrieve().toBodilessEntity().map(ResponseEntity::getHeaders);
+	}
+
+	@Override
+	public <T> Mono<T> requestToBody(HttpRequestDefinition request, ParameterizedTypeReference<T> bodyType) {
+		return toBodySpec(request).retrieve().bodyToMono(bodyType);
+	}
+
+	@Override
+	public <T> Flux<T> requestToBodyFlux(HttpRequestDefinition request, ParameterizedTypeReference<T> bodyType) {
+		return toBodySpec(request).retrieve().bodyToFlux(bodyType);
+	}
+
+	@Override
+	public Mono<ResponseEntity<Void>> requestToBodilessEntity(HttpRequestDefinition request) {
+		return toBodySpec(request).retrieve().toBodilessEntity();
+	}
+
+	@Override
+	public <T> Mono<ResponseEntity<T>> requestToEntity(HttpRequestDefinition request, ParameterizedTypeReference<T> bodyType) {
+		return toBodySpec(request).retrieve().toEntity(bodyType);
+	}
+
+	@Override
+	public <T> Mono<ResponseEntity<Flux<T>>> requestToEntityFlux(HttpRequestDefinition request, ParameterizedTypeReference<T> bodyType) {
+		return toBodySpec(request).retrieve().toEntityFlux(bodyType);
+	}
+
+	@SuppressWarnings("ReactiveStreamsUnusedPublisher")
+	private WebClient.RequestBodySpec toBodySpec(HttpRequestDefinition request) {
+
+		HttpMethod httpMethod = request.getHttpMethodRequired();
+		WebClient.RequestBodyUriSpec uriSpec = this.webClient.method(httpMethod);
+
+		WebClient.RequestBodySpec bodySpec;
+		if (request.getUri() != null) {
+			bodySpec = uriSpec.uri(request.getUri());
+		}
+		else if (request.getUriTemplate() != null) {
+			bodySpec = (!request.getUriVariables().isEmpty() ?
+					uriSpec.uri(request.getUriTemplate(), request.getUriVariables()) :
+					uriSpec.uri(request.getUriTemplate(), request.getUriVariableValues()));
+		}
+		else {
+			bodySpec = uriSpec.uri("");
+		}
+
+		bodySpec.headers(headers -> headers.putAll(request.getHeaders()));
+		bodySpec.cookies(cookies -> cookies.putAll(request.getCookies()));
+
+		if (request.getBodyValue() != null) {
+			bodySpec.bodyValue(request.getBodyValue());
+		}
+		else if (request.getBodyPublisher() != null) {
+			bodySpec.body(request.getBodyPublisher(), request.getBodyPublisherElementType());
+		}
+
+		return bodySpec;
+	}
+
+}

spring-webflux/src/main/java/org/springframework/web/reactive/service/package-info.java

@@ -0,0 +1,9 @@
+/**
+ * Support for an HTTP service proxy created from an interface declaration.
+ */
+@NonNullApi
+@NonNullFields
+package org.springframework.web.reactive.service;
+
+import org.springframework.lang.NonNullApi;
+import org.springframework.lang.NonNullFields;

spring-webflux/src/test/java/org/springframework/web/reactive/function/client/support/WebClientHttpServiceProxyTests.java

@@ -0,0 +1,107 @@
+/*
+ * 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.web.reactive.function.client.support;
+
+
+import java.io.IOException;
+import java.time.Duration;
+import java.util.Collections;
+import java.util.function.Consumer;
+
+import okhttp3.mockwebserver.MockResponse;
+import okhttp3.mockwebserver.MockWebServer;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import reactor.core.publisher.Mono;
+import reactor.test.StepVerifier;
+
+import org.springframework.core.ReactiveAdapterRegistry;
+import org.springframework.http.client.reactive.ReactorClientHttpConnector;
+import org.springframework.web.reactive.function.client.WebClient;
+import org.springframework.web.service.annotation.GetRequest;
+import org.springframework.web.service.invoker.HttpServiceProxyFactory;
+
+
+/**
+ * Integration tests for {@link HttpServiceProxyFactory HTTP Service proxy}
+ * using {@link WebClient} and {@link MockWebServer}.
+ *
+ * @author Rossen Stoyanchev
+ */
+public class WebClientHttpServiceProxyTests {
+
+	private MockWebServer server;
+
+	private TestHttpService httpService;
+
+
+	@BeforeEach
+	void setUp() {
+		this.server = new MockWebServer();
+		WebClient webClient = WebClient
+				.builder()
+				.clientConnector(new ReactorClientHttpConnector())
+				.baseUrl(this.server.url("/").toString())
+				.build();
+
+		WebClientAdapter webClientAdapter = new WebClientAdapter(webClient);
+
+		HttpServiceProxyFactory proxyFactory = new HttpServiceProxyFactory(
+				Collections.emptyList(), webClientAdapter, ReactiveAdapterRegistry.getSharedInstance(),
+				Duration.ofSeconds(5));
+
+		this.httpService = proxyFactory.createService(TestHttpService.class);
+	}
+
+	@SuppressWarnings("ConstantConditions")
+	@AfterEach
+	void shutdown() throws IOException {
+		if (this.server != null) {
+			this.server.shutdown();
+		}
+	}
+
+
+	@Test
+	void greeting() {
+
+		prepareResponse(response ->
+				response.setHeader("Content-Type", "text/plain").setBody("Hello Spring!"));
+
+		StepVerifier.create(this.httpService.getGreeting())
+				.expectNext("Hello Spring!")
+				.expectComplete()
+				.verify(Duration.ofSeconds(5));
+	}
+
+	private void prepareResponse(Consumer<MockResponse> consumer) {
+		MockResponse response = new MockResponse();
+		consumer.accept(response);
+		this.server.enqueue(response);
+	}
+
+
+	private interface TestHttpService {
+
+		@GetRequest("/greeting")
+		Mono<String> getGreeting();
+
+	}
+
+
+}