Organiza tus páginas con colecciones
Guarda y categoriza el contenido según tus preferencias.
gRPC es un framework de RPC moderno, de código abierto y de alto rendimiento, que se puede ejecutar en cualquier entorno. Puede conectar de forma eficiente servicios en centros de datos y entre ellos con compatibilidad conectable para balanceo de cargas, seguimiento, verificación de estado y autenticación. También se aplica en el último tramo de la computación distribuida para conectar dispositivos, aplicaciones para dispositivos móviles y navegadores a servicios de backend. Puedes encontrar documentación en el sitio web oficial de gRPC y obtener asistencia de comunidades de código abierto. En esta guía, encontrarás soluciones a fin de compilar apps para Android con gRPC.
grpc.io es el sitio web oficial para el proyecto de gRPC. Para obtener más información acerca de cómo funciona gRPC, consulta ¿Qué es gRPC?
y Conceptos de gRPC.
Si deseas aprender a usar gRPC en una app para Android, consulta el ejemplo de Hello World en la Guía de inicio rápido de Java para Android de gRPC.
También puedes encontrar otros varios ejemplos de Android de gRPC en GitHub.
Funciones
Simplificación gracias a llamadas a procedimientos
Debido a que es RPC, el modelo de programación consiste en llamadas a procedimiento: el aspecto de red de la tecnología se abstrae del código de la aplicación, por lo que parece casi como si fuera una llamada normal a función en proceso. Tu interacción cliente-servidor no estará limitada por la semántica de los métodos de recursos HTTP (como GET, PUT, POST y DELETE). En comparación con las APIs de REST, tu implementación se ve más natural, sin la necesidad de controlar los metadatos del protocolo HTTP.
Transmisión de red eficiente con HTTP/2
La transmisión de datos desde dispositivos móviles a un servidor de backend puede ser un proceso que requiera muchos recursos. Con el protocolo HTTP/1.1 estándar, las conexiones frecuentes de un dispositivo móvil a un servicio en la nube pueden agotar la batería, aumentar la latencia y bloquear la conexión de otras apps. De forma predeterminada, gRPC se ejecuta sobre HTTP/2, que presenta la transmisión bidireccional, el control de flujo, la compresión del encabezado y la capacidad de multiplexar solicitudes en una sola conexión TCP/IP. El resultado es que gRPC puede reducir el uso de recursos, lo que da como resultado tiempos de respuesta más bajos entre tu app y los servicios que se ejecutan en la nube, un uso reducido de la red y una mayor duración de la batería para los clientes que se ejecutan en dispositivos móviles.
Asistencia incorporada de intercambio de datos de transmisión
gRPC se diseñó teniendo en cuenta la compatibilidad de HTTP/2 para la transmisión bidireccional de dúplex completo desde el principio. La transmisión permite que una solicitud y una respuesta tengan un tamaño arbitrariamente grande, como las operaciones que requieren subir o descargar una gran cantidad de información. Con la transmisión, el cliente y el servidor pueden leer y escribir mensajes simultáneamente y suscribirse entre sí sin realizar un seguimiento de los ID de recursos. Esto hace que la implementación de tu app sea más flexible.
Integración continua con el búfer de protocolo
gRPC usa búferes de protocolo (Protobuf) como su método de serialización/deserialización con el complemento codegen optimizado para Android (Protobuf Java Lite).
En comparación con el formato basado en texto (como JSON), Protobuf ofrece un intercambio de datos más eficiente en términos de velocidad de ordenamiento y tamaño de código, lo que lo hace más adecuado para usarlo en entornos móviles. Además, la sintaxis concisa de la definición de mensaje/servicio de Protobuf facilita mucho la definición del modelo de datos y los protocolos de aplicación para tu app.
Definir servicios de RPC con búferes de protocolo y generar las interfaces de cliente de gRPC
Crear un canal que sirva como medio para las llamadas RPC entre el cliente y el servidor
Crear un cliente Stub como punto de entrada para iniciar llamadas RPC del lado del cliente
Realizar llamadas RPC al servidor remoto como lo harías cuando realizas llamadas a procedimientos locales
Para fines de demostración, en el ejemplo proporcionado, los bytes se transmiten en texto sin formato. Sin embargo, tu app siempre debe encriptar los datos de la red en producción. gRPC proporciona compatibilidad con la encriptación SSL/TLS, además de intercambio de tokens OAuth (OAuth2 con servicios de Google) para la autenticación. Para conocer más detalles, consulta TLS en Android y Cómo usar OAuth2.
Transporte
gRPC ofrece dos opciones de implementaciones de transporte para clientes de Android: OkHttp y Cronet.
Elección de un transporte (avanzado)
OkHttp
OkHttp es una pila de redes liviana diseñada para usar en dispositivos móviles. Es el transporte predeterminado de gRPC para ejecutar en el entorno de Android. Para usar OkHttp como transporte de gRPC para tu app, crea el canal con AndroidChannelBuilder, que une OkHttpChannelBuilder y registra un monitor de red con el SO Android para responder rápidamente a los cambios de red. Puedes encontrar un ejemplo de uso en gRPC-Java AndroidChannelBuilder.
Cronet (experimental)
Cronet es la pila de redes de Chromium empaquetada como una biblioteca para dispositivos móviles. Ofrece una sólida compatibilidad de red con el protocolo QUIC de vanguardia, que puede ser especialmente eficaz en entornos de red poco confiables. Para obtener más información sobre Cronet, consulta Cómo realizar operaciones de red con Cronet.
Si deseas usar Cronet como transporte de gRPC para tu app, crea el canal con CronetChannelBuilder.
Puedes encontrar un ejemplo de uso en Transporte de Cronet gRPC-Java.
En términos generales, recomendamos que las apps orientadas a versiones recientes del SDK usen Cronet, ya que ofrece una pila de red más potente. La desventaja de usar Cronet es el aumento del tamaño del APK, ya que agregar la dependencia binaria de Cronet agregará más de 1 MB al tamaño de la app, en comparación con ~100 KB para OkHttp. A partir de GMSCore v.10, se puede cargar una copia actualizada de Cronet desde los Servicios de Google Play. Es posible que el tamaño del APK ya no sea una preocupación, aunque los dispositivos sin el último GMSCore instalado pueden preferir usar OkHttp.
El contenido y las muestras de código que aparecen en esta página están sujetas a las licencias que se describen en la Licencia de Contenido. Java y OpenJDK son marcas registradas de Oracle o sus afiliados.
Última actualización: 2025-07-27 (UTC)
[[["Fácil de comprender","easyToUnderstand","thumb-up"],["Resolvió mi problema","solvedMyProblem","thumb-up"],["Otro","otherUp","thumb-up"]],[["Falta la información que necesito","missingTheInformationINeed","thumb-down"],["Muy complicado o demasiados pasos","tooComplicatedTooManySteps","thumb-down"],["Desactualizado","outOfDate","thumb-down"],["Problema de traducción","translationIssue","thumb-down"],["Problema con las muestras o los códigos","samplesCodeIssue","thumb-down"],["Otro","otherDown","thumb-down"]],["Última actualización: 2025-07-27 (UTC)"],[],[],null,["# Build client-server applications with gRPC\n\ngRPC is a modern, open-source, high-performance RPC framework that can run in any\nenvironment. It can efficiently connect services in and across data centers with\npluggable support for load balancing, tracing, health-checking, and\nauthentication. It is also applicable in the last mile of distributed computing\nto connect devices, mobile applications, and browsers to backend services. You\ncan find documentation on gRPC's official website and get support from\nopen source communities. This guide points you to solutions for\nbuilding Android apps using gRPC.\n\n[grpc.io](https://grpc.io) is the official website for the\ngRPC project. To learn more about how gRPC works, see [What is gRPC?](https://grpc.io/docs/guides/)\nand [gRPC Concepts](https://grpc.io/docs/guides/concepts/).\nTo learn how to use gRPC in an Android app, see the Hello World example in\n[gRPC Android Java Quickstart](https://grpc.io/docs/quickstart/android/).\nYou can also find several other gRPC Android examples [on GitHub](https://github.com/grpc/grpc-java/tree/v1.24.0/examples/android).\n\nFeatures\n--------\n\n**Procedure call makes it simple**\n: Because it's RPC, the programming model is procedure calls: the networking\n aspect of the technology is abstracted away from application code, making it\n look almost as if it was a normal in-process function call. Your client-server\n interaction will not be constrained by the semantics of HTTP resource methods\n (such as GET, PUT, POST, and DELETE). Compared to REST APIs, your implementation\n looks more natural, without the need for handling HTTP protocol metadata.\n\n**Efficient network transmission with HTTP/2**\n: Transmitting data from mobile devices to a backend server can be a very\n resource-intensive process. Using the standard HTTP/1.1 protocol, frequent\n connections from a mobile device to a cloud service can drain the battery,\n increase latency, and block other apps from connecting. By default, gRPC runs on\n top of HTTP/2, which introduces bi-directional streaming, flow control, header\n compression, and the ability to multiplex requests over a single TCP/IP\n connection. The result is that gRPC can reduce resource usage, resulting in\n lower response times between your app and services running in the cloud,\n reduced network usage, and longer battery life for client running on mobile\n devices.\n\nBuilt-in streaming data exchange support\n: gRPC was designed with HTTP/2's support for full-duplex bidirectional\n streaming in mind from the outset. Streaming allows a request and response to\n have an arbitrarily large size, such as operations that require uploading or\n downloading a large amount of information. With streaming, client and server\n can read and write messages simultaneously and subscribe to each other without\n tracking resource IDs. This makes your app implementation more flexible.\n\n**Seamless integration with Protocol Buffer**\n: gRPC uses Protocol Buffers (Protobuf) as its\n serialization/deserialization method with optimized-for-Android codegen plugin\n ([Protobuf Java Lite](https://github.com/protocolbuffers/protobuf/blob/v3.9.0/java/lite.md)).\n Compared to text-based format (such as JSON), Protobuf offers more efficient data\n exchanging in terms of marshaling speed and code size, which makes it more\n suitable to be used in mobile environments. Also Protobuf's concise\n message/service definition syntax makes it much easier to define data model\n and application protocols for your app.\n\nUsage overview\n--------------\n\nFollowing the [gRPC Basics - Android Java](https://grpc.io/docs/tutorials/basic/android/)\ntutorial, using gRPC for Android apps involves four steps:\n\n- Define RPC services with protocol buffers and generate the gRPC client interfaces.\n- Build a Channel that serves as the medium for RPC calls between client and server.\n- Create a client Stub as the entry point for initiating RPC calls from client side.\n- Make RPC calls to remote server as you would when performing local procedure calls.\n\nFor demonstration purposes, bytes are transmitted in plain text in the provided\nexample. However, your app should always encrypt network data in production.\ngRPC provides SSL/TLS encryption support as well as OAuth token exchanging\n(OAuth2 with Google services) for authentication. For more details, see\n[TLS on Android](https://github.com/grpc/grpc-java/blob/v1.24.0/SECURITY.md#tls-on-android)\nand [Using OAuth2](https://github.com/grpc/grpc-java/blob/v1.24.0/SECURITY.md#using-oauth2).\n| **Note:** If you are using Gradle as the build tool for your app, the Protobuf Gradle plugin is a handy tool for automating the process of generating and building gRPC Java code into your app. For more information, see [Protobuf Plugin for Gradle](https://github.com/google/protobuf-gradle-plugin#protobuf-plugin-for-gradle-).\n\nTransport\n---------\n\ngRPC provides two choices of Transport implementations for Android clients:\nOkHttp and Cronet.\n| **Note:** Creating channels with transport-specific channel builders (such as [`OkHttpChannelBuilder`](https://github.com/grpc/grpc-java/blob/v1.24.0/okhttp/src/main/java/io/grpc/okhttp/OkHttpChannelBuilder.java#L57) or [`CronetChannelBuilder`](https://github.com/grpc/grpc-java/blob/v1.24.0/cronet/src/main/java/io/grpc/cronet/CronetChannelBuilder.java#L49)) is for more advanced usage. If you build the channel with [`ManagedChannelBuilder`](https://github.com/grpc/grpc-java/blob/v1.24.0/api/src/main/java/io/grpc/ManagedChannelBuilder.java#L31), the class loader will load the plain [`OkHttpChannelBuilder`](https://github.com/grpc/grpc-java/blob/v1.24.0/okhttp/src/main/java/io/grpc/okhttp/OkHttpChannelBuilder.java#L57) as the default implementation at runtime. Starting from gRPC's 1.24 release, we recommend using [`AndroidChannelBuilder`](https://github.com/grpc/grpc-java/blob/v1.24.0/android/src/main/java/io/grpc/android/AndroidChannelBuilder.java#L54), which is similar, but with some Android-specific optimizations.\n\n**Choose a transport (advanced)**\n\n-\n\n OkHttp\n : OkHttp is a light-weight networking stack designed for use on mobile. It is\n gRPC's default transport for running in Android environment. To use OkHttp as\n gRPC transport for your app, construct the channel with [`AndroidChannelBuilder`](https://github.com/grpc/grpc-java/blob/v1.24.0/android/src/main/java/io/grpc/android/AndroidChannelBuilder.java#L54),\n which wraps [`OkHttpChannelBuilder`](https://github.com/grpc/grpc-java/blob/v1.24.0/okhttp/src/main/java/io/grpc/okhttp/OkHttpChannelBuilder.java#L57)\n and will register a network monitor with the Android OS to quickly respond to\n network changes. An example usage can be found in [gRPC-Java AndroidChannelBuilder](https://github.com/grpc/grpc-java/blob/v1.24.0/documentation/android-channel-builder.md#example-usage).\n-\n\n Cronet (experimental)\n : Cronet is Chromium's Networking stack packaged as a library for mobile. It\n offers robust networking support with state-of-the-art QUIC protocol, which can\n be especially effective in unreliable network environments. To learn more\n details about Cronet, see [Perform network operations using Cronet](/guide/topics/connectivity/cronet).\n To use Cronet as gRPC transport for your app, construct the channel with\n [`CronetChannelBuilder`](https://github.com/grpc/grpc-java/blob/v1.24.0/cronet/src/main/java/io/grpc/cronet/CronetChannelBuilder.java#L49).\n An example usage is provided in [gRPC-Java Cronet Transport](https://github.com/grpc/grpc-java/tree/v1.24.0/cronet#grpc-cronet-transport).\n\n| **Note:** Cronet's bidirectional streaming feature is still experimental. Therefore, [`CronetChannelBuilder`](https://github.com/grpc/grpc-java/blob/v1.24.0/cronet/src/main/java/io/grpc/cronet/CronetChannelBuilder.java#L49) is marked as an experimental API.\n\nGenerally speaking, we recommend apps targeting recent SDK versions use Cronet\nas it offers a more-powerful network stack. The downside of using Cronet is the\nAPK size increase, as adding the binary Cronet dependency will add \\\u003e1MB to the\napp size, versus \\~100KB for OkHttp. Starting with GMSCore v.10, an\nup-to-date copy of Cronet can be loaded from Google Play Services. The APK size\nmay no longer be a concern, although devices without the latest GMSCore\ninstalled may still prefer using OkHttp.\n| **Note:** When loading Cronet from Google Play services, call [`CronetProviderInstaller.installProvider(Context)`](https://developers.google.com/android/reference/com/google/android/gms/net/CronetProviderInstaller) before creating [`CronetEngine/ExperimentalCronetEngine`](https://developer.android.com/guide/topics/connectivity/cronet/reference/org/chromium/net/CronetEngine) objects to prevent unexpected exceptions from being thrown due to errors like devices requiring an updated version of Google Play services."]]
