使用中间件模式,让代码和 ExpressJS, ReduxJS 一样容易扩展

tidelgl 发布于 2016年12月23日
无人欣赏。

ExpressJS 和 ReduxJS 的易扩展性正是得益于应用了中间件的设计模式。如果想在自己平日的项目里使用,可以试试 Middleware.js 这个中间件工具,它能使任意对象中间件化,用好中间件能有效解藕代码也易于维护。

MiddlewareJS 已发布到GitHub

Readme

Apply middleweare to an object.

Middleware functions are functions that have access to the target function and it's arguments, and the target object and the next middleware function in the target function cycle. The next middleware function is commonly denoted by a variable named next.

Middleware functions can perform the following tasks: - Execute any code. - Make changes to the function's arguments. - End the target function. - Call the next middleware in the stack.

If the current middleware function does not end the target function cycle, it must call next() to pass control to the next middleware function. Otherwise, the target function will be left hanging.

API

.use(methodName, ...middlewares)

Apply middleware to the target object. If the first argument is a middleware object, the rest arguments must be middleware objects. - {string|object} methodName String for target function name, object for a middleware object. - {...function} middlewares The middleware chain to be applied. - return {object} this

Usages

Basic

We define a Person class. ``` // the target object class Person { // the target function walk(step) { this.step = step; }

speak(word) { this.word = word; } } ``` Then we define a middleware function to print log.

// middleware for walk function const logger = target => next => (...args) => { console.log(`walk start, steps: ${args[0]}.`); const result = next(...args); console.log(`walk end.`); return result; } Now we apply the log function as a middleware to a Person instance.

// apply middleware to target object const p = new Person(); const applyMiddleware = new ApplyMiddleware(p); applyMiddleware.use('walk', walk); p.walk(3); Whenever a Person instance call it's walk method, we'll see logs from the looger middleware.

Middleware object

We can also apply a middleware object to a target object. Middleware object is an object that contains function's name as same as the target object's function name. Function's name start or end with "_" will not be able to apply middleware.

``` const PersonMiddleware { walk: target => next => (step) => { console.log(walk start, steps: step.); const result = next(step); console.log(walk end.); return result; }, speak: target => next => (word) => { word = 'this is a middleware trying to say: ' + word; return next(word); } }

// apply middleware to target object const p = new Person(); const applyMiddleware = new ApplyMiddleware(p); applyMiddleware.use(PersonMiddleware); p.walk(3); p.speak('hi'); ```

middlewareMethods

Or we can use middlewareMethods to define function names for middleweare target within a class.

``` class CuePointMiddleware { constructor() { /** * Define function names for middleweare target. * @type {Array} */ this.middlewareMethods = ['walk', 'speak']; } log(text) { console.log('Middleware log: ' + text); } walk(target) { return next => (step) => { this.log(walk start, steps: step.); const result = next(step); this.log(walk end.); return result; } } speak(target) { return next => (word) => { this.log('this is a middleware tring to say: ' + word); return next(word); } } }

// apply middleware to target object const p = new Person(); const applyMiddleware = new ApplyMiddleware(p); applyMiddleware.use(new PersonMiddleware()) p.walk(3); p.speak('hi'); ```

共1条回复
brambles 回复于 2016年12月24日

嗯,作为一个 “黑科技”,这项东西想法不错。但是作为常规科技,这东西设计得其实还是有问题的。不知道做这是不是单纯因为不想加新依赖进来,所以采用这种 “侵入式” 的设计。其实这种 “侵入式” 的设计会改变原对象的行为从而使得程序变得不可控。

如果是我设计的话,我习惯给它加上一次层代理来避免直接修改原对象而带来的不可控。当然使用上就会更为冗长一些。

登录 或者 注册
相关帖子