Utilisez GRPC pour améliorer les performances de microservice Java; 2. Définir des contrats solides via des fichiers .proto; 3. Configurer les dépendances GRPC avec Maven et générer du code; 4. Implémentez la logique du serveur GRPC; 5. appelez les services du client; 6. TLS, la gestion des erreurs, la découverte de services et l'observabilité doivent être activées dans l'environnement de production. Suivez les étapes pour construire rapidement un système de communication de microservice efficace et sécurisé.

Vous construisez donc une architecture de microservices Java et que vous souhaitez utiliser GRPC? Bon choix. Il est rapide, efficace et idéal pour la communication du service à la service - en particulier lorsque vous vous souciez des performances et de la clarté du contrat. Voici comment commencer sans se faire submerger.

Pourquoi GRPC a du sens pour les microservices Java

Avant de plonger dans la configuration, il est utile de savoir pourquoi GRPC s'intègre bien dans un environnement microservices:

• Haute performance : utilise HTTP / 2 et la sérialisation binaire (tampons de protocole), il est donc plus rapide et plus léger que JSON sur HTTP / 1.1.
• Contrats forts : les interfaces de service et les structures de messages sont définies dans les fichiers .proto , rendant les API explicites et agnostiques linguistiques.
• Génération de code intégrée : vous définissez votre service une fois et les outils génèrent un code client et serveur pour Java (et autres langues).
• Prise en charge du streaming : GRPC prend en charge le streaming du serveur, le streaming client et le streaming bidirectionnel - utile pour les modèles en temps réel ou motivés par des événements.

Si vos services se parlent beaucoup (par exemple, le service d'inventaire des appels de commande), GRPC peut réduire la latence et améliorer le débit.

étape 1: Définissez votre service avec des tampons de protocole

Commencez par écrire un fichier .proto . Cela définit vos modèles de données et votre interface de service.

Exemple: inventory.proto

 syntax = "proto3";

package com.example.inventory;

InventoryService de service {
  RPC GetStock (StockRequest) Returns (StockResponse);
}

Message StockRequest {
  String product_id = 1;
}

Message StockResponse {
  int32 disponible_count = 1;
}

Cela définit un service simple qui vérifie les actions d'un produit. Gardez vos fichiers .proto dans un emplacement ou un package partagé si plusieurs services en dépendent.

étape 2: Configurez GRPC dans votre projet Java

Utilisez Maven ou Gradle. Voici une configuration Maven minimale ( pom.xml ):

 <dépendances>
  <dépendance>
    <bandrandId> io.grpc </romp grouped>
    <ArtefactId> GRPC-NetTy-Shaded </refactive>
    <version> 1.58.0 </ version>
  </Dependance>
  <dépendance>
    <bandrandId> io.grpc </romp grouped>
    <ArtefactId> GRPC-Protobuf </Retifactid>
    <version> 1.58.0 </ version>
  </Dependance>
  <dépendance>
    <bandrandId> io.grpc </romp grouped>
    <ArtefactId> GRPC-Stub </Retifactid>
    <version> 1.58.0 </ version>
  </Dependance>
</DENDENDENCES>

<fuild>
  <extensions>
    <ralosque>
      <GroupId> kr.motd.maven </rombandid>
      <ArtefactId> OS-Maven-Plugin </Retifactid>
      <version> 1.7.1 </ version>
    </pulsex>
  </tensions>
  <fr?ins>
    <fruit>
      <groupId> org.xolstice.maven.plugins </rombandid>
      <ArtefactId> Protobuf-Maven-Plugin </ ArfactId>
      <version> 0.6.1 </DERNIER>
      <Iconguration>
        <ProtoSourCeroot> $ {project.basedir} / src / main / proto </rotoSourceroot>
        <utputDirectory> $ {project.build.directory} / généré-source </putputDirectory>
        <ClearOutputDirectory> false </ ClearOutputDirectory>
      </FIGIGURATION>
      <Cecultes>
        <exécution>
          <buts>
            <butard> compiler </pual>
            <FORME> compile-Custom </ but>
          </ buts>
        </ Execution>
      </IMICATION>
    </ plugin>
  </plugins>
</ build>

Après avoir ajouté cela, exécutez:

 compilation MVN

Le plugin génère des classes Java à partir de votre fichier .proto - y compris les cours de base de service, les talons et les types de messages.

étape 3: Implémentez le serveur

Créez une classe qui étend l' InventoryServiceGrpc.InventoryServiceImplBase généré

 import io.grpc.server;
import io.grpc.ServerBuilder;
Importer java.io.ioException;

Inventoryserver de classe publique {

  serveur de serveurs privés;

  public void start () lève IOException {
    server = serverbuilder.forport (8080)
        .AddService (nouvel inventoryServiceImpl ())
        .construire()
        .commencer();

    System.out.println ("Serveur démarré sur le port 8080");

    Runtime.getRuntime (). AddShutdownHook (nouveau thread (() -> {
      System.out.println ("Arrêt du serveur GRPC");
      InventoryServer.This.stop ();
    }));

    Blockulshutdown ();
  }

  Blockulshutdown privé () lance InterruptedException {
    if (server! = null) {
      server.awampitring ();
    }
  }

  VOID privé stop () {
    if (server! = null) {
      server.shutdown ();
    }
  }

  public static void main (String [] args) lance ioException, InterruptedException {
    new inventoryserver (). start ();
  }

  InventoryServiceImpl de classe statique étend les inventaires de serviette
    @Outrepasser
    public void getStock (StockRequest Request, StreamObserver <StockResponse> ResponseObserver) {
      // Simuler la logique
      int Stock = "p123" .equals (request.getProductid ())? 42: 0;

      StockResponse Response = StockResponse.newBuilder ()
          .setAvailableCount (stock)
          .construire();

      ResponseObserver.onExt (réponse);
      ResponseObserver.Oncompleted ();
    }
  }
}

C'est tout - vous avez un serveur GRPC fonctionnel.

étape 4: Appelez le service à partir d'un autre microservice (client)

Maintenant, dans votre service d'appel (par exemple, un service de commande), créez un client GRPC:

 InventoryClient de classe publique {

  Inventaire final privéServicegrpc.InventoryServiceBlockingStub BlockingStub;

  public InventoryClient (String Host, int port) {
    ManagedChannel Channel = ManagedChannelBuilder.ForAddress (h?te, port)
        .UsePlainText () // N'utilisez pas dans la production sans TLS
        .construire();

    BlockingStub = InventoryServiceGrpc.NewBlockingStub (canal);
  }

  public int getStock (String productId) {
    StockRequest Request = StockRequest.NewBuilder (). SetProductId (ProductId) .Build ();
    StockResponse Response = BlockingStub.getStock (demande);
    return réponse.getAvailableCount ();
  }
}

Utilisez-le comme:

 InventoryClient client = new InventoryClient ("localhost", 8080);
int Stock = client.getStock ("p123");
System.out.println ("Stock:" Stock);

Conseils pour une utilisation réelle

• Utilisez TLS dans la production : activez toujours le cryptage entre les services. GRPC prend en charge SSL / TLS hors de la bo?te.
• Gérer les erreurs avec les codes d'état GRPC : utilisez Status et StatusException pour la propagation d'erreur propre.
• Intégrer à la découverte de service : associez le GRPC à des outils comme Consul, Eureka ou Kubernetes DNS.
• Ajouter l'observabilité : utilisez des intercepteurs pour la journalisation, les mesures (par exemple, micromètre) et le tra?age distribué (par exemple, opentélémétrie).
• évitez le couplage serré : même si les fichiers .proto définissent les contrats, les versionz attentivement et évitez les modifications fréquemment brisées.

Conclure

GRPC dans une configuration de microservices Java vous donne une vitesse, taper la sécurité et des interfaces propres. Commencez petit: définissez un service, faites-le fonctionner et appelez-le à partir d'un autre. Une fois que vous êtes à l'aise, ajoutez le streaming, l'authentification et la surveillance.

Ce n'est pas toujours le bon choix (par exemple, si vous avez besoin de clients du navigateur), mais pour la communication backend-backend, c'est difficile à battre.

Fondamentalement, définissez .proto , générez du code, implémentez le serveur, appelez à partir du client - et vous roulez.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!