Implement routing function in nodejs

When I first started learning Node, I discovered a situation that was completely different from my previous views - what is JavaScript used for in your eyes? Special effects? or just interaction with the client? It can be said that JavaScript first ran in the browser. However, if you think about it this way, the browser just provides you with a context (context), which defines what can be done using JavaScript. It can be thought of as a similar enterprise. It defines what you can do here, but doesn't say much about what the JavaScript language itself can do. In fact, as a complete language, JavaScript can be used in different contexts and reflect different capabilities. The Nodejs mentioned here actually provides a context, a running environment, which allows JavaScript code to be run on the backend (out of the browser environment).

The core of routing selection is routing. As the name suggests, routing means that we have different processing methods for different URLs, such as processing the business logic of /start and processing the business of /upload module; the logic is inconsistent . In a realistic implementation, the routing process will "end" in the routing module, and the routing module is not the module that actually "takes action" on the request, otherwise it will not be available when our application becomes more complex. Nice extension.

Here we first create a module called requestHandlers, and add a placeholder function to each request handler:

function start(){   
    console.log("Request handler 'start' was called.");   
       
    function sleep(milliSeconds){   
        var startTime=new Date().getTime();   
        while(new Date().getTime()<startTime+milliSeconds);   
    }   
    sleep(10000);   
    return "Hello Start";   
}   
function upload(){   
    console.log("Request handler &#39;upload&#39; was called.");   
    return "Hello Upload";   
}   
  
exports.start=start;   
exports.upload=upload;

So that we can connect the request handler and the routing module, Let the route "have a path to follow". After that, we determined to pass a series of request handlers through an object, and we need to use a loose coupling method to inject this object into the router() function. The main file index.js:

var server=require("./server");   
var router=require("./router");   
var requestHandlers=require("./requestHandlers");   
  
var handle={};   
handle["/"]=requestHandlers.start;   
handle["/start"]=requestHandlers.start;   
handle["/upload"]=requestHandlers.upload;   
  
server.start(router.route,handle);

is as shown above, Mapping different URLs to the same request handler is easy: just add a property with the key "/" to the object corresponding to requestHandlers.start. In this way, we can simply configure that requests for /start and / are handled by the start handler. After completing the definition of the object, we pass it to the server as an additional parameter, see server.js:

var http=require("http");   
var url=require("url");   
  
function start(route,handle){   
    function onRequest(request,response){   
        var pathname=url.parse(request.url).pathname;   
        console.log("Request for "+pathname+" received.");   
           
        route(handle,pathname);   
           
        response.writeHead(200,{"Content-Type":"text/plain"});   
        var content=route(handle,pathname);   
        response.write(content);   
        response.end();   
    }   
    http.createServer(onRequest).listen(8888);   
    console.log("Server has started.");   
}    
exports.start=start;

In this way, the handle parameter is added to the start() function, and the handle object is used as the first A parameter is passed to the route() callback function. Route.js is defined below:

function route(handle,pathname){   
    console.log("About to route a request for "+ pathname);   
    if(typeof handle[pathname]==='function‘){   
        return handle[pathname]();   
    }else{   
        console.log("No request handler found for "+pathname);   
        return "404 Not Found";   
    }   
}   
exports.route=route;

Through the above code, we first check whether the request handler corresponding to the given path exists, and if it exists, call the corresponding one directly. The function. We can get the request processing function from the passed object in the same way as getting elements from the associative array, that is, handle[pathname](); such an expression gives people the feeling of saying "Hi, please Come and help me deal with this path." The running effect of the program is as follows:

For more articles related to the routing function in nodejs, please pay attention to the PHP Chinese website!