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.

 This post is ad-supported
​