Un tutoriel d'introduction pour les développeurs Java combiné à la programmation Node.js

Tout d'abord, je dois admettre qu'en tant que développeur Java avec plus de dix ans d'expérience en développement, j'ai formé des routines inhérentes pour résoudre la plupart des problèmes, même si elles semblent souvent lourdes et fastidieuses. Par exemple, si vous souhaitez lire un fichier, vous devez initialiser une instance de BufferedReader et transmettre un FileReader. C'est presque logique. J'ai écrit un tel code dans de nombreux projets que je considère comme étant "de niveau entreprise" et je l'apprécie beaucoup. Beaucoup de processus, on peut dire que je ne suis qu'un fanatique de Java qui méprise les autres langages.

Si vous lisez cet article de blog, vous êtes peut-être tombé dans un malentendu dans lequel je suis tombé il y a de nombreuses années. En tant que développeur qualifié, vous devez constamment apprendre de nouvelles technologies et choisir les technologies appropriées en fonction des besoins professionnels réels. Même si je vieillis et que je pourrais un jour en avoir marre de Java. Mais j'ai vraiment découvert une nouvelle chose passionnante maintenant, node.js est comme un enfant qui me donne un nouveau jouet, dans cet article de blog, je vais d'abord vous montrer comment créer un simple Rest en utilisant le service Java EE pour lire la base de données MongoDB. Ensuite, j'utiliserai node.js pour obtenir les mêmes fonctionnalités, et vous comprendrez plus facilement l'enthousiasme suscité par ce nouveau langage de développement.

Commencez par les bases : qu'est-ce que Node.js ?

Tout d’abord, je tiens à préciser que Node.js n’est pas un langage « à la mode » que seuls les « gens à la mode » utilisent. Bien que cela ait commencé avec cette compréhension, je suis heureux d'annoncer que Node.js est un langage mature - et à l'ère actuelle d'Internet, il a trouvé sa place dans les grandes entreprises et alimente certains des sites Web les plus fréquentés. Node.js est un outil très utile dans votre ensemble de compétences et vous surprendra par la facilité avec laquelle il est de créer du code stable, sécurisé et performant.

En bref, Node est un langage pour les activités côté serveur. Il utilise le langage Javascript et de nombreuses bibliothèques sont disponibles, telles que les modèles npm. Vous pouvez comparer ces modèles npm aux packages .jar en Java. Lorsque vous avez besoin d'une fonctionnalité et que vous n'avez pas envie d'écrire tout le code vous-même, il est probable que la fonctionnalité que vous recherchez soit déjà fournie dans le modèle npm.

Les applications de nœud s'exécutent généralement pour maximiser l'efficacité en tirant parti des E/S non bloquantes et des événements asynchrones. Une chose que les développeurs Java doivent savoir est que les applications Node s'exécutent dans un seul thread. Cependant, le code du nœud principal utilise plusieurs threads pour des opérations telles que l'accès au réseau et aux fichiers. Pour cette raison, Node est parfait pour les applications qui nécessitent une expérience en temps réel.

Continuer - Prise en charge de l'IDE

Vous êtes peut-être comme moi et « vivez » et « respirez » dans l'EDI. Cela peut être dû au fait que Java est trop verbeux et nous oblige à écrire du code constant pour remplir les fonctions pendant le processus de développement logiciel. Une fois que nous avons découvert les avantages de la complétion de code, nous avons progressivement appris à utiliser l'EDI pour la gestion de fichiers, le débogage et d'autres fonctionnalités très utiles. Qu'il suffise de dire que j'adore utiliser un IDE et que je continue de l'utiliser lorsque je travaille avec Nodeb. Voici le premier lot d'IDE prenant actuellement en charge Node :

1. Eclipse - Cela devrait être facile à démarrer si vous l'utilisez déjà en Java. Installez simplement le plugin Node.js.
2.JetBrains IntelliJ IDEA – un IDE commercial très populaire. C'est mon IDE préféré jusqu'à présent.
3.Microsoft Visual Studio – Oui, vous avez bien lu. Node s'est développé au point où Microsoft a ajouté une prise en charge native dans Visual Studio. Cette implémentation est très stable et VS est mon deuxième IDE préféré. Curieusement, je n'utilise VS que pour certains projets Node de base.
4.CodeEnvy - un IDE basé sur le Web
5.Cloud9 - un IDE basé sur le Web
6.SublimeText 2 - Un éditeur de texte simple qui devient de plus en plus populaire parmi les développeurs en raison de sa légèreté.

Voici quelques-uns de mes IDE préférés pour travailler sur des projets basés sur Node. Juste un exemple.

Commencez par un exemple

Dans le reste de cet article de blog, nous créerons un service REST simple à l'aide de Java EE et Node.js. Ce service REST lira simplement les informations de la base de données MongoDB et renverra les résultats au demandeur. L'installation et la configuration du serveur d'applications Java et de la base de données MongoDB dépassent le cadre de cet article.

Créez notre application Java

Étape 1 : Configurez le fichier pom.xml

Appelons cet exemple restexample, et j'utiliserai le serveur d'applications JBoss EAP. La première chose que nous devons faire est de configurer notre fichier pom.xml pour la gestion des dépendances à l'aide du système de build Maven. Voici le fichier pom.xml qui contient les dépendances nécessaires dans notre application restexample :

 <projet 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> <dépôts> <dépôt> <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>fourni</scope> </dependency> <dependency> <groupId>org.mongodb</groupId> <artifactId>mongo-java-driver</artifactId> <version>2.9.1</version> </dependency> </dependencies> </project>

Cool, assez détaillé, mais j'espère que vous pourrez comprendre le code. Dans ce billet de blog, je suppose que les lecteurs connaissent déjà Java, donc je n'expliquerai pas les détails.

Étape 2 : Créez le fichier beans.xml et configurez notre mappage de servlet

Dans le cadre de l'exemple, nous utiliserons CDI (Context Dependency Injection) sur notre classe d'accès à la base de données. Selon les instructions officielles de configuration CDI, si une application souhaite utiliser CDI, elle doit inclure un fichier beans.xml dans le répertoire WEB-INF de l'application. Créons donc ce fichier et configurons-le avec les informations dont nous avons besoin. Accédez à votre répertoire /src/main/webapp/WEB-INF et créez un fichier beans.xml et ajoutez le code suivant :

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

Nous devons également configurer le mappage de servlet pour notre API RESI dans le fichier web.xml. Ajoutez l'élément de mappage de servlet suivant au fichier dans le répertoire /src/main/webapp/WEB-INF :

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

Étape 3 : Créer la classe DBConnection

À ce stade, nous avons configuré le projet et notre fichier pom.xml contient déjà les dépendances des pilotes de la base de données MongoDB. N'oubliez pas de vous assurer que les pilotes requis ont été packagés dans notre application. La prochaine chose que nous devons faire est de créer une classe pour gérer la connexion à la base de données. Créez un nouveau fichier nommé DBConnection.java, placez ce fichier dans le répertoire /src/main/java/com/strongloop/data, puis ajoutez le code suivant à ce fichier :

REMARQUE : assurez-vous que l'installation de votre base de données MongoDB est configurée avec les détails d'autorisation de connexion appropriés !

 package com.strongloop.data ; importer java.net.UnknownHostException ; importer javax.annotation.PostConstruct ; importer javax.enterprise.context.ApplicationScoped ; importer com.mongodb.DB ; ; @Named@ApplicationScopedpublic classe DBConnection { DB privée 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("Impossible de se connecter à MongoDB : " + e.getMessage() + " :: " + e. getClass()); } mongoDB = mongo.getDB(mongoDBName); if (mongoDB.authenticate(mongoUser, mongoPassword.toCharArray()) == false) { System.out.println("Échec de l'authentification de la base de données "); } } public DB getDB() { return mongoDB } }

Étape 4 : Importer des données dans MongoDB (bière mmmm)

Dans notre projet, nous voulons charger une liste de toutes les bières portant le nom Pabst. Si vous êtes nouveau dans l'industrie de la bière, vous voudrez peut-être essayer l'American Light Ale de Pabst Brewing. Ces bières arborent des rubans bleus et des motifs Colt, et comprennent tous les types de boissons maltées.

Vous devez d’abord télécharger un fichier json contenant toutes les données qui doivent être renvoyées. Vous pouvez utiliser l'URL suivante pour y parvenir :
https://dl.dropboxusercontent.com/u/72466829/beers.json

Après le téléchargement, utilisez la commande mongoimport pour l'importer dans la base de données. La commande est la suivante :

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

Vous pouvez voir les résultats suivants :

 connecté à : 127.0.0.1:27017mar 10 juin 20:09:55.436 check 9 24mar 10 juin 20:09:55.437 importé 24 objets

Étape 5 : Créer un objet modèle Beer

Nous avons créé une classe de connexion à la base de données et chargé les informations sur la bière dans la base de données MongoDB. Il est temps de créer un objet modèle pour contrôler nos informations sur la bière. Créez un nouveau fichier nommé Beer.java et placez-le dans le répertoire /src/main/java/com/strongloop/data. Après avoir créé le fichier, ajoutez-y le code suivant :

 package com.strongloop.data; public class Beer { private String id; private String description; public String getId() { return id; getName() { nom de retour } public void setName (nom de chaîne) { this.name = nom } public String getDescription() { description de retour } public void setDescription (description de chaîne) { ceci.description = description; }}

Remarque : Le fichier JSON fourni contient plus d'informations que nous utiliserons, alors consultez-le et ajoutez-y des fonctionnalités supplémentaires pour élargir votre expérience d'apprentissage.

Étape 6 : Créer un service REST

Devinez quoi faire ? Ok, nous sommes enfin prêts à créer un service Web basé sur REST qui nous permettra d'obtenir les informations sur la bière chargées à l'étape précédente. Pour ce faire, nous devons créer un nouveau fichier appelé BeerWS.java et le placer dans le répertoire /src/main/java/com/strongloop/webservice. Après l'avoir créé, ajoutez le code suivant :

 package com.strongloop.webservice ; importer java.util.ArrayList ; importer java.util.List ; importer javax.enterprise.context.RequestScoped ; importer javax.inject.Inject ; importer javax.ws.rs.GET ; importer javax.ws .rs.Path; importer javax.ws.rs.Produces; importer javax.ws.rs.QueryParam; importer com.strongloop.data.DBConnection; importer com.strongloop.data.Beer; importer com.mongodb.BasicDBObject; importer com.mongodb.DB; importer com.mongodb.DBCollection; importer com.mongodb.DBCursor; importer com.mongodb. DBObject; @RequestScoped@Path("/beers")classe publique BeerWS { @Inject private DBConnection dbConnection; private DBCollection getBeerCollection() { DB db = dbConnection.getDB(); DBCollection beerCollection = db.getCollection("beers"); 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()); // Récupère toutes les bières @GET() @Produces("application/json") public List<Beer> getAllBeers() { ArrayList<Beer> allBeersList = new ArrayList<Beer>(); DBCollection beers = this.getBeerCollection(); DBCursor curseur = beers.find(); try { while (cursor.hasNext()) { allBeersList.add(this.populateBeerInformation(cursor.next ())); } } enfin { curseur.close(); } return allBeersList }}

Étape 7 : Parcourir les informations sur la bière

Oh, c'est fait. Nous avons écrit un service REST capable de récupérer toutes les informations sur la bière de la base de données. Maintenant, pour déployer votre code sur votre serveur d'applications, ouvrez l'adresse suivante dans votre navigateur pour voir si cela fonctionne correctement :
http://emplacement de votre serveur/ws/beers

Si tout va bien, vous verrez une liste de toutes les informations sur la bière, comme indiqué ci-dessous :

Créer une application de nœud

Si vous suivez les étapes ci-dessus pour programmer en Java, vous vous rendrez compte que même si la création d'applications utilisant JavaEE progresse très rapidement, il reste très difficile de créer une application simple comme un service REST. Ne vous méprenez pas, j'aime toujours utiliser javaEE, mais je trouve que pour de nombreux scénarios, tels que la création de services REST qui renvoient des données json, Node est plus approprié. Ensuite, nous allons créer un service Web simple à l'aide de l'API LoopBack de StrongLoop. De plus, je vais vous montrer comment installer Node sur Apple OSX.

Étape 1 : Installer le nœud

Le moyen le plus simple d’installer Node consiste à utiliser un package binaire compatible avec la plupart des systèmes d’exploitation. Ouvrez votre navigateur et visitez la page Web ci-dessous pour télécharger la version applicable en fonction de votre système d'exploitation :
http://nodejs.org/download/

Une fois le téléchargement terminé, vous verrez ce qui suit :

Si vous utilisez Mac OSX, cliquez sur le fichier générique .pkg. Cela enregistrera le programme d'installation sur votre ordinateur. Après avoir téléchargé le fichier, double-cliquez dessus pour démarrer le programme d'installation. Vous verrez la boîte de dialogue d'installation suivante :

Continuez l'installation par défaut. Après une installation réussie, cliquez sur le bouton de fermeture pour quitter le programme d'installation.

Assez simple, non ?

Étape 2 : Installer LoopBack à l’aide de NPM

Maintenant que Node a été installé sur le système local, l'étape suivante consiste à installer le package LoopBack fourni par StroopLoop. LoopBack est un package de code source API ouvert Lorsque vous apprenez à utiliser Node pour développer et déployer des logiciels, LoopBack peut faciliter la programmation.

Pour installer LoopBack, nous utiliserons la ligne de commande npm, qui fait partie du langage principal de Node. NPM est un outil officiel de gestion de packages utilisé pour installer des bibliothèques de classes ou des modèles dont dépendent les applications. Si vous êtes un programmeur Java, vous pouvez comparer NPM à Maven. En utilisant Maven pour créer un projet, les développeurs peuvent configurer les packages jar ou les modèles dont dépend le projet dans pom.xml. Lorsque la compilation du projet commence, Maven téléchargera tous les fichiers dépendants et introduira le package jar dans le projet. NPM fonctionne de la même manière que Maven. Pour certains projets spéciaux, il utilise le fichier package.json pour configurer les fichiers dont dépend le projet. Vous pouvez également utiliser la ligne de commande pour télécharger les fichiers dépendants sur le système local. Si vous ne comprenez pas cela, ne vous inquiétez pas, nous décrirons le fichier package.json en détail dans les prochaines étapes.

Pour installer LoopBack, nous utilisons une simple ligne de commande pour télécharger et installer tous les fichiers dépendants. Ouvrez la fenêtre de ligne de commande de votre fenêtre et entrez la commande suivante :

 $ npm install -g boucle forte

Astuce : Lors de l'installation, vous devrez peut-être utiliser un autre compte utilisateur pour exécuter cette commande.

Que signifie cette ligne de commande ? Le paramètre -g indique à npm que nous souhaitons installer le package strong-cli. Le paramètre -g rend ce package compatible avec n'importe quel système et application. Une fois que vous aurez exécuté la commande ci-dessus, NPM téléchargera tous les fichiers dépendants. Le temps de téléchargement dépend de votre vitesse Internet et peut prendre plusieurs minutes.

Étape 3 : Créer l'application

Créer une application à l'aide de l'API LoopBack est simple. Ouvrez la fenêtre de ligne de commande de votre fenêtre et utilisez la commande suivante pour créer un nouveau restexample d'application.

 $ bouclage slc

Ensuite, il vous demandera le nom du chemin racine du projet. Dans cet exemple, restexample est utilisé. Ensuite, il vous demandera un nom d'application. Utilisez le restexemple par défaut.

La commande slc a maintenant créé une application LoopBack nommée restexample et configuré l'application. Si vous exécutez à nouveau la commande ci-dessus et utilisez toujours restexample pour la nommer, LoopBack créera un nouveau répertoire. Vous pouvez utiliser la commande cd pour modifier le chemin racine de l'application.

 $ cd restexemple

Maintenant que nous avons créé une application, nous configurons MongoDB comme source de données pour l'application.

Étape 4 : Définir la source de données

Pour nous connecter à MongoDB, nous devons ajouter une source de données à l'application et exécuter la commande suivante :

 $ bouclage slc : source de données

À l'invite contextuelle, vous pouvez saisir n'importe quel nom de source de données personnalisé. Ici, choisissez myMongo.

 [?] Entrez le nom de la source de données : myMongo

De cette façon, nous attachons la définition de la source de données du backend à un vrai connecteur alimenté par StrongLoop. Ici, nous sélectionnons le connecteur MongoDB dans la liste.

 [?] Sélectionnez le connecteur pour myMongo : PostgreSQL (pris en charge par StrongLoop)Oracle (pris en charge par StrongLoop)Microsoft SQL (pris en charge par StrongLoop)MongoDB (pris en charge par StrongLoop)Services Web SOAP (pris en charge par StrongLoop)Services REST (pris en charge par StrongLoop)Neo4j ( fourni par la communauté)(Déplacez-vous de haut en bas pour révéler plus de choix)

Étape 5 : Pointez vers la source de données réelle

Pour nous connecter à MongoDB, nous devons pointer vers l'instance MongoDB réelle. LoopBack définit toutes les informations de configuration de la source de données dans le fichier datasource.json. Ce fichier se trouve dans le répertoire racine/serveur de l'application. comme suit. MongoDB ajoute une source de données :

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

Remarque : Assurez-vous de fournir l'URL de connexion correcte à la base de données MongoDB. Pour cet exemple, j'ai créé une base de données nommée restexample, qui est utilisée comme source de données.

Étape 6 : Importer des données dans MongoDB (mmmmm bière)

Comme mentionné dans la partie Java de cet article, nous devons charger l'ensemble de données dans la base de données MongoDB. Si vous avez effectué cette étape selon la méthode mentionnée dans cet article et que vous envisagez ensuite d'utiliser la même base de données, vous pouvez ignorer l'étape. 6 et passez directement à l’étape 7.

Tout d'abord, vous devez télécharger un fichier JSON contenant toutes les informations à renvoyer, qui peuvent être obtenues à partir de l'URL suivante :
https://dl.dropboxusercontent.com/u/72466829/beers.json

Une fois le fichier de l'ensemble de données téléchargé, utilisez directement la commande mongoimport suivante pour le charger dans la base de données :

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

Vous devriez voir les résultats suivants :

 connecté à : 127.6.189.2:27017mar 10 juin 20:09:55.436 check 9 24mar 10 juin 20:09:55.437 importé 24 objets

Étape 7 : Créer notre propre modèle de bière

Dans le monde Java, on peut penser au modèle objet. Il représente cet objet, mais ici, cet objet est une bière qui fournit un moyen simple de créer des objets modèles via la ligne de commande. Ouvrez une fenêtre de terminal et entrez dans le dossier du projet. entrez la commande suivante :

 $ bouclage slc: modèle

Cela ouvrira une session interactive pour définir le modèle. La première chose que vous devez saisir est le nom du modèle, entrez « bière » ici. Ensuite, vous serez invité à indiquer la source de données à laquelle ce modèle doit être attaché. la source de données myMongo créée précédemment.

 [?] Entrez le nom du modèle : beer[?] Sélectionnez la source de données à laquelle attacher la bière : db (mémoire) myMongo (mongodb)

Ensuite, il vous demande s'il faut exposer cette API via REST. Bien sûr, nous l'espérons ici.

 [?] Exposer la bière via l'API REST Oui ?

Enfin, sélectionnez le nom pluriel du réseau pour le modèle. Ici, le modèle est nommé bière, le pluriel est donc haricots (par défaut). Appuyez sur Entrée pour accepter la valeur par défaut.

 [?] Forme plurielle personnalisée (utilisée pour créer l'URL REST) :

Ensuite, vous serez invité à définir les propriétés du modèle. Pour cet exemple de programme, nous nous concentrons sur le nom et la description de la bière.

 Entrez un nom de propriété vide lorsque vous avez terminé.[?] Nom de la propriété : nom

Tant que vous appuyez sur Entrée, vous serez invité à saisir le type de données de chaque attribut spécifié. Le premier élément est le nom, sélectionnez ici le type de chaîne, puis appuyez sur.

 Entrez.[?] Type de propriété : (Utilisez les touches fléchées)stringnumberbooleanobjectarraydatebuffergeopoint(other)

Ensuite, créez l'attribut de description de la même manière, puis il vous sera demandé de saisir le type de données. Il s'agit également d'un type de chaîne, sélectionnez l'option de chaîne, puis cliquez sur.

 Entrez.Ajoutons une autre propriété de bière.Entrez un nom de propriété vide lorsque vous avez terminé.[?] Nom de la propriété : descriptioninvoke loopback:property[?] Type de propriété : string[?] Obligatoire ?

Félicitations ! Vous avez terminé la création d'objets de modèle à l'aide de LoopBack combiné avec Node. Si vous souhaitez voir ce qui a été réellement créé au cours de ce processus, vous pouvez ouvrir le fichier beer.json situé dans le répertoire racine/common/models de l'application et faire défiler jusqu'à. à la fin du fichier, vous verrez le modèle suivant :

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

Comme vous pouvez le voir ici, nous avons créé un modèle, et en même temps, les attributs de nom et de description ont été attribués à ce modèle.

Dans le fichier /server/model-config.js, vous pouvez remarquer que le fichier contient des champs supplémentaires, notamment public et datasource. Le champ public spécifie que nous souhaitons exposer ce modèle à l'extérieur via un service réseau REST. Le champ est Spécifiez la source de données qui sera utilisée pour les opérations CRUD sur ce modèle.

 "bière": { "dataSource": "myMongo", "public": true }

Étape 8 : Savourez la joie de voir des bières

Félicitations ! Vous avez créé votre première application Node.js qui contient un service Web REST pouvant obtenir des informations sur la bière. Enfin, il ne nous reste plus qu'à déployer l'application.

Heureusement, le déploiement est déjà simple. Il peut être effectué en exécutant la commande suivante dans le répertoire racine de l'application :

 $ slc exécuter

Dès que l'application est exécutée, vous pouvez confirmer si le déploiement a réussi en vous rendant à l'URL suivante avec votre navigateur :

http://0.0.0.0:3000/api/beers

Plutôt cool, n'est-ce pas ?

LoopBack contient également une page qui vous permet de visualiser tous les services disponibles de l'application, y compris le modèle Beer et le service REST que nous avons créé. Pointez votre navigateur vers l'URL suivante pour afficher :

http://0.0.0.0:3000/explorer

Une fois la page chargée avec succès, vous verrez l'interface suivante. Nous avons créé le nœud beans dans le cadre du blog. J'ai mis en évidence le point de terminaison /beers :

Vous pouvez cliquer sur /beers pour développer les API disponibles. Vous pouvez les utiliser et les tester, comme le montre la figure ci-dessous :

en conclusion

Dans cet article de blog, je montre comment utiliser Java EE pour créer un service REST qui renvoie les données de liste de produits de bière de Pabst Beer Company. Plus tard, j'ai utilisé node.js et le framework de bouclage basé sur node.js pour implémenter le service rest avec la même fonction en utilisant très peu de code. Le plus important est que l'API LoopBack fournit également une implémentation par défaut pour l'ajout, la suppression, la vérification et la modification des entités bière, afin que nous puissions obtenir un service de repos avec des fonctions complètes d'ajout, de suppression, de vérification et de modification sans écrire une seule ligne. de code.

La liste suivante compare les fonctionnalités respectives de javaEE et de node.js mentionnées dans l'article de blog :

Quelle est la prochaine étape ?

Le prochain Node v0.12 apportera au moins 8 nouvelles fonctionnalités intéressantes, quelles seront-elles ? Visitez la page « Quoi de neuf dans Node.js v0.12 » pour en savoir plus.
Intéressé par une formation et une certification liées aux nœuds ? StrongLoop propose une variété de services pour répondre à vos besoins.