journey由cloudhead编写，模块下载地址https://github.com/cloudhead/journey

这几天在看别人的一个web service的实现，看到journey这个模块，感觉这个模块挺实用的，就拿过来仔细学习一下。
这个模块的功能虽然不是很复杂，但却完全按照事件驱动的思想来实现，作为nodejs的学习代码，感觉还是很有帮助的。如果你是在学习事件驱动的设计思想或者对nodejs还不是很熟的话，可以和我一起来了解这个模块。

一个使用journey模块的示例程序https://github.com/indexzero/nodejs-intro/tree/master/lib/01routing

journey模块是一个主要用来路由请求的模块。通过自定义自己的请求路由规则，可以将发往服务器的请求进行不同的处理。
路由的功能我们自己也能实现，为什么要使用journey这个模块呢？
这是因为journey封装了许多路由的细节，只暴露一些对设置规则的接口，所以使用journey模块只需要把注意力集中在路由规则上就可以了。其次，journey还提供了过滤器（filter），可以在服务器路由请求前拦截请求进行处理。

使用:

/*

 * service.js: Defines the web service for the Pinpoint module.

 *

 * © 2011 Charlie Robbins

 * MIT LICENSE

 *

 /



var journey = require(‘journey’),



//创建一个新的请求路由

exports.createRouter = function (resource) {

  var router = new (journey.Router)({

    strict: false,

    strictUrls: false,

    api: 'basic’,

    filter: helpers.auth.basicAuth

  });



//说明请求上的公共路径

  router.path(//bookmarks/, function () {



//设置过滤器

    this.filter(function () {



//把GET请求绑定到相应函数上

      this.get().bind(function (res) {});



//满足正则表达式的GET请求绑定在相应函数上

      this.get(//([\w|\d|-|_]+)/).bind(function (res, id) { });



//绑定POST请求

      this.post().bind(function (res, bookmark) { });



//绑定PUT请求

      this.put(//([\w|\d|-|_]+)/).bind(function (res, id, bookmark) {});



//绑定DEL请求

      this.del(//([\w|\d|-|_]+)/).bind(function (res, id) { });

    });

  });



  return router;

};

exports.createServer = function (port, database) {

      router = service.createRouter(resource);



  var server = http.createServer(function (request, response) {

    var body = '’;



…



      var emitter = router.handle(request, body, function (route) {

        response.writeHead(route.status, route.headers);

        response.end(route.body);

      });



…



    })

  });



  if (port) {

    server.listen(port);

  }



  return server;

};

journey.Router = function Router(options) {

    var that = this;



    this.routes = [];

    this.options = mixin({}, journey.options, options || {});



    if (this.options.extension) {

        this.options.extension = this.options.extension.replace('.’, ‘\.’);

    }

};



function mixin(target) {

    var args = Array.prototype.slice.call(arguments, 1);



    args.forEach(function (a) {

        var keys = Object.keys(a);

        for (var i = 0; i < keys.length; i++) {

            target[keys[i]] = a[keys[i]];

        }

    });

    return target;

}

journey.Router.prototype = {

    //

    // Define the routing table

    //

    map: function (routes) {

        // Calls the function in the context of this instance,

        // so it can be used to define routes on this.

        routes.call(this, this);

    },

    paths: [],

    required: [],



    filter: function (/ variable arguments /) {

        var args = Array.prototype.slice.call(arguments),

            map = (typeof(args[args.length - 1]) === ‘function’) && args.pop(),

            filter = args.pop() || this.options.filter;



        this.required.push(filter);

        map.call(this, this);

        this.required.pop();

    },



    get:  function (pattern, opts) { return this.route('GET’,    pattern, opts) },

    put:  function (pattern, opts) { return this.route('PUT’,    pattern, opts) },

    post: function (pattern, opts) { return this.route('POST’,   pattern, opts) },

    del:  function (pattern, opts) { return this.route('DELETE’, pattern, opts) },



    route: function (/ variable arguments /) {

        if (arguments[0].headers) { throw new(Error)(“Router#route method renamed to 'handle’”) }



        var that = this, route,

            args = Array.prototype.slice.call(arguments).filter(function (a) { return a }),

            // Defaults

            pattern     = this.paths.length ? ‘’ : /./,

            ignoreCase  = false,

            method      = journey.Router.methods.slice(0),

            constraints = [],

            extension   = this.options.extension ? '(?:’ + this.options.extension + ')?’ : '’;



        Array.prototype.push.apply(constraints, this.required);



        args.forEach(function (arg) {

            if (journey.Router.methods.indexOf(arg) !== -1 || Array.isArray(arg)) {

                method = arg;

            } else if (typeof(arg) === “string” || arg.exec) {

                pattern = arg;

            } else {

                throw new(Error)(“cannot understand route.”);

            }

        });



        if (typeof(pattern) === “string”) {

            pattern = escapeRe(pattern);

        } else {

            // If we’re in a nested path, ‘/i’ doesn’t mean much,

            // as we concatinate strings and regexps.

            ignoreCase = this.paths.length || pattern.ignoreCase;

            pattern = pattern.source;

        }

        // Trim trailing and duplicate slashes and add ^$ markers

        pattern = ‘^’ + this.paths.concat(pattern ? [pattern] : [])

                                  .join(‘/’)

                                  .match(/^^?(.*?)$?$/)[1]       // Strip ^ and $

                                  .replace(/^(/|\/)(?!$)/, ‘’)  // Strip root / if pattern != ‘/’

                                  .replace(/(/|\/)+/g, ‘/’) +   // Squeeze slashes

                                  extension;

        pattern += this.options.strictUrls ? ‘$’ : '\/?$’;     // Add optional trailing slash if requested

        pattern = new(RegExp)(pattern, ignoreCase ? ‘i’ : ‘’);



        this.routes.push(route = {

            pattern: pattern,

            method: Array.isArray(method) ? method : [method],

            constraints: constraints

        });



        return {

            bind: function (handler) {

                route.handler = handler;

                return route;

            },

            ensure: function (handler) {

                route.constraints.push(handler);

                return this;

            },

            filter: function (handler) {

                return this.ensure(handler || that.options.filter);

            }

        };

    }

  }