Add gRPC client sample with Spring Integration

Implement a new basic sample demonstrating Spring Integration's gRPC
client capabilities. This sample shows how to integrate gRPC with
Spring Boot and Spring Integration for both single-response and
streaming response patterns.

This example is based on the proto file that exists in the Spring
gRPC project, to provide user familiarity

Author: cppwfs

basic/grpc-client/README.md

@@ -0,0 +1,58 @@
+gRPC Client Sample
+==================
+
+This example demonstrates the use of Spring Integration's **gRPC Outbound Gateway** for client-side communication.
+
+It uses Java configuration and the Spring Integration DSL to configure the gRPC client adapters.
+
+The sample demonstrates two gRPC communication patterns:
+
+1. **Single Response** - Simple request/reply pattern where the client sends a request and receives a single response
+2. **Streaming Response** - The client sends a request and receives a stream of responses
+
+## Prerequisites
+
+This sample requires a gRPC server to be running. You can use any gRPC server that implements the `Simple` service defined in `hello.proto`, or run the test which uses an in-process gRPC server.
+
+## Running the sample
+
+### Command Line Using Gradle
+
+To run the sample using Gradle, execute:
+
+    $ gradlew :grpc-client:bootRun
+
+This will start the Spring Boot application using the [Spring Boot Gradle Plugin](https://docs.spring.io/spring-boot/docs/current/gradle-plugin/reference/html/).
+
+## Configuration
+
+The application expects a gRPC server to be available. By default, it connects to `localhost:9090`. You can configure the server address in `application.properties`:
+
+```properties
+spring.grpc.client.channels.local.address=static://localhost:9090
+```
+
+## Output
+
+The application demonstrates two patterns:
+
+### Single Response Pattern
+
+The client sends a `HelloRequest` with name "Jack" and receives a single `HelloReply`:
+
+    Single response reply: message: Hello Jack
+
+### Streaming Response Pattern
+
+The client sends a `HelloRequest` with name "Jane" and receives multiple `HelloReply` messages:
+
+    Stream received reply: Hello Jane
+    Stream received reply: Hello Again
+
+## Running the Tests
+
+The test uses an in-process gRPC server and does not require an external server:
+
+    $ gradlew :grpc-client:test
+
+The test validates both single-response and streaming-response patterns.

basic/grpc-client/src/main/java/org/springframework/integration/samples/Application.java

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2026-present 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.integration.samples;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+/**
+ * Run the gRPC client sample application.
+ * <p>
+ * Demonstrates how to use Spring Integration with gRPC for client-side communication.
+ *
+ * @author Glenn Renfro
+ */
+@SpringBootApplication
+public class Application {
+
+	/**
+	 * Run the Spring Boot application.
+	 * @param args the command line arguments
+	 */
+	public static void main(String[] args) {
+		SpringApplication.run(Application.class, args);
+	}
+
+}

basic/grpc-client/src/main/java/org/springframework/integration/samples/GrpcClientConfiguration.java

@@ -0,0 +1,123 @@
+/*
+ * Copyright 2026-present 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.integration.samples;
+
+import io.grpc.ManagedChannel;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import reactor.core.publisher.Flux;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.boot.ApplicationRunner;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.grpc.client.GrpcChannelFactory;
+import org.springframework.integration.channel.FluxMessageChannel;
+import org.springframework.integration.core.MessagingTemplate;
+import org.springframework.integration.dsl.IntegrationFlow;
+import org.springframework.integration.grpc.dsl.Grpc;
+import org.springframework.integration.support.MessageBuilder;
+import org.springframework.messaging.Message;
+import org.springframework.messaging.MessageChannel;
+
+/**
+ * Service for demonstrating gRPC client functionality with Spring Integration.
+ *
+ * @author Glenn Renfro
+ */
+@Configuration(proxyBeanMethods = false)
+public class GrpcClientConfiguration {
+
+	private static final Log LOGGER = LogFactory.getLog(GrpcClientConfiguration.class);
+
+	@Bean
+	ManagedChannel managedChannel(GrpcChannelFactory factory) {
+		return factory.createChannel("local");
+	}
+
+	/**
+	 * Create an integration flow for outbound gRPC requests with single responses.
+	 * @param managedChannel the gRPC managed channel
+	 * @return the integration flow
+	 */
+	@Bean
+	IntegrationFlow grpcOutboundFlowSingleResponse(ManagedChannel managedChannel) {
+		return flow -> flow
+				.handle(Grpc.outboundGateway(managedChannel, SimpleGrpc.class)
+						.methodName("SayHello"));
+	}
+
+	/**
+	 * Create an integration flow for outbound gRPC requests with streaming responses.
+	 * @param managedChannel the gRPC managed channel
+	 * @return the integration flow
+	 */
+	@Bean
+	IntegrationFlow grpcOutboundFlowStreamResponse(ManagedChannel managedChannel) {
+		return flow -> flow
+				.handle(Grpc.outboundGateway(managedChannel, SimpleGrpc.class)
+						.methodName("StreamHello"));
+	}
+
+	/**
+	 * Create an application runner that sends a single gRPC request and receives a single response.
+	 * @param grpcInputChannelSingleResponse the message channel for single response requests
+	 * @return the application runner
+	 */
+	@Bean
+	ApplicationRunner grpcClientSingleResponse(
+			@Autowired @Qualifier("grpcOutboundFlowSingleResponse.input") MessageChannel grpcInputChannelSingleResponse) {
+
+		return args -> {
+			HelloReply reply = new MessagingTemplate().convertSendAndReceive(grpcInputChannelSingleResponse,
+					HelloRequest.newBuilder().setName("Jack").build(),
+					HelloReply.class);
+
+			LOGGER.info("Single response reply: " + (reply != null ? reply.getMessage() : "No reply received"));
+		};
+	}
+
+	/**
+	 * Create an application runner that sends a gRPC request and receives a stream of responses.
+	 * @param grpcInputChannel the message channel for streaming response requests
+	 * @return the application runner
+	 */
+	@Bean
+	ApplicationRunner grpcClientStreamResponse(
+			@Autowired @Qualifier("grpcOutboundFlowStreamResponse.input") MessageChannel grpcInputChannel) {
+
+		return args -> {
+			FluxMessageChannel grpcStreamOutputChannel = new FluxMessageChannel();
+			Flux.from(grpcStreamOutputChannel)
+						.map(message -> (HelloReply) message.getPayload())
+						.map(HelloReply::getMessage)
+						.doOnNext(msg -> LOGGER.info("Stream received reply: " + msg))
+						.doOnError(error -> {
+							LOGGER.error("Error in stream: " + error.getMessage(), error);
+						})
+						.subscribe();
+
+				Message<?> requestMessage = MessageBuilder
+						.withPayload(HelloRequest.newBuilder().setName("Jane").build())
+						.setReplyChannel(grpcStreamOutputChannel)
+						.build();
+				grpcInputChannel.send(requestMessage);
+		};
+	}
+
+}

basic/grpc-client/src/main/proto/hello.proto

@@ -0,0 +1,23 @@
+syntax = "proto3";
+
+option java_multiple_files = true;
+option java_package = "org.springframework.integration.samples";
+option java_outer_classname = "HelloWorldProto";
+
+// The greeting service definition.
+service Simple {
+    // Sends a greeting
+    rpc SayHello (HelloRequest) returns (HelloReply) {
+    }
+    rpc StreamHello(HelloRequest) returns (stream HelloReply) {}
+}
+
+// The request message containing the user's name.
+message HelloRequest {
+    string name = 1;
+}
+
+// The response message containing the greetings
+message HelloReply {
+    string message = 1;
+}

basic/grpc-client/src/main/resources/application.properties

@@ -0,0 +1,2 @@
+# gRPC Client Configuration
+spring.grpc.client.channels.local.address=static://localhost:9090

basic/grpc-client/src/test/java/org/springframework/integration/samples/GrpcClientTests.java

@@ -0,0 +1,102 @@
+/*
+ * Copyright 2026-present 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.integration.samples;
+
+import java.time.Duration;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.context.TestConfiguration;
+import org.springframework.boot.test.system.CapturedOutput;
+import org.springframework.boot.test.system.OutputCaptureExtension;
+import org.springframework.context.annotation.Bean;
+import org.springframework.test.annotation.DirtiesContext;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.awaitility.Awaitility.await;
+
+/**
+ * Integration test for gRPC client functionality.
+ *
+ * @author Glenn Renfro
+ */
+@SpringBootTest(properties = {
+		"spring.grpc.server.inprocess.name=test",
+		"spring.grpc.client.channels.local.address=in-process:test"
+})
+@DirtiesContext
+@ExtendWith(OutputCaptureExtension.class)
+public class GrpcClientTests {
+
+	/**
+	 * Verify the gRPC service returns the expected greeting message.
+	 * @param output the captured console output
+	 */
+	@Test
+	void verifyMessage(CapturedOutput output) {
+		await()
+				.atMost(Duration.ofSeconds(5))
+				.untilAsserted(() -> {
+					assertThat(output.getAll())
+							.contains("Single response reply: Hello Jack")
+							.contains("Stream received reply: Hello Jane")
+							.contains("Stream received reply: Hello Again");
+				});
+	}
+
+	@TestConfiguration(proxyBeanMethods = false)
+	static class TestGrpcServerConfig {
+
+		/**
+		 * Create a test gRPC service implementation for the Simple service.
+		 * @return the gRPC service implementation
+		 */
+		@Bean
+		SimpleGrpc.SimpleImplBase simpleService() {
+			return new SimpleGrpc.SimpleImplBase() {
+
+				@Override
+				public void sayHello(HelloRequest request, io.grpc.stub.StreamObserver<HelloReply> responseObserver) {
+					HelloReply reply = HelloReply.newBuilder()
+							.setMessage("Hello " + request.getName())
+							.build();
+					responseObserver.onNext(reply);
+					responseObserver.onCompleted();
+				}
+
+				@Override
+				public void streamHello(HelloRequest request,
+						io.grpc.stub.StreamObserver<HelloReply> responseObserver) {
+
+					HelloReply reply = HelloReply.newBuilder()
+							.setMessage("Hello " + request.getName())
+							.build();
+					responseObserver.onNext(reply);
+					reply = HelloReply.newBuilder()
+							.setMessage("Hello Again")
+							.build();
+					responseObserver.onNext(reply);
+					responseObserver.onCompleted();
+				}
+			};
+		}
+
+	}
+
+}