Gunakan GRPC untuk meningkatkan prestasi microservice Java; 2. Tentukan kontrak yang kuat melalui fail .proto; 3. Konfigurasikan kebergantungan GRPC dengan Maven dan menghasilkan kod; 4. Melaksanakan logik pelayan GRPC; 5. Perkhidmatan panggilan dari pelanggan; 6. TLS, pengendalian ralat, penemuan perkhidmatan dan pemerhatian mesti didayakan dalam persekitaran pengeluaran. Ikuti langkah-langkah untuk membina sistem komunikasi microservice yang cekap dan selamat.

Oleh itu, anda membina seni bina mikroservis Java dan mahu menggunakan GRPC? Pilihan yang baik. Ia pantas, cekap, dan hebat untuk komunikasi perkhidmatan-ke-perkhidmatan-terutamanya apabila anda mengambil berat tentang prestasi dan kejelasan kontrak. Inilah caranya untuk memulakan tanpa terkejut.

Mengapa GRPC masuk akal untuk Microservices Java

Sebelum menyelam ke persediaan, ia membantu mengetahui mengapa GRPC sesuai dengan persekitaran mikroservis:

• Prestasi Tinggi : Menggunakan HTTP/2 dan Serialization Perduaan (buffer protokol), jadi lebih cepat dan lebih ringan daripada JSON atas HTTP/1.1.
• Kontrak yang kuat : Antara muka perkhidmatan dan struktur mesej ditakrifkan dalam fail .proto , menjadikan API eksplisit dan bahasa-agnostik.
• Generasi Kod Terbina : Anda menentukan perkhidmatan anda sekali, dan alat menjana kod klien dan pelayan untuk Java (dan bahasa lain).
• Sokongan untuk Streaming : GRPC menyokong streaming pelayan, streaming pelanggan, dan streaming bidedirectional-berguna untuk corak masa nyata atau yang didorong oleh peristiwa.

Sekiranya perkhidmatan anda bercakap dengan banyak (misalnya, perkhidmatan inventori panggilan perkhidmatan pesanan), GRPC dapat mengurangkan latensi dan meningkatkan throughput.

Langkah 1: Tentukan perkhidmatan anda dengan penampan protokol

Mula dengan menulis fail .proto . Ini mentakrifkan model data dan antara muka perkhidmatan anda.

Contoh: inventory.proto

 sintaks = "proto3";

pakej com.example.inventory;

Perkhidmatan InventoryService {
  RPC GetStock (StockRequest) pulangan (StockResponse);
}

Mesej StockRequest {
  string product_id = 1;
}

Mesej StockResponse {
  int32 tersedia_count = 1;
}

Ini mentakrifkan perkhidmatan mudah yang memeriksa stok untuk produk. Simpan fail .proto anda di lokasi atau pakej bersama jika pelbagai perkhidmatan bergantung kepada mereka.

Langkah 2: Sediakan GRPC dalam projek Java anda

Gunakan Maven atau Gradle. Berikut adalah persediaan maven minimum ( pom.xml ):

 <dependencies>
  <geterlihat>
    <groupId> io.grpc </groupId>
    <stifactid> GRPC-Netty-Shaded </artifactid>
    <versi> 1.58.0 </versi>
  </ketergantungan>
  <geterlihat>
    <groupId> io.grpc </groupId>
    <sttifactid> GRPC-protobuf </artifactid>
    <versi> 1.58.0 </versi>
  </ketergantungan>
  <geterlihat>
    <groupId> io.grpc </groupId>
    <ctiFactId> GRPC-STUB </artifactid>
    <versi> 1.58.0 </versi>
  </ketergantungan>
</dependencies>

<build>
  <semtions>
    <mpasten>
      <groupId> kr.motd.maven </groupId>
      <stifactid> os-maven-plugin </artifactid>
      <versi> 1.7.1 </versi>
    </lanjutan>
  </sambungan>
  <sugin>
    <sugin>
      <groupId> org.xolstice.maven.plugins </groupId>
      <stifactid> protobuf-maven-plugin </artifactid>
      <versi> 0.6.1 </versi>
      <figuration>
        <Protosourceroot> $ {project.basedir}/src/main/proto </protosourceroot>
        <utputDirectory> $ {project.build.directory}/sumber yang dihasilkan </outputDirectory>
        <learoutputdirectory> false </clearoutputdirectory>
      </konfigurasi>
      <Secution>
        <Execution>
          <isf gol>
            <iffial> compile </goal>
            <iffial> Compile-Custom </goal>
          </matlamat>
        </pelaksanaan>
      </pelaksanaan>
    </plugin>
  </plugin>
</binaan>

Selepas menambah ini, jalankan:

 MVN Compile

Plugin menjana kelas Java dari fail .proto anda - termasuk kelas asas perkhidmatan, stub, dan jenis mesej.

Langkah 3: Melaksanakan pelayan

Buat kelas yang memanjangkan InventoryServiceGrpc.InventoryServiceImplBase yang dihasilkan:

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

Inventory Kelas Awam {

  pelayan pelayan peribadi;

  public void start () melemparkan ioException {
    pelayan = serverbuilder.forport (8080)
        .AddService (InventoryServiceImpl baru ())
        .build ()
        .start ();

    System.out.println ("Pelayan bermula pada port 8080");

    Runtime.getRuntime (). AddShutDownHook (thread baru (() -> {
      System.out.println ("Menutup Server GRPC");
      InventoryServer.This.Stop ();
    }));

    blockuntilshutdown ();
  }

  void swasta blockuntilshutdown () melemparkan gangguan yang diganggu {
    jika (pelayan! = null) {
      server.AwaitterMination ();
    }
  }

  berhenti void peribadi () {
    jika (pelayan! = null) {
      server.shutdown ();
    }
  }

  public static void main (string [] args) melemparkan ioException, tergangguException {
    InventoryServer baru (). Mula ();
  }

  Inventori Kelas StatikServiceImpl memanjangkan InventoryServiceGrpc.InventoryServiceImplBase {
    @Override
    public void getstock (StockRequest Request, StreamObserver <StockResponse> ResponseObserver) {
      // simulasi logik
      int stok = "p123" .equals (request.getProductId ())? 42: 0;

      Respons Tempahan Saham = StockResponse.NewBuilder ()
          .setavailableCount (stok)
          .build ();

      responseObserver.onnext (respons);
      ResponseObserver.onCompleted ();
    }
  }
}

Itu sahaja - anda mempunyai pelayan GRPC yang bekerja.

Langkah 4: Hubungi perkhidmatan dari microservice yang lain (pelanggan)

Sekarang, dalam perkhidmatan panggilan anda (contohnya, perkhidmatan pesanan), buat pelanggan GRPC:

 InventoryClient Kelas Awam {

  Inventory Final PrivateServiceGrpc.InventoryServiceBlockingStub BlockingStub;

  InventoryClient Public (Host String, Int Port) {
    Saluran ManagedChannel = ManagedChannelBuilder.ForAddress (Host, Port)
        .UsepLaintext () // Jangan gunakan dalam pengeluaran tanpa TLS
        .build ();

    BlockingStub = InventoryServiceGrpc.NewBlockingStub (Channel);
  }

  public int getStock (String ProductID) {
    Permintaan stockRequest = stockRequest.newBuilder (). SetProductId (ProductID) .build ();
    Response StockResponse = BlockingStub.getStock (permintaan);
    respons balik.GetAvailableCount ();
  }
}

Gunakannya seperti:

 InventoryClient Client = InventoryClient baru ("localhost", 8080);
int stock = client.getStock ("p123");
System.out.println ("Stok:" Saham);

Petua untuk kegunaan dunia sebenar

• Gunakan TLS dalam pengeluaran : Sentiasa aktifkan penyulitan antara perkhidmatan. GRPC menyokong SSL/TLS keluar dari kotak.
• Mengendalikan kesilapan dengan kod status GRPC : Gunakan Status dan StatusException untuk penyebaran ralat bersih.
• Mengintegrasikan dengan Penemuan Perkhidmatan : Pasangan GRPC dengan alat seperti Konsul, Eureka, atau Kubernet DNS.
• Tambah pemerhatian : Gunakan pemintas untuk pembalakan, metrik (misalnya, mikrometer), dan pengesanan yang diedarkan (misalnya, OpenTelemetry).
• Elakkan gandingan yang ketat : Walaupun .proto Fail menentukan kontrak, versi mereka dengan teliti dan elakkan kerap memecahkan perubahan.

Balut

GRPC dalam persediaan microservices Java memberikan anda kelajuan, jenis keselamatan, dan antara muka yang bersih. Mulakan Kecil: Tentukan satu perkhidmatan, dapatkannya, dan panggilnya dari yang lain. Sebaik sahaja anda selesa, tambahkan streaming, pengesahan, dan pemantauan.

Ia tidak selalunya pilihan yang tepat (contohnya, jika anda memerlukan pelanggan pelayar), tetapi untuk komunikasi backend-to-backend, sukar untuk ditewaskan.

Pada asasnya, tentukan .proto , menjana kod, melaksanakan pelayan, hubungi dari klien - dan anda bergulir.

Atas ialah kandungan terperinci Bermula dengan GRPC dalam Senibina Microservices Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!