Ausführliche Erklärung von Express.JS use_node.js

Erstellen Sie nach der Installation von Node (Download) ein Verzeichnis auf Ihrem Computer und starten Sie Ihre erste Anwendung.

$ mkdir hello-world

In diesem Verzeichnis definieren Sie Anwendungspakete, die sich nicht von anderen Knotenpaketen unterscheiden. Die JSON-Datei im Dateiverzeichnis definiert eindeutig eine Abhängigkeit. Sie können den Befehl npm verwenden, um die neueste Version von Express zu erhalten, je nachdem, was Sie bevorzugen, anstatt eine andere Version als „3.x“ zu installieren, um unbekannte Überraschungen zu vermeiden.

{
 
"name": "hello-world",
 
"description": "hello world test app",
 
"version": "0.0.1",
 
"private": true,
 
"dependencies": {
  "express": "3.x"
}
}

Jetzt haben Sie ein Paket. json-Datei in diesem Verzeichnis können Sie npm(1) verwenden, um diese Abhängigkeit zu installieren. Geben Sie in diesem Fall einfach Folgendes ein:

$ npm install

Sobald npm abgeschlossen ist, haben Sie eine Express 3.x-Abhängigkeit im Verzeichnis /node_modules. Sie können dies mit npm ls überprüfen, da das folgende Snippet den Express-Baum und seine eigenen Abhängigkeiten zeigt.

$ npm ls
hello-world@0.0.1 /private/tmp
└─┬ express@3.0.0beta7
 ├── commander@0.6.1
 ├─┬ connect@2.3.9
 │ ├── bytes@0.1.0
 │ ├── cookie@0.0.4
 │ ├── crc@0.2.0
 │ ├── formidable@1.0.11
 │ └── qs@0.4.2
 ├── cookie@0.0.3
 ├── debug@0.7.0
 ├── fresh@0.1.0
 ├── methods@0.0.1
 ├── mkdirp@0.3.3
 ├── range-parser@0.0.4
 ├─┬ response-send@0.0.1
 │ └── crc@0.2.0
 └─┬ send@0.0.3
  └── mime@1.2.6

Jetzt erstellen Sie die Anwendung selbst! Erstellen Sie eine Datei mit dem Namen app.js oder server.js, je nachdem, was Sie bevorzugen, importieren Sie express und verwenden Sie dann express(), um eine neue Anwendung zu erstellen:

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

Neue Anwendungsinstanzen können mit der Definition von Routen über app.VERB() beginnen und in diesem Fall auf eine „GET/“-Anfrage mit der Zeichenfolge „Hello World“ antworten. req und res sind genau die gleichen Knotenobjekte, die Ihnen zur Verfügung gestellt werden. Sie können also res.pipe(), req.on('data', callback) und andere Dinge aufrufen, die nichts mit Express zu tun haben.

Express erweitert diese Objekte, um Ihnen Schnittstellen auf höherer Ebene wie res.send() zur Verfügung zu stellen und zusätzlich die Inhaltslänge für Sie hinzuzufügen:

app.get('/hello.txt', function(req, res){
 res.send('Hello World');
});

Rufen Sie nun die Methode app.listen() auf, damit die Verbindung gebunden und überwacht werden soll, und akzeptieren Sie dabei die gleichen Parameter wie der net.Server #listen() des Knotens:

var server = app.listen(3000, function() {
  console.log('Listening on port %d', server.address().port);
});

Verwenden Sie express(1), um die Anwendung zu generieren

Das Express-Team unterhält einen praktischen Projektgenerator namens express-generator(1). Wenn Sie Express-Generator global mit npm installieren, können Sie von überall auf Ihrem Computer darauf zugreifen:

$ npm install -g express-generator

Dieses Tool bietet eine einfache Möglichkeit, ein Anwendungs-Framework zu erhalten, ist jedoch in seinem Umfang begrenzt. Es unterstützt beispielsweise nur wenige Template-Engines, während Express selbst tatsächlich die Erstellung beliebiger Website-Framework-Vorlagen für Node unterstützt. Kann über die Hilfe angezeigt werden:

Usage: express [options]
Options:
 -h, --help     output usage information
 -V, --version    output the version number
 -e, --ejs      add ejs engine support (defaults to jade)
 -H, --hogan     add hogan.js engine support
 -c, --css  add stylesheet support (less|stylus|compass) (defaults to plain css)
 -f, --force     force on non-empty directory

Wenn Sie eine Anwendung erstellen möchten, die jede Situation unterstützt, müssen Sie nur Folgendes ausführen::

$ express --css stylus myapp
create : myapp
create : myapp/package.json
create : myapp/app.js
create : myapp/public
create : myapp/public/javascripts
create : myapp/public/images
create : myapp/public/stylesheets
create : myapp/public/stylesheets/style.styl
create : myapp/routes
create : myapp/routes/index.js
create : myapp/views
create : myapp/views/index.jade
create : myapp/views/layout.jade

install dependencies:
$ cd myapp && npm install

run the app:
$ DEBUG=myapp node app

Wie bei jeder anderen Knotenanwendung müssen Sie die folgenden Abhängigkeiten installieren:

Dann fangen wir an.

$ npm start

Das ist alles, was Sie brauchen, um eine einfache App zum Laufen zu bringen. Denken Sie daran, dass Express nicht an eine bestimmte Verzeichnisstruktur gebunden ist. Diese dienen lediglich als Orientierung. Auswahlmöglichkeiten für Anwendungsstrukturen können in den Beispielen im Github-Repository eingesehen werden.

Fehlerbehandlung

Fehlerbehandlungs-Middleware ist wie gewöhnliche Middleware definiert, muss jedoch die Anzahl von 4 Parametern definieren. Dies ist die Funktionssignatur (err, req, res, next):

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

Obwohl die obligatorische Fehlerbehandlungs-Middleware am Ende normalerweise nicht definiert ist, lautet ihr Aufruf nach anderem app.use() wie folgt:

var bodyParser = require('body-parser');
var methodOverride = require('method-override');
app.use(bodyParser());
app.use(methodOverride());
app.use(app.router);
app.use(function(err, req, res, next){
 // logic
});

Antworten in diesen Middlewares sind völlig willkürlich. Möglicherweise möchten Sie mit einer HTML-Fehlerseite, einer einfachen Nachricht, einer JSON-Zeichenfolge oder einer anderen gewünschten Antwort antworten.

Um ein organisiertes und übergeordnetes Framework aufzubauen, können Sie mehrere dieser Fehlerbehandlungs-Middlewares definieren, genau wie Sie normale Middleware definieren würden. Angenommen, Sie möchten einen Fehlerhandler für XHR-Anfragen definieren. Darüber hinaus können Sie Folgendes tun:

var bodyParser = require('body-parser');
var methodOverride = require('method-override'); 

app.use(bodyParser());
app.use(methodOverride());
app.use(app.router);
app.use(logErrors);
app.use(clientErrorHandler);
app.use(errorHandler);

In allgemeineren logErrors können Sie Anforderungs- und Fehlermeldungen an stderr, loggly oder ähnliche Dienste schreiben:

function logErrors(err, req, res, next) {
 console.error(err.stack);
 next(err);
}

Die Definition von clientErrorHandler lautet wie folgt. Beachten Sie, dass dieser Fehler explizit an den nächsten übergeben wird.

function clientErrorHandler(err, req, res, next) {
 if (req.xhr) {
  res.send(500, { error: 'Something blew up!' });
 } else {
  next(err);
 }
}

Die folgende „Allround“-Implementierung von errorHandler kann wie folgt definiert werden:

function errorHandler(err, req, res, next) {
 res.status(500);
 res.render('error', { error: err });
}

Anzahl der Online-Benutzer

In diesem Abschnitt wird ausführlich eine (kleine) Anwendung erläutert, die Redis verwendet, um die Anzahl der Online-Benutzer zu verfolgen. Erstellen Sie zunächst ein Paket. Die JSON-Datei enthält zwei Anhänge, einen für den Redis-Client und einen für Express selbst. Stellen Sie außerdem sicher, dass Redis über $redis-server verpackt ist und ausgeführt wird.

{
 "name": "app",
 "version": "0.0.1",
 "dependencies": {
  "express": "3.x",
  "redis": "*"
 }
}

Als nächstes müssen Sie eine Anwendung und eine Verbindung zu Redis erstellen:

var express = require('express');
var redis = require('redis');
var db = redis.createClient();
var app = express();

Die nächste Middleware verfolgt Online-Benutzer. Hier verwenden wir einen sortierten Satz, sodass wir Online-Benutzer über Redis abfragen können, was nur N Millisekunden dauert. Wir nutzen Zeitstempel als „Online-Standard“ für Mitglieder. Beachten Sie, dass wir hier die User-Agent-Zeichenfolge anstelle der üblichen Benutzer-ID verwenden.

app.use(function(req, res, next){
 var ua = req.headers['user-agent'];
 db.zadd('online', Date.now(), ua, next);
});

Die nächste Middleware besteht darin, zrevrangebyscore zu verwenden, um im letzten Moment die maximale Anzahl von Online-Benutzern zu ermitteln. Wir erhalten immer den aktuellsten Online-Benutzer, und seine Obergrenze ist der aktuelle Zeitstempel minus 60000 Millisekunden.

app.use(function(req, res, next){
 var min = 60 * 1000;
 var ago = Date.now() - min;
 db.zrevrangebyscore('online', '+inf', ago, function(err, users){
  if (err) return next(err);
  req.online = users;
  next();
 });
});

最后,我们通过一个url使用它,并绑定到一个端口!这就完了,在一个新浏览器访问这个应用程序,您会看到在线人数增加。

app.get('/', function(req, res){
 res.send(req.online.length + ' users online');
});

app.listen(3000);

Expree的反向代理

在反向代理背后使用Expree,如Varnish 或Nginx是微不足道的,然而它需要配置。通过启用“信任代理”设置app.enable(“trust proxy”),Express有一些反向代理的技巧，X-Forwarded - *头字段可能是可信的,否则他们可能很容易被欺骗。

启用该设置有一些微妙的影响。第一个是X-Forwarded-Proto可能被反向代理设定，告诉app那是https或者只是简单的http。这个值由req.protocol反射。

第二个变化是req.ip和req.ips值将填充X-Forwarded-For地址的列表。

调试Express

Express内部使用调试模块记录路径匹配和应用程序模式的信息。要看到这条信息,只要简单设置调试环境变量为express:*,当启动应用程序后，你将在控制台看以调试信息。

$ DEBUG=express:* node ./bin/www

运行这个hello world示例将打印以下内容：

express:application booting in development mode +0ms
express:router defined get /hello.txt +0ms
express:router defined get /hello.txt +1ms

另外, 表达可执行(生成器)生成的程序也使用调试模块,默认作用域是my-application调试命名空间。

你可以用以下命令启用这些调试语句

$ DEBUG=my-application node ./bin/www

关于调试的更多信息,请参见调试 指南