基于路由动态加载 Node.js 模块 | 基于路由动态加载

本文介绍了基于路由动态加载 Node.js 模块的处理方法，对大家解决问题具有一定的参考价值，需要的朋友们下面随着小编来一起学习吧！

问题描述

我正在使用 express 在 Node.js 中做一个项目.这是我的目录结构:

I'm doing a project in Node.js using express. Here's my directory structure:

root
|-start.js
|-server.js
|-lib/
|    api/
|        user_getDetails.js
|        user_register.js

lib/api/ 目录中有许多与 API 相关的 JS 文件.我需要做的是创建一种挂钩系统，每当从快速 HTTP 服务器请求一个 API 函数时，它就会执行相应 API 处理程序中指定的任何操作.这可能令人困惑，但希望你能明白.

The lib/api/ directory has a number of JS files relating to the API. What I need to do is make a sort of hooking system, that whenever one of the API functions gets requested from the express HTTP server, it does whatever action is specified in the according API handler. It's probably confusing, but hopefully you get the idea.

Larry 通过 POST 发送请求以获取用户详细信息.
服务器在 lib/api 中查找与该请求关联的函数.
服务器执行操作并将数据发送回 Larry.

Larry sends request via POST to get user details.
Server looks in lib/api to find the function associated with that request.
Server carrys out action and sends back data to Larry.

希望你能帮助我.我认为可以使用原型来完成，但不确定.

Hopefully you can help me out. I was thinking it could be done using prototypes, not sure though.

谢谢！

推荐答案

如果你知道你的脚本在哪里，即你有一个初始目录，例如 DIR，那么你可以使用 fs，例如:

If you know where your scripts are, i.e. you have an initial directory, for example DIR, then you can work with fs, for example:

server.js

var fs = require('fs');
var path_module = require('path');
var module_holder = {};

function LoadModules(path) {
    fs.lstat(path, function(err, stat) {
        if (stat.isDirectory()) {
            // we have a directory: do a tree walk
            fs.readdir(path, function(err, files) {
                var f, l = files.length;
                for (var i = 0; i < l; i++) {
                    f = path_module.join(path, files[i]);
                    LoadModules(f);
                }
            });
        } else {
            // we have a file: load it
            require(path)(module_holder);
        }
    });
}
var DIR = path_module.join(__dirname, 'lib', 'api');
LoadModules(DIR);

exports.module_holder = module_holder;
// the usual server stuff goes here

现在您的脚本需要遵循以下结构(因为require(path)(module_holder) 行)，例如:

Now your scripts need to follow the following structure (because of the require(path)(module_holder) line), for example:

user_getDetails.js

function handler(req, res) {
    console.log('Entered my cool script!');
}

module.exports = function(module_holder) {
    // the key in this dictionary can be whatever you want
    // just make sure it won't override other modules
    module_holder['user_getDetails'] = handler;
};

现在，在处理请求时，您可以:

and now, when handling a request, you do:

// request is supposed to fire user_getDetails script
module_holder['user_getDetails'](req, res);

这应该将所有模块加载到 module_holder 变量.我没有测试它，但它应该可以工作(错误处理除外！！！).您可能想要更改此函数(例如，使 module_holder 成为一棵树，而不是一层字典)，但我认为您会掌握这个想法.

This should load all your modules to module_holder variable. I didn't test it, but it should work (except for the error handling!!!). You may want to alter this function (for example make module_holder a tree, not a one level dictionary) but I think you'll grasp the idea.

这个函数应该在每次服务器启动时加载一次(如果你需要更频繁地启动它，那么你可能正在处理动态服务器端脚本，这是一个 baaaaaad 想法，恕我直言).您现在唯一需要的是导出 module_holder 对象，以便每个视图处理程序都可以使用它.

This function should load once per server start (if you need to fire it more often, then you are probably dealing with dynamic server-side scripting and this is a baaaaaad idea, imho). The only thing you need now is to export module_holder object so that every view handler can use it.

这篇关于基于路由动态加载 Node.js 模块的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持！