是否像PHP一样，node.js或django是“请求驱动”的？

Question

To be honest I'm a Linux admin and haven't done web development in a few years. My tool of choice for making anything web of the past 10+ years has been LAMP.

I'm working on a REST API and I'm thinking of branching out. There are ways to do REST in PHP I know but maybe it's not the best way anymore.

The PHP model as far as I'm concerned goes like this:

• User makes request in their browser (or an AJAX call)
• PHP get's called up.
• PHP starts at the top and works it's way sequentially to the bottom, connecting to the DB, running queries, doing stuff, and outputting data.
• Request is over, the user has their data and is ready to make a new one.

With PHP each request is a new deal. There are no shared variables (you can pass things with cookies\\sessions) and once the script is done it is done.

While reading about Node's architecture it seems as if everything runs in this single threaded event loop. Does that mean node is "always running" and you can share variables between requests or is there a new event loop per request? Does that mean you can write sloppy code to block node from accepting new requests from other random users? Does Django operate similar? If that is the case is it possible to spawn new node processes per request?

That seems kind dangerous. In PHP you can write sloppy code that causes the single request to run slow but each request is kind of independent (system resources permitting). I also like the "do script and terminate" nature of PHP but maybe that is just an old school way of thinking.

I'm going to have a phone app\\website that passes data back and forth to an API to get information from a database (think an inventory management tool). I have clearly defined API calls and a front end dev just calls them as needed. I have various calls to get various bits of data.

Answer 1

All code works exactly the way you describe, because this is how the (traditional) web works. Request leads to a response. There is no context shared between requests. Each request is blocking on the client.

It works the same way for PHP, for Django and for everyone else since the days of CGI.

The difference is how the web server delegates these requests to the backend code. You have different models here; some involve multiple threads, others involve multiple processes of the backend code.

The only thing that is "always running" is the web server (or whatever process you have bound to a socket listening on port 80 in an infinite loop). Everything else is waiting for a request to come in.

Node is a runtime envrionment; you typically develop applications to run on top of node using a framework, such as express .

If you look at the basic hello world of express, you'll notice it runs an infinite loop listening for requests:

const express = require('express')
const app = express()

app.get('/', function (req, res) {
  res.send('Hello World!')
})

app.listen(3000, function () {
  console.log('Example app listening on port 3000!')
})

In the node world, there is one main event loop - but all i/o happens in separate non-blocking threads.

Each event is put on a queue, and the main loop processes things from this queue (image from the excellent software engineering daily ):

Therefore, you have to be careful when writing node applications because if you accidentally write a lot of blocking code - it will have a drastic impact on the rest of the application - unlike other architectures where you can get away with a bit of sloppiness since each process is separate and isolated.

Answer 2

I dont know about node (since I use python only) but I do know that DJANGO is request driven. (request driven I assume means that you must handle a request properly when stating a view function or else youll get an error.) also isn't this a little too broad

Answer 3

While reading about Node's architecture it seems as if everything runs in this single threaded event loop. Does that mean node is "always running" and you can share variables between requests or is there a new event loop per request?

Yes, node.js is a always running single thread. Its a loop that handles your requests and sends out responses. Compared to a LAMP setup: node.js is apache and php together.

Does that mean you can write sloppy code to block node from accepting new requests from other random users?

Yes, it does. You can share states between requests and you can block other requests, even worse you can kill the process completely, or display some personal data to other users. There are quite a few ways to shoot yourself in the foot with node.js. But on the other hand you can write terrific efficient applications in node.js and you can gain a lot of performance from the fact that you don't need to restart your whole app for every single request.

Answer 4

Does that mean you can write sloppy code to block node from accepting new requests from other random users?

Yup try, this :

const express = require('express')
const app = express()

app.get('/', function (req, res) {
    while(true){
    }
  res.send('Hello World!')
})
app.get('/ok', function (req, res) {
  res.send('ok!')
})

app.listen(3000, function () {
  console.log('Example app listening on port 3000!')
})

Access /ok , no biggie. Then access / which won't give you any answer back, then in another tab access /ok again, you can't. Node is still in the loop of / , blocking other users.

The obvious solution would be to not write sloppy code, but since you mention just starting out it could make you somewhat anxious. IE: you might not know what's good or bad. I'll argue that it is the same in any language.

So as you asked, can you run it in multiple process ? Yes.

To do so, I guess your imagination is the limit. For example, if your app has no state (you mentioned REST), you could run multiple servers, each listening on different port and route each request to an individual server.

There is also NodeCluster , although I don't use it, I guess that's what it helps doing.