Použitie middleware

Express je webový framework s minimálnou vlastnou funkcionalitou: Express aplikácia je v podstate séria volaní middleware funkcií.

Middleware funkcie sú funkcie, ktoré majú prístup k request objektu (req), response objektu (res) a nasledujúcej middleware funkcii v request-response cykle aplikácie. Nasledujúca middleware funkcia v poradí je bežne označovaná premennou next.

Middleware funkcie dokážu vykonávať nasledujúce úlohy:

• Vykonať akýkoľvek kód.
• Vykonať zmeny na request a response objektoch.
• Ukončiť request-response cyklus.
• Zavolať nasledujúcu middleware funkciu v poradí.

Ak aktuálna middleware funkcia neukončuje request-response cyklus, musí posunúť obsluhu nasledujúcej middleware funkcii vyvolaním next(). V opačnom prípade zostane request ‘visieť’.

Express aplikácia môže použiť nasledovné typy middleware funkcií:

• Application-level middleware
• Router-level middleware
• Error-handling middleware
• Built-in middleware
• Third-party middleware

Application-level a router-level middleware môžete načítať s voliteľnou cestou (path-om). Môžete taktiež načítať skupinu middleware funkcií dohromady, čím vytvoríte sub-stack middleware systém na danej ceste.

Application-level middleware

Pripojte application-level middleware k inštancii app objektu použitím app.use() a app.METHOD() funkcií, kde METHOD je typicky HTTP metóda requestu, ktorý mddleware funkcia handluje (ako napr. GET, PUT, či POST) zapísaná v lowercase formáte.

Nasledujúci príklad ukazuje middleware funkciu, ktorá nie je pripojená na žiaden path. Funkcia bude vykonaná vždy, keď aplikácia obdrží request.

var app = express();

app.use(function (req, res, next) {
  console.log('Time:', Date.now());
  next();
});

Nasledujúci príklad ukazuje middleware funkciu pripojenú na ceste /user/:id. Funkcia bude vykonaná vždy, keď aplikácia održí request na /user/:id a to bez ohľadu na typ použitej HTTP metódy.

app.use('/user/:id', function (req, res, next) {
  console.log('Request Type:', req.method);
  next();
});

Nasledujúci príklad ukazuje route a jej handler funkciu (middleware systém). Táto funkcia handluje GET requesty na ceste /user/:id.

app.get('/user/:id', function (req, res, next) {
  res.send('USER');
});

Tu je príklad načítania skupiny middleware funkcií pripojených na konkrétnu cesty. Príklad ilustruje sub-stack middleware, ktorý vypíše info o requeste pre všetky typy HTTP requestov vykonaných na /user/:id.

app.use('/user/:id', function(req, res, next) {
  console.log('Request URL:', req.originalUrl);
  next();
}, function (req, res, next) {
  console.log('Request Type:', req.method);
  next();
});

Route handlery dovoľujú definovať viacero route-ov pre jednu cestu. Nasledujúci príklad definuje dva routy pre GET requesty na ceste /user/:id. Definovanie druhého route nespôsobí žiadne problémy, ale ani sa nikdy nezavolá, pretože prvý route ukončí request-response cyklus.

Tento príklad zobrazuje middleware sub-stack ktorý handluje GET requesty na ceste /user/:id.

app.get('/user/:id', function (req, res, next) {
  console.log('ID:', req.params.id);
  next();
}, function (req, res, next) {
  res.send('User Info');
});

// handler for the /user/:id path, which prints the user ID
app.get('/user/:id', function (req, res, next) {
  res.end(req.params.id);
});

Ak chcete preskočiť zostávajúce middleware funkcie z router middleware stack-u, zavolajte next('route') čím posuniete obsluhu ďalšiemu route. POZNÁMKA: next('route') zafunguje iba v takých middleware funkciách, ktoré boli načítané pomocou app.METHOD() alebo router.METHOD() funkcií.

Tento príklad zobrazuje middleware sub-stack, ktorý handluje GET requesty na ceste /user/:id.

app.get('/user/:id', function (req, res, next) {
  // if the user ID is 0, skip to the next route
  if (req.params.id == 0) next('route');
  // otherwise pass the control to the next middleware function in this stack
  else next(); //
}, function (req, res, next) {
  // render a regular page
  res.render('regular');
});

// handler for the /user/:id path, which renders a special page
app.get('/user/:id', function (req, res, next) {
  res.render('special');
});

Router-level middleware

Router-level middleware funguje rovnakým spôsobom ako application-level middleware, avšak je pripojený k express.Router() inštancii.

var router = express.Router();

Router-level middleware načítate pomocou router.use() a router.METHOD() funkcií.

Nasledujúci príklad replikuje vyššie zobrazený application-level middleware použitím router-level middlewaru:

var app = express();
var router = express.Router();

// a middleware function with no mount path. This code is executed for every request to the router
router.use(function (req, res, next) {
  console.log('Time:', Date.now());
  next();
});

// a middleware sub-stack shows request info for any type of HTTP request to the /user/:id path
router.use('/user/:id', function(req, res, next) {
  console.log('Request URL:', req.originalUrl);
  next();
}, function (req, res, next) {
  console.log('Request Type:', req.method);
  next();
});

// a middleware sub-stack that handles GET requests to the /user/:id path
router.get('/user/:id', function (req, res, next) {
  // if the user ID is 0, skip to the next router
  if (req.params.id == 0) next('route');
  // otherwise pass control to the next middleware function in this stack
  else next(); //
}, function (req, res, next) {
  // render a regular page
  res.render('regular');
});

// handler for the /user/:id path, which renders a special page
router.get('/user/:id', function (req, res, next) {
  console.log(req.params.id);
  res.render('special');
});

// mount the router on the app
app.use('/', router);

Error-handling middleware

Error-handling middleware funkcie sa definujú rovnako ako ostatné middleware funkcie, len majú štyri argumenty namiesto troch, špecificky podľa signatúry (err, req, res, next):

app.use(function(err, req, res, next) {
  console.error(err.stack);
  res.status(500).send('Something broke!');
});

Pre viac informácií ohľadom error-handling middlewarov si pozrite sekciu: Error handling.

Built-in middleware

Express počnúc od verzie 4.x nie je závislý na Connect module. Okrem výnimky express.static, všetky predošlé middleware funkcie pôvodne obsiahnuté v Express sú teraz samostatné moduly. Zoznam middleware funkcií si pozrite tu.

Jediným vstavaným middlewarom v Express je express.static funkcia. Tento middleware je založený na serve-static module a je zodpovedný za servovanie statických assetov ako HTML súbory, obráky atď.

Signatúra tejto funkcie je:

express.static(root, [options])

Parameter root špecifikuje hlavný adresár z ktorého bude statický obsah servovaný.

Informácie ohľadom options parametra ako i ďalšie detaily ohľadom tohto middleware nájdete tu: express.static.

Tu je príklad použitia express.static middleware funkcie s rôznou konfiguráciou options objektu:

var options = {
  dotfiles: 'ignore',
  etag: false,
  extensions: ['htm', 'html'],
  index: false,
  maxAge: '1d',
  redirect: false,
  setHeaders: function (res, path, stat) {
    res.set('x-timestamp', Date.now());
  }
}

app.use(express.static('public', options));

Môžete nastaviť aj viac ako jeden priečinok so statickým obsahom:

app.use(express.static('public'));
app.use(express.static('uploads'));
app.use(express.static('files'));

Pre viac detailov ohľadom serve-static funkcie a jej možnostiach si pozrite dokumentáciu k serve-static modulu.

Third-party middleware

V Express aplikácii možete využiť taktiež third-party middleware funkcionalitu.

Nainštalujte požadovaný Node.js modul a načítajte ho do aplikácie ako aplikačný, či router middleware.

Nasledujúci príklad demonštruje inštaláciu a načítanie middleware funkcie cookie-parser slúžiacej na prácu s cookies.

$ npm install cookie-parser

var express = require('express');
var app = express();
var cookieParser = require('cookie-parser');

// load the cookie-parsing middleware
app.use(cookieParser());

Čiastočný zoznam bežne používaných third-party middleware funkcií pre Express nájdete v sekcii: Third-party middleware.