Verwenden Sie GRPC, um die Leistung von Java Microservice zu verbessern. 2. Definieren Sie starke Vertr?ge durch .Proto -Dateien; 3. Konfigurieren Sie die GRPC -Abh?ngigkeiten mit Maven und generieren Code. 4. Implementieren Sie die GRPC -Serverlogik; 5. Anrufdienste vom Kunden; 6. TLS, Fehlerbehebung, Serviceerkennung und Beobachtbarkeit müssen in der Produktionsumgebung aktiviert werden. Befolgen Sie die Schritte, um schnell ein effizientes und typersicheres Microservice-Kommunikationssystem zu erstellen.

Sie bauen also eine Java Microservices -Architektur und m?chten GRPC verwenden? Gute Wahl. Es ist schnell, effizient und gro?artig für die Kommunikation von Service-to-Service-insbesondere wenn Sie sich um Leistung und Vertragsklarheit kümmern. Hier erfahren Sie, wie man anf?ngt, ohne überw?ltigt zu werden.

Warum GRPC für Java Microservices sinnvoll ist

Bevor Sie in das Setup eintauchen, k?nnen Sie wissen, warum GRPC gut in eine Microservices -Umgebung passt:

• Hohe Leistung : Verwendet HTTP/2 und bin?re Serialisierung (Protokollpuffer), sodass es schneller und leichter ist als JSON gegenüber HTTP/1.1.
• Starke Vertr?ge : Service-Schnittstellen und Nachrichtenstrukturen werden in .proto Dateien definiert, wodurch APIs explizit und sprachunabh?ngig werden.
• Integrierte Codegenerierung : Sie definieren Ihren Dienst einmal und Tools generieren Client- und Servercode für Java (und andere Sprachen).
• Unterstützung für Streaming : GRPC unterstützt Server-Streaming, Client-Streaming und Baitedirectional Streaming-nützlich für Echtzeit- oder ereignisgesteuerte Muster.

Wenn Ihre Dienste viel miteinander sprechen (z. B. den Bestandsdiensten des Auftrags für den Auftragsdienst), kann GRPC die Latenz reduzieren und den Durchsatz verbessern.

Schritt 1: Definieren Sie Ihren Dienst mit Protokollpuffern

Schreiben Sie zun?chst eine .proto -Datei. Dies definiert Ihre Datenmodelle und Ihre Serviceschnittstelle.

Beispiel: inventory.proto

 syntax = "proto3";

paket com.example.inventory;

Service InventoryService {
  RPC GetStock (StockRequest) Renditen (StockResponse);
}

Message StockRequest {
  String product_id = 1;
}

Message Stockresponse {
  INT32 AUFEHLE_COUNT = 1;
}

Dies definiert einen einfachen Service, der die Aktien für ein Produkt überprüft. Halten Sie Ihre .proto -Dateien in einem gemeinsam genutzten Ort oder Paket, wenn mehrere Dienste von ihnen abh?ngen.

Schritt 2: Richten Sie GRPC in Ihrem Java -Projekt ein

Verwenden Sie Maven oder Gradle. Hier ist ein Mindest -Maven -Setup ( pom.xml ):

 <Depecies>
  <De vorangehen>
    <gruppeID> io.grpc </Groupid>
    <artifactid> grpc-netty-Shaded </artifactid>
    <version> 1.58.0 </Version>
  </abh?ngig>
  <De vorangehen>
    <gruppeID> io.grpc </Groupid>
    <artifactid> grpc-proTobuf </artifactid>
    <version> 1.58.0 </Version>
  </abh?ngig>
  <De vorangehen>
    <gruppeID> io.grpc </Groupid>
    <artifactId> grpc-stub </artifactid>
    <version> 1.58.0 </Version>
  </abh?ngig>
</Abh?ngigkeiten>

<Build>
  <Exterssions>
    <EXTERS>
      <gruppe> kr.motd.maven </Groupid>
      <artifactid> os-maven-plugin </artifactid>
      <version> 1.7.1 </Version>
    </extension>
  </Erweiterungen>
  <plugins>
    <plugin>
      <CruupId> org.xolstice.maven.plugins </Groupid>
      <artifactId> Protobuf-Maven-Plugin </artifactid>
      <version> 0.6.1 </Version>
      <Configuration>
        <Protosourceroot> $ {project.basedir}/src/main/proto </protosourceroot>
        <outputDirectory> $ {project.build.directory}/generated-sources </outputDirectory>
        <ClearOutputDirectory> Falsch </clearOutputDirectory>
      </Konfiguration>
      <ausführungen>
        <ausführung>
          <ziele>
            <Geor> Compile </toce>
            <Geor> Compile-Custom </Ziel>
          </ziele>
        </Ausführung>
      </Executions>
    </plugin>
  </plugins>
</bauen>

Nachdem dies hinzugefügt wird, rennen Sie:

 MVN Compile

Das Plugin generiert Java -Klassen aus Ihrer .proto -Datei - einschlie?lich Service -Basisklassen, Stubs und Nachrichtentypen.

Schritt 3: Implementieren Sie den Server

Erstellen Sie eine Klasse, die den generierten InventoryServiceGrpc.InventoryServiceImplBase erweitert:

 importieren io.grpc.server;
importieren io.grpc.serverbuilder;
importieren java.io.ioException;

public class InventoryServer {

  privater Server;

  public void start () wirft ioException {aus
    server = serverbuilder.forport (8080)
        .AddService (neuer InventoryServiceImpl ())
        .bauen()
        .Start();

    System.out.println ("Server auf Port 8080 gestartet");

    Runtime.getRuntime (). AddShutDownhook (neuer Thread (() -> {
      System.out.println ("Schaltstillung von GRPC -Server");
      InventoryServer.this.Stop ();
    }));

    BlockuntilShutdown ();
  }

  private void blockuntilshutdown () l?st unterbrochene Ausnahme {aus
    if (server! = null) {
      server.awaittermination ();
    }
  }

  private void stop () {
    if (server! = null) {
      server.shutdown ();
    }
  }

  public static void main (String [] args) l?st IoException, InterruptedException {aus
    neuer InventoryServer (). start ();
  }

  statische Klasseninventar -serviceImpl erweitert InventoryServiceGrpc.inventoryServiceImplbase {
    @Override
    public void getStock (StockRequest Request, Streamobserver <St StockResponse> responseBserver) {
      // Logik simulieren
      int stock = "p123" .equals (request.getProductId ())? 42: 0;

      Stockresponse -Antwort = Stockresponse.NewBuilder ())
          .SetAvailableCount (Aktie)
          .bauen();

      ResponseObserver.onnext (Antwort);
      ResponseObserver.oncompleted ();
    }
  }
}

Das war's - Sie haben einen funktionierenden GRPC -Server.

Schritt 4: Rufen Sie den Dienst von einem anderen Microservice (Client) an

Erstellen Sie nun in Ihrem Anrufdienst (z. B. einen Bestelldienst) einen GRPC -Client:

 ?ffentliche Klasse InventoryClient {

  private endgültige InventoryServiceGrpc.InventoryServiceBlockingstub BlockingStub;

  public InventoryClient (String -Host, int Port) {
    ManagedChannel Channel = ManagedChannelBuilder.forAddress (Host, Port)
        .UsEplainText () // in der Produktion nicht ohne TLS verwenden
        .bauen();

    BlockingStub = InventoryServiceGrpc.NewBlockingStub (Kanal);
  }

  public int getStock (String ProductID) {
    StockRequest Request = StockRequest.NewBuilder (). SetProductId (productId) .build ();
    StockResponse response = blockingStub.getStock (Anfrage);
    return response.getAavailableCount ();
  }
}

Benutze es wie:

 InventoryClient Client = New InventoryClient ("Localhost", 8080);
int stile = client.getStock ("p123");
System.out.println ("Aktie:" Stock);

Tipps für die reale Verwendung

• Verwenden Sie TLS in Produktion : Aktivieren Sie die Verschlüsselung zwischen Diensten immer. GRPC unterstützt SSL/TLS aus der Schachtel.
• Behandeln Sie Fehler mit GRPC -Statuscodes : Verwenden Sie Status und StatusException für saubere Fehlerausbreitung.
• Integrieren Sie sich in Service Discovery : Kombinieren Sie GRPC mit Tools wie Consul, Eureka oder Kubernetes DNS.
• Hinzufügen von Beobachtbarkeit : Verwenden Sie Interceptors für Protokollierung, Metriken (z. B. Mikrometer) und verteilte Verfolgung (z. B. Opentelemetrie).
• Vermeiden Sie eine enge Kopplung : Auch wenn .proto -Dateien Vertr?ge definieren, ver?ffentlichen Sie sie sorgf?ltig und vermeiden Sie h?ufig Ver?nderungen.

Einpacken

GRPC In einem Java -Microservices -Setup bietet Ihnen Geschwindigkeit, Type Sicherheit und saubere Schnittstellen. Starten Sie klein: Definieren Sie einen Dienst, lassen Sie ihn zum Laufen und rufen Sie ihn von einem anderen an. Sobald Sie sich wohl fühlen, fügen Sie Streaming, Authentifizierung und überwachung hinzu.

Es ist nicht immer die richtige Wahl (z. B. wenn Sie Browser-Kunden ben?tigen), aber für Backend-to-Backend-Kommunikation ist es schwer zu schlagen.

Definieren Sie im Grunde .proto

Das obige ist der detaillierte Inhalt vonErste Schritte mit GRPC in einer Java Microservices -Architektur. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!