Un tutorial introductorio para desarrolladores de Java combinado con la programación de Node.js

En primer lugar, debo admitir que, como desarrollador de Java con más de diez años de experiencia en desarrollo, he formado rutinas inherentes para resolver la mayoría de los problemas, aunque a menudo parecen engorrosos y engorrosos. Por ejemplo, si desea leer un archivo, debe inicializar una instancia de BufferedReader y pasar un FileReader. Esto es casi lógico. He escrito este código en muchos proyectos que considero de "nivel empresarial" y lo disfruto mucho. Mucho proceso, se puede decir que solo soy un fanático de Java que desdeña otros lenguajes.

Si está leyendo esta publicación de blog, es posible que haya caído en un malentendido en el que yo caí hace muchos años. Como desarrollador calificado, debe aprender constantemente nuevas tecnologías y elegir las tecnologías apropiadas en función de las necesidades laborales reales. Aunque me estoy haciendo mayor y puede que algún día me canse de Java. Pero ahora realmente he descubierto algo nuevo y emocionante: node.js es como un niño que me regala un juguete novedoso. En esta publicación de blog, primero les mostraré cómo crear un Rest simple usando el servicio Java EE para leer la base de datos MongoDB. Luego usaré node.js para lograr la misma funcionalidad y comprenderá más fácilmente el entusiasmo de este nuevo lenguaje de desarrollo.

Comience con lo básico: ¿qué es Node.js?

En primer lugar, quiero dejar claro que Node.js no es un lenguaje "de moda" que sólo utiliza la "gente de moda". Aunque comenzó con este entendimiento, me complace informar que Node.js es un lenguaje maduro y, en la era actual de Internet, se ha abierto camino en grandes empresas que impulsan algunos de los sitios web de mayor tráfico. Node.js es una herramienta muy útil en tu conjunto de habilidades y te sorprenderá con lo fácil que es crear código estable, seguro y de alto rendimiento.

En resumen, Node es un lenguaje para actividades del lado del servidor. Utiliza el lenguaje Javascript y hay muchas bibliotecas disponibles, como los modelos npm. Puede comparar esos modelos npm con paquetes .jar en Java. Cuando necesita una funcionalidad y no tiene ganas de escribir todo el código usted mismo, es probable que la característica que está buscando ya esté incluida en el modelo npm.

Las aplicaciones de nodo normalmente se ejecutan para maximizar la eficiencia aprovechando las E/S sin bloqueo y los eventos asincrónicos. Una cosa que los desarrolladores de Java deben saber es que las aplicaciones Node se ejecutan en un solo subproceso. Sin embargo, el código del nodo backend utiliza múltiples subprocesos para operaciones como el acceso a la red y a archivos. Por este motivo, Node es perfecto para aplicaciones que requieren experiencia en tiempo real.

Continuar - Soporte IDE

Puede que seas como yo y "vivas" y "respires" en el IDE. Esto puede deberse a que Java tiene demasiadas palabras y requiere que escribamos código constante para completar funciones durante el proceso de desarrollo de software. Una vez que descubrimos los beneficios de completar código, poco a poco aprendimos a usar el IDE para la administración de archivos, la depuración y otras funciones muy útiles. Basta decir que me encanta usar un IDE y sigo usándolo cuando trabajo con Nodeb. Los siguientes son el primer lote de IDE que actualmente admiten Node:

1. Eclipse: debería ser fácil comenzar con esto si ya lo está utilizando en Java. Simplemente instale el complemento Node.js.
2.JetBrains IntelliJ IDEA: un IDE comercial muy popular. Este es mi IDE favorito hasta ahora.
3.Microsoft Visual Studio: sí, has leído bien. Node ha crecido hasta el punto en que Microsoft agregó soporte nativo en Visual Studio. Esta implementación es muy estable y VS es mi segundo IDE favorito. Curiosamente, solo uso VS para algunos proyectos básicos de Node.
4.CodeEnvy: un IDE basado en web
5.Cloud9: un IDE basado en web
6.SublimeText 2: un editor de texto sencillo que se está volviendo cada vez más popular entre los desarrolladores debido a su naturaleza liviana.

Estos son algunos de mis IDE favoritos para trabajar en proyectos basados ​​en Node. Sólo un ejemplo.

Comience con un ejemplo

En el resto de esta publicación de blog, crearemos un servicio REST simple utilizando Java EE y Node.js. Este servicio REST simplemente leerá información de la base de datos MongoDB y devolverá los resultados al solicitante. La instalación y configuración del servidor de aplicaciones Java y la base de datos MongoDB están fuera del alcance de este artículo.

Crea nuestra aplicación Java

Paso 1: configurar el archivo pom.xml

Llamemos a este ejemplo reejemplo y usaré el servidor de aplicaciones JBoss EAP. Lo primero que debemos hacer es configurar nuestro archivo pom.xml para la gestión de dependencias utilizando el sistema de compilación Maven. El siguiente es el archivo pom.xml que contiene las dependencias necesarias en nuestra aplicación reejemplo:

 <proyecto 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> <versión>1.0</version> <nombre>restexample</name> <repositorios> <repositorio> <id>eap</id> <url>http://maven.repository.redhat.com/techpreview/all</url> <lanzamientos> <enabled>true</enabled> </lanzamientos> <snapshots> <enabled>true</enabled> </snapshots> </repository> </repositories> <pluginRepositories> <pluginRepository> <id>eap</ id> <url>http://maven.repository.redhat.com/techpreview/all</url> <lanzamientos> <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> <dependencias> <dependencia> <groupId>org.jboss.spec</groupId> <artifactId>jboss-javaee-6.0</artifactId> <versión>3.0.2.Final-redhat-4</versión> <type>pom</type> <scope>proporcionado</scope> </dependency> <dependency> <groupId>org.mongodb</groupId> <artifactId>mongo-java-driver</artifactId> <versión>2.9.1</versión> </dependencia> </dependencias> </proyecto>

Genial, bastante detallado, pero espero que puedas entender el código. En esta publicación de blog asumo que los lectores ya conocen Java, así que no explicaré los detalles.

Paso 2: cree el archivo beans.xml y configure nuestro mapeo de servlet

Como parte del ejemplo, usaremos CDI (Inyección de dependencia de contexto) en nuestra clase de acceso a la base de datos. Según las instrucciones de configuración oficiales de CDI, si una aplicación quiere utilizar CDI, debe incluir un archivo beans.xml en el directorio WEB-INF de la aplicación. Así que creemos este archivo y configurémoslo con la información que necesitamos. Vaya a su directorio /src/main/webapp/WEB-INF, cree un archivo beans.xml y agregue el siguiente código:

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

También necesitamos configurar la asignación de servlet para nuestra API RESI en el archivo web.xml. Agregue el siguiente elemento de asignación de servlet al archivo en el directorio /src/main/webapp/WEB-INF:

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

Paso 3: crear la clase DBConnection

En este punto, hemos configurado el proyecto y nuestro archivo pom.xml ya contiene las dependencias del controlador de la base de datos MongoDB. Recuerde asegurarse de que los controladores necesarios estén empaquetados en nuestra aplicación. Lo siguiente que debemos hacer es crear una clase para administrar la conexión de la base de datos. Cree un nuevo archivo llamado DBConnection.java, coloque este archivo en el directorio /src/main/java/com/strongloop/data y luego agregue el siguiente código a este archivo:

NOTA: ¡Asegúrese de que la instalación de su base de datos MongoDB esté configurada con los detalles de autorización de conexión adecuados!

 paquete com.strongloop.data; importar java.net.UnknownHostException; importar javax.annotation.PostConstruct; importar javax.enterprise.context.ApplicationScoped; importar javax.inject.Named; ; @Named@ApplicationScopedpublic class DBConnection { base de datos privada mongoDB; DBConnection() { super(); } @PostConstruct public void afterCreate() { String mongoHost = "127.0.0.1" String mongoPort = "27001" String mongoUser = "strongloop; String mongoPassword = "rocas"; String mongoDBName = "restexample" ; int puerto = Integer.decode(mongoPort Mongo mongo); null; intente { mongo = new Mongo(mongoHost, puerto); } catch (UnknownHostException e) { System.out.println("No se pudo conectar a MongoDB: " + e.getMessage() + " :: " + e. getClass()); } mongoDB = mongo.getDB(mongoDBName); if (mongoDB.authenticate(mongoUser, mongoPassword.toCharArray()) == false) { System.out.println("Error al autenticar la base de datos ");

Paso 4: Importar datos a MongoDB (mmmm cerveza)

En nuestro proyecto queremos cargar una lista de todas las cervezas con el nombre Pabst. Si eres nuevo en la industria cervecera, quizás quieras probar la American Light Ale de Pabst Brewing. Estas cervezas presentan cintas azules y diseños Colt e incluyen todo tipo de bebidas de malta.

Primero debe descargar un archivo json que contiene todos los datos que deben devolverse. Puede utilizar la siguiente URL para lograr esto:
https://dl.dropboxusercontent.com/u/72466829/beers.json

Después de la descarga, use el comando mongoimport para importarlo a la base de datos. El comando es el siguiente:

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

Puedes ver los siguientes resultados:

 conectado a: 127.0.0.1:27017Mar 10 de junio 20:09:55.436 check 9 24Mar 10 de junio 20:09:55.437 importó 24 objetos

Paso 5: crear un objeto modelo de cerveza

Creamos una clase de conexión de base de datos y cargamos la información de la cerveza en la base de datos MongoDB. Es hora de crear un objeto modelo para controlar nuestra información de la cerveza. Cree un nuevo archivo llamado Beer.java y colóquelo en el directorio /src/main/java/com/strongloop/data. Después de crear el archivo, agréguele el siguiente código:

 paquete com.strongloop.data; cerveza de clase pública {id de cadena privada; nombre de cadena privada; getId de cadena pública() {id de retorno} setId vacío público (id de cadena) {this.id = id} getName() { devolver nombre } public void setName(nombre de cadena) { this.name = nombre } public String getDescription() { devolver descripción } public void setDescription(descripción de cadena) { esta.descripción = descripción; }}

Nota: El archivo JSON proporcionado contiene más información que usaremos, así que compruébelo y agréguele algunas funciones adicionales para ampliar su experiencia de aprendizaje.

Paso 6: crear el servicio REST

¿Adivina qué hacer? Ok, finalmente estamos listos para crear un servicio web basado en REST que nos permitirá cargar la información de la cerveza en el paso anterior. Para hacer esto, necesitamos crear un nuevo archivo llamado BeerWS.java y colocarlo en el directorio /src/main/java/com/strongloop/webservice. Después de crearlo, agregue el siguiente código:

 paquete com.strongloop.webservice; importar java.util.ArrayList; importar java.util.List; importar javax.enterprise.context.RequestScoped; importar javax.inject.Inject; importar javax.ws.rs.GET; importar javax.ws .rs.Path;importar javax.ws.rs.Produces;importar javax.ws.rs.QueryParam;importar com.strongloop.data.DBConnection;importar com.strongloop.data.Beer;importar com.mongodb.BasicDBObject;importar com.mongodb.DB;importar com.mongodb.DBCollection;importar com.mongodb.DBCursor;importar com.mongodb. DBObject; @RequestScoped@Path("/cervezas")clase pública BeerWS { @Inject Private DBConnection dbConnection; DBCollection getBeerCollection() { DB db = dbConnection.getDB(); DBCollection beerCollection = db.getCollection("cervezas"); (); theBeer.setName(dataValue.get("name")); theBeer.setDescription(dataValue.get("name")); theBeer.setId(dataValue.get("_id").toString()); // Obtener todas las cervezas @GET() @Produces("application/json") public List<Cerveza> getAllBeers() { ArrayList<Cerveza> allBeersList = new ArrayList<Beer>(); DBCollection cervezas = this.getBeerCollection(); DBCursor cursor = beers.find(); intente { while (cursor.hasNext()) { allBeersList.add(this.populateBeerInformation(cursor.next) ())); } } finalmente { cursor.close(); devolver todas las Cervezas }}

Paso 7: busque información sobre la cerveza de forma tonta

Ah, hecho. Hemos escrito un servicio REST que puede recuperar toda la información sobre la cerveza de la base de datos. Ahora, para implementar su código en su servidor de aplicaciones, abra la siguiente dirección en su navegador para ver si funciona bien:
http://ubicacióndesuservidor/ws/beers

Si todo está bien, verá una lista con toda la información de la cerveza, como se muestra a continuación:

Crear aplicación de nodo

Si sigue los pasos anteriores para programar en Java, se dará cuenta de que, aunque la creación de aplicaciones utilizando javaEE avanza muy rápidamente, todavía es muy problemático crear una aplicación simple como un servicio REST. No me malinterpretes, todavía me gusta usar javaEE, pero encuentro que para muchos escenarios, como la creación de servicios REST que devuelven datos json, Node es más adecuado. A continuación, vamos a crear un servicio web simple utilizando la API LoopBack de StrongLoop. Además, te mostraré cómo instalar Node en Apple OSX.

Paso 1: instalar el nodo

La forma más sencilla de instalar Node es a través de un paquete binario que sea compatible con la mayoría de los sistemas operativos. Abra su navegador y visite la página web a continuación para descargar la versión aplicable según su sistema operativo:
http://nodejs.org/download/

Una vez completada la descarga, verá lo siguiente:

Si está utilizando Mac OSX, haga clic en el archivo genérico .pkg. Esto guardará el instalador en su computadora. Después de descargar el archivo, haga doble clic en él para iniciar el programa de instalación. Verá el siguiente cuadro de diálogo de instalación:

Continúe la instalación de forma predeterminada. Después de una instalación exitosa, haga clic en el botón cerrar para salir del programa de instalación.

Bastante simple, ¿verdad?

Paso 2: instale LoopBack usando NPM

Ahora que Node se ha instalado en el sistema local, el siguiente paso es instalar el paquete LoopBack proporcionado por StroopLoop. LoopBack es un paquete de código fuente API abierto. Cuando aprende a utilizar Node para desarrollar e implementar software, LoopBack puede facilitar la programación.

Para instalar LoopBack, usaremos la línea de comando npm, que es parte del lenguaje principal de Node. NPM es una herramienta oficial de administración de paquetes que se utiliza para instalar bibliotecas de clases o plantillas de las que dependen las aplicaciones. Si es un programador de Java, puede comparar NPM con Maven. Al utilizar Maven para crear un proyecto, los desarrolladores pueden configurar los paquetes jar o las plantillas de los que depende el proyecto en pom.xml. Cuando el proyecto comience a compilarse, Maven descargará todos los archivos dependientes e introducirá el paquete jar en el proyecto. NPM funciona igual que Maven. Para algunos proyectos especiales, utiliza el archivo package.json para configurar los archivos de los que depende el proyecto. También puede utilizar la línea de comando para descargar archivos dependientes al sistema local. Si no comprende esto, no se preocupe, describiremos el archivo package.json en detalle en los siguientes pasos.

Para instalar LoopBack, utilizamos una línea de comando simple para descargar e instalar todos los archivos dependientes. Abra la ventana de línea de comando de su ventana e ingrese el siguiente comando:

 $ npm instalar -g bucle fuerte

Consejo: Durante la instalación, es posible que necesite utilizar otra cuenta de usuario para ejecutar este comando.

¿Qué significa esta línea de comando? El parámetro -g le dice a npm que queremos instalar el paquete strong-cli. El parámetro -g hace que este paquete sea compatible con cualquier sistema y aplicación. Una vez que ejecute el comando anterior, NPM descargará todos los archivos dependientes. El tiempo de descarga depende de la velocidad de Internet y puede tardar varios minutos.

Paso 3: crea la aplicación

Crear una aplicación utilizando la API LoopBack es simple. Abra la ventana de línea de comando de su ventana y use el siguiente comando para crear un nuevo ejemplo de aplicación.

 $ slc bucle invertido

A continuación, le solicitará el nombre de la ruta raíz del proyecto. En este ejemplo, se utiliza restample. A continuación le pedirá un nombre de aplicación. Utilice el reejemplo predeterminado.

El comando slc ahora creó una aplicación LoopBack llamada restexample y configuró la aplicación. Si ejecuta el comando anterior nuevamente y aún usa restample para nombrarlo, LoopBack creará un nuevo directorio. Puede utilizar el comando cd para modificar la ruta raíz de la aplicación.

 $ cd reejemplo

Ahora que hemos creado una aplicación, configuramos MongoDB como fuente de datos para la aplicación.

Paso 4: definir la fuente de datos

Para conectarnos a MongoDB, necesitamos agregar una fuente de datos a la aplicación y ejecutar el siguiente comando:

 $ slc bucle invertido: fuente de datos

En el mensaje emergente, puede ingresar cualquier nombre de fuente de datos personalizado. Aquí, elija myMongo.

 [?] Ingrese el nombre de la fuente de datos: myMongo

De esta manera adjuntamos la definición de fuente de datos del backend a un conector real impulsado por StrongLoop. Aquí seleccionamos el conector MongoDB de la lista.

 [?] Seleccione el conector para myMongo:PostgreSQL (compatible con StrongLoop)Oracle (compatible con StrongLoop)Microsoft SQL (compatible con StrongLoop)MongoDB (compatible con StrongLoop)Servicios web SOAP (compatibles con StrongLoop)Servicios REST (compatibles con StrongLoop)Neo4j ( proporcionado por la comunidad) (Muévase hacia arriba y hacia abajo para revelar más opciones)

Paso 5: señale la fuente de datos real

Para conectarnos a MongoDB, debemos apuntar a la instancia real de MongoDB. LoopBack define toda la información de configuración de la fuente de datos en el archivo datasource.json. Este archivo se encuentra en el directorio raíz/servidor de la aplicación. de la siguiente manera.

 { "db": { "nombre": "db", "conector": "memoria" }, "myMongo": { "nombre": "myMongo", "conector": "mongodb" "url": "mongodb: //localhost:27017/restexample" }}

Nota: asegúrese de proporcionar la URL de conexión correcta a la base de datos MongoDB. Para este ejemplo, creé una base de datos llamada restexample, que se utiliza como fuente de datos.

Paso 6: Importar datos a MongoDB (mmmmm cerveza)

Como se menciona en la parte de Java de este artículo, debemos cargar el conjunto de datos en la base de datos MongoDB. Si completó este paso de acuerdo con el método mencionado en este artículo y luego planea usar la misma base de datos, puede ignorar el paso. 6 y salte directamente al Paso 7.

En primer lugar, es necesario descargar un archivo JSON que contiene toda la información a devolver, el cual se puede obtener en la siguiente URL:
https://dl.dropboxusercontent.com/u/72466829/beers.json

Una vez descargado el archivo del conjunto de datos, utilice directamente el siguiente comando mongoimport para cargarlo en la base de datos:

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

Deberías ver los siguientes resultados:

 conectado a: 127.6.189.2:27017Mar 10 de junio 20:09:55.436 check 9 24Mar 10 de junio 20:09:55.437 importó 24 objetos

Paso 7: Crea nuestro propio modelo de cerveza

En el mundo de Java, podemos pensar en el modelo de objetos. Representa este objeto, pero aquí, este objeto es cerveza. LoopBack proporciona una forma sencilla de crear objetos modelo a través de la línea de comando. Abra una ventana de terminal e ingrese a la carpeta del proyecto. ingrese el siguiente comando:

 $ slc bucle invertido: modelo

Esto abrirá una sesión interactiva para definir el modelo. Lo primero que debe ingresar es el nombre del modelo, ingrese "cerveza" aquí. A continuación, se le solicitará la fuente de datos a la que se debe adjuntar este modelo. la fuente de datos myMongo creada previamente.

 [?] Ingrese el nombre del modelo: beer[?] Seleccione la fuente de datos para adjuntar beer a:db (memoria)myMongo (mongodb)

A continuación, pregunta si se debe exponer esta API a través de REST. Por supuesto, así lo esperamos.

 [?] ¿Exponer cerveza a través de la API REST?

Finalmente, seleccione el nombre plural de la red para el modelo. Aquí el modelo se llama cerveza, por lo que el plural es beans (predeterminado). Presione Entrar para aceptar el valor predeterminado.

 [?] Forma plural personalizada (utilizada para crear la URL REST):

A continuación se le pedirá que defina las propiedades del modelo. Para este programa de ejemplo, nos centramos en el nombre y la descripción de la cerveza.

 Introduzca un nombre de propiedad vacío cuando haya terminado.[?] Nombre de propiedad: nombre

Siempre que presione Enter, se le pedirá que ingrese el tipo de datos de cada atributo especificado. El primer elemento es nombre, aquí seleccione el tipo de cadena y luego presione.

 Intro.[?] Tipo de propiedad: (Utilice las teclas de flecha)stringnumberbooleanobjectarraydatebuffergeopoint(otro)

A continuación, cree el atributo de descripción de la misma manera y luego se le pedirá que ingrese el tipo de datos. También es un tipo de cadena, seleccione la opción de cadena y luego haga clic.

 Ingrese.Agreguemos otra propiedad de cerveza.Ingrese un nombre de propiedad vacío cuando haya terminado.[?] Nombre de propiedad: descripcióninvocar bucle invertido:propiedad[?] Tipo de propiedad: cadena[?] ¿Obligatorio?

¡Felicitaciones! Ha completado la creación de objetos modelo usando LoopBack combinado con Node. Si desea ver qué se creó realmente durante este proceso, puede abrir el archivo beer.json ubicado en el directorio raíz de la aplicación/common/models y desplazarse hasta Al final del archivo, verá el siguiente modelo:

 { "nombre": "cerveza", "base": "PersistedModel", "properties": { "nombre": { "tipo": "cadena", "requerido": verdadero }, "descripción": { "tipo" : "cadena", "requerido": verdadero } }, "validaciones": [], "relaciones": {}, "acls": [], "métodos": []}

Como puede ver aquí, hemos creado un modelo y, al mismo tiempo, se le han asignado los atributos de nombre y descripción.

En el archivo /server/model-config.js, puede observar que el archivo contiene algunos campos adicionales, incluidos público y fuente de datos. El campo público especifica que queremos exponer este modelo al exterior a través de un servicio de red REST. El campo es Especificar la fuente de datos que se utilizará para las operaciones CRUD en este modelo.

 "cerveza": { "dataSource": "myMongo", "public": verdadero }

Paso 8: disfruta del placer de ver cervezas

¡Felicitaciones! Ha creado su primera aplicación Node.js que contiene un servicio web REST que puede obtener información sobre cerveza. Finalmente, todo lo que tenemos que hacer es implementar la aplicación.

Afortunadamente, la implementación ya es sencilla. Se puede realizar ejecutando el siguiente comando en el directorio raíz de la aplicación:

 $ slc ejecutar

Tan pronto como se ejecute la aplicación, podrá confirmar si la implementación se realizó correctamente accediendo a la siguiente URL con su navegador:

http://0.0.0.0:3000/api/beers

Muy bueno, ¿no?

LoopBack también contiene una página que le permite ver todos los servicios disponibles de la aplicación, incluido el modelo Beer y el servicio REST que creamos. Dirija su navegador a la siguiente URL para verlo:

http://0.0.0.0:3000/explorador

Después de que la página se cargue correctamente, verá la siguiente interfaz. Hemos creado el nodo beans como parte del blog. He resaltado el punto final /beers:

Puede hacer clic en /beers para expandir las API disponibles. Puede operarlas y probarlas, como se muestra en la siguiente figura:

en conclusión

En esta publicación de blog, muestro cómo usar Java EE para crear un servicio REST que devuelva datos de listado de productos de cerveza de Pabst Beer Company. Más tarde, utilicé node.js y el marco loopback basado en node.js para implementar el servicio resto con la misma función usando muy poco código. Lo más importante es que la API LoopBack también proporciona una implementación predeterminada para agregar, eliminar, verificar y modificar entidades de cerveza, de modo que podamos obtener un servicio de descanso con funciones completas de agregar, eliminar, verificar y modificar sin escribir una sola línea. de código.

La siguiente lista compara las características respectivas de javaEE y node.js mencionadas en la publicación del blog:

¿Qué sigue?

El próximo Node v0.12 traerá al menos 8 características nuevas e interesantes, ¿cuáles serán? Visite la página "Novedades de Node.js v0.12" para obtener más información.
¿Está interesado en capacitación y certificación relacionadas con Node? StrongLoop ofrece una variedad de servicios para satisfacer sus necesidades.