Node.js: Erstellen von RESTful-APIs mit Loopback und MySQL

Dieses Tutorial führt Sie durch das Schreiben einfacher REST-APIs mit Loopback (einem Node.js-Framework) und MySQL als Back-End. Am Ende dieses Tutorials sind Sie in der Lage, mithilfe des Loopback-Frameworks Ihre eigenen REST-APIs zu schreiben.

In einem unserer vorherigen Beiträge hier haben wir über die Erstellung von RESTful-APIs mit ExpressJS und MongoDB geschrieben. Für jedes Programmiersprachen-Ökosystem haben wir mehr als ein Web-Framework und das Gleiche gilt auch für Node.js. Eines dieser beliebten Frameworks ist das Loopback. Sowohl ExpressJS als auch Loopback werden gesponsert von StrongLoop.

In diesem Beitrag werden wir dasselbe Beispiel implementieren, das wir in diesem Beitrag verwendet haben, jedoch mit Loopback und MySQL DB.

Loopback und Node.js

Inhaltsverzeichnis

Die in diesem Tutorial behandelten Abschnitte sind:

  • Was ist Loopback?
  • Loopback installieren
  • Erstellen Sie eine Loopback-App
  • Erstellen einer MySQL-Datenquelle
  • Modell in Loopback erstellen
  • Testen von CRUD-APIs
  • Abschluss
  • Bevor wir mit dem Lernen von Loopback beginnen, wollen wir uns ein genaueres Bild davon machen, was dieses neue Framework im Node.js-Ökosystem ist und wie es sich von anderen Frameworks wie ExpressJS unterscheidet.

    Was ist Loopback?

    Loopback ist ein Open-Source-Node.js-API-Framework zum Erstellen von REST-APIs für Ihre Clientanwendungen (z. B. Browser, Mobilgeräte usw.) auf einfachste Weise. Dies ist zwar ein weiterer Spitzenreiter in der schnell wachsenden Masse der Node.js-Frameworks, doch Loopback unterscheidet sich von anderen Frameworks wie ExpressJS durch die Bereitstellung sehr einfacher und leicht zu entwickelnder APIs. Dies basiert auf Express, dem beliebtesten Framework für Node.js.

    Es gibt viele große Vorteile von Loopback, die es wirkungsvoll machen, es als De-facto-Framework für Node.js zu wählen. In Zukunft werden mehr JavaScript-Frameworks das Internet dominieren. Loopback passt mit seiner einfachen und einfachen Entwicklung perfekt zur serverseitigen Sprache, um mehr Entwickler anzulocken.

    Javascript-Stack

    Loopback installieren

    • Loopback ist als NPM-Paket verfügbar. Wie alle NPM-Pakete kann LoopBack mit installiert werden npm.
    • Zuerst werden wir installieren slc Befehlszeilentool mit diesem Befehl npm install -g strongloop. slc Mit dem Befehlszeilentool können Anwendungen und andere App-Artefakte erstellt werden.
    • Als nächstes müssen Sie Loopback installieren, was durch Ausführen des folgenden Befehls erfolgen kann: npm install -g loopback.
    • Aber um eine Loopback-Anwendung zu erstellen mit slc Befehlszeilentool müssten wir zwei weitere npm-Pakete installieren, nämlich: cookie-parser Und errorhandler. Diese Pakete können mit dem folgenden Befehl installiert werden: npm install -g cookie-parser, errorhandler.

    Notiz: Unter Windows müsste man die Eingabeaufforderung als Administrator ausführen, um SLC installieren zu können.

    • Lesen Sie auch: Verpacken und Bereitstellen von Node.js-Anwendungen

    Erstellen Sie eine Loopback-App

    Das Strongloop-Knotenpaket enthält ein Befehlszeilentool namens slc Dies kann verwendet werden, um neue Anwendungen zu erstellen, Klassen zu modellieren, Eigenschaften hinzuzufügen und Datenquellen zu definieren, um nur einige zu nennen.

    Führen Sie diesen Befehl aus, um mit der Erstellung einer neuen Anwendung zu beginnen: slc loopback. Sie werden aufgefordert, den Namen Ihrer Anwendung und den Ordner (standardmäßig der Name der Anwendung) anzugeben, in dem sich Ihre Anwendung befinden soll. Folgendes finden Sie auf Ihren Bildschirmen:

    G:\node>slc loopback
    
         _-----_
        |       |    .--------------------------.
        |--(o)--|    |  Let's create a LoopBack |
       `---------´   |       application!       |
        ( _´U`_ )    '--------------------------'
        /___A___\
         |  ~  |
       __'.___.'__
     ´   `  |° ´ Y `
    
    ? What's the name of your application? loopback-rest
    ? Enter name of the directory to contain the project: loopback-rest
       create loopback-rest/
         info change the working directory to loopback-rest
    
    Generating .yo-rc.json
    
    I'm all done. Running npm install for you to install the required dependencies. If this fails, try running the command yourself.
    
       create .editorconfig
       create .jshintignore
       create .jshintrc
       create README.md
       create server\boot\authentication.js
       create server\boot\explorer.js
       create server\boot\rest-api.js
       create server\boot\root.js
       create server\middleware.json
       create server\server.js
       create .gitignore
       create client\README.md
    
    .... npm packages installation output ....
    
    Next steps:
    
      Change directory to your app
        $ cd loopback-rest
    
      Create a model in your app
        $ slc loopback:model
    
      Compose your API, run, deploy, profile, and monitor it with Arc
        $ slc arc
    
      Run the app
        $ node
    

    Die nächsten Schritte finden Sie auch in gedruckter Form. Aber jetzt haben wir eine Verzeichnisstruktur erstellt, die wie folgt aussieht:
    Loopback-Projektstruktur

    Es gibt viel automatisch generierten Code. Machen wir uns darüber vorerst keine Sorgen.

    Wir können die Anwendung jetzt ausführen, um zu sehen, was alles für uns generiert wird. Wechseln Sie in das App-Verzeichnis und führen Sie den Befehl aus: node .. Sie können die folgende Ausgabe sehen:

    G:\node\loopback-rest>node .
    Browse your REST API at http://localhost:3000/explorer
    Web server listening at: http://localhost:3000/
    

    Wenn wir die URL http://localhost:3000/explorer im Browser öffnen, erhalten wir die Liste der in der Anwendung verfügbaren APIs.
    Loopback-Run-AnwendungIm Bild oben sehen Sie eine Liste der APIs, die nur für den Benutzer verfügbar sind. Und das alles wird vom Framework geliefert.

    Wenn wir die URL http://localhost:3000/ im Browser öffnen, erhalten wir Folgendes:
    Loopback-Code

    Erstellen einer MySQL-Datenquelle

    Lassen Sie uns der Anwendung eine Datenquelle zuordnen. Wie bereits erwähnt, werden wir die MySQL-Datenbank verwenden. Zuerst müssen wir den Loopback-MySQL-Connector installieren, was durch Ausführen des folgenden Befehls erfolgen kann: npm install loopback-connector-mysql --save.

    Als Nächstes erstellen wir mit dem folgenden Befehl eine Datenquelle für die Anwendung, die den MySQL-Connector verwenden würde:

    G:\node\loopback-rest>slc loopback:datasource
    ? Enter the data-source name: mysql_db
    ? Select the connector for mysql_db: MySQL (supported by StrongLoop)
    

    Es erfordert den Namen der Datenquelle und den zu verwendenden Connector, was in diesem Fall der Fall ist MySQL.

    Der obige Befehl aktualisiert die server/datasources.json mit den folgenden:

    "mysql_db": {
      "name": "mysql_db",
      "connector": "mysql"
    }
    
    We would have to update the above datasource to define the database name, hostname, port, username and password. Let us update it with the following data:
    
    "mysql_db": {
        "name": "mysql_db",
        "connector": "mysql",
        "database":"test",
        "host":"localhost",
        "port":3306,
        "password":"password",
        "username":"root"
    }
    

    Modell in Loopback erstellen

    Lassen Sie uns mit dem SLC-Tool ein neues Modell im Loopback erstellen. Das neue Modell kann mit dem folgenden Befehl erstellt werden: slc loopback:model. Es wird eine Reihe von Fragen gestellt, beginnend mit dem Modellnamen, der Datenquelle, der Basisklasse des Modells und den Eigenschaften sowie deren Typen in der Modellklasse. Im Folgenden erfahren Sie, wie wir die Antworten auf die Fragen und auch die Eigenschaften bereitgestellt haben:

    G:\node\loopback-rest>slc loopback:model
    ? Enter the model name: book
    ? Select the data-source to attach book to: mysql_db (mysql)
    ? Select model's base class: PersistedModel
    ? Expose book via the REST API? Yes
    ? Custom plural form (used to build REST URL): books
    Let's add some book properties now.
    
    Enter an empty property name when done.
    ? Property name: name
    (!) generator#invoke() is deprecated. Use generator#composeWith() - see http://yeoman.io/authoring/composability.html
       invoke   loopback:property
    ? Property type: string
    ? Required? Yes
    
    Let's add another book property.
    Enter an empty property name when done.
    ? Property name: isbn
    (!) generator#invoke() is deprecated. Use generator#composeWith() - see http://yeoman.io/authoring/composability.html
       invoke   loopback:property
    ? Property type: string
    ? Required? Yes
    
    Let's add another book property.
    Enter an empty property name when done.
    ? Property name: author
    (!) generator#invoke() is deprecated. Use generator#composeWith() - see http://yeoman.io/authoring/composability.html
       invoke   loopback:property
    ? Property type: string
    ? Required? No
    
    Let's add another book property.
    Enter an empty property name when done.
    ? Property name: pages
    (!) generator#invoke() is deprecated. Use generator#composeWith() - see http://yeoman.io/authoring/composability.html
       invoke   loopback:property
    ? Property type: number
    ? Required? No
    
    Let's add another book property.
    Enter an empty property name when done.
    ? Property name:
    

    Nach Abschluss werden zwei Dateien generiert: book.js Und book.json wie im Bild unten gezeigt:
    Loopback-Modell-Datenquelle MySQL

    Abgesehen von den beiden oben genannten Dateien wird das neue Modell in aufgezeichnet model-config.json Wie nachfolgend dargestellt:

    "book": {
        "dataSource": "mysql_db",
        "public": true
      }
    

    Wenn wir die URL http://localhost:3000/explorer/#!/books/ laden, finden Sie viele APIs, die mit Büchern verknüpft sind. Das Laden einer der Buch-APIs, zum Beispiel dieser: http://localhost:3000/api/books, führt zu einer Fehlermeldung Tabelle test.books wurde nicht gefunden. Lassen Sie uns nun die Tabelle erstellen:

    CREATE TABLE `test`.`book` (
      `id` VARCHAR(250) NOT NULL,
      `name` VARCHAR(250) NOT NULL ,
      `isbn` VARCHAR(20) NOT NULL ,
      `author` VARCHAR(500) NULL ,
      `pages` INT NULL
    ) ENGINE = InnoDB;
    

    Laden wir nun dieselbe URL http://localhost:3000/api/books und dieses Mal erhalten wir eine leere JSON-Array-Antwort.

    Allein durch die Erstellung eines Modells wurde eine ganze Reihe von REST-APIs rund um dieses Modell erstellt. Lassen Sie uns im nächsten Abschnitt die APIs für CRUD-Operationen ausprobieren.

    Testen von CRUD-APIs

    Die URL http://localhost:3000/explorer stellt nicht nur die Liste der APIs für jedes Modell bereit, sondern bietet auch ein Tool zum Testen der APIs.

    Ein neues Buch hinzufügen

    Die Anfrage zum Hinzufügen eines Buchs erfolgt über die Explorer-URL, wie im Bild unten gezeigt:
    Loopback-Add-Data

    Die Antwort nach dem Hinzufügen des Buches ist wie im Bild unten dargestellt:Loopback-AntwortAbrufen bestimmter Buchdetails

    Die URL: http://localhost:3000/api/books/{id} wird zum Abrufen der Buchdetails verwendet, anhand derer das Buch identifiziert wird id Parameter. Lassen Sie uns die Details des oben hinzugefügten Buchs über die URL abrufen: http://localhost:3000/api/books/123. Dies gibt uns die Antwort, wie im Bild unten gezeigt:
    W7aMaiw

    Buchdetails werden aktualisiert

    Die Anfrage zur Aktualisierung der Buchdetails erfolgt mit dem unten gezeigten Tool:
    Loopback-Update-Daten

    Sie können im obigen Bild sehen, dass ich nur den Namen und die ISBN aktualisiere und den Rest beibehalte. Die Antwort der API ist wie im Bild unten dargestellt:

    Loopback

    Buch löschen

    Der Antrag auf Löschung des Buchs erfolgt wie folgt:
    Buch löschenDie Antwort ist wie folgt:
    Antwort-Loopback löschenWenn Sie nun versuchen, die Details des Buchs mit der ID 123 abzurufen, wird der folgende Fehler angezeigt:
    UBWCVNE

    Liste der Bücher abrufen

    Fügen wir ein paar neue Bücher hinzu. Laden Sie dann die URL http://localhost:3000/api/books, um die Liste der Bücher wie unten gezeigt zu erhalten:
    O2Ef5fF

    Abschluss

    Damit haben wir die Demonstration von CRUD-Operationen mithilfe der APIs von Loopback abgeschlossen und nicht eine einzige Codezeile geschrieben. Alle oben genannten Funktionen wurden vom Loopback-Framework bereitgestellt. In den kommenden Beiträgen werden wir mehr über dieses Framework erfahren und sehen, wie wir damit APIs erstellen können. Ich habe meinen nächsten Artikel über die Verwendung des SpringLoop ARC-Tools zum Entwickeln von REST-APIs mithilfe einer GUI veröffentlicht.

    Kommentar verfassen

    Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert

    Nach oben scrollen