gRPC en Java: cuándo usarlo y cómo no equivocarse al elegir

Introducción: ¿REST ha muerto? No, solo ha aparecido una opción

Cada desarrollador Java ha escrito al menos una vez una API REST. Es cómodo, familiar, y el JSON se lee a simple vista. Pero cuando la carga crece y los retrasos se vuelven críticos, REST empieza a chirriar. Y entonces entra en escena gRPC — una tecnología de Google que promete velocidad como la de una llamada local, velocidad de serialización 10 veces mayor que JSON y soporte integrado para streaming.

En este artículo analizaremos cuándo gRPC en Java está realmente justificado y cuándo es mejor quedarse con REST. Sin rodeos: solo escenarios reales, ejemplos de código y benchmarks honestos.

¿Qué es gRPC y por qué se habla de él?

gRPC es un framework para llamadas a procedimientos remotos (RPC). En lugar de JSON, utiliza Protocol Buffers (protobuf) — un formato de serialización binario. En lugar de HTTP/1.1, utiliza HTTP/2 con multiplexación y compresión de cabeceras.

Para Java, esto significa:

\n
• Tipado estricto de contratos mediante archivos .proto
\n
• Generación automática de clientes y servidores
\n
• Cuatro tipos de interacción: unario, server streaming, client streaming, bidireccional streaming
\n
• Soporte integrado para timeouts, deadlines y balanceo de carga
\n

¿Cómo se ve un archivo .proto típico?

syntax = "proto3";\n\npackage com.pythonlib.example;\n\nservice UserService {\n    rpc GetUser (UserRequest) returns (UserResponse);\n    rpc ListUsers (UserListRequest) returns (stream UserResponse);\n    rpc UpdateUser (stream UserUpdateRequest) returns (UserResponse);\n    rpc Chat (stream ChatMessage) returns (stream ChatMessage);\n}\n\nmessage UserRequest {\n    int32 id = 1;\n}\n\nmessage UserResponse {\n    int32 id = 1;\n    string name = 2;\n    string email = 3;\n}\n\nmessage UserListRequest {\n    int32 page = 1;\n    int32 size = 2;\n}\n\nmessage UserUpdateRequest {\n    int32 id = 1;\n    string name = 2;\n}\n\nmessage ChatMessage {\n    string user = 1;\n    string text = 2;\n}\n

Después de compilar con protoc, obtendrás una clase Java lista con builders — sin mapeadores manuales.

¿Cuándo es gRPC en Java la mejor opción? 5 escenarios

1. Microservicios con alta carga

Si tienes 50+ microservicios que se comunican entre sí miles de veces por segundo, gRPC reduce la latencia entre un 30-50% en comparación con REST. Protobuf ocupa menos espacio, HTTP/2 permite mantener una sola conexión para todas las solicitudes.

Ejemplo práctico: migramos un servicio interno de recomendaciones de REST a gRPC. El tiempo de respuesta bajó de 12 ms a 4 ms, y el tráfico se redujo 3 veces.

2. Streaming de datos en tiempo real

gRPC soporta de forma nativa server-side streaming, client-side streaming y bidireccional streaming. Es ideal para:

\n
• Logs y métricas (el agente envía un flujo de datos)
\n
• Sistemas de chat y notificaciones
\n
• Procesamiento de archivos grandes por fragmentos
\n

Implementación de un servidor con server streaming en Java:

import io.grpc.stub.StreamObserver;\n\npublic class UserServiceImpl extends UserServiceGrpc.UserServiceImplBase {\n\n    @Override\n    public void listUsers(UserListRequest request,\n                          StreamObserver<UserResponse> responseObserver) {\n        for (int i = 0; i < 10; i++) {\n            UserResponse user = UserResponse.newBuilder()\n                    .setId(i)\n                    .setName("User_" + i)\n                    .setEmail("user" + i + "@pythonlib.ru")\n                    .build();\n            responseObserver.onNext(user);\n            try {\n                Thread.sleep(200); // simulación de retardo\n            } catch (InterruptedException e) {\n                responseObserver.onError(e);\n            }\n        }\