Mit Sammlungen den Überblick behalten
Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.
gRPC ist ein modernes, leistungsstarkes Open-Source-RPC-Framework, das in jeder Umgebung ausgeführt werden kann. Es kann Dienste in und über Rechenzentren hinweg effizient verbinden und bietet flexible Unterstützung für Load-Balancing, Tracing, Systemdiagnose und Authentifizierung. Sie eignet sich auch für die letzte Meile des verteilten Computings, um Geräte, mobile Anwendungen und Browser mit Back-End-Diensten zu verbinden. Eine Dokumentation finden Sie auf der offiziellen Website von gRPC. Außerdem erhalten Sie Support von Open-Source-Communities. Dieser Leitfaden zeigt Ihnen Lösungen zum Erstellen von Android-Apps mit gRPC.
gRPC.io ist die offizielle Website für das gRPC-Projekt. Weitere Informationen zur Funktionsweise von gRPC finden Sie unter What is gRPC?
und gRPC-Konzepte.
Informationen zur Verwendung von gRPC in einer Android-App finden Sie im „Hello World“-Beispiel in der Kurzanleitung für gRPC Android Java.
Außerdem finden Sie einige andere gRPC-Android-Beispiele auf GitHub.
Funktionen
Prozeduraufruf leicht gemacht
Da es sich um RPC handelt, handelt es sich bei dem Programmiermodell um Prozeduraufrufe: Der Netzwerkaspekt der Technologie ist vom Anwendungscode abstrahiert, sodass es fast so aussieht, als wäre es ein normaler laufender Funktionsaufruf. Die Client-Server-Interaktion wird nicht durch die Semantik von HTTP-Ressourcenmethoden (z. B. GET, PUT, POST und DELETE) eingeschränkt. Im Vergleich zu REST APIs sieht Ihre Implementierung natürlicher aus, ohne dass HTTP-Protokollmetadaten verarbeitet werden müssen.
Effiziente Netzwerkübertragung mit HTTP/2
Die Übertragung von Daten von Mobilgeräten an einen Back-End-Server kann sehr ressourcenintensiv sein. Bei Verwendung des HTTP/1.1-Standardprotokolls können häufige Verbindungen von einem Mobilgerät mit einem Cloud-Dienst den Akku entladen, die Latenz erhöhen und andere Apps daran hindern, eine Verbindung herzustellen. Standardmäßig wird gRPC auf HTTP/2 ausgeführt, das bidirektionales Streaming, Ablaufsteuerung, Header-Komprimierung und die Möglichkeit zum Multiplexing von Anfragen über eine einzelne TCP/IP-Verbindung ermöglicht. Dies führt dazu, dass gRPC die Ressourcennutzung reduzieren kann. Dies führt zu kürzeren Antwortzeiten zwischen Ihrer App und den in der Cloud ausgeführten Diensten, einer geringeren Netzwerknutzung und einer längeren Akkulaufzeit für Clients, die auf Mobilgeräten ausgeführt werden.
Integrierte Unterstützung für Streaming-Datenaustausch
gRPC wurde von Anfang an mit der HTTP/2-Unterstützung für bidirektionales Vollduplex-Streaming entwickelt. Streaming ermöglicht das Hoch- oder Herunterladen einer großen Menge an Informationen, sodass Anfragen und Antworten beliebig groß sein können. Beim Streaming können Client und Server Nachrichten gleichzeitig lesen und schreiben und sich gegenseitig abonnieren, ohne Ressourcen-IDs zu verfolgen. Dadurch wird Ihre App-Implementierung flexibler.
Nahtlose Integration mit Protokollzwischenspeicher
gRPC verwendet Protocol Buffers (Protobuf) als Serialisierungs-/Deserialisierungsmethode mit dem für Android optimierten Codegen-Plug-in (Protobuf Java Lite).
Im Vergleich zum textbasierten Format (z. B. JSON) bietet Protobuf einen effizienteren Datenaustausch in Bezug auf Marshalling-Geschwindigkeit und Codegröße, was den Einsatz in mobilen Umgebungen besser macht. Außerdem erleichtert die prägnante Syntax für Nachrichten-/Dienstdefinitionen von Protobuf das Definieren von Datenmodell- und Anwendungsprotokollen für Ihre Anwendung erheblich.
Nutzungsübersicht
Gemäß der Anleitung gRPC-Grundlagen – Android Java sind vier Schritte zur Verwendung von gRPC für Android-Apps erforderlich:
RPC-Dienste mit Protokollzwischenspeichern definieren und gRPC-Clientschnittstellen generieren.
Erstellen Sie einen Kanal, der als Medium für RPC-Aufrufe zwischen Client und Server dient.
Erstellen Sie einen Client-Stub als Einstiegspunkt zum Initiieren von RPC-Aufrufen von der Clientseite.
Führen Sie RPC-Aufrufe an den Remoteserver wie bei lokalen Prozeduraufrufen aus.
Im bereitgestellten Beispiel werden Byte zu Demonstrationszwecken im Nur-Text-Format übertragen. Ihre Anwendung sollte jedoch immer die Netzwerkdaten in der Produktion verschlüsseln. gRPC unterstützt die SSL/TLS-Verschlüsselung sowie den OAuth-Tokenaustausch (OAuth2 mit Google-Diensten) für die Authentifizierung. Weitere Informationen finden Sie unter TLS auf Android-Geräten und OAuth2 verwenden.
Transport
gRPC bietet zwei verschiedene Transportimplementierungen für Android-Clients: OkHttp und Cronet.
Transport auswählen (erweitert)
OkHttp
OkHttp ist ein schlankes Netzwerk-Stack, das für den Einsatz auf Mobilgeräten entwickelt wurde. Es ist der gRPC-Standardtransport zum Ausführen in der Android-Umgebung. Wenn Sie OkHttp als gRPC-Transport für Ihre App verwenden möchten, erstellen Sie den Kanal mit AndroidChannelBuilder, der OkHttpChannelBuilder umschließt und einen Netzwerkmonitor beim Android-Betriebssystem registriert, um schnell auf Netzwerkänderungen zu reagieren. Ein Anwendungsbeispiel finden Sie im gRPC-Java AndroidChannelBuilder.
Cronet (experimentell)
Cronet ist der Netzwerk-Stack von Chromium, der als Bibliothek für Mobilgeräte verpackt ist. Es bietet robuste Netzwerkunterstützung mit dem modernen QUIC-Protokoll, das in unzuverlässigen Netzwerkumgebungen besonders effektiv sein kann. Weitere Informationen zu Cronet finden Sie unter Netzwerkvorgänge mit Cronet ausführen.
Wenn Sie Cronet als gRPC-Transport für Ihre App verwenden möchten, erstellen Sie den Kanal mit CronetChannelBuilder.
Ein Anwendungsbeispiel finden Sie in gRPC-Java Cronet Transport.
Generell empfehlen wir Anwendungen, die auf aktuelle SDK-Versionen ausgerichtet sind, da dieses einen leistungsfähigeren Netzwerk-Stack bietet. Der Nachteil von Cronet ist die Erhöhung der APK-Größe, da durch das Hinzufügen der Binär-Cronet-Abhängigkeit mehr als 1 MB zur App-Größe hinzugefügt wird, im Gegensatz zu etwa 100 KB bei OkHttp. Ab GMSCore Version 10 kann eine aktuelle Kopie von Cronet über die Google Play-Dienste geladen werden. Die APK-Größe spielt möglicherweise keine Rolle mehr, obwohl Geräte, auf denen noch nicht die neueste GMSCore installiert ist, OkHttp verwenden kann.
Alle Inhalte und Codebeispiele auf dieser Seite unterliegen den Lizenzen wie im Abschnitt Inhaltslizenz beschrieben. Java und OpenJDK sind Marken oder eingetragene Marken von Oracle und/oder seinen Tochtergesellschaften.
Zuletzt aktualisiert: 2025-07-27 (UTC).
[[["Leicht verständlich","easyToUnderstand","thumb-up"],["Mein Problem wurde gelöst","solvedMyProblem","thumb-up"],["Sonstiges","otherUp","thumb-up"]],[["Benötigte Informationen nicht gefunden","missingTheInformationINeed","thumb-down"],["Zu umständlich/zu viele Schritte","tooComplicatedTooManySteps","thumb-down"],["Nicht mehr aktuell","outOfDate","thumb-down"],["Problem mit der Übersetzung","translationIssue","thumb-down"],["Problem mit Beispielen/Code","samplesCodeIssue","thumb-down"],["Sonstiges","otherDown","thumb-down"]],["Zuletzt aktualisiert: 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."]]
