On the previous example we had a Java application spinning up an http server and upon this Java process operating a GRPC application.
If you use frameworks like Spring you might wonder how you can achieve a Grpc and Spring integration.
There are libraries out there that do so, we shall use the grpc-spring-boot-starter from io.github.lognet.
We shall start with the dependencies. We do need to import the gRPC generating plugins we used on the previous example.
<dependencies>
<dependency>
<groupId>io.github.lognet</groupId>
<artifactId>grpc-spring-boot-starter</artifactId>
<version4.5.8</version>
</dependency>
</dependencies>
<build>
<extensions>
<extension>
<groupId>kr.motd.maven</groupId>
<artifactId>os-maven-plugin</artifactId>
<version>1.6.2</version>
</extension>
</extensions>
<plugins>
<plugin>
<groupId>org.xolstice.maven.plugins</groupId>
<artifactId>protobuf-maven-plugin</artifactId>
<version>0.6.1</version>
<configuration>
<protocArtifact>com.google.protobuf:protoc:3.17.2:exe:${os.detected.classifier}</protocArtifact>
<pluginId>grpc-java</pluginId>
<pluginArtifact>io.grpc:protoc-gen-grpc-java:1.39.0:exe:${os.detected.classifier}</pluginArtifact>
</configuration>
<executions>
<execution>
<goals>
<goal>compile</goal>
<goal>compile-custom</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>What happens behind the scenes.
- Spring environment spins up
- gRPC Server starts
- Spring services annotated with @GRpcService are picked up and registered to the gRPC server
- Security and other filtering based components are integrated with the equivalent gRPC ServerInterceptor.
So pretty much we expect that instead of controllers we shall have GRpcServices and ServerInterceptors for filters.
Let’s add the proto files. We shall use the same proto of the previous example.
The location is src/main/proto/Order.proto and the contents would be
syntax = "proto3";
option java_multiple_files = true;
option java_package = "com.egkatzioura.order.v1";
service OrderService {
rpc ExecuteOrder(OrderRequest) returns (OrderResponse) {};
}
message OrderRequest {
string email = 1;
string product = 2;
int32 amount = 3;
}
message OrderResponse {
string info = 1;
}As expected an mvn clean install will generate the gRPC classes. Now we should create the spring service.
package com.gkatzioura.order.impl;
import com.egkatzioura.order.v1.OrderRequest;
import com.egkatzioura.order.v1.OrderResponse;
import com.egkatzioura.order.v1.OrderServiceGrpc;
import io.grpc.stub.StreamObserver;
import org.lognet.springboot.grpc.GRpcService;
@GRpcService
public class OrderServiceImpl extends OrderServiceGrpc.OrderServiceImplBase{
@Override
public void executeOrder(OrderRequest request, StreamObserver<OrderResponse> responseObserver) {
OrderResponse response = OrderResponse.newBuilder()
.setInfo("Hi "+request.getEmail()+", you order has been executed")
.build();
responseObserver.onNext(response);
responseObserver.onCompleted();
}
}Also let’s add the main class
package com.gkatzioura.order;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}The Spring context is spun up, and the @GRpcService annotated services kick off.
By default the port would be 6565
Let’s run the same client that we run on the previous example.
package com.gkatzioura.order;
import com.egkatzioura.order.v1.Order;
import com.egkatzioura.order.v1.OrderRequest;
import com.egkatzioura.order.v1.OrderResponse;
import com.egkatzioura.order.v1.OrderServiceGrpc;
import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;
public class ApplicationClient {
public static void main(String[] args) {
ManagedChannel managedChannel = ManagedChannelBuilder.forAddress("localhost", 6565)
.usePlaintext()
.build();
OrderServiceGrpc.OrderServiceBlockingStub orderServiceBlockingStub
= OrderServiceGrpc.newBlockingStub(managedChannel);
OrderRequest orderRequest = OrderRequest.newBuilder()
.setEmail("hello@word.com")
.setProduct("no-name")
.setAmount(3)
.build();
OrderResponse orderResponse = orderServiceBlockingStub.executeOrder(orderRequest);
System.out.println("Received response: "+orderResponse.getInfo());
managedChannel.shutdown();
}
}The response is the one expected. We did connect to the server and got back a response. We did not have to manually register the services to the gRPC server, since spring did this one for us. You can find the code on github.
Published on Java Code Geeks with permission by Emmanouil Gkatziouras, partner at our JCG program. See the original article here: Add Grpc to your Spring Application Opinions expressed by Java Code Geeks contributors are their own. |
