GraphQL & Apollo | Komentor

GraphQL ist eine Abfragesprache für APIs und eine Laufzeitumgebung zum Erfüllen dieser Abfragen mit Ihren vorhandenen Daten. GraphQL bietet eine vollständige und verständliche Beschreibung der Daten in Ihrer API, gibt Kunden die Möglichkeit, genau nach dem zu fragen, was sie benötigen, und nicht mehr, erleichtert die Entwicklung von APIs im Laufe der Zeit und ermöglicht leistungsstarke Entwicklertools.

Überholen: Übermäßiges Abrufen bedeutet, dass zu viele Daten abgerufen werden, auch bekannt als Daten in der Antwort, die Sie nicht verwenden.

Unter Holen: Underfetching bedeutet, dass bei einem Aufruf an einen Endpunkt nicht genügend Daten vorhanden sind, was dazu führt, dass Sie den zweiten Endpunkt anrufen. In beiden Fällen handelt es sich um Leistungsprobleme: Sie verwenden entweder mehr Bandbreite, als Sie sollten, oder Sie stellen mehr HTTP-Anforderungen, als Sie sollten.

In einer perfekten Welt würden diese Probleme niemals auftreten; Sie hätten genau die richtigen Endpunkte, um Ihren Produkten genau die richtigen Daten zu geben.

Diese Probleme treten häufig auf, wenn Sie Ihre Produkte skalieren und iterieren. Die Daten, die Sie auf Ihren Seiten verwenden, ändern sich häufig, und die Kosten für die Verwaltung eines separaten Endpunkts mit genau den richtigen Daten für jede Komponente werden zu hoch.

Am Ende haben Sie also einen Kompromiss zwischen nicht zu vielen Endpunkten und den Endpunkten, die den Anforderungen am besten entsprechen. Dies führt in einigen Fällen zu einem Überholen (der Endpunkt liefert mehr Daten, die Sie für Ihre spezifische Komponente benötigen) und in anderen zu einem Unterholen (Sie müssen einen zweiten Endpunkt aufrufen).

GraphQL behebt dieses Problem, da es den Zugriff auf eine beliebige Menge von Daten ermöglicht, die vom Server bereitgestellt werden. Sie geben genau an, was Sie benötigen, und erhalten diese Daten, und nur diese Daten, in einer einzigen Fahrt zum Server.

Erstellen Sie eine Spring-Boot-Anwendung (und öffnen Sie sie in Ihrer bevorzugten IDE, meistens IntelliJ
Richten Sie Ihre MongoDB ein (https://docs.mongodb.com/manual/tutorial/install-mongodb-on-os-x)
Fügen Sie Ihrer POM.xml die folgenden Zeilen hinzu und synchronisieren Sie. Sie können die neueste Version verwenden.

<dependency>
 <groupId>com.graphql-java</groupId>
 <artifactId>graphiql-spring-boot-starter</artifactId>
 <version>4.2.0</version>
</dependency>

<dependency>
 <groupId>com.graphql-java</groupId>
 <artifactId>graphql-spring-boot-starter</artifactId>
 <version>4.2.0</version>
</dependency>

<dependency>
 <groupId>com.graphql-java</groupId>
 <artifactId>graphql-java-tools</artifactId>
 <version>5.1.0</version>
</dependency>

Beginnen wir mit dem Schreiben von Code.

1.Abfrage
Es ist wie eine GET-Anfrage. Jedes Mal, wenn wir zum Lesen auf die Daten zugreifen möchten, verwenden wir Abfragen.
Wir können in unserer GraphQL-Anwendung beliebig viele Abfragen angeben und diese Abfragen nach Bedarf aufrufen.,
Wir können auch optionale oder erforderliche Parameter an die Abfrage übergeben, und wir können diese Parameter intern verwenden, um die richtigen Daten zu filtern und zurückzugeben.
Wie auch immer, Query ruft die Daten nicht ab, es fungiert als Proxy, es verarbeitet die eingehende GraphQL-Anforderung und ruft die Methode „resolve“ auf und übergibt alle Parameter. Es ist die Aufgabe der Methode „resolve“, die Daten aus einer beliebigen Quelle abzurufen und geben Sie es an die Abfrage zurück.
Die Abfrage überprüft dann die Daten auf korrekte Feldtypen und gibt sie an den Client zurück.

2. Mutation
Genau wie bei Abfragen wird Mutation immer dann verwendet, wenn wir die Daten manipulieren möchten. Dies wird für Erstellungs-, Aktualisierungs- und Löschvorgänge verwendet.
Jedes Mal, wenn wir einen Datensatz hinzufügen/manipulieren möchten, rufen wir GraphQL Mutation auf und übergeben alle Argumente/Parameter. Die Mutation ruft dann die Auflösungsmethode auf und leitet alle empfangenen Daten weiter.
Hier machen wir mit den Daten, wo immer wir wollen, und wie auch immer wir es machen wollen, sobald wir fertig sind, senden wir die Antwort an die Mutation zurück, die wiederum die Antwort an den Client zurücksendet. (nach Validierung der Feldtypen)

3. Abonnement
Im einfachsten Sinne sind Abonnements wie Abfragen, aber jedes Mal, wenn sich die Daten ändern, wird die Abfrage ausgeführt und die neue Antwort an alle verbundenen Clients zurückgesendet.
Das ist relativ neu, aber ein Schritt nach vorn in Richtung Echtzeit-Updates.

4. Resolver
Wir verwenden resolve zum Abrufen und Bearbeiten der Daten. Wie wir das machen wollen, bleibt ganz uns überlassen.
Wir können die Daten aus Datenbank, API, Datei oder einer beliebigen Datenquelle abrufen. GraphQL schränkt uns nicht ein.
Um eine starke Typisierung und ein intuitives Design beizubehalten, ist es üblich, GraphQL-Typen mit äquivalenten Java-Klassen und Felder mit Methoden darzustellen. graphql-java-tools definiert zwei Arten von Klassen: Datenklassen, die die Domäne modellieren und normalerweise einfache POJOs sind, und Resolver, die die Abfragen und Mutationen modellieren und die Resolver-Funktionen enthalten.

5. Typen
GraphQL wird standardmäßig mit einer Reihe von Standard-Skalartypen geliefert:
Int: Eine vorzeichenbehaftete 32-Bit-Ganzzahl.
Float: Ein vorzeichenbehafteter Gleitkommawert mit doppelter Genauigkeit.
String: Eine UTF-8-Zeichenfolge.
Boolesch: wahr/falsch
ID: Der Skalartyp ID stellt einen eindeutigen Bezeichner dar, der häufig zum erneuten Abrufen eines Objekts oder als Schlüssel für einen Cache verwendet wird. Der Typ „ID“ wird wie ein String serialisiert; die Definition als „ID“ bedeutet jedoch, dass sie nicht für Menschenlesbarkeit gedacht ist.

6. Schema
Hier verbinden wir alles miteinander.
Hier erstellen wir eine ‘RootQuery’ (Name kann beliebig sein) und hier geben wir alle von uns geschriebenen Abfragen an.
In ähnlicher Weise erstellen wir eine „RootMutation“ und spezifizieren alle Mutationen, die wir geschrieben haben.
Schließlich geben wir ein GraphQLSchema mit diesem Abfrage- und Mutationsobjekt zurück.

****emessage.graphqls

type EMessage {
    id: ID
    subject: String
    description: String
    category: String
    read: Boolean
    sentDateTime:String
    sender: Sender
}
extend type Query {
    allMessage: [EMessage]
    message(id: ID): EMessage
}
extend type Mutation {
    createMessage(subject: String, description: String,
                  category: String, senderEmail:String): String
}

****sender.graphqls

type Sender {
    email:String
    firstName:String
    lastName:String
}
type Query {
    allSender: [Sender]
}
type Mutation {
    createSender(email: String, firstName: String,
                 lastName: String): String
}

Wie testen?

query {
  allMessage {
    id
    subject
    description
    sender {
      firstName
      lastName
    }
  }
}
query {
 message(id:"5b3658d1cf56c459c6ce07fa") {
     id
    subject
  }
}
mutation {
createMessage(subject: "GraphQL new Message",
    		description: "This is new description 1",
   			category:"Social")
}

Bitte gehen Sie durch den verlinkten Github, um mehr darüber zu erfahren
GraphQLDemo-Android
GraphQLDemo-IOS
GraphQLDemo-Server

https://graphql.org
https://www.howtographql.com
https://www.apollographql.com

Similar Posts

Leave a Reply

Your email address will not be published.