Cette serie d’articles à pour objet de montrer comment créer des sites web dynamique, qui délivre des response de type Rest au differentes requete HTTP recues.
Nous allons utiliser le framework Express(Nodejs/Javascript) pour créer une application simple.
il est, dans l’état actuel du web, primoridal de se pencher sur les technologies coté server.
l’ideal en terme developpement d’application est de debuter avec la partie serveur qui est plus facile que la partie front car les operations coté serveur sont souvant les même (CRUD, Validation de form,check des permissions et login users etc) sans oublier l’apport considerable que les framework apporte en terme de mise en place et de module (middelware) disponible, ce qui nous évite de réinventer la roue.

Avant de commencer quelques présentation:
Nodejs : est une plateforme open source qui nous permet de créer des applications et programme coté serveur en javascript. plusieurs avantage à utiliser Node( performance,écrit en Javascript pratique quand on travail sur le front,le gestionnaire de package npm sert aussi d’outils de build,portable sur la plupart des OS,grande communauté).
un exemple de creation d’un serveur node utilisant le module http pour l’ecoute des requéte sur le port 8000 et la reponse envoyé au client:
créeons le fichier server.js suivant:

//Load HTTP module
var http = require("http");

//Create HTTP server and listen on port 8000 for requests
http.createServer(function (request, response) {

// Set the response HTTP header with HTTP status and Content type
 response.writeHead(200, {'Content-Type': 'text/plain'});

 // Send the response body "Hello World"
 response.end('Hello World\n');
}).listen(8000);

// Print URL for accessing server
console.log('Server running at http://127.0.0.1:8000/')

éxécution du programme:

résultat d’une requete sur le port 8000

Nodejs ne permet pas d’utiliser les verbe GET,POST etc . il ne gere pas non plus les routes. pour cela nous allons soit écrire le code pour ce genre de fonctionalité, soit utiliser les framework existant et qui beneficie de grande communauté derriere ce qui garantie un code bien ecrit.

ExpressJs: est un framework Node trés populaire qui nous permet entre autre de :

• écrire different verbes pour les requete http (GET,POST,DELETE etc)
• integre un moteur template et d’y inserer les data
• utiliser des middelware (connecteur de base de donné, authentification etc)

Créeons à present le même programme mais avec express.

avant de pouvoir utiliser express nous devons l’importer dans nos dependences

npm install express --save 

server-express.js:

var express = require('express');
var app = express();

app.get('/', function (request, response) {
 response.send('Hello world from express');
});

app.listen(4200, function () {
 console.log('Serveur Express listening on port :4200');
});

explication du code:
les deux premiéres lignes servent à l’import du module express précedement installé, et de définir une application express dans la variable app.
cette object app a à présent des methodes de routage des requêtes http, de configuration de middleware, de template.

la seconde partie du code montre l’utilisation d’une route, une requête sur le chemin ‘/’ de type get va déclencher la fonction callback qui prend en argument la requete et la reponse et fait un send de la réponse dans le cas ou nous somme dans un get sur le chemin ‘/’

la derniere partie est un listen sur le port 4200.

 

import et export de modules:

un module est un fichier javascript que l’on peux importer avec la fonction require de nodejs, c’est ce que nous avons fait dans l’exemple précedent, un var express = require(‘express’) effectuera l’imprort du module express dans la variable express. nous pouvons donc importer n’importe quel module de type middleware (librairie d’acces à une base, login et authentification par exemple).
Nous pouvons aussi créer nos propres modules, pour cela il suffit d’ajouter un export de l’objet que l’ont souhaite importer dans un autres module.
prenons un exemple simple pour mieux comprendre le fonctionnement:

soit le fichier calc.js qui effectue la somme et la multiplication de deux nombres

exports.somme = function (a, b) {
 return a + b;
};

exports.mult = function (a, b) {
 return a * b;
};

nous voulons importer ces deux fonction dans un autre module nomé app.js:

var calc = require('./calc');

console.log('la Somme de 5 + 4 est égale à :' + calc.somme(5, 4));
console.log('le Produit de 5 * 4 est égale à :' + calc.mult(5, 4));

les fonctions du module calc.js peuvent etre groupé et exporter en un seul exports:

module.exports = {
 somme: function (a, b) {
 return a + b;
 },

mult: function (a, b) {
 return a * b;
 },

soustraction: function (a, b) {
 return a - b;
 },
 division: function (a, b) {
 return a / b;
 }
};

Api asynchrone:

un autre concepte important dans nodejs est la possibilité d’écrire du code asynchrone afin d’éviter d’attendre qu’un bout de code ne se termine avant de passer à la suite.
prenons l’exemple d’un code synchorne c’est à dire que chaque ligne de code ne s’execute qu’aprés la fin de la ligne précedente:

Nous ajoutons au programme précedent des numero pour chaque ligne affiché:

nous allons à présent bloqué en utilisant un timeout de 4 secondes sur la premiére opération:

var calc = require('./calc');

setTimeout(function () {
 console.log('1-la Somme 5 + 4 est égale à :' + calc.somme(5, 4));
}, 4000);
console.log('2-le Produit 5 * 4 est égale à :' + calc.mult(5, 4));
console.log('3-la Soustraction 5 - 4 est égale à :' + calc.soustraction(5, 4));
console.log('4-la division 5 / 4 est égale à :' + calc.division(5, 4));

Nous remarquons que les operations qui suivent n’attendent pas pour s’executer ce qui a pour effet de ne pas bloquer l’application (tres bon pour les performance).

l’utilisation de code non bloquant est donc trés important pour node, car celui ci est un environement « single threaded » ce qui signifie que toutes les requetes destinées au serveur s’execute sur la même thread.

pour utilisé du code non bloquant (asynchrone) il existe plusieurs facons de faire dont l’utilisation d’une fonction callback qui sera executé apres la fin des operations du code asynchrone.

Gestionnaire de routes:

Nous avons precedement defini une fonction callback pour la gestion de la route get(‘/’) :

app.get('/', function (request, response) {
 response.send('Hello world from express');
});

le callback prend deux argument request et response, ici notre response utilise la methode send pour envoyé la chaine de caractere (Hello world…) au browser. nous pouvons utiliser d’autre fonctions comme response.json() pour recevoir une reponse au format json response.sendFile() pour envoyer un fichier etc.

nous allons à present creer un module nommé route-api-blog.js qui regroupera toutes les route concernant la partie blog de notre site. pour separer les requetes nous allons attribué a chaque partie de notre site un prefixe qui specifie la route a utiliser, dans notre cas http://localhost:4200/blog/…. pour cela nous allons utilisé express.router

route-api-blog.js:

var express = require('express');
var router = express.Router();

//Home page blog
router.get('/', function (request, response) {
 response.send('Blog Home page');
});
//About page blog
router.get('/about', function (request, response) {
 response.send('Blog about page');
});
//Contact page blog
router.get('/contact', function (request, response) {
 response.send('Blog contact page');
});

module.exports = router;

serveur-express.js:

var express = require('express');
//import du module de route
var blog = require('./route-api-blog');

var app = express();
//specifie que nous allons requeter a partie de /blog
app.use('/blog', blog);

app.get('/', function (request, response) {
 response.send('Hello world from express');
});

app.listen(4200, function () {
 console.log('Serveur Express listening on port :4200');
});

Utilisation de middleware:

Pour utiliser un middleware il faut auparavant l’installer en utilisant le gestionnaire de paquet de node :
npm install morgan –save // morgan est un middleware de loggin (creation de log)
npm install mongodb –save // acces a la base mongo

l’option –save permet d’installer le module uniquement dans le repertoire nodes_module du projet courant.

pour utiliser le module nous utilisons app.use. l’ordre de declaration des module est important

var express = require('express');
var logger = require('morgan')
var blog = require('./route-api-blog');
var app = express();

app.use(logger('start route'));

Nous pouvons aussi creer notre propre middleware que nous souhaitons definir uniquement sur la route ‘/’:

var express = require('express');
var logger = require('morgan')
var blog = require('./route-api-blog');
var app = express();
//notre fonction middleware qui contient a l'inverse de morgan un argument next qui ne s'executera que si le cycle de request response n'est pas terminé
var mylog = function (req, res, next) {
 console.log('log function');
 next();
}

//pour le morgan cela engloble toutes les routes.
app.use(logger('start route'));

app.use('/blog', blog);

//nous utilisons ici app.use qui ne sera lancé que si '/' est requeter
app.use(mylog);

app.get('/', function (request, response) {
 response.send('Hello world from express');
});

app.listen(4200, function () {
 console.log('Serveur Express listening on port :4200');
});

Repertoire Public:

Nous pouvons utiliser le middleware express.static pour rendre accessible nos fichier public (css, image, javascript) ce middleware et le seul qui fait partie d’expressjs.
app.use(express.static(‘public’)); pour rendre le dossier public.

Connection à une base de donnée:

Express peut utiliser n’importe quel base supporter par nodejs, express ne pose aucun prérequis ou standart lié au base.
il faut avant de pouvoir utiliser une base installer le driver associé.
npm install mongodb –save // pour utiliser une base mongodb.

//import du driver
var MongoClient = require('mongodb').MongoClient
//Connection a la base
MongoClient.connect('mongodb://localhost:27017/animals', function (err, db) {
if (err) throw err

db.collection('mammals').find().toArray(function (err, result) {
if (err) throw err

console.log(result)
})
})

une autre methode est d’acceder a la base en utilisant ce qu’on appel des ODM du style Mongoose nous aurons l’occasion d’y revenir.

 

Article2 : Mise en place d’un nouveau projet