深入理解Node.js中通用基础设计模式

谈到设计模式，你可能会想到 singletons, observers（观察者） 或 factories（工厂方法）。本文不并专门探讨他们。只是探讨node.js一些基础模式的实现，像依赖注入或中间件。

什么是设计模式？

设计模式是用来解决一般的，普遍发生的问题，且可重复使用的解决方案。

singletons （单例）

singletons模式限制了“类”，只有一个实例。在node.js的创建单例是非常简单的，比如下面这个require。

//area.js
var pi = math.pi;
function circle (radius) { 
 return radius * radius * pi;
}
module.exports.circle = circle; 

你引用多少次都没有关系;它将只存在一个单一的实例。

var areacalc = require('./area');
console.log(areacalc.circle(5)); 

由于 require 的这种实现，单例可能在npm模块中最常见的node.js设计模式。

observers（观察者）

一个维护了侦听/观察列表的对象，当状态改变时会自动通知他们。为了实现观察者模式，eventemitter就派上用场了。

// myfancyobservable.js
var util = require('util'); 
var eventemitter = require('events').eventemitter;
function myfancyobservable() { 
 eventemitter.call(this);
}
util.inherits(myfancyobservable, eventemitter); 

就是这个;我们实现了一个可观察的对象！为了用它，让我们添加一些方法吧。

myfancyobservable.prototype.hello = function (name) { 
 this.emit('hello', name);
};

太好了，试试侦听并响应这个事件！

var myfancyobservable = require('myfancyobservable'); 
var observable = new myfancyobservable();
observable.on('hello', function (name) { 
 console.log(name);
});
observable.hello('john'); 

factories (工厂方法)

工厂模式是一种创建者模式，不需要我们使用构造函数，它提供用于创建对象的通用接口。这种模式可以用于生成创建过程非常复杂的对象。

function myclass (options) { 
 this.options = options;
}
function create(options) { 
 // modify the options here if you want
 return new myclass(options);
}
module.exports.create = create; 

工厂可以让测试更简单，因为你可以在里面注入依赖关系。

dependency injection 依赖注入

依赖注入是将其中的一个或多个依赖（或服务）注入，或通过引用传递到从属对象的设计模式。

在这个例子中，我们将创建一个的usermodel它获取数据库的依赖。

function usermodel (options) { 
 var db;
 if (!options.db) {
  throw new error('options.db is required');
 }
 db = options.db;
 return {
  create: function (done) {
   db.query('insert ...', done);
  }
 }
}
module.exports = usermodel; 

现在，我们利用它创建一个实例：

var db = require('./db');
var usermodel = require('user')({ 
 db: db
});

它为什么有用呢？它使测试变得更容易 - 当你写单元测试时，你可以把假的数据库实例注入模型。

middlewares/pipelines 中间件/管道

中间件是一个强大功能且简单的概念：一个功能单元的输出是下一个功能单元的输入。如果你用过express那么你已经使用了这个模式。

我们看一看 koa 是如何做的:

app.use = function(fn){ 
 this.middleware.push(fn);
 return this;
};

所以基本上，当你添加一个中间件时，它只是被压入一个中间件队列中。但是当一个请求到达这个服务器会发生什么？

var i = middleware.length; 
while (i--) { 
 next = middleware[i].call(this, next);
}

没什么神奇的 - 你的中间件被一个接着一个调用了。

streams

你可以把流作为特殊的管道。他比较适合处理大量数据流，即他们是字节，而不是对象。

process.stdin.on('readable', function () { 
  var buf = process.stdin.read(3);
  console.dir(buf);
  process.stdin.read(0);
});

总结

以上所述是小编给大家介绍的node.js中通用基础设计模式，希望对大家有所帮助