Header Ads Widget

Ticker

6/recent/ticker-posts

Desarrolle API RESTful usando MongoDB y Nodejs

 En este artículo, aprenderemos cómo construir API Restful desde cero usando bases de datos de nodo y NoSQL como MongoDB. Para empezar, comprendamos nuestra pila de desarrollo antes de comenzar a construir nuestra aplicación.

Node.js es un tiempo de ejecución de JavaScript de código abierto diseñado para crear aplicaciones escalables y utiliza una E / S sin bloqueo y basada en eventos. Node.js está diseñado para mantener una latencia baja y la transmisión como una prioridad, lo que lo hace muy adecuado para una base de biblioteca web.

MongoDB es un tipo de base de datos NoSQL de código abierto diseñado para utilizar modelos de datos de documentos como la estructura de datos JSON. Según el sitio web de MongoDB: “MongoDB es una base de datos de documentos con la escalabilidad y flexibilidad que desea con las consultas y la indexación que necesita”. Para obtener más información sobre MongoDB, tiene muy buena documentación que vale la pena leer

1. Requisitos previos

  • Descargue e instale Node
  • Instalación de MongoDB
  • Instalar Express Server
  • Descarga el cliente Postman para probar nuestras API
  • Su editor de texto favorito o IDE como Atom, sublime o JetBrains
  • Terminal instalado

1.1 Descargar e instalar Node

Node.js se puede descargar e instalar en múltiples versiones y sistemas operativos. Siga el enlace de documentación del nodo y elija la instalación correcta que funcione mejor. Si tuviera que utilizar Mac, siga las instrucciones que se proporcionan a continuación

  • Haga clic en el instalador de macOS y abra el archivo .pkg descargado, en nuestro caso, node-v10.15.1.pkg es el nombre del archivo
  • Haga clic en continuar para continuar con el instalador
API RESTful usando MongoDB y Nodejs - Instalador de Node Js
Instalador de Node Js
  • Siga las instrucciones en pantalla para completar la instalación con éxito
  • Confirme que el nodo se haya instalado correctamente comprobando la versión instalada
Verifique la versión del nodo instalada
1
2
$ node -v<font></font>
v10.15.1

Felicidades, tiene el nodo instalado correctamente y comencemos con la instalación de MongoDB

1.2 Instalación de MongoDB

MongoDB se puede instalar manualmente descargando la instalación o Homebrew.

Instala Mongo usando brew
1
2
3
4
5
6
7
8
9
$ brew install mongodb<font></font>
Updating Homebrew...<font></font>
==> Installing dependencies for mongodb: openssl, readline, sqlite and python@2<font></font>
==> Installing mongodb<font></font>
==> mongodb<font></font>
To have launchd start mongodb now and restart at login:<font></font>
brew services start mongodb<font></font>
Or, if you don't want/need a background service you can just run:<font></font>
  mongod --config /usr/local/etc/mongod.conf<font></font>

Para comprobar si mongo se ha instalado correctamente

Instalación exitosa de Mongo
1
2
$ which mongo<font></font>
/usr/local/bin/mongo<font></font>

Para iniciar el servidor MongoDB:

Inicie el servidor Mongo
1
2
$ brew services start mongodb<font></font>
==> Successfully started mongodb<font></font>

Pruebe su conexión a mongodb:

Compruebe la conexión de Mongo
1
2
3
$ mongo<font></font>
MongoDB shell version v4.0.3<font></font>
connecting to: mongodb://127.0.0.1:27017<font></font>

Ahora que tenemos MongoDB instalado, instalemos rápidamente Postman para que podamos comenzar a construir nuestras API.

1.3 Descargar el cliente Postman

Postman es un cliente HTTP de interfaz gráfica de usuario (GUI) que se utiliza para probar servicios API mediante la construcción de una solicitud API con una respuesta API legible. El cliente Postman se puede descargar desde https://www.getpostman.com/downloads/ y seguir las instalaciones en pantalla para una instalación exitosa.

Ahora tenemos nuestra pila de desarrollo instalada y estamos listos para comenzar a construir API. Creemos una aplicación que almacene información de productos y llamémosla Catálogo de productos. Para comenzar a crear la aplicación, abriremos el terminal y crearemos una carpeta con el nombre product-catalog-api y desde el directorio raíz crearemos el archivo package.json siguiendo los pasos a continuación:

Crear estructura de directorio de productos
1
2
3
$ mkdir product-catalog-api<font></font>
$ cd product-catalog-api<font></font>
$ npm init<font></font>

Realice cualquier cambio en el package.json desde la terminal o siempre puede realizar cambios más tarde, aquí está mi copia con algunos detalles agregados

Modificar el archivo del paquete con actualizaciones
01
02
03
04
05
06
07
08
09
10
{<font></font>
    "name": "product-catalog-api",<font></font>
    "version": "1.0.0",<font></font>
    "description": "Sample   Product Catalog app using node and mongodb",<font></font>
    "main": "index.js",<font></font>
    "scripts": {<font></font>
      "test": "echo \"Error: no test   specified\" && exit 1"<font></font>
    },<font></font>
    "author": "RM",<font></font>
    "license":"ISC"<font></font>

Ahora creamos el archivo de paquete que es el archivo de inicio para que el servidor de nodo reconozca los pasos para iniciar el servidor, creemos una carpeta api y creemos el controlador, el modelo y la carpeta de rutas respectivamente

crear estructura MVC
1
2
3
4
5
6
$ mkdir api<font></font>
$ cd api<font></font>
$ mkdir contollers<font></font>
$ mkdir models<font></font>
$ mkdir routes<font></font>
$ cd ../ && touch server.js<font></font>

Aquí está la estructura de carpetas después de que se crean los archivos:

La estructura debe incluir una carpeta api y controladores, modelos y rutas como subcarpetas en ella. Asegúrese de que los archivos package.json y server.js formen parte de la carpeta api.

Estamos listos para crear nuestro primer modelo, archivos de controlador junto con rutas.

Crea controlador, modelo y rutas
1
2
3
$ touch api/controllers/productCatalogController.js <font></font>
$ touch api/models/productCatalogModel.js<font></font>
$ touch api/routes/productCatalogRoutes.js<font></font>

Es hora de crear nuestro servidor usando comandos express y npm

1.4 Instalación Express Server

Según el sitio expressjs.com:

"Express es un marco de aplicación web Node.js mínimo y flexible que proporciona un conjunto sólido de funciones para aplicaciones web y móviles".

Express.js está diseñado para crear aplicaciones web híbridas, tanto de una sola página como de varias páginas. Express.js es el marco más utilizado para aplicaciones node.js que proporciona una capa delgada para aplicaciones web sin obstaculizar las características de node.js

Instalar express y nodemon
1
2
$ npm install express --save<font></font>
$ npm install --save-dev nodemon<font></font>

En la instalación exitosa, se creará una carpeta adicional con el nombre node_modules con todas las dependencias express instaladas y guardadas. Usaremos nodemon server.js para iniciar el servidor de aplicaciones. Agregue la línea dentro del archivo package.json para iniciar automáticamente el servidor.

1.5 Instalar la biblioteca Mongoose

La biblioteca Mongoose se usa ampliamente como modelado de datos de objetos (ODM) para MongoDB y aplicaciones de nodo. Mongoose se encarga de las relaciones entre los datos y las validaciones de esquemas, compruebe cómo.

Comencemos instalando mongoose usando el paquete npm

Instalar mongoose usando el paquete npm
1
$ npm install mongoose --save

Si notó cambios en la base de código, package.json y package-lock.json se actualizan desde el comando npm install junto con la carpeta de mangosta dentro de una carpeta de módulo de nodo.

2. Cree un esquema de producto

Comencemos a definir nuestro modelo de catálogo de productos agregando un esquema que identificaría productos como:

  • Nombre → Identifica el nombre del producto
  • Descripción → Identifica la descripción del Producto
  • Precio → Identifica el precio del Producto
  • Moneda → Identifica la moneda del Producto
  • Creado en → Identifica la marca de tiempo de creación del producto
  • Actualizado en → Identifica la marca de tiempo del producto última marca de tiempo actualizada

Definamos el esquema en la nomenclatura de mongoose y nodejs agregando el siguiente código en el archivo productCatalogModel.js y guarde. El código a continuación se explica por sí mismo con el modelo y el esquema definidos con las colecciones mencionadas anteriormente.

Definición de esquema para el modelo de producto
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
dieciséis
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
'use strict';<font></font>
var <code>mongoose</code> = require('mongoose');<font></font>
var <code>Schema</code> = mongoose.Schema;<font></font>
<font></font>
<font></font>
var <code>ProductSchema</code> = new Schema({<font></font>
  name: {<font></font>
    type: String,<font></font>
    required: 'Enter Product Name'<font></font>
  },<font></font>
  description: {<font></font>
    type: String,<font></font>
    required: 'Enter Product Description'<font></font>
  },<font></font>
  price: {<font></font>
    type: Number,<font></font>
    required: 'Enter Product Price'<font></font>
  },<font></font>
  currency: {<font></font>
    type: String,<font></font>
    required: 'Enter Product Currency'<font></font>
  },<font></font>
  Created_date: {<font></font>
    type: Date,<font></font>
    default: Date.now<font></font>
  },<font></font>
  Updated_date: {<font></font>
    type: Date,<font></font>
    default: Date.now<font></font>
  }<font></font>
});<font></font>
<font></font>
module.exports = mongoose.model('<code>Products</code>',  <code> ProductSchema</code>);  

Creemos nuestro controlador con acciones para listar, crear, leer, actualizar y eliminar un producto del catálogo de productos. Gracias a los métodos de Mongoose y las funciones exportadas de node.js. Modifique el archivo del controlador productCatalogController.js como se menciona a continuación

Operaciones CRUD usando mangosta
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
dieciséis
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
'use strict';
 
var <code>mongoose</code> = require('mongoose'),
  <code>Product</code> = mongoose.model('Products');
 
exports.list_all_products = function(req, res) {
  <code>Product.find</code>({}, function(err, product) {
    if (err)
      res.send(err);
    res.json(product);
  });
};
 
exports.create_a_product = function(req, res) {
  var new_product   = new Product(req.body);
  new_product.save(function(err, product) {
    if (err)
      res.send(err);
    res.json(product);
  });
};
 
 
exports.read_a_product = function(req, res) {
    Product.findById(req.params.productId, function(err,   product) {
    if (err)
      res.send(err);
    res.json(product);
  });
};
 
 
exports.update_a_product = function(req, res) {
  <code>Product.findOneAndUpdate</code>({_id:   req.params.productId}, req.body, {new: true}, function(err, product) {
    if (err)
      res.send(err);
    res.json(product);
  });
};
 
 
exports.delete_a_product = function(req, res) {
 
 
  Product.remove({
    _id: req.params.productId
  }, function(err,   product) {
    if (err)
      res.send(err);
    res.json({ message: 'Product successfully deleted' });
  });
};  

Juntemos todo esto modificando el archivo de rutas productCatalogRoutes.js para que nuestra aplicación sepa las rutas cuando se llama a una acción en particular.

Modificar rutas para que coincidan con los controladores
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
'use strict';
module.exports = function(app) {
  var productList   = require('../controllers/productCatalogController');
 
  // todoList Routes
  app.route('/products')
    .get(productList.list_all_products)
      .post(productList.create_a_product);
 
 
  app.route('/products/:productId')
    .get(productList.read_a_product)
    .put(productList.update_a_product)
      .delete(productList.delete_a_product);
};  

Finalmente, agreguemos los detalles de la conexión de nuestro modelo y Mongoose en nuestro archivo server.js que creamos al comienzo del proyecto. 

Actualice los detalles de la conexión de la base de datos para conectarse a mongoose en el archivo del servidor
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
dieciséis
17
18
19
20
var express = require('express'),
  app = express(),
  port = process.env.PORT || 3000
  mongoose = require('mongoose'),
  Product = require('./api/models/productCatalogModel'),
  bodyParser = require('body-parser');
 
// mongoose instance connection   url connection
mongoose.Promise = global.Promise;
mongoose.connect('mongodb://localhost/ProductCatalogdb');
 
app.use(bodyParser.urlencoded({ extended: true }));
app.use(bodyParser.json());
 
var routes = require('./api/routes/productCatalogRoutes'); //importing   route
routes(app);
 
app.listen(port);
 
console.log('Product   Catalog RESTful API server started on: ' + port);  

El último paso es iniciar su servidor MongoDB, servidores de nodo para conectarse a la instancia de MongoDB.

iniciar el servidor mongo
1
$ mongod

La API construida debería funcionar con todas las acciones mencionadas en el controlador y usar cartero para probar sus API enviando una solicitud, por ejemplo, use la URL a continuación para enumerar todos los productos con éxito desde su instancia local.

http: // localhost: 3000 / productos

3. Referencias

Publicar un comentario

0 Comentarios