阅读目录javascript
一：body-parser中间件html
一：body-parser中间件github
body-parser是一个HTTP请求体解析的中间件，该中间件的做用是解析客户端请求的body中的内容的，使用该模块能够解析JSON、Raw、文本、URL-encoded格式的请求体。web
如何使用？数据库
在项目的根目录下，执行命令，先下载 body-parser, 代码执行以下：express
npm install body-parser --save
基本使用以下：npm
1. 首先须要引入进来： const bodyParser = require('body-parser');
2. 而后再进行解析，目前支持以下四种格式的解析，以下：
1. 解析json数据：bodyParser.json(options)
2. 解析二进制格式(好比Buffer数据流这样的)：bodyParser.raw(options);
3. 解析文本数据： bodyParser.text(options);
4. 解析UTF-8的编码数据：bodyParser.urlencoded(options);
bodyParser.json(options); 它返回一个仅解析json格式数据的中间件。该方法支持任意Unicode编码的请求体，且支持gzip和deflate编码的数据压缩。
options参数有以下选项，及各选项的含义分别以下解析：
1）inflate: 该参数默认为true，deflate压缩数据被压缩，设置为false，压缩数据会被拒绝。
2）limit: 设置请求的最大数据量，默认为 '100kb'。
3）reviver： 传递给JSON.parse()方法的第二个参数。
4）strict: 默认为true，仅会解析Array和Object两种格式，若是设置为false的话，就会解析全部的JSON.parse支持的格式。
5）type: 该选项用于设置为指定MIME类型的数据使用当前解析的中间件。该选项能够是一个函数或一个字符串，若是是字符串的话会
使用type-is来查找MIME类型；若是是函数的话，中间件会经过fn(req)来获取实际值，默认为 application/json.
bodyParser.raw(options); 它是返回一个将全部数据为Buffer格式处理的中间件。其后全部的req.body中会是一个Buffer值。
options参数有以下选项，及各选项的含义分别以下解析：
1）inflate: 该参数默认为true，deflate压缩数据被压缩，设置为false，压缩数据会被拒绝。
2）limit: 设置请求的最大数据量，默认为 '100kb'。
3）type: 该选项用于设置为指定MIME类型的数据使用当前解析的中间件。该选项能够是一个函数或一个字符串，若是是字符串的话会
使用type-is来查找MIME类型；若是是函数的话，中间件会经过fn(req)来获取实际值，默认为 application/octet-stream.
bodyParser.text(options); 它是返回一个仅处理字符串格式处理的中间件。该req.body全部的将会是一个字符串值。
options参数有以下选项，及各选项的含义分别以下解析：
1）defaultCharset: 若是Content-Type没有指定编码的话，默认为 'utf-8'.
2）inflate: 该参数默认为true，deflate压缩数据被压缩，设置为false，压缩数据会被拒绝。
3）limit: 设置请求的最大数据量，默认为 '100kb'。
4）type: 该选项用于设置为指定MIME类型的数据使用当前解析的中间件。该选项能够是一个函数或一个字符串，若是是字符串的话会
使用type-is来查找MIME类型；若是是函数的话，中间件会经过fn(req)来获取实际值，默认为 application/octet-stream.
bodyParser.urlencoded(options) 解析UTF-8编码的数据，返回一个处理urlencoded数据的中间件。
options参数有以下选项，及各选项的含义分别以下解析：
1）extended - 当设置为false时，会使用querystring库解析URL编码的数据；当设置为true时，会使用qs库解析URL编码的数据。后没有指定编码时，使用此编码。默认为true。
2）inflate - 设置为true时，deflate压缩数据会被解压缩；设置为true时，deflate压缩数据会被拒绝。默认为true。
3）limit - 设置请求的最大数据量。默认为'100kb'
4）parameterLimit - 用于设置URL编码值的最大数据。默认为1000
5）type - 该选项用于设置为指定MIME类型的数据使用当前解析中间件。这个选项能够是一个函数或是字符串，当是字符串是会使用type-is来查找MIMI类型；当为函数是，中间件会经过fn(req)来获取实际值。默认为application/octet-stream。
如上bodyParser有四种方法来解析不一样的数据，可是在实际项目中，咱们是如何使用的呢？
Express框架默认是使用body-parser做为请求体解析中间件的。咱们能够在项目中的根目录下建立一个bodyParser.js代码以下：
所以在运行执行，咱们还须要安装express框架；安装命令以下：
npm install --save express
bodyParser.js 代码以下：
const express = require('express'); const bodyParser = require('body-parser'); const app = express(); // 对不一样的路由使用不一样的内容类型来解析
// 建立 application/json 解析
const jsonParser = bodyParser.json(); // 建立 application/x-www-form-urlencoded解析
const urlencodedParser = bodyParser.urlencoded({ extended: false }); // post /a 获取URL编码的请求体
app.post('/a', urlencodedParser, function(req, res) { if (!req.body) { return res.sendStatus(400); } console.log(req.body); res.send('welcome,' + req.body.userName); res.end(); }); // post /b 获取URL编码的请求体
app.post('/b', jsonParser, function(req, res) { if (!req.body) { return res.sendStatus(400); } res.send('welcome,' + req.body.userName); res.end(); }); const port = process.env.port || 3000; app.listen(port, () => { console.log('http://127.0.0.1:%s', port) });
如上代码，当咱们使用post请求 http://127.0.0.1:3000/a 请求的时候，他们使用的是 application/x-www-form-urlencoded格式来解析的，我这边使用postman来演示下，以下所示：
当咱们使用 post请求 http://127.0.0.01:3000/b 的时候，咱们使用的是 application/json格式来解析的，那么 Postman 以raw 方式发送JSON 数据，以下图所示：
注意：若是在模拟器上以非JSON格式发送，则会得到一个空的JSON对象。
注意：若是咱们 app.use(bodyParser.urlencoded({ extended: false })) 这样使用的话，那么它会全局使用全部的都是以 application/x-www-form-urlencoded 来进行解析的。若是单个路由使用了 格式来解析的话，那么使用的格式的优先级更高。
二：cookie-parser中间件
cookieParser中间件是用于获取web浏览器发送的cookie中的内容。由于http协议它是无状态的，用户从A页面跳转到B页面会发起http请求，当服务器端返回响应以后，当用户A继续访问其余页面的时候，服务器端没法获知该状态的，所以须要一个cookie来记录用户的状态。
至于http无状态的缘由，当初为何须要这么设计，官方文档是以下说明的：
1. HTTP最初的目的是为了提供一种发布和接收HTML页面的方法，那个时候只有纯粹静态HTML页面，所以不须要协议来保持状态。
2. 用户在收到响应的时候，通常会花一些时间来阅读页面，若是客户端和服务器端还保持链接的话，那么这个链接在大多数时候都将是空闲的，这是一种资源的浪费，所以HTTP最初的设计是短链接，即：客户端和服务端完成一次请求和响应以后就断开TCP链接，所以服务端没法知道客户端的下一个动做。
3. 这样设计也可使HTTP协议更加的相对简单，那么这种简单能够赋予HTTP更强的扩展能力，所以好比session就是一种协议扩展。或者后来出现了CGI动态技术等。
而正是由于HTTP不能保持状态的缘由，所以客户端会出现cookie来保存状态，及后面即将讲解的session。所以浏览器第一次向服务器发送请求，服务器会返回一个cookie给客户端浏览器，浏览器下一次发请求的时候，会把该cookie传递过去，所以服务器端就知道该cookie对应值，就能获取该状态的。
1) cookie是如何建立的？
express直接提供了对应的API，只要在响应中设置cookie便可，以下代码所示：
function(req, res, next) { res.cookie(name, value, [, options]); }
如上代码，express会将其填入 Response Header中的Set-Cookie中，达到浏览器中设置cookie的做用的。
如上参数 options 类型为一个对象，可使用的属性有以下：
domain: cookie在什么域名下有效，类型为String, 默认为网站的域名。
expires: cookie的过时时间，类型为Date, 若是没有设置或设置为0，那么该cookie只在这个会话中有校，关闭浏览器的话，那么cookie就会被浏览器删除。
httpOnly: 只能被web server访问。类型为布尔型(Boolean)
maxAge: 实现expires的功能，设置cookie的过时时间，类型为String，指明从如今开始，过多少毫秒之后，cookie到期。
path: cookie在什么路径下有校，默认为 '/'
secure: 只能被HTTPS使用，默认为false。
signed: 使用签名，默认为false。
通常简单的用法以下：
res.cookie('name', 'kongzhi', { domain: 'xxx.abc.com', path: '/', secure: true }); //cookie的有效期为900000ms
res.cookie('age', '30', { expires: new Date(Date.now() + 900000), httpOnly: true }); //cookie的有效期为900000ms
res.cookie('age', '30', { maxAge: 900000, httpOnly: true }); //cookie的value为对象
res.cookie('kongzhi1', { items: [1,2,3] }); res.cookie('kongzhi2', { items: [1,2,3] }, { maxAge: 900000 }); res.cookie('name', 'longen', { signed: true });
2）cookie是如何被删除的？
express也提供了api删除浏览器中的cookie，只须要调用对应的API便可，以下代码：
function(req, res, next) { res.clearCookie(name, [, options]); }
3) cookie-parser 读取cookie
在使用 cookie-parser 插件以前，咱们首先要安装该插件，运行命令以下：
npm install --save cookie-parser
使用的demo基本以下(在项目的根目录下新建 cookieParser.js, 代码以下)：
//引入cookieparser 框架，读取客户端发送的cookie const express = require('express'); const cookieParase = require('cookie-parser'); var app = express(); //若是没有，下面的req.cookies 会返回undefined app.use(cookieParase()); app.use('/', function (req,res) { res.cookie('user', 'kongzhi'); console.log(req.cookies); res.send('cookie我来了'); }); const port = process.env.port || 3001; app.listen(port, () => { console.log('http://127.0.0.1:%s', port) });
使用浏览器访问 http://127.0.0.1:3001/ 而后再看下控制台，能够看到以下读取到了：
下面咱们再来看个demo来理解使用cookie，首先须要有一个提交cookie的页面 cookie.html, 该页面显示一个 '提交cookie' 按钮，在用户点击该按钮后，客户端会建立一些cookie，而后使用 XMLHttpRequest对象向服务器端提交数据，该页面全部的cookie也会被提交上去，待接到服务器端响应数据后会将这些数据显示在页面中。
在项目的根目录中新建 cookie.html 代码以下：
<!DOCTYPE html> <html> <head> <title>cookie</title> <meta charset="utf-8"> <style> #result { font-size: 16px; } </style> </head> <body> <div id="app"> <form id="form1" method="post" action='index.html'> <input type="button" value="提交cookie" onclick="cookieTest()" /> </form> <div id="result"></div> </div> <script type="text/javascript"> function cookieTest() { var xhr = new XMLHttpRequest(); xhr.open('post', 'cookie.html', true); document.cookie = 'username=kongzhi'; document.cookie = 'age=30'; xhr.onload = function() { if (this.status === 200) { document.getElementById('result').innerHTML = this.response; } }; xhr.send(); } </script> </body> </html>
在项目中的根目录新建 testCookie.js 代码以下：
const express = require('express'); const cookieParase = require('cookie-parser'); const fs = require('fs'); const app = express(); app.use(cookieParase()); app.get('/cookie.html', function(req, res) { res.sendfile(__dirname + '/cookie.html'); }); app.post('/cookie.html', function(req, res) { for (const key in req.cookies) { res.write('cookie名：' +key); res.write(',cookie值为:'+req.cookies[key] + "<br/>"); } res.end(); }); const port = process.env.port || 3002; app.listen(port, () => { console.log('http://127.0.0.1:%s', port) });
而后咱们进入项目中的根目录运行 node testCookie.js ，接着浏览器访问 http://127.0.0.1:3002/cookie.html 后点击提交，
能够看到以下显示了。以下所示：
三：express-session 中间件
session中间件用于保存用户数据提供一个session管理器，它和cookie相似，都是记录用户状态的，而与cookie不一样的是：
cookie有以下限制：
1. cookie存储的大小最多为4kb。
2. cookie有域或路径的概念，而且最重要的一点是 cookie安全性很低，通常重要的信息，好比用户名和密码这样的不容许放入cookie里面的。
如上cookie有最主要上面两点的缺点，所以对于安全性的一些信息建议放到session上存储，session是保存到服务器上的。
session基本原理：当客户端向服务端请求时，会建立一个session标识(好比叫jsessionid)存在客户端的cookie当中,每次请求的时候服务器端首先会检查这个客户端的请求里面是否已经包含了一个session标识，若是已经包含了，那么服务器端就会根据该session标识把对应的数据检索出来，若是不包含的话，服务端会建立一个新的session标识传给客户端cookie中，之后客户端每次请求的时候，从cookie中获取该标识把它传递过来。
服务端执行session机制的时候会生成Session口令，在Tomcat默认会采用jsessionid这个值，可是在其余服务器上会有所不一样，好比Connect默认会叫 connect_uid, 虽然把一些敏感信息放到cookie当中是不可取的，可是将口令放在cookie中仍是能够的，若是口令被篡改了的话，就丢失了映射关系，也没法修改服务端存在的数据了，而且session的有效期是很是短的，通常为20分钟，若是在20分钟内客户端和服务器端没有产生交互，服务端会将数据删除掉。
express-session 是服务器端保存数据的中间件，安装命令以下所示：
npm install express-session --save
而后在js中引入后，再接着use便可，简单的代码以下：
const express = require('express'); const app = express(); const session = require('express-session'); app.use(session(options));
如上参数 options 值为一个对象，它有以下属性值：
key: String类型，用于指定用来保存session的cookie名称，默认为 connect.sid.
store: 属性值为一个用来保存session数据的第三方存储对象。
fingerprint: 属性值为一个自定义指纹生成的函数。
cookie: 属性值为一个用来指定保存session数据的cookie设置的对象，默认值为 {path: '/', httpOnly: true, maxAge: 14400000}, path是用于指定cookie保存的路径，httpOnly属性值用于指定是否只针对http保存的cookie，maxAge用于指定cookie的过时时间，单位为毫秒。
secret: 属性值为一个字符串，用来指定来对session数据进行加密的字符串。
下面咱们来和cookie同样，作一个简单的demo，来理解下使用 session的实列。
在页面中index.html 有一个form表单post提交数据，页面一访问的时候，监听get请求，给session设置数据，好比用户名和密码这样的，而后当我按钮提交post请求的时候，咱们在服务器端监听post请求，而后把刚刚保存的session数据打印出来，代码以下：
session.html 代码以下：
<!DOCTYPE html> <html> <head> <title>cookie</title> <meta charset="utf-8"> <style> #result { font-size: 16px; } </style> </head> <body> <div id="app"> <form id="form1" method="post" action='session.html'> <input type="submit" /> </form> <div id="result"></div> </div> </body> </html>
session.js 代码以下：
const express = require('express'); const fs = require('fs'); const app = express(); const cookieParase = require('cookie-parser'); const sessionParser = require('express-session'); app.use(cookieParase()); app.use(sessionParser({secret: 'test'})); app.get('/session.html', function(req, res) { res.sendfile(__dirname+'/session.html'); req.session.username = 'kongzhi111'; req.session.password = '123456'; }); app.post('/session.html', function(req, res) { console.log(req.session.username); console.log(req.session.password); res.end(); }); const port = process.env.port || 3003; app.listen(port, () => { console.log('http://127.0.0.1:%s', port) });
在命令行中，执行命令 node session.js, 而后在浏览器中 访问 http://127.0.0.1:3003/session.html ，点击按钮后，在命令行中打印以下信息，以下所示：
1）理解使用 http.IncomingMessage 中regenerate 方法从新生成一个session管理器
咱们也可使用 http.IncomingMessage对象的session属性值对象的 regenerate 方法从新生成一个session管理器，以下基本代码：
req.session.regenerate(function(err) {});
session.js 代码改为以下：
const express = require('express'); const fs = require('fs'); const app = express(); const cookieParase = require('cookie-parser'); const sessionParser = require('express-session'); app.use(cookieParase()); app.use(sessionParser({secret: 'test'})); app.get('/session.html', function(req, res) { res.sendfile(__dirname+'/session.html'); req.session.username = 'kongzhi111'; req.session.password = '123456'; req.session.regenerate(function(err) { if (err) { console.log('session从新初始化失败'); } else { console.log('session被从新初始化'); } }); }); app.post('/session.html', function(req, res) { console.log(req.session.username); console.log(req.session.password); res.end(); }); const port = process.env.port || 3003; app.listen(port, () => { console.log('http://127.0.0.1:%s', port) });
在页面浏览器访问 http://127.0.0.1:3003/session.html 后，命令行中会打印 以下所示：
而后点击提交后，命令中打印以下：
2）理解使用 http.IncomingMessage 中的destroy方法销毁当前在用的session管理器
destroy使用方式以下：
req.session.destroy(function(err) {});
session.js 代码改为以下：
const express = require('express'); const fs = require('fs'); const app = express(); const cookieParase = require('cookie-parser'); const sessionParser = require('express-session'); app.use(cookieParase()); app.use(sessionParser({secret: 'test'})); app.get('/session.html', function(req, res) { res.sendfile(__dirname+'/session.html'); req.session.username = 'kongzhi111'; req.session.password = '123456'; req.session.destroy(function(err) { if (err) { console.log('session销毁失败'); } else { console.log('session被销毁'); } }); }); app.post('/session.html', function(req, res) { console.log(req.session.username); console.log(req.session.password); res.end(); }); const port = process.env.port || 3003; app.listen(port, () => { console.log('http://127.0.0.1:%s', port) });
同理在浏览器中运行 http://127.0.0.1:3003/session.html 后，在命令行中看到以下信息：
而后当咱们点击按钮后，在命令行中看到以下信息：
3）查看http.IncomingMessage对象的session中保存cookie属性的全部信息
session代码以下：
const express = require('express'); const fs = require('fs'); const app = express(); const cookieParase = require('cookie-parser'); const sessionParser = require('express-session'); app.use(cookieParase()); app.use(sessionParser({secret: 'test', cookie: {maxAge: 3600000}})); app.get('/session.html', function(req, res) { res.sendfile(__dirname+'/session.html'); console.log(req.session.cookie); }); const port = process.env.port || 3003; app.listen(port, () => { console.log('http://127.0.0.1:%s', port) });
查看效果以下：
4）使用http.IncomingMessage对象session对象获取cookie的剩余时间
session.js 代码以下：
const express = require('express'); const fs = require('fs'); const app = express(); const cookieParase = require('cookie-parser'); const sessionParser = require('express-session'); app.use(cookieParase()); app.use(sessionParser({secret: 'test', cookie: {maxAge: 3600000}})); app.get('/session.html', function(req, res) { res.sendfile(__dirname+'/session.html'); var h = 3600000; req.session.cookie.expires = new Date(Date.now() + h); req.session.cookie.maxAge = h; setTimeout(function() { console.log('cookie的剩余时间'+req.session.cookie.maxAge); }, 5000); }); const port = process.env.port || 3003; app.listen(port, () => { console.log('http://127.0.0.1:%s', port) });
打印以下所示：
咱们最后再来看下浏览器请求头信息，以下：
请求头看到 服务器会返回 cookie 和 用于指定用来保存session的cookie名称，默认为 connect.sid， connect.sid 是session的签名，做用是知道session是否被修改过。
5）使用Express + session 实现用户登陆
当咱们登陆淘宝网站的时候，登陆成功后，咱们没有点击退出按钮或有效期没有过时的状况下，咱们把浏览器关闭掉，从新进入淘宝的首页会发现咱们的session会话还一直保持登陆状态，那么这个状态就是session帮咱们保存下来的。那么它在node中是如何实现的呢？
用户登陆的基本原理是：若是用户没有登陆或者登陆时用户名或密码错误的时候，那么服务器将该请求重定向到登陆页，或者的话就登陆成功，登陆成功后，服务器须要记录保存该客户端的登陆状态，那么下一次服务器请求主页的时候，会先判断客户端的登陆状态，若是登陆状态在
有效期内是有效的，就直接进入主页，不然的话，和以前同样会重定向到登陆页面。
下面如何使用session来作这件事的呢？
下面咱们须要以下目录结构
|-- demo1 # 项目根目录 | |--- login.html # 登陆页面 | |--- home.html # 主页 | |--- app.js # node服务端
至于 package.json 和项目是同目录的。下面先看下 login.html 代码以下：
<!DOCTYPE html> <html> <head> <title>expree+session实现用户登陆</title> <meta charset="utf-8"> </head> <body> <div id="app"> <form action="/login" method="post"> <p> <label>用户名：</label> <input type="text" name="username" /> </p> <p> <label>密码：</label> <input type="password" name="password" /> </p> <input type="submit" value="提交" /> </form> </div> </body> </html>
home.html 代码以下：
<!DOCTYPE html> <html> <head> <title>expree+session实现用户登陆</title> <meta charset="utf-8"> </head> <body> <div id="app"> <div> 用户名：<span><%= username %></span> <a href="/logout">退出登陆</a> </div> </div> </body> </html>
如上home.html 代码，使用了 <%= username %> 这样的语法，这个是ejs模板语法，所以咱们须要安装一下 ejs 以下命令安装：
npm install ejs --save
下面咱们再来看看服务器端 app.js 代码如何处理业务的，代码以下：
const express = require('express'); const app = express(); const session = require('express-session'); const bodyParser = require('body-parser'); const ejs = require('ejs').__express; app.set('views', __dirname); // 设置模板目录
app.set('view engine', 'html'); // 设置模板引擎为 html
app.engine('html', ejs); // 使用ejs模板引擎解析html文件中ejs语法
app.use(bodyParser.json()); // 使用 body-parser中间件 json形式
// 解析UTF-8编码的数据，返回一个处理urlencoded数据的中间件
app.use(bodyParser.urlencoded({ extended: true })); // 使用session中间件 设置cookie相关的信息
app.use(session({ secret: 'test', // 对 session id 相关的cookie 进行加密签名
cookie: { maxAge: 1000 * 60 * 1 // 设置 session的有效时间，单位为毫秒，设置有效期为1分钟
} })); // get 登陆页面
app.get('/login', (req, res) => { res.sendFile(__dirname + '/login.html'); }); // 监听post表单事件 用户登陆
app.post('/login', (req, res) => { // 这里没有链接数据库，因此用户名和密码假如是写死的，因此简单进行判断一下
if (req.body.username === 'kongzhi' && req.body.password === '123456') { req.session.username = req.body.username; // 登陆成功，把登陆信息保存到session里面去了
// 登陆成功后，进行重定向到首页
res.redirect('/'); } else { // 用户名或密码登陆错误
res.json({ 'code': 1, 'errorMsg': '帐户或密码错误' }); } }); // 处理重定向首页的逻辑代码
app.get('/', (req, res) => { // 若是session有已经登陆的用户名的话，且有效期有效的话，则到 home.html， 不然重定向到登陆页面
if (req.session.username) { res.render('home', {username: req.session.username}); } else { res.redirect('login'); } }); // 处理退出的逻辑
app.get('/logout', (req, res) => { req.session.username = null; // 删除session
// 重定向到登陆页面
res.redirect('login'); }); const port = process.env.port || 3004; app.listen(port, () => { console.log('http://127.0.0.1:%s', port) });
首先在命令行中 执行 node app.js ，而后在浏览器中访问 http://127.0.0.1:3004 后，以下所示：
当我输入正确的用户名和密码成功后，以下图所示：
session的有效期是1分钟，在1分钟以内无论如何刷新页面，都是在home.html页面，1分钟以后，session过时了，再刷新页面会自动跳转到登陆页面去了。这时候就须要从新登陆了。固然在home页面，你能够点击退出按钮，退出到登陆页面去。
四：理解使用morgan记录操做日志
morgan中间件是来记录详细的操做日志或错误日志的。
1）morgan 安装命令以下所示：
npm install --save morgan
2) 基本使用方式以下：
const express = require('express'); const app = express(); const morgan = require('morgan'); app.use(morgan(format, [, options]));
如上代码使用morgan, morgan(format, options);
参数 format（可选）该参数定义了几种日志格式，每种格式都有对应的名称，默认是default，详细有哪些格式，请看github官网(https://github.com/expressjs/morgan/#predefined-formats)
参数 options(可选)，包含 stream, skip, immediate
stream: 日志输出流配置，默认是 process.stdout
skip: 是否跳过日志记录，使用方式看github上(https://github.com/expressjs/morgan/#skip)
immediate: 布尔值，默认false，含义是在请求返回后，再记录日志，若是为true的话，含义是一收到请求，就记录日志。
1）下面咱们来看下简单的demo来理解下morgan的使用：
基本结构目录以下：
---morgan #项目的文件夹 |--- morgan.html # html文件 |--- morgan.js # js文件
morgan.html 代码以下：
<!DOCTYPE html> <html> <head> <title>morgan</title> <meta charset="utf-8"> </head> <body> <div id="app"> <form id="form1"> <input type="text" id="username" /> <input type="button" value='提交' onclick="clickFunc()"/> </form> <div id="result"></div> </div> <script type="text/javascript"> function clickFunc() { var obj = { username: document.getElementById('username').value }; var xhr = new XMLHttpRequest(); xhr.open('POST', 'morgan.html', true); xhr.onload = function(e) { if (this.status === 200) { document.getElementById('result').innerHTML = this.response; } }; xhr.send(JSON.stringify(obj)); } </script> </body> </html>
morgan.js 代码以下：
const express = require('express'); const morgan = require('morgan'); const app = express(); // 使用中间件，'combined' 是日志显示的格式，具体看github上(https://github.com/expressjs/morgan/#predefined-formats)
app.use(morgan('combined')); app.get('/morgan.html', (req, res) => { res.sendFile(__dirname + '/morgan.html'); }); // post 请求监听
app.post('/morgan.html', (req, res) => { req.on('data', (data) => { console.log(data.toString()); res.end(); }); }); const port = process.env.port || 3005; app.listen(port, () => { console.log('http://127.0.0.1:%s', port) });
当咱们在项目的对应目录下 执行 node morgan.js 会启动服务器，而后在浏览器中 http://127.0.0.1:3005/morgan.html中访问的时候，会打印出以下信息：
当咱们输入内容后，点击提交，会打印以下日志信息，以下所示：
2）如何将日志信息保存到文件内？
morgan提供了写入文件流将这些日志相关的信息保存到文件中，以下morgan.js代码改为以下：
const express = require('express'); const morgan = require('morgan'); const app = express(); const fs = require('fs'); const path = require('path'); const accessLogStream = fs.createWriteStream(path.join(__dirname, 'access.log')); // 使用中间件，'combined' 是日志显示的格式，具体看github上(https://github.com/expressjs/morgan/#predefined-formats)
app.use(morgan('combined', {stream: accessLogStream})); app.get('/morgan.html', (req, res) => { res.sendFile(__dirname + '/morgan.html'); }); // post 请求监听
app.post('/morgan.html', (req, res) => { req.on('data', (data) => { console.log(data.toString()); res.end(); }); }); const port = process.env.port || 3005; app.listen(port, () => { console.log('http://127.0.0.1:%s', port) });
如上代码，把日志信息写入文件中 在morgan.js 同级目录下会自动生成 access.log 日志文件。
上面全部的demo，能够到github上查看。