Restez organisé à l'aide des collections
Enregistrez et classez les contenus selon vos préférences.
gRPC est un framework RPC moderne, Open Source et hautes performances qui peut s'exécuter dans n'importe quel environnement. Il peut connecter efficacement les services dans et entre les centres de données grâce à une compatibilité connectable pour l'équilibrage de charge, le traçage, la vérification de l'état et l'authentification. Il est également possible de connecter des appareils, des applications mobiles et des navigateurs à des services de backend lors du dernier kilomètre de l'informatique distribuée. Vous pouvez trouver la documentation sur le site Web officiel de gRPC et obtenir de l'aide auprès des communautés Open Source. Ce guide vous présente des solutions permettant de créer des applications Android à l'aide de gRPC.
grpc.io est le site Web officiel du projet gRPC. Pour en savoir plus sur le fonctionnement de gRPC, consultez la page Qu'est-ce que gRPC ?
et Concepts gRPC.
Pour apprendre à utiliser gRPC dans une application Android, consultez l'exemple "Hello World" du guide de démarrage rapide de gRPC Android pour Java.
Vous trouverez également plusieurs autres exemples gRPC pour Android sur GitHub.
Fonctionnalités
L'appel de procédure simplifie les choses
Comme il s'agit d'un RPC, le modèle de programmation est constitué d'appels de procédure: l'aspect réseau de la technologie est extrait du code d'application, ce qui donne l'impression qu'il s'agit d'un appel de fonction en cours de traitement normal. Votre interaction client-serveur ne sera pas limitée par la sémantique des méthodes de ressources HTTP (telles que GET, PUT, POST et DELETE). Par rapport aux API REST, votre implémentation semble plus naturelle, sans qu'il soit nécessaire de gérer les métadonnées du protocole HTTP.
Transmission réseau efficace avec HTTP/2
La transmission de données depuis des appareils mobiles vers un serveur backend peut représenter un processus très gourmand en ressources. Grâce au protocole HTTP/1.1 standard, les connexions fréquentes d'un appareil mobile à un service cloud peuvent décharger la batterie, augmenter la latence et empêcher d'autres applications de se connecter. Par défaut, gRPC s'exécute sur HTTP/2, qui introduit le streaming bidirectionnel, le contrôle de flux, la compression des en-têtes et la possibilité de multiplexer les requêtes sur une seule connexion TCP/IP. gRPC peut ainsi réduire l'utilisation des ressources, ce qui réduit les temps de réponse entre votre application et les services exécutés dans le cloud, l'utilisation du réseau et l'autonomie de la batterie pour les clients s'exécutant sur des appareils mobiles.
Prise en charge intégrée de l'échange de données en flux continu
gRPC a été conçu en pensant dès le départ à la compatibilité de HTTP/2 avec le streaming bidirectionnel full-duplex. Le streaming permet à une requête et à une réponse d'avoir une taille arbitrairement élevée, telles que les opérations nécessitant l'importation ou le téléchargement d'une grande quantité d'informations. Avec le streaming, le client et le serveur peuvent lire et écrire des messages simultanément, et s'abonner les uns aux autres sans suivre les ID de ressource. Cela rend l'implémentation de votre application plus flexible.
Intégration parfaite au tampon de protocole
gRPC utilise les tampons de protocole (Protobuf) comme méthode de sérialisation/désérialisation avec le plug-in de génération de code optimisé pour Android (Protobuf Java Lite).
Par rapport au format texte (tel que JSON), Protobuf offre un échange de données plus efficace en termes de vitesse de marshaling et de taille de code, ce qui le rend plus adapté à une utilisation dans les environnements mobiles. De plus, la syntaxe concise des messages et des définitions de service de Protobuf facilite la définition du modèle de données et des protocoles d'application pour votre application.
Présentation de l'utilisation
Suite au tutoriel gRPC Basics - Android Java (Principes de base de gRPC – Java pour Android), l'utilisation de gRPC pour les applications Android comporte quatre étapes:
Définir les services RPC avec des tampons de protocole et générer les interfaces client gRPC.
Créer un canal servant de support pour les appels RPC entre le client et le serveur
Créez un stub client comme point d'entrée pour lancer des appels RPC côté client.
Effectuez des appels RPC sur le serveur distant comme vous le feriez pour des appels de procédure locale.
À des fins de démonstration, les octets sont transmis en texte brut dans l'exemple fourni. Cependant, votre application doit toujours chiffrer les données réseau en production. gRPC prend en charge le chiffrement SSL/TLS, ainsi que l'échange de jetons OAuth (OAuth2 avec les services Google) pour l'authentification. Pour en savoir plus, consultez TLS sur Android et Utiliser OAuth2.
Transport
gRPC propose deux implémentations de Transport pour les clients Android : OkHttp et Cronet.
Choisir un mode de transport (avancé)
OkHttp
OkHttp est une pile réseau légère conçue pour être utilisée sur mobile. Il s'agit du transport gRPC par défaut pour l'exécution dans l'environnement Android. Pour utiliser OkHttp comme transport gRPC pour votre application, créez le canal avec AndroidChannelBuilder, qui encapsule OkHttpChannelBuilder et enregistre un moniteur réseau auprès de l'OS Android pour répondre rapidement aux modifications du réseau. Vous trouverez un exemple d'utilisation dans gRPC-Java AndroidChannelBuilder.
Cronet (expérimental)
Cronet est la pile réseau de Chromium présentée sous la forme d'une bibliothèque pour mobile. Il offre une compatibilité réseau fiable avec un protocole QUIC de pointe, ce qui peut être particulièrement efficace dans les environnements réseau peu fiables. Pour en savoir plus sur Cronet, consultez la page Effectuer des opérations réseau à l'aide de Cronet.
Pour utiliser Cronet comme transport gRPC pour votre application, créez le canal avec CronetChannelBuilder.
Vous trouverez un exemple d'utilisation dans la section gRPC-Java Cronet Transport.
En règle générale, nous recommandons aux applications ciblant les versions récentes du SDK d'utiliser Cronet, car cette solution offre une pile réseau plus puissante. L'inconvénient de l'utilisation de Cronet est l'augmentation de la taille de l'APK, car l'ajout de la dépendance binaire Cronet ajoutera plus de 1 Mo à la taille de l'application, contre environ 100 Ko pour OkHttp. À partir de GMSCore v.10, une copie à jour de Cronet peut être chargée à partir des services Google Play. La taille de l'APK n'est peut-être plus un problème, même si les appareils sur lesquels la dernière version de GMSCore n'est pas installée peuvent continuer à utiliser OkHttp.
Le contenu et les exemples de code de cette page sont soumis aux licences décrites dans la Licence de contenu. Java et OpenJDK sont des marques ou des marques déposées d'Oracle et/ou de ses sociétés affiliées.
Dernière mise à jour le 2025/07/27 (UTC).
[[["Facile à comprendre","easyToUnderstand","thumb-up"],["J'ai pu résoudre mon problème","solvedMyProblem","thumb-up"],["Autre","otherUp","thumb-up"]],[["Il n'y a pas l'information dont j'ai besoin","missingTheInformationINeed","thumb-down"],["Trop compliqué/Trop d'étapes","tooComplicatedTooManySteps","thumb-down"],["Obsolète","outOfDate","thumb-down"],["Problème de traduction","translationIssue","thumb-down"],["Mauvais exemple/Erreur de code","samplesCodeIssue","thumb-down"],["Autre","otherDown","thumb-down"]],["Dernière mise à jour le 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."]]
