Implement routing function in nodejs_node.js

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:

Copy code The code is as follows:

function start(){
console.log("Request handler 'start' was called.");
                         
Function sleep(milliSeconds){
        var startTime=new Date().getTime();                                        ​​​​​while(new Date().getTime() Sleep(10000);
Return "Hello Start";
}
function upload(){
console.log("Request handler 'upload' was called.");
Return "Hello Upload";
}

exports.start=start;
exports.upload=upload;

In this way, we can connect the request handler and the routing module so that the routing "has a path to follow". After that, we determined that a series of request handlers will be passed through an object, and this object needs to be injected into the router() function using a loose coupling method. The main file index.js:

Copy code The code is as follows:

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);

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:

Copy code The code is as follows:

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 passed as the first parameter to the route() callback function. Route.js is defined below:

Copy code

The code is as follows: 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 function directly. 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: