Qt GRPC

Qt GRPCLe module Qt Protobuf permet une communication rapide et peu encombrante avec les gRPC™ et peu encombrants. Il intègre les services gRPC de manière transparente dans le cadre Qt, ce qui permet de communiquer avec différents langages de programmation ou environnements, que le serveur soit ou non basé sur Qt.

Vue d'ensemble

gRPC Qt est un cadre d'appel de procédure à distance (RPC) multiplateforme et très performant. Il utilise le compilateur Protobuf (protoc) pour générer des interfaces client et serveur à partir de sections service dans un schéma Protobuf pour différents langages de programmation. Il est couramment utilisé pour connecter des services dans des architectures de type microservices ou pour relier des applications mobiles et des navigateurs à des systèmes dorsaux. Pour plus de détails, voir l'introduction de gRPC.

Qt GRPC gRPC est constitué d'API C++ et Qt Quick qui gèrent la nature asynchrone des appels de procédure à distance à l'aide du mécanisme bien connu des signaux et des créneaux. Il fournit également des outils en ligne de commande et une API CMake pour rationaliser la génération d'interfaces spécifiques à Qt XML à l'aide de protoc.

Qt GRPC Qt prend actuellement en charge la fonctionnalité côté client. Cela signifie qu'il peut communiquer avec un serveur compatible gRPC. Il peut s'agir de votre propre serveur avec son API protobuf ou d'une API publique, comme les API de Google.

Utilisation du module

Prérequis du module

• protocLe module Protoc, le compilateur Protocol Buffers, est nécessaire pour exécuter les plugins du générateur de code Qt. Voir l'installation de Protoc.
• Facultatif : Support SSL.
• Facultatif : gRPC C++ pour l'exécution des exemples.

API C

Pour ajouter des fichiers Qt Protobuf à un projet basé sur Qt et générer le code source requis, utilisez le compilateur protoc ainsi que les plugins Qt qtgrpcgen et qtprotobufgen.

• L'outil qtprotobufgen génère des classes Qt à partir des définitions de messages protobuf. Utilisez la commande CMake qt_add_protobuf pour automatiser ce processus.
• L'outil qtgrpcgen génère des interfaces à partir des définitions de services protobuf. Utilisez la commande CMake qt_add_grpc pour automatiser ce processus.

Un exemple minimal de fichier de projet CMake utilisant Qt GRPC peut ressembler à ceci :

cmake_minimum_required(VERSION 3.16...3.22)
project(MyProject)

find_package(Qt6 REQUIRED COMPONENTS Protobuf Grpc)
qt_standard_project_setup()

qt_add_executable(MyApp main.cpp)

qt_add_protobuf(MyApp
    PROTO_FILES
        path/to/messages.proto
)

qt_add_grpc(MyApp CLIENT
    PROTO_FILES
        path/to/service.proto
)

target_link_libraries(MyApp PRIVATE Qt6::Protobuf Qt6::Grpc)

API QML

Les types QML du module sont disponibles via l'importation QtGrpc. Pour utiliser les types, ajoutez l'instruction d'importation suivante à votre fichier .qml :

import QtGrpc

Articles et guides

• Qt GRPC Guide du client
• Commandes CMake dans Qt6 GRPC
• Qt GRPC Considérations sur la sécurité

Références

• C++ Classes
• Qt GRPC Quick

Exemples d'utilisation

• Qt GRPC Exemples

Licences et attributions

Le module Qt GRPC est disponible sous licence commerciale auprès de The Qt Company. En outre, il est disponible sous des licences de logiciel libre : La licence publique générale GNU, version 3. Voir Qt Licensing pour plus de détails.

En outre, Qt GRPC dans Qt 6.11.0 peut contenir des modules tiers sous les licences permissives suivantes :