Sind Sie bereit, die Art und Weise, wie Sie APIs erstellen, zu revolutionieren? Wenn Sie schon eine Weile in der Entwicklungswelt tätig sind, haben Sie wahrscheinlich schon von GraphQL, Node.js und Express gehört. Zusammen bilden diese Technologien ein leistungsstarkes Toolkit für den Aufbau moderner, effizienter APIs. Heute tauchen wir tief in die Welt von GraphQL mit Node.js und Express ein, um Ihnen zu helfen, diese Kombination in Ihren Projekten zu verstehen und zu implementieren.
Aber zuerst möchte ich Ihnen ein Tool vorstellen, das Ihre API-Entwicklung noch reibungsloser macht: Apidog. Apidog ist ein kostenloses API-Test- und -Verwaltungstool, das sich nahtlos in GraphQL, Node.js und Express integriert. Wenn Sie Ihren API-Entwicklungsprozess optimieren möchten, laden Sie Apidog kostenlos herunter und sehen Sie den Unterschied!
Einführung in GraphQL, Node.js und Express
Was ist GraphQL?
GraphQL ist eine Abfragesprache für Ihre API und eine serverseitige Laufzeitumgebung für die Ausführung von Abfragen unter Verwendung eines Typsystems, das Sie für Ihre Daten definieren. Entwickelt von Facebook, bietet es eine effizientere, leistungsstärkere und flexiblere Alternative zu REST. Mit GraphQL können Sie genau die Daten anfordern, die Sie benötigen, und so das Über- oder Unterabrufen von Daten vermeiden.
Was ist Node.js?
Node.js ist eine JavaScript-Laufzeitumgebung, die auf der V8-JavaScript-Engine von Chrome basiert. Sie ermöglicht es Entwicklern, skalierbare Netzwerkanwendungen mit JavaScript auf der Serverseite zu erstellen. Node.js ist bekannt für sein ereignisgesteuertes, nicht blockierendes I/O-Modell, das es leicht und effizient macht.
Was ist Express?
Express ist ein minimales und flexibles Node.js-Webanwendungs-Framework, das eine robuste Reihe von Funktionen zur Entwicklung von Web- und mobilen Anwendungen bietet. Es erleichtert die schnelle Entwicklung von Node-basierten Webanwendungen und wird häufig als Rückgrat für den Aufbau von RESTful-APIs verwendet.
Einrichten Ihrer Entwicklungsumgebung
Bevor wir mit dem Erstellen unserer API beginnen, richten wir unsere Entwicklungsumgebung ein. Folgendes benötigen Sie:
- Node.js und npm (Node Package Manager) installiert
- Ein Code-Editor (wie Visual Studio Code)
- Ein Terminal oder eine Eingabeaufforderung
Installieren von Node.js und npm
Laden Sie Node.js von der offiziellen Node.js-Website herunter und installieren Sie es. npm wird mit Node.js gebündelt, sodass Sie es nicht separat installieren müssen.
Initialisieren eines neuen Node.js-Projekts
Öffnen Sie Ihr Terminal und erstellen Sie ein neues Verzeichnis für Ihr Projekt. Navigieren Sie in Ihr Projektverzeichnis und führen Sie den folgenden Befehl aus, um ein neues Node.js-Projekt zu initialisieren:
npm init -y
Dieser Befehl erstellt eine package.json-Datei in Ihrem Projektverzeichnis.
Erstellen eines einfachen Express-Servers
Nachdem unser Projekt eingerichtet ist, erstellen wir einen einfachen Express-Server.
Installieren von Express
Führen Sie den folgenden Befehl aus, um Express zu installieren:
npm install express
Erstellen des Servers
Erstellen Sie eine neue Datei mit dem Namen server.js und fügen Sie den folgenden Code hinzu:
const express = require('express');
const app = express();
const PORT = process.env.PORT || 4000;
app.get('/', (req, res) => {
res.send('Hello World!');
});
app.listen(PORT, () => {
console.log(`Server is running on port ${PORT}`);
});
Dieser Code richtet einen einfachen Express-Server ein, der auf Port 4000 lauscht und mit "Hello World!" antwortet, wenn er unter der Stamm-URL aufgerufen wird.
Um den Server zu starten, führen Sie Folgendes aus:
node server.js
Besuchen Sie http://localhost:4000 in Ihrem Browser, um die Nachricht "Hello World!" anzuzeigen.
Integrieren von GraphQL mit Express
Wenn unser einfacher Server läuft, ist es an der Zeit, GraphQL zu integrieren.
Installieren von GraphQL und Apollo Server
Apollo Server ist ein von der Community verwalteter Open-Source-GraphQL-Server, der mit jedem GraphQL-Client kompatibel ist. Wir verwenden ihn, um unsere GraphQL-Anforderungen zu bearbeiten.
Installieren Sie Apollo Server und GraphQL:
npm install apollo-server-express graphql
Einrichten von Apollo Server
Ändern Sie server.js, um Apollo Server mit Express einzurichten:
const express = require('express');
const { ApolloServer, gql } = require('apollo-server-express');
const app = express();
const PORT = process.env.PORT || 4000;
// Define the schema
const typeDefs = gql`
type Query {
hello: String
}
`;
// Define the resolvers
const resolvers = {
Query: {
hello: () => 'Hello World!',
},
};
// Create an instance of ApolloServer
const server = new ApolloServer({ typeDefs, resolvers });
// Apply middleware to connect ApolloServer with Express
server.applyMiddleware({ app });
app.listen(PORT, () => {
console.log(`Server is running on port ${PORT}${server.graphqlPath}`);
});
Dieser Code richtet einen einfachen Apollo Server mit einer einzelnen hello-Abfrage ein, die "Hello World!" zurückgibt.
Definieren von GraphQL-Schemas und Resolvers
Nachdem wir nun einen einfachen GraphQL-Server am Laufen haben, wollen wir uns eingehender mit Schemas und Resolvers befassen.
Was ist ein Schema?
Ein GraphQL-Schema definiert die Typen und Beziehungen in Ihrer API. Es beschreibt, welche Abfragen gestellt werden können und welche Daten abgerufen werden können.
Was sind Resolvers?
Resolver sind Funktionen, die das Abrufen der Daten für ein bestimmtes Feld in Ihrem Schema verarbeiten. Sie sagen GraphQL, wie die Daten für jede Abfrage abgerufen werden sollen.
Definieren komplexerer Schemas
Erweitern Sie Ihre typeDefs und resolvers in server.js:
const typeDefs = gql`
type Book {
title: String
author: String
}
type Query {
books: [Book]
}
`;
const books = [
{
title: 'The Awakening',
author: 'Kate Chopin',
},
{
title: 'City of Glass',
author: 'Paul Auster',
},
];
const resolvers = {
Query: {
books: () => books,
},
};
Dieses Schema definiert einen Book-Typ und eine books-Abfrage, die eine Liste von Büchern zurückgibt.
Verbinden mit einer Datenbank
Für eine reale Anwendung müssen Sie Ihre API mit einer Datenbank verbinden. Nehmen wir MongoDB für dieses Beispiel.
Einrichten von MongoDB
Melden Sie sich für ein kostenloses MongoDB Atlas-Konto an oder richten Sie eine lokale MongoDB-Instanz ein. Installieren Sie dann mongoose, um von Node.js aus mit MongoDB zu interagieren:
npm install mongoose
Verbinden mit MongoDB
Ändern Sie server.js, um eine Verbindung zu MongoDB herzustellen:
const mongoose = require('mongoose');
mongoose.connect('mongodb://localhost:27017/graphql', {
useNewUrlParser: true,
useUnifiedTopology: true,
});
const db = mongoose.connection;
db.on('error', console.error.bind(console, 'connection error:'));
db.once('open', () => {
console.log('Connected to MongoDB');
});
// Define a Mongoose schema and model
const bookSchema = new mongoose.Schema({
title: String,
author: String,
});
const Book = mongoose.model('Book', bookSchema);
// Modify the resolver to fetch data from MongoDB
const resolvers = {
Query: {
books: async () => await Book.find(),
},
};
Jetzt ruft die books-Abfrage Daten von MongoDB ab.
Optimieren Ihrer GraphQL-API
Um sicherzustellen, dass Ihre GraphQL-API effizient und leistungsfähig ist, sollten Sie die folgenden Optimierungstechniken in Betracht ziehen:
DataLoader für effizientes Batch-Laden
DataLoader ist ein Dienstprogramm zum Batch- und Caching von Datenabrufen. Es hilft, die Anzahl der Datenbankanforderungen zu reduzieren.
Installieren Sie DataLoader:
npm install dataloader
Verwenden Sie DataLoader in Ihren Resolvers:
const DataLoader = require('dataloader');
const bookLoader = new DataLoader(async (keys) => {
const books = await Book.find({ _id: { $in: keys } });
return keys.map((key) => books.find((book) => book.id === key));
});
const resolvers = {
Query: {
books: async () => await bookLoader.loadAll(),
},
};
Caching
Implementieren Sie Caching-Strategien, um redundantes Datenabrufen zu vermeiden. Sie können In-Memory-Caches wie Redis verwenden, um häufig angeforderte Daten zu speichern.
Paginierung
Implementieren Sie für Abfragen, die große Datensätze zurückgeben, die Paginierung, um Daten in Chunks abzurufen. Verwenden Sie die Parameter limit und skip, um Ergebnisse zu paginieren.
Testen Ihrer API mit Apidog
Das Testen Ihrer API ist entscheidend, um sicherzustellen, dass sie wie erwartet funktioniert. Apidog vereinfacht diesen Prozess mit seiner intuitiven Benutzeroberfläche und leistungsstarken Funktionen.
Schritt 1: Öffnen Sie Apidog und erstellen Sie eine neue Anfrage.
Schritt 2: Suchen Sie die API-Details für die POST-Anfrage, die Sie erstellen möchten, oder geben Sie sie manuell ein.
Schritt 3: Füllen Sie die erforderlichen Parameter und alle Daten aus, die Sie in den Anfragetext aufnehmen möchten.
Durch die Integration von Apidog in Ihren Workflow können Sie Zeit sparen und häufige Fallstricke in der API-Entwicklung vermeiden. Außerdem ist der Download und die Nutzung kostenlos!
Apidog mit Ihrem GraphQL
Sobald Sie Apidog installiert haben, können Sie Ihr GraphQL-Schema importieren, um Ihre API effizienter zu verwalten und zu testen. Navigieren Sie zum Importabschnitt in Apidog und laden Sie Ihre schema.graphqls-Datei hoch.
Geben Sie Ihre Abfrage in das Feld "Query" auf der Registerkarte "Run" ein. Sie können auch auf die Schaltfläche "Fetch Schema" im Eingabefeld klicken, um die Funktion "Code-Vervollständigung" für Abfrageausdrücke zu aktivieren und so die Eingabe von Abfrageanweisungen zu unterstützen.
Mit Ihrem importierten Schema können Sie Apidog verwenden, um Ihre Abfragen und Mutationen zu testen, Dokumentationen zu generieren und sogar Antworten zu simulieren. Dies hilft Ihnen sicherzustellen, dass Ihre API wie erwartet funktioniert, und bietet einen umfassenden Leitfaden für Ihre API-Benutzer.
Verwenden Sie die automatisierten Testfunktionen von Apidog, um Ihre Testfälle nach einem Zeitplan auszuführen. Dies hilft, Probleme frühzeitig zu erkennen und stellt sicher, dass Ihre API zuverlässig bleibt.
Best Practices für den Aufbau von APIs
Der Aufbau robuster und skalierbarer APIs erfordert die Einhaltung von Best Practices. Hier sind einige wichtige Tipps:
Verwenden Sie beschreibende Fehlermeldungen
Stellen Sie sicher, dass Ihre API aussagekräftige Fehlermeldungen zurückgibt, damit Clients verstehen, was schief gelaufen ist.
Sichern Sie Ihre API
Implementieren Sie Authentifizierungs- und Autorisierungsmechanismen, um Ihre API vor unbefugtem Zugriff zu schützen.
Dokumentieren Sie Ihre API
Stellen Sie eine klare und umfassende Dokumentation für Ihre API bereit. Tools wie Swagger und GraphQL Playground können bei der Erstellung interaktiver Dokumentationen helfen.
Überwachen Sie die Leistung
Verwenden Sie Überwachungstools, um die Leistung Ihrer API zu verfolgen. Identifizieren und beheben Sie Leistungsengpässe umgehend.
Organisieren Sie Ihre Codebasis
Befolgen Sie eine konsistente Codestruktur und Namenskonventionen, um Ihre Codebasis sauber und wartbar zu halten.
Fazit
Herzlichen Glückwunsch! Sie haben gelernt, wie Sie eine leistungsstarke GraphQL-API mit Node.js und Express erstellen. Wir haben alles behandelt, von der Einrichtung Ihrer Entwicklungsumgebung über die Definition von Schemas und Resolvers bis hin zur Verbindung mit einer Datenbank, der Optimierung Ihrer API und dem Testen mit Apidog.
Denken Sie daran, dass der Aufbau großartiger APIs ein fortlaufender Prozess ist. Verfeinern Sie kontinuierlich Ihre Fähigkeiten, bleiben Sie über die neuesten Entwicklungen im GraphQL-Ökosystem auf dem Laufenden und experimentieren Sie weiter mit neuen Tools und Techniken.
