Servidor en nodeJS

Vamos a crear un servidor http que escuche peticiones en el puerto 8080 y responda con un holaMundo:

var http=require('http');

var numeroPuerto=8080;

var functionServidora = function (request,response) {

response.writeHead(200, {'Content-Type' : 'text/plain'});

response.end('Hola Mundo');

};

var server = http.createServer(functionServidora).listen(numeroPuerto);

console.log('Servidor escuchando en el puerto: ' + numeroPuerto +'...');

Donde importamos el paquete http, establecemos el puerto 8080, y pasamos la función servidora al método createServer de http

Middlewares

Un middleware es un bloque de código que se ejecuta entre la petición que hace el usuario (request) hasta que la petición llega al servidor.

Las funciones de middleware pueden realizar las siguientes tareas:

Ejecutar cualquier código.
Realizar cambios en la solicitud y los objetos de respuesta.
Finalizar el ciclo de solicitud/respuestas.
Invocar la siguiente función de middleware en la pila.
Ejecutar código

Es usado en las aplicaciones de express:

Tareas para servir archivos estáticos
Gestión de errores
Compresión de las respuestas HTTP

Tipos de middleware:

Middleware de nivel de aplicación
Middleware de nivel de direccionador
Middleware de manejo de errores
Middleware incorporado
Middleware de terceros

La mayoría de las aplicaciones usan middleware de terceros, para simplificar funciones habituales en el desarrollo web

Por ejemplo:·

Gestión de cookies,
Sesiones,
Autentificado de usuarios,
Peticiones POST y datos en JSON,
Registros de eventos, etc.

En la siguiente dirección podemos encontrar listas de middleware de Express:

http://expressjs.com/en/resources/middleware.html

Por ejemplo tenemos algunos como:

app.use(morgan('dev'));

app.use(bodyParser.json());

app.use(cookieParser());

app.use(bodyParser.urlencoded({ extended: false }));

Middleware de nivel de aplicación

Cada que declaramos un middleware con las funciones app.use(), app.get(), app.put() y app.post()se crea una pila de middlewares que son llamadas en el mismo orden:

El middleware de nivel de aplicación usa las funciones app.use(), app.get(), app.put() y app.post().

Podemos ejecutar las funciones de middleware en cualquier ruta o en una ruta especifica mediante app.use(), app.get(), o app.post()

Donde app.use () donde generalmente se usa para introducir middlewares en su aplicación y puede manejar todo tipo de solicitudes HTTP mientras que app.get() o app.post() son solo para manejar solicitudes HTTP GET y HTTP POST respectivamente.

Cuando el servidor recibe una solicitud en cualquier ruta se ejecuta la siguiente función de middleware:

var app = express();

app.use(function (req, res, next) {

  console.log('Bienvenido');

  next();

});

La siguiente función de middleware se ejecuta en la ruta / :

app.use('/',function (req, res, next) {

console.log('Bienvenido');

  next();

});

El middleware siguiente se ejecuta en la ruta / cuando llega una solicitud tipo GET:

app.get('/',function (req, res, next) {

  console.log('Bienvenido');

  next();

});

El middleware siguiente se ejecuta en la ruta / cuando llega una solicitud tipo POST:

app.post('/',function (req, res, next) {

  console.log('Bienvenido');

  next();

});

Si no se finaliza el ciclo debe llamar a la función next() para pasar el control de la ejecución a la siguiente función del middleware, por ejemplo cargamos una serie de funciones de middleware en la ruta /

app.use('/',function (req, res, next) {

console.log('middleware1');

next();

},function (req, res, next) {

console.log('middleware2');

next();

});

Vamos a montar tres middlewares en dos rutas en la dirección / de peticiones de tipo GET, la primera ruta imprime middleware1 y middleware2, pero la segunda no porque finaliza el ciclo de la petición al no tener next() en el segundo middleware de la primera ruta.

app.get('/', function (req, res, next) {

console.log('middleware1');

next();

}, function (req, res, next) {

console.log('middleware2');

});

app.get('/', function (req, res, next) {

console.log('middleware3');

});

Middleware de nivel de direccionador

El middleware de nivel de direccionador usamos:

express.Router()

var router = express.Router();

Utilizamos las funciones las funciones router.use(),router.get(),router.put() y router.post().

Cuando el servidor recibe una solicitud en cualquier ruta se ejecuta la siguiente funcion de middleware:

var express = require('express');

var router = express.Router();

router.use(function (req, res, next) { //Middleware1

console.log('CualquierDireccion')

next();

})

module.exports = router;

Cuando el servidor recibe una solicitud en la ruta / se ejecuta la siguiente función de middleware:

var express = require('express');

var router = express.Router();

router.use('/', function (req, res, next) {

res.send('Bienvenido')

next();

});

module.exports = router;

app.use('/', router); //Montaje de router en el codigo principal de la aplicación

Vamos crear el siguiente árbol de rutas:

Donde cada ruta tiene un middleware:

var express = require('express');

var router = express.Router();

router.get('/', function (req, res, next) { //Middleware1

console.log('rutaPrincipal')

next();

});

router.get('/ruta1', function (req, res, next) { //Middleware2

console.log('ruta1');

next();

});

router.get('/ruta2', function (req, res, next) { //Middleware3

console.log('ruta2');

next();

});

module.exports = router;

app.use('/rutaPrincipal', router); //Montaje de router en el codigo principal de la aplicación

Una sub-pila de middleware muestra información de solicitud para cualquier tipo de solicitud HTTP a la ruta /

var express = require('express');

var router = express.Router();

router.use('/', function (req, res, next) {

console.log('middleware1');

next();

},function (req, res, next) {

console.log('middleware2');

next();

});

module.exports = router;

Una sub-pila de middleware que maneja las solicitudes GET a / donde la primera ruta tiene dos middlewares y la segunda tiene uno solo

var express = require('express');

var router = express.Router();

router.get('/', function (req, res, next) {

// if es cierto pasa al siguiente enrutador

cierto = true;

if (cierto) next('route');

// De lo contrario, pasa el control a la siguiente función de middleware en esta pila

else next(); //

}, function (req, res, next) {

res.send('middleware1');

});

router.get('/', function (req, res, next) {

res.send('siguiente router');

});

module.exports = router;

En el siguiente ejemplo:

var express = require('express');

var router = express.Router();

router.get('/', function (req, res) {

res.send("Usuario de administracion");

});

router.get('/usuario1', function (req, res) {

res.send("Usuario1");

});

router.get('/usuario2', function (req, res) {

res.send("Usuario2");

});

module.exports = router;

app.use('/',guardarUsuario);

Podemos acceder a Usuario de administración en http://localhost:4200 y a las sub-páginas en http://localhost:4200/usuario1 y http://localhost:4200/usuario2

Tanto las funciones middleware como routing son llamadas en el orden que son declaradas, donde importa el orden, por ejemplo si el middleware de sesión depende del middleware de cookie, entonces el manejador de cookie tiene que ser llamado antes.

Por ejemplo si queremos saber si un usuario esta autentificado o no:

loginMiddleware = function(req,res,callback){

if (req.isAuthenticated()){

return callback(req,res);

}else {

res.redirect('/login');

}

Lo usamos en la ruta principal al llamar al metodo post desde un formulario:

app.post('/', function(req,res){

loginMiddleware(req,res,function(req,res){
//Recuperamos los parametros del formulario

var nombre = req.body.nombre;

var nombreUsuario = req.body.nombreUsuario;

var password = req.body.password;

var usuario = {

nombre : nombre,

nombreUsuario : nombreUsuario,

password : password

}

creaUsuario(usuario,function(err,valido){

res.redirect('/');

})

Rutas

fichero index.js:

var express = require('express');

var router = express.Router();

router.get('/', function(req, res, next) {

res.render('index', { title: 'Express' });

});

module.exports = router;

Montamos la función de middleware en la ruta ‘/’:

var index = require(‘./routes/index);

app.use(‘/’,index);

Paquete expres()

Es un framework de nodeJs, que permite manejar rutas, archivos estáticos, motores de plantillas y middlewares

Tenemos las siguientes instrucciones:

npm install –g express-generator: Instala el paquete a nivel global

express nombreProyecto: Genera un proyecto llamado nombreProyecto

cd nombreProyecto : Accede a la carpeta llamada nombreProyecto

npm install : Instala las dependencias de package.json

node app.js : Arranca la aplicación

Se crea un proyecto con la siguiente estructura de carpetas:

bin:

Es el archivo principal de la aplicación

Carga los paquetes:

var app = require('../app'); //Donde app es una instancia de la aplicación en el servidor

var debug = require('debug')('appweb:server');

Intenta que port sea un número valido:

var port = normalizePort(process.env.PORT || '4200');

Inicia el servidor en el puerto 4200

app.set('port', port);

var server = http.createServer(app);

server.listen(port);

Define los eventos que ocurran en el sistema

server.on('error', onError);

server.on('listening', onListening);

node_modules: Es la carpeta que contiene las librerias descargadas de npm
public:Es la carpeta que contiene los elementos estaticos del proyecto, imágenes, hojas de estilo, ect…
routes:Son los middlewares que se van a encargar de procesar las peticiones que llegen de la request

var express = require('express');

var router = express.Router();

router.get('/', function(req, res, next) {

res.render('index', { title: 'Express' });

});

module.exports = router;

var express = require('express');

var router = express.Router();

router.get('/', function(req, res, next) {

res.send('respond with a resource');

});

module.exports = router;

views: Contiene las vistas de la aplicación.
app:Contiene la definicion de la aplicación:

Carga de Modulos:

var createError = require('http-errors');
var express = require('express');
var path = require('path'); //Se encarga de las rutas relativas del proyecto.
var cookieParser = require('cookie-parser');
var logger = require('morgan');
var indexRouter = require('./routes/index');
var usersRouter = require('./routes/users');
var app = express();
app.set('views', path.join(__dirname, 'views')); //Define la carpeta de vista de la aplicacion.
app.set('view engine', 'jade'); //Establece el motor de plantilla.
app.use(logger('dev'));
app.use(express.json()); //Pone los parametros de la peticion y de la URL en req.body
app.use(express.urlencoded({ extended: false }));
app.use(cookieParser()); //permite añadir a los pararetros de la peticion las cookies del cliente
app.use(express.static(path.join(__dirname, 'public'))); //Carpeta donde estan los archivos estaticos.
Monta los middlewares indexRouter y userRouter en las rutas / y /users respectivamente:
app.use('/', indexRouter);
app.use('/users', usersRouter);
Middleware de ruta nos encontradas
app.use(function(req, res, next) {
next(createError(404));
});

// error handler

app.use(function(err, req, res, next) {

// set locals, only providing error in development

res.locals.message = err.message;

res.locals.error = req.app.get('env') === 'development' ? err : {};

// render the error page

res.status(err.status || 500);

res.render('error');

});

package.json:

tiene las siguientes dependencias:

"cookie-parser": "~1.4.4",

"debug": "~2.6.9",

"express": "~4.16.1",

"http-errors": "~1.6.3",

"jade": "~1.11.0",

"morgan": "~1.9.1"

Donde:

cookie-parser: Añade a la peticion las cookies que residen en el navegador

debug: Depurador que muestra lo que va sucediendo en el sistema

express: "~4.16.1",

http-errors: "~1.6.3",

jade: Es el motor de plantilas de nodeJS

morgan: Es una paquete de login de nodeJS

package-lock:

Contiene el arbol de los paquetes y dependencias definidas en el package.json e instaladas en el proyecto

NodeJS y Angular

miércoles, 10 de junio de 2020