Ein Einführungs-Tutorial für Java-Entwickler in Kombination mit der Node.js-Programmierung

Zunächst muss ich zugeben, dass ich als Java-Entwickler mit mehr als zehn Jahren Entwicklungserfahrung inhärente Routinen entwickelt habe, um die meisten Probleme zu lösen, obwohl sie oft umständlich und umständlich erscheinen. Wenn Sie beispielsweise eine Datei lesen möchten, sollten Sie eine BufferedReader-Instanz initialisieren und einen FileReader übergeben. Das ist fast logisch. Ich habe in vielen Projekten solchen Code geschrieben, den ich als „Unternehmensebene“ betrachte, und er gefällt mir sehr Prozess, man kann sagen, dass ich nur ein Java-Fanatiker bin, der andere Sprachen verachtet.

Wenn Sie diesen Blogbeitrag lesen, geraten Sie möglicherweise in ein Missverständnis, in das ich vor vielen Jahren geraten bin. Als qualifizierter Entwickler sollten Sie ständig neue Technologien erlernen und geeignete Technologien basierend auf den tatsächlichen Arbeitsanforderungen auswählen. Obwohl ich älter werde und eines Tages möglicherweise keine Lust mehr auf Java habe. Aber ich habe jetzt wirklich eine aufregende neue Sache entdeckt: node.js ist für mich wie ein Kind, das ein neuartiges Spielzeug bekommt. In diesem Blogbeitrag werde ich Ihnen zunächst zeigen, wie Sie mithilfe des Java EE-Dienstes einen einfachen Rest erstellen, um die MongoDB-Datenbank zu lesen. Dann werde ich node.js verwenden, um die gleiche Funktionalität zu erreichen, und Sie werden die Spannung dieser neuen Entwicklungssprache leichter verstehen.

Beginnen Sie mit den Grundlagen – was ist Node.js?

Zunächst möchte ich klarstellen, dass Node.js keine „modische“ Sprache ist, die nur „modische Leute“ verwenden. Obwohl es mit diesem Verständnis begann, freue ich mich, berichten zu können, dass Node.js eine ausgereifte Sprache ist – und im aktuellen Internetzeitalter Eingang in einige der am stärksten frequentierten Websites großer Unternehmen gefunden hat. Node.js ist ein sehr nützliches Tool für Ihre Fähigkeiten und wird Sie überraschen, wie einfach es ist, stabilen, sicheren und leistungsstarken Code zu erstellen.

Kurz gesagt ist Node eine Sprache für serverseitige Aktivitäten. Es verwendet die Javascript-Sprache und es stehen viele Bibliotheken zur Verfügung, beispielsweise NPM-Modelle. Sie können diese NPM-Modelle mit .jar-Paketen in Java vergleichen. Wenn Sie eine Funktionalität benötigen und nicht den gesamten Code selbst schreiben möchten, ist die gesuchte Funktion wahrscheinlich bereits im npm-Modell enthalten.

Knotenanwendungen werden in der Regel so ausgeführt, dass die Effizienz maximiert wird, indem nicht blockierende E/A-Vorgänge und asynchrone Ereignisse genutzt werden. Java-Entwickler müssen wissen, dass Node-Anwendungen in einem einzelnen Thread ausgeführt werden. Der Backend-Knotencode verwendet jedoch mehrere Threads für Vorgänge wie Netzwerk- und Dateizugriff. Aus diesem Grund eignet sich Node perfekt für Anwendungen, die Echtzeiterfahrung erfordern.

Weiter – IDE-Unterstützung

Sie sind vielleicht wie ich und „leben“ und „atmen“ in der IDE. Dies kann daran liegen, dass Java zu wortreich ist und wir während des Softwareentwicklungsprozesses konstanten Code schreiben müssen, um Funktionen abzuschließen. Nachdem wir die Vorteile der Code-Vervollständigung entdeckt hatten, lernten wir langsam, die IDE für die Dateiverwaltung, das Debuggen und andere sehr nützliche Funktionen zu verwenden. Es genügt zu sagen, dass ich die Verwendung einer IDE liebe und sie weiterhin verwende, wenn ich mit Nodeb arbeite. Im Folgenden sind die ersten IDEs aufgeführt, die derzeit Node unterstützen:

1. Eclipse – Der Einstieg sollte einfach sein, wenn Sie es bereits in Java verwenden. Installieren Sie einfach das Node.js-Plugin.
2.JetBrains IntelliJ IDEA – eine sehr beliebte kommerzielle IDE. Das ist bisher meine Lieblings-IDE.
3.Microsoft Visual Studio – Ja, Sie haben richtig gelesen. Node ist so weit gewachsen, dass Microsoft in Visual Studio native Unterstützung dafür hinzugefügt hat. Diese Implementierung ist sehr stabil und VS ist meine zweitliebste IDE. Seltsamerweise verwende ich VS nur für einige grundlegende Node-Projekte.
4.CodeEnvy – eine webbasierte IDE
5.Cloud9 – eine webbasierte IDE
6.SublimeText 2 – Ein schnörkelloser Texteditor, der aufgrund seiner leichten Beschaffenheit bei Entwicklern immer beliebter wird.

Dies sind einige meiner Lieblings-IDEs für die Arbeit an Node-basierten Projekten. Nur ein Beispiel.

Beginnen Sie mit einem Beispiel

Im weiteren Verlauf dieses Blogbeitrags werden wir einen einfachen REST-Dienst mit Java EE und Node.js erstellen. Dieser REST-Dienst liest einfach Informationen aus der MongoDB-Datenbank und gibt die Ergebnisse an den Anforderer zurück. Die Installation und Konfiguration des Java-Anwendungsservers und der MongoDB-Datenbank gehen über den Rahmen dieses Artikels hinaus.

Erstellen Sie unsere Java-Anwendung

Schritt 1: Konfigurieren Sie die Datei pom.xml

Nennen wir dieses Beispiel restexample und ich verwende den JBoss EAP-Anwendungsserver. Als Erstes müssen wir unsere pom.xml-Datei für die Abhängigkeitsverwaltung mithilfe des Maven-Build-Systems konfigurieren. Das Folgende ist die pom.xml-Datei, die die in unserer Restexample-Anwendung benötigten Abhängigkeiten enthält:

 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http:/ /maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>restexample</groupId> <artifactId>restexample</artifactId> <packaging>war</packaging> <version>1.0</version> <name>restexample</name> <repositories> <repository> <id>eap</id> <url>http://maven.repository.redhat.com/techpreview/all</url> <releases> <enabled>true</enabled> </releases> <snapshots> <enabled>true</enabled> </snapshots> </repository> </repositories> <pluginRepositories> <pluginRepository> <id>eap</ id> <url>http://maven.repository.redhat.com/techpreview/all</url> <releases> <enabled>true</enabled> </releases> <snapshots> <enabled>true</enabled> </snapshots> </pluginRepository> </pluginRepositories> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <maven .compiler.source>1.6</maven.compiler.source> <maven.compiler.target>1.6</maven.compiler.target> </properties> <dependencies> <dependency> <groupId>org.jboss.spec</groupId> <artifactId>jboss-javaee-6.0</artifactId> <version>3.0.2.Final-redhat-4</version> <type>pom</type> <scope>bereitgestellt</scope> </dependency> <dependency> <groupId>org.mongodb</groupId> <artifactId>mongo-java-driver</artifactId> <version>2.9.1</version> </dependency> </dependencies> </project>

Cool, ziemlich detailliert, aber ich hoffe, Sie können den Code verstehen. In diesem Blog-Beitrag gehe ich davon aus, dass die Leser Java bereits kennen, daher werde ich die Details nicht erklären.

Schritt 2: Erstellen Sie die Datei „beans.xml“ und richten Sie unsere Servlet-Zuordnung ein

Als Teil des Beispiels verwenden wir CDI (Context Dependency Injection) für unsere Datenbankzugriffsklasse. Gemäß den offiziellen CDI-Konfigurationsanweisungen muss eine Anwendung, wenn sie CDI verwenden möchte, eine Beans.xml-Datei im WEB-INF-Verzeichnis der Anwendung enthalten. Erstellen wir also diese Datei und konfigurieren sie mit den benötigten Informationen. Gehen Sie in Ihr Verzeichnis /src/main/webapp/WEB-INF, erstellen Sie eine Beans.xml-Datei und fügen Sie den folgenden Code hinzu:

 <?xml version="1.0"?><beans xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema- Instanz" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://jboss.org/schema/cdi/beans_1_0.xsd"/>

Wir müssen auch die Servlet-Zuordnung für unsere RESI-API in der Datei web.xml einrichten. Fügen Sie der Datei im Verzeichnis /src/main/webapp/WEB-INF das folgende Servlet-Zuordnungselement hinzu:

 <servlet-mapping> <servlet-name>javax.ws.rs.core.Application</servlet-name> <url-pattern>/ws/*</url-pattern></servlet-mapping>

Schritt 3: Erstellen Sie die DBConnection-Klasse

Zu diesem Zeitpunkt haben wir das Projekt eingerichtet und unsere pom.xml-Datei enthält bereits die Treiberabhängigkeiten der MongoDB-Datenbank. Denken Sie daran, sicherzustellen, dass die erforderlichen Treiber in unserer Anwendung gepackt wurden. Als nächstes müssen wir eine Klasse erstellen, um die Datenbankverbindung zu verwalten. Erstellen Sie eine neue Datei mit dem Namen DBConnection.java, platzieren Sie diese Datei im Verzeichnis /src/main/java/com/strongloop/data und fügen Sie dann den folgenden Code zu dieser Datei hinzu:

HINWEIS: Stellen Sie sicher, dass Ihre MongoDB-Datenbankinstallation mit den entsprechenden Verbindungsautorisierungsdetails konfiguriert ist!

 package com.strongloop.data; import javax.annotation.PostConstruct; import javax.inject.Named; import com.mongodb.Mongo ; @Named@ApplicationScopedpublic class DBConnection { private DB mongoDB public; DBConnection() { super(); } @PostConstruct public void afterCreate() { String mongoHost = "127.0.0.1" String mongoPort = "27001" String mongoUser = "strongloop; String mongoPassword = "rocks"; String mongoDBName = "restexample" ; int port = Integer.decode(mongoPort); null; try { mongo = new Mongo(mongoHost, port); } Catch (UnknownHostException e) { System.out.println("Verbindung zu MongoDB konnte nicht hergestellt werden: " + e.getMessage() + " :: " + e. getClass()); } mongoDB = mongo.getDB(mongoDBName); if (mongoDB.authenticate(mongoUser, mongoPassword.toCharArray()) == false) { System.out.println("Fehler beim Authentifizieren der DB"); } } public DB getDB() { return mongoDB;

Schritt 4: Daten in MongoDB importieren (mmmm Bier)

In unserem Projekt wollen wir eine Liste aller Biere mit dem Namen Pabst laden. Wenn Sie neu in der Bierbranche sind, sollten Sie vielleicht das American Light Ale von Pabst Brewing probieren. Diese Biere sind mit blauen Bändern und Colt-Motiven versehen und umfassen alle Arten von Malzgetränken.

Zuerst müssen Sie eine JSON-Datei herunterladen, die alle Daten enthält, die zurückgegeben werden müssen. Sie können dazu die folgende URL verwenden:
https://dl.dropboxusercontent.com/u/72466829/beers.json

Verwenden Sie nach dem Herunterladen den Befehl mongoimport, um ihn in die Datenbank zu importieren. Der Befehl lautet wie folgt:

 $ mongoimport --jsonArray -d yourDBName -c beers --type json --file /tmp/beers.json -h yourMongoHost --port yourMongoPort -u yourMongoUsername -p yourMongoPassword

Sie können folgende Ergebnisse sehen:

 verbunden mit: 127.0.0.1:27017Di 10. Juni 20:09:55.436 check 9 24Di 10. Juni 20:09:55.437 24 Objekte importiert

Schritt 5: Erstellen Sie ein Beer-Modellobjekt

Wir haben eine Datenbankverbindungsklasse erstellt und die Bierinformationen in die MongoDB-Datenbank geladen. Es ist Zeit, ein Modellobjekt zur Steuerung unserer Bierinformationen zu erstellen. Erstellen Sie eine neue Datei mit dem Namen Beer.java und platzieren Sie sie im Verzeichnis /src/main/java/com/strongloop/data. Fügen Sie nach dem Erstellen der Datei den folgenden Code hinzu:

 package com.strongloop.data; public class Beer { private String name; private String description; getName() { return name; } public void setName(String name) { this.name = name } public String getDescription() { return description; this.description = Beschreibung; }}

Hinweis: Die bereitgestellte JSON-Datei enthält weitere Informationen, die wir verwenden werden. Probieren Sie sie also aus und fügen Sie einige zusätzliche Funktionen hinzu, um Ihr Lernerlebnis zu erweitern.

Schritt 6: REST-Dienst erstellen

Ratet mal, was zu tun ist? Ok, wir sind endlich bereit, einen REST-basierten Webdienst zu erstellen, der es uns ermöglicht, die im vorherigen Schritt geladenen Bierinformationen abzurufen. Dazu müssen wir eine neue Datei namens BeerWS.java erstellen und diese im Verzeichnis /src/main/java/com/strongloop/webservice ablegen. Fügen Sie nach der Erstellung den folgenden Code hinzu:

 Paket com.strongloop.webservice; import java.util.ArrayList;import java.util.List;import javax.enterprise.context.RequestScoped;import javax.inject.Inject;import javax.ws.rs.GET;import javax.ws .rs.Path;import javax.ws.rs.Produces;import javax.ws.rs.QueryParam;import com.strongloop.data.DBConnection;import com.strongloop.data.Beer;import com.mongodb.BasicDBObject;import com.mongodb.DB;import com.mongodb.DBCollection;import com.mongodb.DBCursor;import com.mongodb. DBObject; @RequestScoped@Path("/beers")public class BeerWS { @Inject private DBConnection dbConnection; private DBCollection getBeerCollection() { DBdb = dbConnection.getDB(); return beerCollection; } private Beer populateBeerInformation(DBObject dataValue) { Beer theBeer = new Beer (); theBeer.setName(dataValue.get("name")); theBeer.setDescription(dataValue.get("name"); theBeer.setId(dataValue.get("_id").toString()); // Alle Biere abrufen @GET() @Produces("application/json") public List<Beer> getAllBeers() { ArrayList<Beer> allBeersList = new ArrayList<Beer>(); DBCollection beers = this.getBeerCollection(); DBCursorcursor = beers.find(); try { while (cursor.hasNext()) { allBeersList.add(this.populateBeerInformation(cursor.next ()));

Schritt 7: Durchsuchen Sie die Bierinformationen von Silly

Oh, fertig. Wir haben einen REST-Dienst geschrieben, der alle Bierinformationen aus der Datenbank abrufen kann. Um nun Ihren Code auf Ihrem Anwendungsserver bereitzustellen, öffnen Sie die folgende Adresse in Ihrem Browser, um zu sehen, ob er einwandfrei funktioniert:
http://IhrServerstandort/ws/beers

Wenn alles in Ordnung ist, wird eine Liste aller Bierinformationen angezeigt, wie unten dargestellt:

Erstellen Sie eine Knotenanwendung

Wenn Sie die oben genannten Schritte zum Programmieren in Java befolgen, werden Sie feststellen, dass die Erstellung von Anwendungen mit JavaEE zwar sehr schnell voranschreitet, es jedoch immer noch sehr mühsam ist, eine einfache Anwendung wie einen REST-Dienst zu erstellen. Verstehen Sie mich nicht falsch, ich verwende immer noch gerne JavaEE, finde aber, dass Node für viele Szenarien, wie zum Beispiel die Erstellung von REST-Diensten, die JSON-Daten zurückgeben, besser geeignet ist. Als Nächstes erstellen wir einen einfachen Webdienst mithilfe der LoopBack-API von StrongLoop. Außerdem zeige ich Ihnen, wie Sie Node unter Apple OSX installieren.

Schritt 1: Knoten installieren

Der einfachste Weg, Node zu installieren, ist über ein Binärpaket, das mit den meisten Betriebssystemen kompatibel ist. Öffnen Sie Ihren Browser und besuchen Sie die folgende Webseite, um die entsprechende Version für Ihr Betriebssystem herunterzuladen:
http://nodejs.org/download/

Nachdem der Download abgeschlossen ist, sehen Sie Folgendes:

Wenn Sie Mac OSX verwenden, klicken Sie auf die generische .pkg-Datei. Dadurch wird das Installationsprogramm auf Ihrem Computer gespeichert. Nachdem Sie die Datei heruntergeladen haben, doppelklicken Sie darauf, um das Installationsprogramm zu starten. Es erscheint das folgende Installationsdialogfeld:

Setzen Sie die Installation standardmäßig fort. Klicken Sie nach erfolgreicher Installation auf die Schaltfläche „Schließen“, um das Installationsprogramm zu beenden.

Ziemlich einfach, oder?

Schritt 2: Installieren Sie LoopBack mit NPM

Nachdem Node nun im lokalen System installiert wurde, besteht der nächste Schritt darin, das von StroopLoop bereitgestellte LoopBack-Paket zu installieren. LoopBack ist ein offenes API-Quellcodepaket. Wenn Sie lernen, Node zum Entwickeln und Bereitstellen von Software zu verwenden, kann LoopBack die Programmierung erleichtern.

Um LoopBack zu installieren, verwenden wir die npm-Befehlszeile, die Teil der Kernsprache von Node ist. NPM ist ein offizielles Paketverwaltungstool, das zum Installieren von Klassenbibliotheken oder Vorlagen verwendet wird, von denen Anwendungen abhängig sind. Wenn Sie ein Java-Programmierer sind, können Sie NPM mit Maven vergleichen. Mithilfe von Maven zum Erstellen eines Projekts können Entwickler die JAR-Pakete oder Vorlagen konfigurieren, von denen das Projekt in pom.xml abhängt. Wenn das Projekt mit der Kompilierung beginnt, lädt Maven alle abhängigen Dateien herunter und führt das JAR-Paket in das Projekt ein. NPM funktioniert genauso wie Maven. Bei einigen speziellen Projekten wird die Datei package.json verwendet, um die Dateien zu konfigurieren, von denen das Projekt abhängt. Sie können auch die Befehlszeile verwenden, um abhängige Dateien auf das lokale System herunterzuladen. Wenn Sie dies nicht verstehen, machen Sie sich keine Sorgen, wir werden die Datei package.json in den nächsten Schritten ausführlich beschreiben.

Um LoopBack zu installieren, verwenden wir eine einfache Befehlszeile, um alle abhängigen Dateien herunterzuladen und zu installieren. Öffnen Sie Ihr Windows-Befehlszeilenfenster und geben Sie den folgenden Befehl ein:

 $ npm install -g strongloop

Tipp: Während der Installation müssen Sie möglicherweise ein anderes Benutzerkonto verwenden, um diesen Befehl auszuführen.

Was bedeutet diese Befehlszeile? Der Parameter -g teilt npm mit, dass wir das Strong-Cli-Paket installieren möchten. Der Parameter -g macht dieses Paket mit jedem System und jeder Anwendung kompatibel. Sobald Sie den obigen Befehl ausführen, lädt NPM alle abhängigen Dateien herunter. Die Downloadzeit hängt von Ihrer Internetgeschwindigkeit ab und kann mehrere Minuten dauern.

Schritt 3: Erstellen Sie die Anwendung

Das Erstellen einer Anwendung mithilfe der LoopBack-API ist einfach. Öffnen Sie Ihr Windows-Befehlszeilenfenster und verwenden Sie den folgenden Befehl, um ein neues Anwendungsbeispiel zu erstellen.

 $ SLC-Loopback

Als nächstes werden Sie nach dem Namen des Projektstammpfads gefragt. In diesem Beispiel wird restexample verwendet. Als Nächstes werden Sie zur Eingabe eines Anwendungsnamens aufgefordert. Verwenden Sie das Standard-Restbeispiel.

Der Befehl slc hat nun eine LoopBack-Anwendung namens restexample erstellt und die Anwendung konfiguriert. Wenn Sie den obigen Befehl erneut ausführen und weiterhin restexample zum Benennen verwenden, erstellt LoopBack ein neues Verzeichnis. Mit dem Befehl cd können Sie den Root-Pfad der Anwendung ändern.

 $ cd restexample

Nachdem wir nun eine Anwendung erstellt haben, konfigurieren wir MongoDB als Datenquelle für die Anwendung.

Schritt 4: Datenquelle definieren

Um eine Verbindung zu MongoDB herzustellen, müssen wir der Anwendung eine Datenquelle hinzufügen und den folgenden Befehl ausführen:

 $ slc loopback:datasource

An der Popup-Eingabeaufforderung können Sie einen beliebigen benutzerdefinierten Datenquellennamen eingeben. Wählen Sie hier „myMongo“.

 [?] Geben Sie den Namen der Datenquelle ein: myMongo

Auf diese Weise hängen wir die Datenquellendefinition des Backends an einen echten Connector an, der von StrongLoop unterstützt wird. Hier wählen wir den MongoDB-Connector aus der Liste aus.

 [?] Wählen Sie den Connector für myMongo:PostgreSQL (unterstützt von StrongLoop)Oracle (unterstützt von StrongLoop)Microsoft SQL (unterstützt von StrongLoop)MongoDB (unterstützt von StrongLoop)SOAP-Webservices (unterstützt von StrongLoop)REST-Dienste (unterstützt von StrongLoop)Neo4j ( bereitgestellt von der Community) (Nach oben und unten bewegen, um weitere Auswahlmöglichkeiten anzuzeigen)

Schritt 5: Zeigen Sie auf die echte Datenquelle

Um eine Verbindung zu MongoDB herzustellen, müssen wir auf die tatsächliche MongoDB-Instanz verweisen, die alle Datenquellenkonfigurationsinformationen in der Datei datasource.json definiert. Diese Datei befindet sich im Stammverzeichnis/Serververzeichnis der Anwendung und fährt fort MongoDB fügt eine Datenquelle hinzu:

 { "db": { "name": "db", "connector": "memory" }, "myMongo": { "name": "myMongo", "connector": "mongodb" "url": "mongodb: //localhost:27017/restexample" }}

Hinweis: Stellen Sie sicher, dass Sie die richtige Verbindungs-URL zur MongoDB-Datenbank angeben. Für dieses Beispiel habe ich eine Datenbank namens restexample erstellt, die als Datenquelle verwendet wird.

Schritt 6: Daten in MongoDB importieren (mmmmm Bier)

Wie im Java-Teil dieses Artikels erwähnt, müssen wir den Datensatz in die MongoDB-Datenbank laden. Wenn Sie diesen Schritt gemäß der in diesem Artikel genannten Methode ausgeführt haben und dann planen, dieselbe Datenbank zu verwenden, können Sie den Schritt ignorieren 6 und springen Sie direkt zu Schritt 7.

Zunächst müssen Sie eine JSON-Datei mit allen zurückzugebenden Informationen herunterladen, die Sie unter der folgenden URL erhalten können:
https://dl.dropboxusercontent.com/u/72466829/beers.json

Nachdem die Datensatzdatei heruntergeladen wurde, laden Sie sie direkt mit dem folgenden mongoimport-Befehl in die Datenbank:

 $ mongoimport --jsonArray -d yourDBName -c beers --type json --file /tmp/beers.json -h yourMongoHost --port

Sie sollten die folgenden Ergebnisse sehen:

 verbunden mit: 127.6.189.2:27017Di 10. Juni 20:09:55.436 check 9 24Di 10. Juni 20:09:55.437 24 Objekte importiert

Schritt 7: Erstellen Sie unser eigenes Biermodell

In der Java-Welt können wir uns das Objektmodell vorstellen, aber hier bietet LoopBack eine einfache Möglichkeit, Modellobjekte über die Befehlszeile zu erstellen. Geben Sie den folgenden Befehl ein:

 $ slc loopback:model

Dadurch wird eine interaktive Sitzung zum Definieren des Modells geöffnet. Als Erstes müssen Sie den Modellnamen eingeben. Geben Sie hier „Bier“ ein. Anschließend werden Sie aufgefordert, die Datenquelle anzugeben, an die dieses Modell angehängt werden soll die zuvor erstellte myMongo-Datenquelle.

 [?] Geben Sie den Modellnamen ein: beer[?] Wählen Sie die Datenquelle aus, an die Bier angehängt werden soll:db (memory)myMongo (mongodb)

Als nächstes werden Sie gefragt, ob diese API über REST verfügbar gemacht werden soll. Natürlich hoffen wir das hier.

 [?] Bier über die REST-API verfügbar machen?

Wählen Sie abschließend den Netzwerk-Pluralnamen für das Modell aus. Hier heißt das Modell beer, der Plural lautet also Beans (Standard). Drücken Sie die Eingabetaste, um die Standardeinstellung zu übernehmen.

 [?] Benutzerdefinierte Pluralform (wird zum Erstellen der REST-URL verwendet):

Als nächstes werden Sie aufgefordert, Modelleigenschaften zu definieren. In diesem Beispielprogramm konzentrieren wir uns auf den Namen und die Beschreibung des Bieres.

 Geben Sie abschließend einen leeren Eigenschaftsnamen ein.[?] Eigenschaftsname: Name

Solange Sie die Eingabetaste drücken, werden Sie aufgefordert, den Datentyp jedes angegebenen Attributs einzugeben. Das erste Element ist der Name. Wählen Sie hier den Zeichenfolgentyp aus und drücken Sie dann

 Geben Sie ein.[?] Eigenschaftstyp: (Pfeiltasten verwenden)stringnumberbooleanobjectarraydatebuffergeopoint(other)

Erstellen Sie als Nächstes das Beschreibungsattribut auf die gleiche Weise. Anschließend werden Sie aufgefordert, den Datentyp einzugeben. Es handelt sich ebenfalls um einen Zeichenfolgentyp. Wählen Sie die Zeichenfolgenoption aus und klicken Sie dann

 Geben Sie ein. Fügen Sie eine weitere Biereigenschaft hinzu. Geben Sie einen leeren Eigenschaftsnamen ein, wenn Sie fertig sind

Herzlichen Glückwunsch! Sie haben die Erstellung von Modellobjekten mit LoopBack in Kombination mit Node abgeschlossen. Wenn Sie sehen möchten, was während dieses Vorgangs tatsächlich erstellt wurde, können Sie die Datei beer.json im Verzeichnis root/common/models öffnen und zu scrollen Am Ende der Datei sehen Sie das folgende Modell:

 { "name": "beer", "base": "PersistedModel", "properties": { "name": { "type": "string", "required": true }, "description": { "type" : „string“, „required“: true } }, „validations“: [], „relations“: {}, „acls“: [], „methods“: []}

Wie Sie hier sehen können, haben wir ein Modell erstellt und gleichzeitig wurden diesem Modell die Attribute Name und Beschreibung zugewiesen.

In der Datei /server/model-config.js können Sie feststellen, dass die Datei einige zusätzliche Felder enthält, darunter „public“ und „datasource“. Das öffentliche Feld gibt an, dass wir dieses Modell über einen REST-Netzwerkdienst offenlegen möchten Das Feld ist Geben Sie die Datenquelle an, die für CRUD-Vorgänge in diesem Modell verwendet wird.

 „beer“: { „dataSource“: „myMongo“, „public“: true }

Schritt 8: Genießen Sie die Freude, Biere zu sehen

Herzlichen Glückwunsch! Sie haben Ihre erste Node.js-Anwendung erstellt, die einen REST-Webdienst enthält, der Bierinformationen abrufen kann. Schließlich müssen wir die Anwendung nur noch bereitstellen.

Glücklicherweise ist die Bereitstellung bereits einfach, indem Sie den folgenden Befehl im Stammverzeichnis der Anwendung ausführen:

 $ slc ausführen

Sobald die Anwendung läuft, können Sie überprüfen, ob die Bereitstellung erfolgreich war, indem Sie mit Ihrem Browser die folgende URL aufrufen:

http://0.0.0.0:3000/api/beers

Ziemlich cool, nicht wahr?

LoopBack enthält außerdem eine Seite, auf der Sie alle verfügbaren Dienste der Anwendung anzeigen können, einschließlich des Beer-Modells und des von uns erstellten REST-Dienstes. Richten Sie Ihren Browser auf die folgende URL, um sie anzuzeigen:

http://0.0.0.0:3000/explorer

Nachdem die Seite erfolgreich geladen wurde, sehen Sie die folgende Schnittstelle. Wir haben den Beans-Knoten als Teil des Blogs erstellt. Ich habe den Endpunkt /beers hervorgehoben.

Sie können auf /beers klicken, um die verfügbaren APIs zu erweitern. Sie können sie bedienen und testen, wie in der folgenden Abbildung dargestellt:

abschließend

In diesem Blogbeitrag zeige ich, wie man mit Java EE einen REST-Dienst erstellt, der Bierproduktlistendaten von der Pabst Beer Company zurückgibt. Später habe ich node.js und das auf node.js basierende Loopback-Framework verwendet, um den restlichen Dienst mit derselben Funktion und sehr wenig Code zu implementieren. Das Wichtigste ist, dass die LoopBack-API auch eine Standardimplementierung zum Hinzufügen, Löschen, Überprüfen und Ändern von Bierentitäten bereitstellt, sodass wir einen Restdienst mit vollständigen Funktionen zum Hinzufügen, Löschen, Überprüfen und Ändern erhalten können, ohne eine einzige Zeile schreiben zu müssen von Code.

Die folgende Liste vergleicht die jeweiligen im Blogbeitrag erwähnten Funktionen von javaEE und node.js:

Was kommt als nächstes?

Der kommende Node v0.12 wird mindestens 8 aufregende neue Funktionen bringen. Welche werden das sein? Besuchen Sie die Seite „Was ist neu in Node.js v0.12“, um mehr zu erfahren.
Interessiert an Node-bezogener Schulung und Zertifizierung? StrongLoop bietet eine Vielzahl von Dienstleistungen an, um Ihren Anforderungen gerecht zu werden.