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

z/OS, ¿Qué es? y ¿Cuáles son sus herramientas?

En este post veremos las herramientas de z/OS de IBM. z/OS es un sistema operativo de mainframe desarrollado por IBM. Es parte de la serie IBM z Systems (anteriormente conocida como System z), que se utiliza en los sistemas mainframe de IBM. z/OS es uno de los sistemas operativos más utilizados en el mundo empresarial para ejecutar aplicaciones críticas y procesar grandes volúmenes de datos. Características clave de z/OS: Escalabilidad : z/OS es conocido por su capacidad para manejar grandes cargas de trabajo y escalabilidad vertical, lo que permite agregar recursos de hardware para satisfacer las demandas de procesamiento. Confiabilidad y disponibilidad : z/OS está diseñado para ofrecer alta disponibilidad y confiabilidad. Incorpora características como redundancia y recuperación ante fallas para garantizar la continuidad de las operaciones. Seguridad : Proporciona una amplia gama de funciones de seguridad, como autenticación, autorización y auditoría, para proteger los...

Alquimista de código

Buscar este blog