该文章为网络课 Introduction to MongoDB using the MEAN Stack学习笔记。
1.关于REST(Representational State Transfer)
1.1 什么是REST?
是一种编程模式，它通过HTTP来搭建客户端浏览器与服务器之间的通信。
It is a paradigm for a browser with a server over HTTP.
关于HTTP request，可以看做是三个方面的组合：
- Verb：e.g. GET/POST
- Resource：e.g. /home
- Body (optional)：e.g. JSON
当服务器收到HTTP request之后，会向客户端返回HTTP request，这其中可以包含很多信息，比如status，JSON等等。
1.2 三个基本方面
3 fundamental aspects of REST design pattern: client, server, resource
1.3 CRUD (Creat/Read/Update/Delete)
POST -> Create
GET -> Read
1.4 什么是endpoint/routes？
HTTP中使用的GET/user/42或者POST/user等被称之为endpoint/routes。创建REST API就是在创建能够让客户端javascript代码能够使用的endpoint/routes。
1.5 什么是RESTful ？
如果一个架构符合REST原则，就称它为RESTful架构。
总结一下什么是RESTful架构：
（1）每一个URI代表一种资源； -----> e.g. URLs
（2）客户端和服务器之间，传递这种资源的某种表现层； -----> e.g. data type
（3）客户端通过四个HTTP动词，对服务器端资源进行操作，实现"表现层状态转化"。 -----> method: GET/POST/PUT/DELETE
2. Express
2.1 是什么？
是用于启动一个HTTP Server的Node.js pakage。相当于是一个Web Application Framework允许设计者用Node.js来搭建server。
2.2 一个简单的Hello World例子
- package.json
"dependencies": {
"express": "4.12.3"
}
- server.js
var express = require('express');
var app = express(); // 创建一个express web app server
app.get('/', function(req, res) { // 创建一个routes为"/"的HTTP GET响应
res.send('Hello, world!'); //返回一个"Hello, world!"页面的响应
});
// 创建一个routes为"/user/:user"的HTTP GET响应
// :user表示user是一个可变的参数，可以利用req.params取到
// req.query.school可以取到HTTP中?之后的school对应的内容
app.get('/user/:user', function(req, res) {
res.send('Page for user ' + req.params.user + + ' with school ' + req.query.school);
});
app.listen(3000); //让这个server监听来自port3000的请求
console.log('Server listening on port 3000!');
- 结果
3. TDD (Test Driven Development)
思想：不需要浏览器来对server进行测试，利用一个叫做“superagent”的package来模拟浏览器发出的HTTP request，并接收HTTP response，然后利用类似常规mocha测试的方法进行测试。
package.json
{
"dependencies": {
"express": "4.12.3",
"mocha": "2.2.4",
"superagent": "1.2.0"
},
"scripts": {
"test": "mocha test.js"
}
}
- server.js
值得注意的是，由于此处重视的是测试，因此server上只写express的逻辑，并以一个函数的方式export出去，此处并不需要写对server的启动，即不需要写对port的监听。
var express = require('express');
module.exports = function() {
var app = express();
app.get('/', function(req, res) {
res.send('Hello, world!');
});
app.get('/user/:user', function(req, res) {
res.send('Page for user ' + req.params.user + ' with option ' +
req.query.option);
});
return app;
};
- test.js
对server的启动以及关闭由测试文件来执行。
var app = require('./server');
var assert = require('assert');
var superagent = require('superagent');
describe('server', function() {
var server;
beforeEach(function() {
server = app().listen(3000); //启动server
});
afterEach(function() {
server.close(); //关闭server
});
it('prints out "Hello, world" when user goes to /', function(done) {
// 创建一个对"http://localhost:3000/"的GET请求，并对响应进行测试
superagent.get('http://localhost:3000/', function(error, res) {
assert.ifError(error);
assert.equal(res.status, 200);
assert.equal(res.text, "Hello, world!");
done();
});
});
});
4. Dependency Injection
思想：相当于一种code isolation。对作用是initialization的代码与使用这些代码的代码进行隔离, 以此增加设计的灵活性。
例子
假设我们需要利用express中从客户端取到的数据对数据库进行操作，那么一个非常直观的做法是：
- 把mongoDB initialization setup的代码放在server.js的全局处，然后在routeHandler中使用从客户端取到的数据对mongoDB进行操作。
//全局scope: mongoDB setup
var mongoose = require('mongoose');
mongoose.connect('mongodb://localhost:27017/test');
var userSchema = new mongoose.Schema({
name: String
});
var User = mongoose.model('User', userSchema);
//express
var express = require('express');
var app = express();
app.get('/user/:user', function(req, res) {
//利用id来查user并以JSON可是作为响应
User.findOne({ _id: req.params.id }, function(error, user) {
res.json({ user: user });
});
});
app.listen(3000);
console.log('Server listening on port 3000!');
这样做的弊端是：当需要用不同的数据库是，我不仅需要改动全局scope中数据库的setup代码，我还需要改动express中的routeHandler代码。当express中逻辑比较复杂的时候，这样的改动就显得很cumbersome。
- 利用一个名叫"wagner-core"的包裹来对数据库setup工作进行封装，写成“service”。
var express = require('express');
var mongoose = require('mongoose');
var wagner = require('wagner-core');
// Dependency Injection： setupModels 和 setupApp的代码被隔离开
setupModels(mongoose, wagner);
var app = express();
setupApp(app, wagner);
app.listen(3000);
console.log('Listening on port 3000!');
//对 model的set up不再是全局scope，而是在一个函数中的局部scope
function setupModels(mongoose, wagner) {
mongoose.connect('mongodb://localhost:27017/test');
var userSchema = new mongoose.Schema({
name: String
});
var User = mongoose.model('User', userSchema);
wagner.factory('User', function() { // 在wagner中定义以个名叫“User”的Service
return User;
});
}
function setupApp(app, wagner) {
//虽然setupApp中的代码与setupModel中的scope并不一样
//但利用wagner.invoke来引入定义了的service，因此setupApp中的代码可以在这个scope中得到利用
var routeHandler = wagner.invoke(function(User) {
return function(req, res) {
User.findOne({ _id: req.params.id }, function(error, user) {
res.json({ user: user });
});
};
});
app.get('/user/:id', routeHandler);
}
这样的好处在于：
- setup的代码不需要在全局scope也可以在express的routeHandler中得到使用。这是一种closure的概念，User是函数routeHandler的closure，相当于虽然User并不在routeHandler的scope里面，但是却可以用它，想到与routeHandler closes User。
- 对setup代码的改动可以反映到express的代码中，而express得代码并不需要动。比如要换一个数据库，只需要改动setupModel中的代码。
