[Backport release-1.17] feat: add DaprClient.invokeHttpClient(appId) factory (#1763)

* feat: add DaprClient.invokeHttpClient(appId) factory (#1742)

* chore: rewrite invoke/http example to use native HttpClient

The DaprClient.invokeMethod wrappers were deprecated by #1666. Rewrite
the invoke/http sample to use java.net.http.HttpClient through the Dapr
sidecar, demonstrating both URL forms accepted by the sidecar — the
dapr-app-id header against the sidecar base URL, and the explicit
/v1.0/invoke/<app-id>/method/<method> path.

Update the matching README snippet and reduce expected_stdout_lines to
'Done' — the previous expected lines never matched what DemoService
returns (a timestamp).

Signed-off-by: Javier Aliaga <javier@diagrid.io>

* feat: add DaprClient.invokeHttpClient(appId) factory

Provides an SDK-native successor to the invokeMethod APIs deprecated by
#1666. DaprClient.invokeHttpClient(appId) returns a DaprInvokeHttpClient
pre-bound to {daprHttpEndpoint}/v1.0/invoke/{appId}/method/ that reuses
the SDK's shared java.net.http.HttpClient and attaches the dapr-api-token
header when configured.

Update the invoke/http example and README to demonstrate the new helper
alongside the raw dapr-app-id header form.

Signed-off-by: Javier Aliaga <javier@diagrid.io>

* feat: add DaprBodyPublishers.json helper and invokeHttpClient migration notes

Adds an opt-in DaprBodyPublishers.json(Object) helper backed by the SDK's
default Jackson serializer, matching the JSON encoding the deprecated
DaprClient.invokeMethod APIs applied internally. Eases migration without
re-introducing auto-serialization into the raw HttpClient surface exposed
by invokeHttpClient.

Also fixes the invoke/http example README expected_stdout_lines to match
the new plain-text body sent by the refactored example (Server: message
one instead of Server: "message one"), and adds migration notes to the
DaprClient.invokeHttpClient and DaprInvokeHttpClient Javadoc as well as
the example README.

Signed-off-by: Javier Aliaga <javier@diagrid.io>

---------

Signed-off-by: Javier Aliaga <javier@diagrid.io>
(cherry picked from commit 9539d70)

* fix: Add missing implementation

Signed-off-by: Javier Aliaga <javier@diagrid.io>

---------

Signed-off-by: Javier Aliaga <javier@diagrid.io>
Co-authored-by: Javier Aliaga <javier@diagrid.io>

Author: dapr-bot

dapr-spring/dapr-spring-boot-4-autoconfigure/src/main/java/io/dapr/spring/boot4/autoconfigure/client/ObservationDaprClient.java

@@ -14,6 +14,7 @@
 package io.dapr.spring.boot4.autoconfigure.client;
 
 import io.dapr.client.DaprClient;
+import io.dapr.client.DaprInvokeHttpClient;
 import io.dapr.client.domain.BulkPublishRequest;
 import io.dapr.client.domain.BulkPublishResponse;
 import io.dapr.client.domain.ConfigurationItem;
@@ -299,6 +300,11 @@ public <T> Mono<T> invokeMethod(InvokeMethodRequest invokeMethodRequest, TypeRef
     return delegate.invokeMethod(invokeMethodRequest, type);
   }
 
+  @Override
+  public DaprInvokeHttpClient invokeHttpClient(String appId) {
+    return delegate.invokeHttpClient(appId);
+  }
+
   // -------------------------------------------------------------------------
   // Bindings
   // -------------------------------------------------------------------------

dapr-spring/dapr-spring-boot-autoconfigure/src/main/java/io/dapr/spring/boot/autoconfigure/client/ObservationDaprClient.java

@@ -14,6 +14,7 @@
 package io.dapr.spring.boot.autoconfigure.client;
 
 import io.dapr.client.DaprClient;
+import io.dapr.client.DaprInvokeHttpClient;
 import io.dapr.client.domain.BulkPublishRequest;
 import io.dapr.client.domain.BulkPublishResponse;
 import io.dapr.client.domain.ConfigurationItem;
@@ -299,6 +300,11 @@ public <T> Mono<T> invokeMethod(InvokeMethodRequest invokeMethodRequest, TypeRef
     return delegate.invokeMethod(invokeMethodRequest, type);
   }
 
+  @Override
+  public DaprInvokeHttpClient invokeHttpClient(String appId) {
+    return delegate.invokeHttpClient(appId);
+  }
+
   // -------------------------------------------------------------------------
   // Bindings
   // -------------------------------------------------------------------------

dapr-spring/dapr-spring-boot-autoconfigure/src/test/java/io/dapr/spring/boot/autoconfigure/client/ObservationDaprClientTest.java

@@ -14,13 +14,10 @@
 package io.dapr.spring.boot.autoconfigure.client;
 
 import io.dapr.client.DaprClient;
-import io.dapr.client.domain.DeleteStateRequest;
-import io.dapr.client.domain.GetSecretRequest;
-import io.dapr.client.domain.GetStateRequest;
+import io.dapr.client.DaprInvokeHttpClient;
 import io.dapr.client.domain.InvokeBindingRequest;
 import io.dapr.client.domain.PublishEventRequest;
 import io.dapr.client.domain.ScheduleJobRequest;
-import io.dapr.client.domain.State;
 import io.micrometer.observation.tck.TestObservationRegistry;
 import io.micrometer.observation.tck.TestObservationRegistryAssert;
 import org.junit.jupiter.api.BeforeEach;
@@ -33,7 +30,6 @@
 import reactor.core.publisher.Mono;
 
 import java.util.List;
-import java.util.Map;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
@@ -378,4 +374,18 @@ void deprecatedInvokeMethodDoesNotCreateSpan() {
     // Registry must be empty — no spans for deprecated methods
     TestObservationRegistryAssert.assertThat(registry).doesNotHaveAnyObservation();
   }
+
+  @Test
+  @DisplayName("invokeHttpClient delegates without creating a span")
+  void invokeHttpClientDelegatesWithoutSpan() {
+    DaprInvokeHttpClient stub = org.mockito.Mockito.mock(DaprInvokeHttpClient.class);
+    when(delegate.invokeHttpClient("orderprocessor")).thenReturn(stub);
+
+    DaprInvokeHttpClient result = client.invokeHttpClient("orderprocessor");
+
+    assertThat(result).isSameAs(stub);
+    verify(delegate).invokeHttpClient("orderprocessor");
+    // Synchronous factory — no Mono/Flux to observe, so no span is expected.
+    TestObservationRegistryAssert.assertThat(registry).doesNotHaveAnyObservation();
+  }
 }

examples/src/main/java/io/dapr/examples/invoke/http/InvokeClient.java

@@ -15,7 +15,13 @@
 
 import io.dapr.client.DaprClient;
 import io.dapr.client.DaprClientBuilder;
-import io.dapr.client.domain.HttpExtension;
+import io.dapr.client.DaprInvokeHttpClient;
+import io.dapr.config.Properties;
+
+import java.net.URI;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
 
 /**
  * 1. Build and install jars:
@@ -24,6 +30,16 @@
  * 3. Send messages to the server:
  * dapr run -- java -jar target/dapr-java-sdk-examples-exec.jar \
  *   io.dapr.examples.invoke.http.InvokeClient 'message one' 'message two'
+ *
+ * <p>This example demonstrates calling another Dapr-enabled application over HTTP.
+ * Two equivalent approaches are shown:
+ * <ol>
+ *   <li>{@link DaprClient#invokeHttpClient(String)} — an SDK-provided {@link java.net.http.HttpClient}
+ *       wrapper pre-bound to the sidecar's {@code /v1.0/invoke/&lt;app-id&gt;/method/} prefix,
+ *       with the {@code dapr-api-token} header attached when configured.</li>
+ *   <li>A raw {@link java.net.http.HttpClient} sending the request to the sidecar's base URL
+ *       with a {@code dapr-app-id} header identifying the target app — no SDK helper required.</li>
+ * </ol>
  */
 public class InvokeClient {
 
@@ -32,22 +48,49 @@ public class InvokeClient {
    */
   private static final String SERVICE_APP_ID = "invokedemo";
 
+  /**
+   * Method on the target service to invoke.
+   */
+  private static final String METHOD = "say";
+
   /**
    * Starts the invoke client.
    *
    * @param args Messages to be sent as request for the invoke API.
    */
   public static void main(String[] args) throws Exception {
-    try (DaprClient client = (new DaprClientBuilder()).build()) {
+    try (DaprClient daprClient = new DaprClientBuilder().build()) {
+      DaprInvokeHttpClient invoker = daprClient.invokeHttpClient(SERVICE_APP_ID);
+
+      int port = Properties.HTTP_PORT.get();
+      String sidecarBase = "http://localhost:" + port;
+      HttpClient rawHttpClient = HttpClient.newHttpClient();
+
       for (String message : args) {
-        byte[] response = client.invokeMethod(SERVICE_APP_ID, "say", message, HttpExtension.POST, null,
-            byte[].class).block();
-        System.out.println(new String(response));
-      }
+        // Form 1: SDK helper — paths resolve against /v1.0/invoke/<app-id>/method/.
+        HttpRequest sdkRequest = invoker.newRequestBuilder(METHOD)
+            .header("Content-Type", "application/json")
+            .POST(HttpRequest.BodyPublishers.ofString(message))
+            .build();
+        HttpResponse<byte[]> sdkResponse =
+            invoker.send(sdkRequest, HttpResponse.BodyHandlers.ofByteArray());
+        System.out.println(new String(sdkResponse.body()));
 
-      // This is an example, so for simplicity we are just exiting here.
-      // Normally a dapr app would be a web service and not exit main.
-      System.out.println("Done");
+        // Form 2: raw HttpClient + dapr-app-id header against the sidecar's base URL.
+        HttpRequest headerRequest = HttpRequest.newBuilder()
+            .uri(URI.create(sidecarBase + "/" + METHOD))
+            .header("Content-Type", "application/json")
+            .header("dapr-app-id", SERVICE_APP_ID)
+            .POST(HttpRequest.BodyPublishers.ofString(message))
+            .build();
+        HttpResponse<byte[]> headerResponse =
+            rawHttpClient.send(headerRequest, HttpResponse.BodyHandlers.ofByteArray());
+        System.out.println(new String(headerResponse.body()));
+      }
     }
+
+    // This is an example, so for simplicity we are just exiting here.
+    // Normally a dapr app would be a web service and not exit main.
+    System.out.println("Done");
   }
 }

examples/src/main/java/io/dapr/examples/invoke/http/README.md

@@ -8,9 +8,23 @@ This sample includes:
 
 Visit [this](https://docs.dapr.io/developing-applications/building-blocks/service-invocation/service-invocation-overview/) link for more information about Dapr and service invocation.
 
-## Remote invocation using the Java-SDK
+## Remote invocation using a native HTTP client
 
-This sample uses the Client provided in Dapr Java SDK invoking a remote method. 
+This sample invokes a method on another Dapr-enabled application via the Dapr sidecar using `java.net.http.HttpClient`. The previous SDK-provided `DaprClient.invokeMethod` wrappers are deprecated; calling the sidecar directly is the recommended approach.
+
+Two equivalent approaches are demonstrated:
+
+1. `DaprClient.invokeHttpClient(appId)` — an SDK-provided wrapper that returns a pre-configured `HttpClient` bound to the sidecar's `/v1.0/invoke/<app-id>/method/` prefix, with the `dapr-api-token` header attached when configured.
+2. A raw `java.net.http.HttpClient` sending the request to the sidecar's base URL with a `dapr-app-id` header identifying the target app — no SDK helper required.
+
+> **Migrating from `DaprClient.invokeMethod`:** the deprecated `invokeMethod` APIs serialized request bodies through the configured `DaprObjectSerializer` (JSON by default), so a `String` payload was sent as a JSON string literal — e.g. `"hello"` instead of `hello`. `invokeHttpClient` does **not** serialize bodies: callers supply raw `BodyPublisher`s exactly as with any `java.net.http.HttpClient`. To preserve the previous JSON encoding, use `DaprBodyPublishers.json(Object)`:
+>
+> ```java
+> HttpRequest request = invoker.newRequestBuilder("orders")
+>     .header("Content-Type", "application/json")
+>     .POST(DaprBodyPublishers.json(order))
+>     .build();
+> ```
 
 ## Pre-requisites
 
@@ -104,8 +118,8 @@ Use the following command to execute the demo service example:
 <!-- STEP
 name: Run demo service
 expected_stdout_lines: 
-  - 'Server: "message one"'
-  - 'Server: "message two"'
+  - 'Server: message one'
+  - 'Server: message two'
 background: true
 sleep: 5
 -->
@@ -121,39 +135,62 @@ Once running, the ExposerService is now ready to be invoked by Dapr.
 
 ### Running the InvokeClient sample
 
-The Invoke client sample uses the Dapr SDK for invoking the remote method. The main method declares a Dapr Client using the `DaprClientBuilder` class. Notice that [DaprClientBuilder](https://github.com/dapr/java-sdk/blob/master/sdk/src/main/java/io/dapr/client/DaprClientBuilder.java) can receive two optional serializers: `withObjectSerializer()` is for Dapr's sent and received objects, and `withStateSerializer()` is for objects to be persisted. It needs to know the method name to invoke as well as the application id for the remote application. This example, we stick to the [default serializer](https://github.com/dapr/java-sdk/blob/master/sdk/src/main/java/io/dapr/serializer/DefaultObjectSerializer.java). In `InvokeClient.java` file, you will find the `InvokeClient` class and the `main` method. See the code snippet below:
+The Invoke client sample calls the remote method through the Dapr sidecar using two equivalent approaches:
+
+1. `DaprClient.invokeHttpClient(appId)` — an SDK-provided wrapper around `java.net.http.HttpClient` pre-bound to `/v1.0/invoke/<app-id>/method/`.
+2. A raw `java.net.http.HttpClient` against the sidecar's base URL with a `dapr-app-id` header.
+
+In `InvokeClient.java` file, you will find the `InvokeClient` class and the `main` method. See the code snippet below:
 
 ```java
 public class InvokeClient {
 
-private static final String SERVICE_APP_ID = "invokedemo";
-///...
-public static void main(String[] args) throws Exception {
-    try (DaprClient client = (new DaprClientBuilder()).build()) {
+  private static final String SERVICE_APP_ID = "invokedemo";
+  private static final String METHOD = "say";
+
+  public static void main(String[] args) throws Exception {
+    try (DaprClient daprClient = new DaprClientBuilder().build()) {
+      DaprInvokeHttpClient invoker = daprClient.invokeHttpClient(SERVICE_APP_ID);
+
+      int port = Properties.HTTP_PORT.get();
+      String sidecarBase = "http://localhost:" + port;
+      HttpClient rawHttpClient = HttpClient.newHttpClient();
+
       for (String message : args) {
-        byte[] response = client.invokeMethod(SERVICE_APP_ID, "say", message, HttpExtension.POST, null,
-            byte[].class).block();
-        System.out.println(new String(response));
+        // Form 1: SDK helper — paths resolve against /v1.0/invoke/<app-id>/method/.
+        HttpRequest sdkRequest = invoker.newRequestBuilder(METHOD)
+            .header("Content-Type", "application/json")
+            .POST(HttpRequest.BodyPublishers.ofString(message))
+            .build();
+        HttpResponse<byte[]> sdkResponse =
+            invoker.send(sdkRequest, HttpResponse.BodyHandlers.ofByteArray());
+        System.out.println(new String(sdkResponse.body()));
+
+        // Form 2: raw HttpClient + dapr-app-id header against the sidecar's base URL.
+        HttpRequest headerRequest = HttpRequest.newBuilder()
+            .uri(URI.create(sidecarBase + "/" + METHOD))
+            .header("Content-Type", "application/json")
+            .header("dapr-app-id", SERVICE_APP_ID)
+            .POST(HttpRequest.BodyPublishers.ofString(message))
+            .build();
+        HttpResponse<byte[]> headerResponse =
+            rawHttpClient.send(headerRequest, HttpResponse.BodyHandlers.ofByteArray());
+        System.out.println(new String(headerResponse.body()));
       }
-
-      // This is an example, so for simplicity we are just exiting here.
-      // Normally a dapr app would be a web service and not exit main.
-      System.out.println("Done");
     }
+
+    System.out.println("Done");
   }
-///...
 }
 ```
 
-The class knows the app id for the remote application. It uses the the static `Dapr.getInstance().invokeMethod` method to invoke the remote method defining the parameters: The verb, application id, method name, and proper data and metadata, as well as the type of the expected return type. The returned payload for this method invocation is plain text and not a [JSON String](https://www.w3schools.com/js/js_json_datatypes.asp), so we expect `byte[]` to get the raw response and not try to deserialize it.
- 
+Form 1 uses `DaprClient.invokeHttpClient(SERVICE_APP_ID)` to obtain an HTTP client whose base URI already targets the desired app via the sidecar's invoke API. Form 2 sends the request directly to the sidecar's base URL and uses the `dapr-app-id` header to identify the target app. Both forms call the remote `say` method and print its response.
+
 Execute the follow script in order to run the InvokeClient example, passing two messages for the remote method:
 
 <!-- STEP
 name: Run demo client
-expected_stdout_lines: 
-  - '"message one" received'
-  - '"message two" received'
+expected_stdout_lines:
   - 'Done'
 background: true
 sleep: 5
@@ -165,15 +202,14 @@ dapr run --app-id invokeclient -- java -jar target/dapr-java-sdk-examples-exec.j
 
 <!-- END_STEP -->
 
-Finally, the console for `invokeclient` should output:
+Finally, the console for `invokeclient` should output two timestamps per message — one from each URL form — followed by `Done`. The exact timestamps come from the `say` method on `DemoService`. For example:
 
 ```text
-"message one" received
-
-"message two" received
-
+2026-05-12 13:45:00.123
+2026-05-12 13:45:00.456
+2026-05-12 13:45:00.789
+2026-05-12 13:45:01.012
 Done
-
 ```
 
 For more details on Dapr Spring Boot integration, please refer to [Dapr Spring Boot](../../DaprApplication.java) Application implementation.

sdk/src/main/java/io/dapr/client/DaprBodyPublishers.java

@@ -0,0 +1,74 @@
+/*
+ * Copyright 2026 The Dapr 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 io.dapr.client;
+
+import io.dapr.serializer.DefaultObjectSerializer;
+
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.net.http.HttpRequest.BodyPublisher;
+import java.net.http.HttpRequest.BodyPublishers;
+
+/**
+ * Convenience {@link BodyPublisher} factories for use with {@link DaprInvokeHttpClient}
+ * and the standard {@link java.net.http.HttpClient}.
+ *
+ * <p>{@link DaprClient#invokeHttpClient(String)} intentionally does <em>not</em>
+ * serialize request bodies for you — callers pass raw {@link BodyPublisher}s
+ * exactly as with any {@link java.net.http.HttpClient}. This class provides an
+ * opt-in helper that matches the JSON encoding the deprecated
+ * {@code DaprClient.invokeMethod} APIs applied internally, easing migration.
+ *
+ * <p>Example:
+ * <pre>{@code
+ * record Order(String id, int qty) {}
+ *
+ * HttpRequest request = invoker.newRequestBuilder("orders")
+ *     .header("Content-Type", "application/json")
+ *     .POST(DaprBodyPublishers.json(new Order("o-1", 3)))
+ *     .build();
+ * }</pre>
+ */
+public final class DaprBodyPublishers {
+
+  private static final DefaultObjectSerializer SERIALIZER = new DefaultObjectSerializer();
+
+  private DaprBodyPublishers() {
+  }
+
+  /**
+   * Serializes the given value as JSON using the SDK's default object serializer
+   * (Jackson) and returns a {@link BodyPublisher} carrying the resulting bytes.
+   *
+   * <p>This matches the wire encoding the deprecated
+   * {@code DaprClient.invokeMethod} APIs applied to request payloads: e.g.
+   * {@code json("hello")} emits {@code "hello"} (a JSON string) and
+   * {@code json(null)} emits an empty body.
+   *
+   * <p>Callers are still responsible for setting an appropriate
+   * {@code Content-Type} header (typically {@code application/json}).
+   *
+   * @param value object to serialize; {@code null} yields an empty body.
+   * @return a body publisher carrying the JSON-encoded bytes.
+   * @throws UncheckedIOException if serialization fails.
+   */
+  public static BodyPublisher json(Object value) {
+    try {
+      byte[] bytes = SERIALIZER.serialize(value);
+      return bytes == null ? BodyPublishers.noBody() : BodyPublishers.ofByteArray(bytes);
+    } catch (IOException e) {
+      throw new UncheckedIOException("Failed to JSON-serialize request body", e);
+    }
+  }
+}