gRPC en Java (y Protobuff)

En este post vamos a ejecutar el ejemplo de cliente-servidor de gRPC para Java del repositorio oficial y crearemos un sencillo ejemplo con Protobuff.

En resumen:

1. Clonar el repositorio oficial de gRPC.
2. Ejecutarlo.
3. Crear un proyecto Java con Maven.
4. Modificar el proyecto. 
5. Agregar Gradle en lugar de Maven.
6. Ejecutar el proyecto Protobuf con Gradle.
   

Clonamos el repositorio de ejemplos para Java:

$ git clone -b v1.63.0 --depth 1 https://github.com/grpc/grpc-java

Nos ubicamos en la carpeta de Java:

$ cd grpc-java/examples

Compilamos el cliente y servidor:

$ ./gradlew installDist

Abrimos una terminal para ejecutar el servidor:

$ ./build/install/examples/bin/hello-world-server

Abrimos otra terminal para ejecutar el cliente:

$ ./build/install/examples/bin/hello-world-client

Si todo funciona podrás ver lo siguiente:

INFO: Server started, listening on 50051

En el lado del servidor, y en el lado del cliente:

INFO: Will try to greet world ...
INFO: Greeting: Hello world

Creando un proyecto Java y gRPC

Creamos un proyecto Java con Maven:

mvn archetype:generate -DgroupId=com.inforhomex.main -DartifactId=grpcwithjava -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

Editamos el pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.inforhomex.main</groupId>
  <artifactId>grpcwithjava</artifactId>
  <packaging>jar</packaging>
  <version>1.0-SNAPSHOT</version>
  <name>grpcwithjava</name>
  <url>http://maven.apache.org</url>

  <properties>
   <maven.compiler.source>1.8</maven.compiler.source>
   <maven.compiler.target>1.8</maven.compiler.target>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
      
    
    <dependency>
        <groupId>com.google.protobuf</groupId>
        <artifactId>protobuf-java</artifactId>
        <version>4.26.1</version>
      </dependency>

  </dependencies>

  <build>
    <extensions>
      <extension>
        <groupId>kr.motd.maven</groupId>
        <artifactId>os-maven-plugin</artifactId>
        <version>1.6.1</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.21.7:exe:${os.detected.classifier}</protocArtifact>
          <pluginId>grpc-java</pluginId>
          <pluginArtifact>io.grpc:protoc-gen-grpc-java:1.51.0:exe:${os.detected.classifier}</pluginArtifact>
          <outputBaseDirectory>src/main/java/</outputBaseDirectory>
          <outputDirectory>src/main/java/</outputDirectory>
          <clearOutputDirectory>false</clearOutputDirectory>
          <protoSourceRoot> 
            ${basedir}/src/main/resources/proto/ 
            </protoSourceRoot>
      </configuration>
      <executions>
          <execution>
              <goals>
                  <goal>compile</goal>
                  <goal>compile-custom</goal>
              </goals>
              <configuration>
              </configuration>
          </execution>
      </executions>
  </plugin>
    



    </plugins>
  </build>



</project>

Instalar Protobuf

sudo apt install -y protobuf-compiler

Verificamos instalación:

protoc --version

Para sistemas Windows podemos usar:

choco install protoc

O así:

choco --install -y protoc

Creamos un archivo .proto

saludar.proto

syntax = "proto3";
option java_multiple_files = true;
package ejemplo.saludo;


message Saludo{
    string nombre = 1;
    string apellido = 2;
}

Este archivo, al ser compilado con protoc, nos generará las clases Java correspondientes.

Podemos hacer esto:

protoc --proto_path=src --java_out=src/main/java src/main/proto/saludar.proto

En caso de que exista problemas con Maven (e incluso con protoc), se puede optar por usar Gradle. Sustituimos el pom.xml por el build.gradle.

build.gradle

plugins {
    id "java"
    id "com.google.protobuf" version "0.9.0"
}

group 'com.inforhomex.main'
version '1.0-SNAPSHOT'

repositories {
    mavenCentral()
}

ext {
    protoVersion =  "3.21.9" // "3.6.1"
}

protobuf {
    protoc {
        artifact = "com.google.protobuf:protoc:$protoVersion"
    }
}

dependencies {
    implementation "com.google.protobuf:protobuf-java:$protoVersion"
    implementation "com.google.protobuf:protobuf-java-util:$protoVersion"
}


task saludar(type: JavaExec){
    group = "Execution"
    description = "Clase principal"
    classpath = sourceSets.main.runtimeClasspath
    mainClass = 'saludar.SaludarMain'
}

Vamos a modificar el proyecto, eliminamos el paquete com.inforhomex.main y creamos un paquete llamado saludar.  Dentro de este paquete la clase principal será la siguiente:

SaludarMain.java

package saludar;

// Importamos clase generada
import ejemplo.saludo.Saludo;

public class SaludarMain{
    public static void main(String[] args) {
        System.out.println("\t [  Proyecto Java con Protobuf & gRPC ]");
        Saludo saludo = Saludo.newBuilder().setNombre("Thomas")
        .setApellido("Muller").build();
        // Imprimimos en consola
        System.out.println(saludo);
    }
}

Para ejecutar el proyecto con Gradle:

$ gradle build
$ gradle tasks
$ gradle saludar

Si ejecutó correctamente, veremos algo como esto:

> Task :saludar
         [  Proyecto Java con Protobuf & gRPC ]
nombre: "Thomas"
apellido: "Muller"

Más ejemplos en próximas entregas.

Enlaces:

https://github.com/Clement-Jean/proto-java-course
https://grpc.io
https://protobuf.dev/