NodeJS의 다음 이벤트 처리기에 요청 보내기

Question

요청에 대한 특정 매개 변수를 기록하고 온라인으로 확인할 수있는 페이지에 인쇄 할 수있는 모듈을 만들려고 시도하면 페이지에 socket.io을 사용하여 최신 로그.

그리고이 모듈을 플러그인으로 사용하여이 모듈을 호출하고 초기화하면 추가 입구 점 /_logger이 응용 프로그램에 추가됩니다. 일단 페이지를 방문하면 최신 로그가됩니다. 실시간으로 업데이트됩니다. 그래서 모듈은 요청을 가로 챌 수 있습니다

function setup(httpServer) { 
    //page 
    httpServer.on("request", function (request, response) { 
     var pathname = url.parse(request.url).pathname; 
     if (pathname === '/_logger') { 
      fs.readFile(__dirname + '/logger.html', (err, data) => { 
       response.writeHead(200, { 'Content-Type': 'text/html' }); 
       response.write(data); 
       response.end(); 
      }); 
     }else{ 
      // how to give up the control for this requset 
     } 
    }); 


    var io = require('socket.io')(httpServer); 
    io.on('connection', function (socket) { 
     //TO BE DONE 
     socket.on('event', function (data) { }); 
     socket.on('disconnect', function() { }); 
    }); 
} 
module.exports = { 
    setup: setup 
} 

사용법 :

var logger= require("./logger/index"); 
var server = require('http').createServer(); 
logger.setup(server); 
server.on("request", function(req,res){ 
    //Normal logic for different application 
}); 
server.listen(3333); 

지금 문제가 요청 된 URL이 없습니다 /_logger되면, 나는이 요청의 제어를 해제해야한다는 것입니다.

 if (pathname === '/_logger') { 
      //take control 
     }else{ 
      // Nothing should be done here, it should go to the next request chain. 
     } 

문서를 읽은 후, 나는 올바른 방법을 찾을 수 없습니다.

아이디어가 있으십니까?

Answer 1

낮은 수준의 NodeJS HTTP API를 사용한다고 가정합니다. 함수 구성을 사용하여 여러 핸들러를 하나의 핸들러로 구성 할 수 있습니다. 각 처리기는 req.url이 일치하지 않으면 다음 처리기로 실행을 생성해야합니다.

var http = require('http'); 

var handler1 = function(req, res) { 
    res.writeHead(200, { 'Content-Type': 'text/html' }); 
    res.write('/'); 
    res.end(); 
} 

var handler2 = function(req, res) { 
    res.writeHead(200, { 'Content-Type': 'text/html' }); 
    res.write('/Hello'); 
    res.end(); 
} 

var middleware = compose([wrapHandler('/', handler1), 
         wrapHandler('/hello', handler2)]); 

http.createServer(middleware).listen(3000); 

function wrapHandler(path, cb) { 
    return function (req, res, next) { 
     if (req.url === path) { 
      cb(req, res); 
     } else { 
      next(); 
     } 
    }; 
} 

function notFoundHandler(req, res) { 
    res.writeHead(404, { 'Content-Type': 'text/html' }); 
    res.write('No Path found'); 
    res.end();  
}; 

// adapted from koa-compose 
function compose(middleware) { 
    return function (req, res){ 
     let next = function() { 
      notFoundHandler.call(this, req, res); 
     }; 

     let i = middleware.length; 
     while (i--) { 
      let thisMiddleware = middleware[i]; 
      let nextMiddleware = next; 
      next = function() { 
       thisMiddleware.call(this, req, res, nextMiddleware); 
      } 
     } 
     return next(); 
    } 
} 

귀하의 경우 귀하가 작성할 수 있습니다.

var loggerHandler = wrapHandler('/_logger', logger.handler); 
httpServer.on('request', compose(loggerHandler, handler2, handler3)); 

Answer 2

httpServer.on("request", ...)은 하나의 요청 수신기입니다. 요청할 필요가 없다면 요청을 처리 할 의무가 없습니다. 아무것도 수행하지 않더라도 다른 요청 청취자는 여전히이 요청을 알립니다.

다른 요청 청취자 (있는 경우)가 있으면 요청한 청취자에서 아무 것도하지 않고 다른 청취자도 특정 요청을받을 수 있습니다. 이렇게하면 자신의 요청 리스너를 작동중인 http 서버에 추가 할 수 있으며 리스너는 지원하려는 새 라우트에만주의를 기울여야하며 다른 모든 라우트는 무시할 수 있으며 다른 리스너에 의해 처리됩니다 이미 자리에 있습니다.

---

이 두 가지를 더 간단하게 만들고 더 잘 제어 할 수 있도록 프레임 워크가 있습니다. 일반적으로 이러한 프레임 워크는 하나의 리스너를 사용하며 사용자가 요청을 처리 할 수있는 방법을 제공합니다. 또는 프레임 워크에 요청을 처리하지 않았으며 다른 라우트 처리기가 요청을 처리하도록 요청합니다. 이것은 여러 청취자를 보유하는 것보다 유연합니다. 모두 동일한 경로를 통보 받게됩니다.

예를 들어, 익스프레스 프레임 워크를 사용하여, 당신은이 작업을 수행 할 수 있습니다

var express = require('express'); 
var app = express(); 

// route handler for/request only when a user=xxx is in the query string 
app.get('/', function(req, res, next) { 
    // if user was included in query parameter 
    if (req.query.user) { 
     // do something specific when ?user=xxxx is included in the URL 
    } else { 
     // pass handling to the next request handler in the chain 
     next(); 
    } 
}); 

// route handler for/request that wasn't already handled 
app.get('/', function(req, res) { 
    // handle the/route here 
}); 

app.listen(80);