gRPC con Java (1era parte)

Ya hemos visto ejemplos de gRPC con:

Ahora continuaremos con Java, el lenguaje preferido por muchos y odiado por otros tantos. Y es que Java es inevitable (sic). Quien necesite o requiera crear microservicios, etc. tendrá que usar alguna vez en su vida este poderoso lenguaje.

Crearemos un proyecto Java con Maven. Se tratará de un proyecto tipo cliente-servidor. En el cual el cliente mandará una cadena cualquiera y el servidor evaluará si es palíndroma o no.

Cadenas como "BOB", "ANITA LAVA LA TINA" serán palíndromas, pues se pueden leer de izquierda a derecha y viceversa. Cualquier otra cadena que no cumpla la regla no será palíndroma.

Requisitos:

Tener Java instalado.
Tener Maven instalado.
Tener la herramienta Protoc instalada.

Creando el proyecto gRPC con Java

1. Creamos el proyecto Java con Maven:

$ mvn archetype:generate -DgroupId=com.inforhomex.grpc -DartifactId=grpc-demo -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

Si tienes Eclipse IDE o cualquier otro, puedes omitir este paso.

Nos ubicamos en el directorio creado.

2. Editamos el archivo ``pom.xml`` para agregar las dependencias necesarias para usar gRPC.

<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.grpc</groupId>
  <artifactId>grpc-demo</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>jar</packaging>
  <name>grpc-demo</name>

  <properties>
    <maven.compiler.source>21</maven.compiler.source>
    <maven.compiler.target>21</maven.compiler.target>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>

    <dependency>
      <groupId>io.grpc</groupId>
      <artifactId>grpc-netty-shaded</artifactId>
      <version>1.63.0</version>
    </dependency>
    <dependency>
      <groupId>io.grpc</groupId>
      <artifactId>grpc-protobuf</artifactId>
      <version>1.63.0</version>
    </dependency>
    <dependency>
      <groupId>io.grpc</groupId>
      <artifactId>grpc-stub</artifactId>
      <version>1.63.0</version>
    </dependency>
	
	<dependency>
  <groupId>jakarta.annotation</groupId>
  <artifactId>jakarta.annotation-api</artifactId>
  <version>1.3.2</version>
</dependency>
  </dependencies>

  <build>
    <plugins>
      <!-- Detecta el sistema operativo para usar el classifier correcto -->
      <plugin>
        <groupId>kr.motd.maven</groupId>
        <artifactId>os-maven-plugin</artifactId>
        <version>1.7.0</version>
        <executions>
          <execution>
            <goals>
              <goal>detect</goal>
            </goals>
          </execution>
        </executions>
      </plugin>

      <!-- Plugin para compilar los .proto -->
      <plugin>
        <groupId>org.xolstice.maven.plugins</groupId>
        <artifactId>protobuf-maven-plugin</artifactId>
        <version>0.6.1</version>
        <configuration>
          <protocArtifact>com.google.protobuf:protoc:3.25.1:exe:${os.detected.classifier}</protocArtifact>
          <pluginId>grpc-java</pluginId>
          <pluginArtifact>io.grpc:protoc-gen-grpc-java:1.63.0:exe:${os.detected.classifier}</pluginArtifact>
        </configuration>
        <executions>
          <execution>
            <goals>
              <goal>compile</goal>
              <goal>compile-custom</goal>
            </goals>
          </execution>
        </executions>
      </plugin>

      <plugin>
        <groupId>org.codehaus.mojo</groupId>
        <artifactId>exec-maven-plugin</artifactId>
        <version>1.4.0</version>
        <configuration>
          <mainClass>com.inforhomex.grpc.App</mainClass>
        </configuration>
      </plugin>

      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.11.0</version>
        <configuration>
          <release>21</release>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

3. Creamos el archivo src/main/proto/palindroma.proto

syntax = "proto3";

option java_package = "com.inforhomex.grpc";
option java_outer_classname = "PalindromaProto";

service PalindromaService {
  rpc evaluaCadena (PalabraRequest) returns (PalabraResponse);
}

message PalabraRequest {
  string cadena = 1;
}

message PalabraResponse {
  string respuesta = 1;
}

Este archivo describe:

Un servicio (PalindromaService) que recibe un PalabraRequest y responde un PalabraResponse.
Que en otras palabras, el método de ese servicio (evaluaCadena) determinará si la cadena recibida es o no una palíndroma.

4. Compilamos el proyecto con Maven o tu IDE preferido (esto generará el código que describimos en el archivo *.proto):

$ mvn clean compile

Nuestro código generado se encontrará en la carpeta target del proyecto.

5. Crearemos una clase tipo service.

PalindromaServiceImpl.java

package com.inforhomex.grpc;

import com.inforhomex.grpc.PalindromaProto.PalabraResponse;
import com.inforhomex.grpc.PalindromaProto.PalabraRequest;
import io.grpc.stub.StreamObserver;

public class PalindromaServiceImpl extends PalindromaServiceGrpc.PalindromaServiceImplBase {

    @Override
    public void evaluaCadena(PalabraRequest request, StreamObserver<PalabraResponse> responseObserver) {
        String cadena = request.getCadena();
        String invertida = new StringBuilder(cadena).reverse().toString();

        String respuesta;
        if (cadena.equalsIgnoreCase(invertida)) {
            respuesta = "La cadena '" + cadena + "' es un palíndromo.";
        } else {
            respuesta = "La cadena '" + cadena + "' NO es un palíndromo.";
        }

        PalabraResponse response = PalabraResponse.newBuilder()
                .setRespuesta(respuesta)
                .build();

        
        responseObserver.onNext(response);
        responseObserver.onCompleted();
    }
}

Esta clase nos servirá para implementar el método evaluaCadena del servicio descrito en el archivo *.proto. El código es simple. Toma la cadena y la convierte en su reverso. Mejoraremos el código.

6. Crearemos el programa que servirá como servidor.

PalindromaServer.java

package com.inforhomex.grpc;

import io.grpc.Server;
import io.grpc.ServerBuilder;

public class PalindromaServer {
    

    public static void main(String[] args) throws Exception {
        Server server = ServerBuilder.forPort(50051)
                .addService(new PalindromaServiceImpl())
                .build()
                .start();

        System.out.println("Servidor gRPC iniciado en el puerto 50051");

        server.awaitTermination();
    }
}

7. Crearemos el programa que servirá como cliente.

PalindromaClient.java

package com.inforhomex.grpc;

import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;
import com.inforhomex.grpc.PalindromaProto.PalabraResponse;
import com.inforhomex.grpc.PalindromaProto.PalabraRequest;

public class PalindromaClient {
    public static void main(String[] args) {
        ManagedChannel channel = ManagedChannelBuilder.forAddress("localhost", 50051)
                .usePlaintext()
                .build();

        PalindromaServiceGrpc.PalindromaServiceBlockingStub stub =
                PalindromaServiceGrpc.newBlockingStub(channel);

        PalabraRequest request = PalabraRequest.newBuilder()
                .setCadena("bob")
                .build();

        PalabraResponse response = stub.evaluaCadena(request);
        System.out.println("Respuesta del servidor: " + response.getRespuesta());

        channel.shutdown();
    }
}

8. Ejecutamos el Servidor:

$ mvn exec:java -Dexec.mainClass="com.inforhomex.grpc.PalindromaServer"

9. Ejecutamos el Cliente (desde otra terminal):

$ mvn exec:java -Dexec.mainClass="com.inforhomex.grpc.PalindromaClient"

En caso de error, tendremos que modificar el archivo 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.grpc</groupId>
  <artifactId>grpc-demo</artifactId>
  <version>1.0</version>
  <packaging>jar</packaging>
  <name>grpc-demo</name>

  <properties>
    <maven.compiler.source>21</maven.compiler.source>
    <maven.compiler.target>21</maven.compiler.target>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>

    <dependency>
      <groupId>io.grpc</groupId>
      <artifactId>grpc-netty-shaded</artifactId>
      <version>1.63.0</version>
    </dependency>
    <dependency>
      <groupId>io.grpc</groupId>
      <artifactId>grpc-protobuf</artifactId>
      <version>1.63.0</version>
    </dependency>
    <dependency>
      <groupId>io.grpc</groupId>
      <artifactId>grpc-stub</artifactId>
      <version>1.63.0</version>
    </dependency>


<dependency>
    <groupId>javax.annotation</groupId>
    <artifactId>javax.annotation-api</artifactId>
    <version>1.3.2</version>
</dependency>



  </dependencies>

  <build>
    <plugins>
      <!-- Detecta el sistema operativo para usar el classifier correcto -->
      <plugin>
        <groupId>kr.motd.maven</groupId>
        <artifactId>os-maven-plugin</artifactId>
        <version>1.7.0</version>
        <executions>
          <execution>
            <goals>
              <goal>detect</goal>
            </goals>
          </execution>
        </executions>
      </plugin>

      <!-- Plugin para compilar los .proto -->
      <plugin>
        <groupId>org.xolstice.maven.plugins</groupId>
        <artifactId>protobuf-maven-plugin</artifactId>
        <version>0.6.1</version>
        <configuration>
          <protocArtifact>com.google.protobuf:protoc:3.25.1:exe:${os.detected.classifier}</protocArtifact>
          <pluginId>grpc-java</pluginId>
          <pluginArtifact>io.grpc:protoc-gen-grpc-java:1.63.0:exe:${os.detected.classifier}</pluginArtifact>
        </configuration>
        <executions>
          <execution>
            <goals>
              <goal>compile</goal>
              <goal>compile-custom</goal>
            </goals>
          </execution>
        </executions>
      </plugin>

    

      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.11.0</version>
        <configuration>
          <release>21</release>
        </configuration>
      </plugin>
	  
	  
	  
	  
	  
	  <plugin>
  <groupId>org.codehaus.mojo</groupId>
  <artifactId>exec-maven-plugin</artifactId>
  <version>1.4.0</version>
  <executions>
    <execution>
      <id>run-server</id>
      <goals>
        <goal>java</goal>
      </goals>
      <configuration>
        <mainClass>com.inforhomex.grpc.PalindromaServer</mainClass>
      </configuration>
    </execution>

    <execution>
      <id>run-client</id>
      <goals>
        <goal>java</goal>
      </goals>
      <configuration>
        <mainClass>com.inforhomex.grpc.PalindromaClient</mainClass>
      </configuration>
    </execution>
  </executions>
</plugin>
	  
	  
	  
	  
	  
	  
	  
	  
    </plugins>
  </build>
</project>

Por lo que ahora para arancar el servidor tecleamos:

$ mvn exec:java@run-server

Y para el cliente:

$ mvn exec:java@run-client

Salida del servidor:

Servidor gRPC iniciado en el puerto 50051

Salida del cliente:

Respuesta del servidor: La cadena 'bob' es un palíndromo.

La cadena "bob" es una palíndroma, por lo que la respuesta es correcta. Pero que pasaría si le mandamos otra cadena como "anita lava la tina".

Salida:

Respuesta del servidor: La cadena 'anita lava la tina' NO es un palíndromo.

¡Da error!

Aunque la cadena si es palíndroma. Y la rqzón es porque el código solo evalua si las cadenas son las mismas, pero omite espacios en blanco y posición de los caracteres.

Corregiremos el código en el siguiente post.

Enlaces:

https://grpcurl.com/
https://grpc.io/
https://protobuf.dev/
https://emanuelpeg.blogspot.com/2024/01/que-es-grpc.html

Odin language: el lenguaje de programación orientado a datos para un desarrollo de software sensato

En esta serie sobre lenguajes de programación hablamos de Odin , un lenguaje orientado a datos. Un nuevo lenguaje de programación que nos podrá recordar a lenguajes como C++, Python, Golang o hasta Rust. Instalación (Windows): 1 2 3 4 $ git clone https://github.com/odin-lang/Odin $ cd Odin $ git pull $ build.bat release Debemos asegurarnos de crear la variable de entorno: Nombre: ODIN_HOME Valor: C:\Users\HP\Documents\pruebasOdin\Odin Ejemplo 1. Como primer programa tendremos al clásico "Hola, mundo". holamundo.odin package holamundo import " core:fmt " main : : proc ( ) { fmt . println ( " ¡Hola, mundo desde Odin! " ) } Construimos: $ odin build holamundo . odin - file Ejecutamos: $ holamundo .exe Recordar que si usamos Visual Studio Code podemos instalar el plugin de Odin Language: https://marketplace.visualstudio.com/items?itemName=DanielGavin.ols Ejemplo 2. Programa que muestre las variables que pod...

Alquimista de código

Buscar este blog