Question

构建我的第一个HAPI api后端，并遇到了一些奇怪的事情。当我第一次点击端点时（GET / api / item / {name}，我可以在我的控制台中看到正在运行处理程序函数（mongo查询），然后发送回复（有响应插件）记录那些）。很好。如果我用另一个参数再次点击端点，我会看到第一个呼叫的响应立即消失，然后处理器函数被命中。实际上，客户端也是如此从第一次通话开始回复。

我甚至不确定在这里发帖会有什么帮助。

这是大多数入口点js（缺少环境和winston的配置）：

const Hapi = require('hapi');
server = new Hapi.Server();

var mongo_connect = 'mongodb://' + options.mongo_creds + options.mongo_host + ':' + options.mongo_port + '/' + options.mongo_db;
const dbOpts = {
    url: mongo_connect,
    settings: {
        poolSize: options.mongo_pool
    },
    decorate: true
};

server.connection({ port: options.server_port });

var routes = require('./routes');

if (options.env === "dev") {
    server.on('response', function (request) {
        winston.log('verbose', `[launch_api] ${request.info.remoteAddress}: ${request.method.toUpperCase()} ${request.url.path} --> ${request.response.statusCode}`);
    });
}

server.register({
    register: require('hapi-mongodb'),
    options: dbOpts
}, function(err) {
    if (err) {
        winston.log('error', "[launch_api] Unable to register db pool");
        throw err;
    }

    server.route(routes);

    server.start(function(err) {

        if (err) {
            throw err;
        }
        winston.log('info', `[launch_api] Server running at: ${server.info.port}`);
    });
});

路由在routes文件夹中的index.js中被拉到一起，但每个文件看起来像：

'use strict';
var controller = require('../controllers/item-controller')

// Routes for Item

module.exports = [
    {
        method: 'POST',
        path: '/api/item',
        config: controller.create
    },
    {
        method: 'GET',
        path: '/api/items',
        config: controller.fetchAll
    },
    {
        method: 'GET',
        path: '/api/item/{name}',
        config: controller.find
    }
];

控制器看起来都是这样的（只是为了简洁而显示查找功能，因为这已经很长了）

const Boom = require('boom');
const Joi = require('joi');
const Item = require('../models/item');

module.exports = {
    find: {
        handler: function(request, reply) {
            Item.initFromName(request.params.name).then( function(newItem) {
                if (newItem == null) {
                    reply(Boom.notFound());
                }
                else {
                    reply(newItem);
                }
            }, function(err) {
                reply(Boom.badImplementation());
            });
        }
    }
}

最后，模型倾向于遵循这个呃模型（同样，切掉所有的原型扩展，只保留这个路线中的一个类功能）

const deferred = require('deferred')()
const winston = require('winston');

const collection_name = "items";


var Item = function() {
    this.name = "";
    this.description = "";
};

// private

function fillFromDB(obj, record) {
    obj._id = record._id;
    obj.name = record.name;
    obj.description = record.description;
}

// Constructor
module.exports.init = function() {
    return new Item();
};

module.exports.initFromName = function(name) {
    var item = new Item();
    const db = server.mongo.db;
    db.collection(collection_name).findOne({name: name}).then( function(opResult) {
            winston.log("debug","Item.loadFromName opResult is: " + opResult);
        if (opResult != undefined) {
            winston.log("debug","Item.loadFromName opResult json is: " + JSON.stringify(opResult));
            fillFromDB(item, opResult);
            deferred.resolve(item);
        } 
        else {
            winston.log("debug","Resolving with null" );
            deferred.resolve();
        }
    }, function(err) {
        winston.log("error", "Item.loadFromName mongo error: " + err);
        deferred.reject();
    });
    return deferred.promise;
};

所有这一切，如果我使用curl命名集合中存在 not 的名称来点击我的端点，我会得到404预期。如果我用一个名字命中，我仍然得到404。

此输入：

$ curl -X GET http://192.168.99.100:3000/api/item/not_here
{"statusCode":404,"error":"Not Found"}
$ curl -X GET http://192.168.99.100:3000/api/item/here
{"statusCode":404,"error":"Not Found"}

生成此日志：

debug: Item.loadFromName opResult is: null
debug: Resolving with null
verbose: [launch_api] 192.168.99.1: GET /api/item/not_here --> 404
verbose: [launch_api] 192.168.99.1: GET /api/item/here --> 404
debug: Item.loadFromName opResult is: [object Object]
debug: Item.loadFromName opResult json is: {"_id":"58b622908ea4d1cee2f46462","name":"here","description":"this item is here"}

请注意，相反的方向也有效。如果我停止并启动节点，然后使用现有名称命中端点，则所有后续调用都将返回相同的对象。我无法弄清楚这个缓存发生在哪里。

Answer 1

问题是延迟对象的全局实例化。不确定我在哪里看到它，但这是一个坏主意。

在模型中，将第一行更改为require

const deferred = require('deferred');

然后，在函数中创建你的延迟对象。

module.exports.initFromName = function(name) {
    const defer = deferred();
    var item = new Item();
    const db = server.mongo.db;
    db.collection(collection_name).findOne({name: name}).then( function(opResult) {
            winston.log("debug","Item.loadFromName opResult is: " + opResult);
        if (opResult != undefined) {
            winston.log("debug","Item.loadFromName opResult json is: " + JSON.stringify(opResult));
            fillFromDB(item, opResult);
            defer.resolve(item);
        } 
        else {
            winston.log("debug","Resolving with null" );
            defer.resolve();
        }
    }, function(err) {
        winston.log("error", "Item.loadFromName mongo error: " + err);
        defer.reject();
    });
    return defer.promise;
};

在后续调用的处理程序之前发送HAPI回复

1 个答案: