{"id":423,"date":"2024-06-01T22:00:09","date_gmt":"2024-06-01T21:00:09","guid":{"rendered":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=423"},"modified":"2024-06-26T22:04:28","modified_gmt":"2024-06-26T21:04:28","slug":"erstellen-von-grpc-services-in-spring-boot","status":"publish","type":"post","link":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=423","title":{"rendered":"Erstellen von gRPC-Services in Spring Boot"},"content":{"rendered":"\n

Einleitung<\/h4>\n\n\n\n

gRPC (gRPC Remote Procedure Call) ist ein modernes, Open-Source Remote Procedure Call (RPC)-Framework, das von Google entwickelt wurde. Es erm\u00f6glicht die einfache Kommunikation zwischen verteilten Systemen und Diensten in einer leistungsstarken und effizienten Weise. Durch die Verwendung von HTTP\/2, Protokollpuffer (Protocol Buffers) und bidirektionalem Streaming bietet gRPC erhebliche Vorteile gegen\u00fcber traditionellen RESTful APIs, insbesondere in Bezug auf Leistung und Skalierbarkeit.<\/p>\n\n\n\n

Spring Boot, ein beliebtes Framework f\u00fcr die Erstellung von Microservices in Java, unterst\u00fctzt gRPC nicht direkt, aber durch die Verwendung des grpc-spring-boot-starter<\/code> wird die Integration von gRPC in Spring Boot-Projekte erheblich vereinfacht. In diesem Artikel werden wir einen detaillierten Leitfaden zur Erstellung von gRPC-Services in Spring Boot mit dem grpc-spring-boot-starter<\/code> bereitstellen.<\/p>\n\n\n\n

Voraussetzungen<\/h4>\n\n\n\n
    \n
  • Grundlegende Kenntnisse in Java und Spring Boot<\/li>\n\n\n\n
  • Maven oder Gradle als Build-Tool<\/li>\n\n\n\n
  • Eine Entwicklungsumgebung wie IntelliJ IDEA oder Eclipse<\/li>\n<\/ul>\n\n\n\n

    Einrichtung des Projekts<\/h4>\n\n\n\n

    Zuerst m\u00fcssen wir ein neues Spring Boot-Projekt erstellen. Dies kann \u00fcber die Spring Initializr-Webseite (https:\/\/start.spring.io\/) erfolgen oder direkt in Ihrer bevorzugten Entwicklungsumgebung. Stellen Sie sicher, dass Sie Maven Project<\/code> und Java<\/code> ausw\u00e4hlen, und f\u00fcgen Sie die folgenden Abh\u00e4ngigkeiten hinzu:<\/p>\n\n\n\n

      \n
    • Spring Boot DevTools<\/li>\n\n\n\n
    • Spring Web<\/li>\n\n\n\n
    • Protobuf (f\u00fcr Protokollpuffer)<\/li>\n<\/ul>\n\n\n\n

      Nachdem das Projekt erstellt wurde, m\u00fcssen wir die grpc-spring-boot-starter<\/code>-Abh\u00e4ngigkeit zu unserer pom.xml<\/code> (f\u00fcr Maven) oder build.gradle<\/code> (f\u00fcr Gradle) hinzuf\u00fcgen.<\/p>\n\n\n\n

      F\u00fcr Maven:<\/strong><\/p>\n\n\n

      <dependency<\/span>><\/span>\n    <groupId<\/span>><\/span>net.devh<\/groupId<\/span>><\/span>\n    <artifactId<\/span>><\/span>grpc-spring-boot-starter<\/artifactId<\/span>><\/span>\n    <version<\/span>><\/span>2.13.0.RELEASE<\/version<\/span>><\/span>\n<\/dependency<\/span>><\/span><\/code><\/span>Code-Sprache:<\/span> HTML, XML<\/span> (<\/span>xml<\/span>)<\/span><\/small><\/pre>\n\n\n
      F\u00fcr Gradle:<\/strong><\/p>\n\n\n
      implementation 'net.devh:grpc-spring-boot-starter:2.13.0.RELEASE'<\/span><\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
      Definition des Protobuf-Dateiformats<\/h4>\n\n\n\n
      Als N\u00e4chstes m\u00fcssen wir unsere gRPC-Services in einer .proto<\/code>-Datei definieren. Erstellen Sie eine neue Datei namens greeting.proto<\/code> im Verzeichnis src\/main\/proto\/<\/code> mit folgendem Inhalt:<\/p>\n\n\n
      syntax = \"proto3\"<\/span>;\n\noption java_multiple_files = true<\/span>;\noption java_package = \"com.example.grpc\"<\/span>;\noption java_outer_classname = \"GreetingProto\"<\/span>;\n\nservice GreetingService {\n    rpc greet (GreetingRequest) returns (GreetingResponse);\n}\n\nmessage GreetingRequest {\n    string name = 1<\/span>;\n}\n\nmessage GreetingResponse {\n    string message = 1<\/span>;\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
      Diese Datei definiert einen gRPC-Service GreetingService<\/code> mit einer RPC-Methode greet<\/code>, die eine GreetingRequest<\/code> empf\u00e4ngt und eine GreetingResponse<\/code> zur\u00fcckgibt.<\/p>\n\n\n\n
      Generierung der Java-Klassen aus der Protobuf-Datei<\/h4>\n\n\n\n
      Um die Java-Klassen aus der Protobuf-Datei zu generieren, m\u00fcssen wir das protobuf-maven-plugin<\/code> in unsere pom.xml<\/code> hinzuf\u00fcgen:<\/p>\n\n\n
      <build<\/span>><\/span>\n    <extensions<\/span>><\/span>\n        <extension<\/span>><\/span>\n            <groupId<\/span>><\/span>kr.motd.maven<\/groupId<\/span>><\/span>\n            <artifactId<\/span>><\/span>os-maven-plugin<\/artifactId<\/span>><\/span>\n            <version<\/span>><\/span>1.6.2<\/version<\/span>><\/span>\n        <\/extension<\/span>><\/span>\n    <\/extensions<\/span>><\/span>\n    <plugins<\/span>><\/span>\n        <plugin<\/span>><\/span>\n            <groupId<\/span>><\/span>org.xolstice.maven.plugins<\/groupId<\/span>><\/span>\n            <artifactId<\/span>><\/span>protobuf-maven-plugin<\/artifactId<\/span>><\/span>\n            <version<\/span>><\/span>0.6.1<\/version<\/span>><\/span>\n            <configuration<\/span>><\/span>\n                <protocArtifact<\/span>><\/span>com.google.protobuf:protoc:3.14.0:exe:${os.detected.classifier}<\/protocArtifact<\/span>><\/span>\n            <\/configuration<\/span>><\/span>\n            <executions<\/span>><\/span>\n                <execution<\/span>><\/span>\n                    <goals<\/span>><\/span>\n                        <goal<\/span>><\/span>compile<\/goal<\/span>><\/span>\n                        <goal<\/span>><\/span>compile-custom<\/goal<\/span>><\/span>\n                    <\/goals<\/span>><\/span>\n                <\/execution<\/span>><\/span>\n            <\/executions<\/span>><\/span>\n        <\/plugin<\/span>><\/span>\n    <\/plugins<\/span>><\/span>\n<\/build<\/span>><\/span><\/code><\/span>Code-Sprache:<\/span> HTML, XML<\/span> (<\/span>xml<\/span>)<\/span><\/small><\/pre>\n\n\n
      F\u00fchren Sie mvn clean install<\/code> aus, um die Protobuf-Dateien zu kompilieren und die entsprechenden Java-Klassen zu generieren.<\/p>\n\n\n\n
      Implementierung des gRPC-Services<\/h4>\n\n\n\n
      Jetzt k\u00f6nnen wir unseren gRPC-Service in Java implementieren. Erstellen Sie eine neue Klasse GreetingServiceImpl<\/code> in einem geeigneten Paket (z.B. com.example.grpc.service<\/code>) und erweitern Sie die generierte GreetingServiceGrpc.GreetingServiceImplBase<\/code>-Klasse:<\/p>\n\n\n
      package com.example.grpc.service;\n\nimport<\/span> com.example.grpc.GreetingRequest;\nimport<\/span> com.example.grpc.GreetingResponse;\nimport<\/span> com.example.grpc.GreetingServiceGrpc;\nimport<\/span> io.grpc.stub.StreamObserver;\nimport<\/span> net.devh.boot.grpc.server.service.GrpcService;\n\n@GrpcService\npublic class<\/span> GreetingServiceImpl<\/span> extends<\/span> GreetingServiceGrpc<\/span>.GreetingServiceImplBase<\/span> <\/span>{\n\n    @Override\n    public void<\/span> greet(GreetingRequest request, StreamObserver<GreetingResponse> responseObserver) {\n        String<\/span> name = request.getName();\n        String<\/span> message = \"Hello, \"<\/span> + name + \"!\"<\/span>;\n\n        GreetingResponse response = GreetingResponse.newBuilder()\n                .setMessage(message)\n                .build();\n\n        responseObserver.onNext(response);\n        responseObserver.onCompleted();\n    }\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
      Diese Klasse implementiert die greet<\/code>-Methode des GreetingService<\/code>. Sie empf\u00e4ngt eine GreetingRequest<\/code>, erstellt eine GreetingResponse<\/code> und sendet diese zur\u00fcck an den Client.<\/p>\n\n\n\n
      Konfiguration von gRPC in Spring Boot<\/h4>\n\n\n\n
      Die grpc-spring-boot-starter<\/code>-Abh\u00e4ngigkeit konfiguriert gRPC automatisch in Ihrem Spring Boot-Projekt. Es sind jedoch einige Konfigurationen erforderlich, um den Server richtig zu starten. F\u00fcgen Sie die folgenden Einstellungen zu Ihrer application.properties<\/code> hinzu:<\/p>\n\n\n
      grpc.server.port=9090<\/code><\/span><\/pre>\n\n\n
      Diese Einstellung gibt den Port an, auf dem der gRPC-Server lauschen soll. Der Standardwert ist 9090, aber Sie k\u00f6nnen ihn nach Bedarf \u00e4ndern.<\/p>\n\n\n\n
      Erstellen eines gRPC-Clients<\/h4>\n\n\n\n
      Um den gRPC-Service zu testen, k\u00f6nnen wir einen einfachen gRPC-Client erstellen. Erstellen Sie eine neue Klasse GreetingClient<\/code>:<\/p>\n\n\n
      package com.example.grpc.client;\n\nimport<\/span> com.example.grpc.GreetingRequest;\nimport<\/span> com.example.grpc.GreetingResponse;\nimport<\/span> com.example.grpc.GreetingServiceGrpc;\nimport<\/span> io.grpc.ManagedChannel;\nimport<\/span> io.grpc.ManagedChannelBuilder;\nimport<\/span> org.springframework.stereotype.Component;\n\nimport<\/span> javax.annotation.PostConstruct;\nimport<\/span> javax.annotation.PreDestroy;\n\n@Component\npublic class<\/span> GreetingClient<\/span> <\/span>{\n\n    private GreetingServiceGrpc.GreetingServiceBlockingStub stub;\n    private ManagedChannel channel;\n\n    @PostConstruct\n    public void<\/span> init() {\n        channel = ManagedChannelBuilder.forAddress(\"localhost\"<\/span>, 9090<\/span>)\n                .usePlaintext()\n                .build();\n\n        stub = GreetingServiceGrpc.newBlockingStub(channel);\n    }\n\n    public String<\/span> greet(String<\/span> name) {\n        GreetingRequest request = GreetingRequest.newBuilder()\n                .setName(name)\n                .build();\n\n        GreetingResponse response = stub.greet(request);\n        return<\/span> response.getMessage();\n    }\n\n    @PreDestroy\n    public void<\/span> shutdown() {\n        if<\/span> (channel != null<\/span>) {\n            channel.shutdown();\n        }\n    }\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
      Dieser Client stellt eine Verbindung zum gRPC-Server her und ruft die greet<\/code>-Methode auf. Um den Client zu verwenden, k\u00f6nnen Sie ihn in einem Spring Boot-Controller einbinden und eine REST-Endpoint erstellen:<\/p>\n\n\n
      package com.example.grpc.controller;\n\nimport<\/span> com.example.grpc.client.GreetingClient;\nimport<\/span> org.springframework.web.bind.annotation.GetMapping;\nimport<\/span> org.springframework.web.bind.annotation.RequestParam;\nimport<\/span> org.springframework.web.bind.annotation.RestController;\n\n@RestController\npublic class<\/span> GreetingController<\/span> <\/span>{\n\n    private final GreetingClient greetingClient;\n\n    public GreetingController(GreetingClient greetingClient) {\n        this<\/span>.greetingClient = greetingClient;\n    }\n\n    @GetMapping(\"\/greet\"<\/span>)\n    public String<\/span> greet(@RequestParam String<\/span> name) {\n        return<\/span> greetingClient.greet(name);\n    }\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
      Mit diesem Controller k\u00f6nnen Sie den gRPC-Service \u00fcber einen einfachen HTTP-GET-Request aufrufen, z.B. http:\/\/localhost:8080\/greet?name=World<\/code>.<\/p>\n\n\n\n
      Fazit<\/h4>\n\n\n\n
      Die Integration von gRPC in Spring Boot mit dem grpc-spring-boot-starter<\/code> ist relativ einfach und bietet eine leistungsstarke Alternative zu herk\u00f6mmlichen RESTful APIs. Mit der M\u00f6glichkeit, bidirektionales Streaming und Protokollpuffer zu nutzen, ist gRPC besonders f\u00fcr hochskalierbare und performante Microservices-Architekturen geeignet. Durch die in diesem Artikel beschriebenen Schritte k\u00f6nnen Sie einen gRPC-Service schnell und effizient in Ihrem Spring Boot-Projekt implementieren.<\/p>\n","protected":false},"excerpt":{"rendered":"
      Einleitung gRPC (gRPC Remote Procedure Call) ist ein modernes, Open-Source Remote Procedure Call (RPC)-Framework, das von Google entwickelt wurde. Es erm\u00f6glicht die einfache Kommunikation zwischen verteilten Systemen und Diensten in einer leistungsstarken und effizienten Weise. Durch die Verwendung von HTTP\/2, Protokollpuffer (Protocol Buffers) und bidirektionalem Streaming bietet gRPC erhebliche Vorteile gegen\u00fcber traditionellen RESTful APIs, insbesondere […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[5],"tags":[],"class_list":["post-423","post","type-post","status-publish","format-standard","hentry","category-spring"],"_links":{"self":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/423","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=423"}],"version-history":[{"count":1,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/423\/revisions"}],"predecessor-version":[{"id":424,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/423\/revisions\/424"}],"wp:attachment":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=423"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=423"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=423"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}