Serwer HTTP w Node.js: http.createServer z przykładami

http.createServer() tworzy serwer WWW z jednej funkcji, handlera żądań, którą Node wywołuje przy każdym przychodzącym żądaniu z dwoma obiektami: req (metoda, URL i nagłówki wysłane przez klienta) i res (to, co odsyłasz). Ustaw na res kod statusu i nagłówki, a potem wywołaj res.end() z body. server.listen(3000) zaczyna przyjmować połączenia na porcie 3000.

const http = require('http');

const server = http.createServer((req, res) => {
    console.log(req.method, req.url);
    res.statusCode = 200;
    res.setHeader('Content-Type', 'text/plain');
    res.end(`You asked for ${req.method} ${req.url}`);
});

// GET /hello?name=Ada
server.listen(3000, () => {
    console.log('Listening on port 3000');
});

Pierwsze żądanie odpowiada You asked for GET /hello?name=Ada, a Console loguje tę samą metodę i URL. Wyślij DELETE /anything z paska żądania: odpowiada ten sam handler, bo zwykły serwer http nie ma tras. Każde żądanie przechodzi przez tę jedną funkcję.

Wysyłanie JSON i ustawianie kodu statusu

res.writeHead(status, headers) ustawia kod statusu i nagłówki w jednym wywołaniu. Dla JSON ustaw Content-Type: application/json i wyślij wynik JSON.stringify(); res.end() przyjmuje tylko string albo Buffer.

const http = require('http');

const users = [
    { id: 1, name: 'Ada' },
    { id: 2, name: 'Linus' },
];

function sendJson(res, status, data) {
    res.writeHead(status, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify(data));
}

const server = http.createServer((req, res) => {
    const url = new URL(req.url, 'http://localhost');
    const limit = Number(url.searchParams.get('limit')) || users.length;

    if (req.method === 'GET' && url.pathname === '/users') {
        return sendJson(res, 200, users.slice(0, limit));
    }
    sendJson(res, 404, { error: 'Not found' });
});

// GET /users?limit=1
server.listen(3000);

GET /users?limit=1 zwraca [{"id":1,"name":"Ada"}]. req.url to ścieżka plus query string, więc new URL(req.url, 'http://localhost') dzieli go na pathname i searchParams (baza jest tylko dlatego, że URL wymaga adresu absolutnego). Wyślij GET /nothing, a status zmieni się na 404.

Routing żądań przez switch

Małe API nie potrzebuje niczego poza switch po metodzie i ścieżce. Zbuduj klucz, np. 'GET /users', i daj każdej trasie własny case:

const http = require('http');

const users = [{ id: 1, name: 'Ada' }];

function sendJson(res, status, data) {
    res.writeHead(status, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify(data));
}

function readBody(req) {
    return new Promise((resolve, reject) => {
        let data = '';
        req.on('data', (chunk) => {
            data += chunk;
        });
        req.on('end', () => resolve(data));
        req.on('error', reject);
    });
}

const server = http.createServer(async (req, res) => {
    const { pathname } = new URL(req.url, 'http://localhost');

    switch (`${req.method} ${pathname}`) {
        case 'GET /users':
            return sendJson(res, 200, users);

        case 'POST /users': {
            let body;
            try {
                body = JSON.parse(await readBody(req));
            } catch {
                return sendJson(res, 400, { error: 'Body must be JSON' });
            }
            const user = { id: users.length + 1, name: body.name };
            users.push(user);
            return sendJson(res, 201, user);
        }

        default:
            sendJson(res, 404, { error: `No route for ${req.method} ${pathname}` });
    }
});

// GET /users
server.listen(3000);

Wyślij POST /users z body {"name": "Grace"}: odpowiedź to 201 z {"id":2,"name":"Grace"}, a GET /users wypisuje teraz obu użytkowników. Wyślij ten sam POST z body hello, a dostaniesz 400 z {"error":"Body must be JSON"}.

Odczyt body żądania POST

Node nie parsuje body za ciebie. req to strumień do odczytu, a body przychodzi kawałkami przez zdarzenia data, potem, gdy jest kompletne, pojawia się end. readBody() powyżej zbiera kawałki w string i zwraca promise, więc handler może na niego poczekać przez await. Ponieważ req jest async iterable, ta pętla robi to samo:

let data = '';
for await (const chunk of req) data += chunk;
const body = JSON.parse(data);

Prawdziwy serwer dodatkowo ogranicza rozmiar (przestaje czytać i odpowiada 413, gdy data.length przekroczy limit) i sprawdza req.headers['content-type'] przed wywołaniem JSON.parse.

Częste błędy

Zapominanie o res.end(). Gałąź, która ustawia status, ale nigdy nie kończy odpowiedzi, zostawia klienta czekającego do timeoutu.

Ustawianie nagłówka po body. Gdy wykona się res.end() albo pierwsze res.write(), nagłówki są już wysłane, a res.setHeader() rzuca ERR_HTTP_HEADERS_SENT. Używaj return, gdy wysyłasz odpowiedź wcześniej, jak w przykładach.

Porównywanie req.url ze ścieżką. req.url zawiera query string, więc req.url === '/users' daje false dla /users?limit=1. Porównuj pathname.

Kiedy lepiej użyć Express

Moduł http wystarczy do health checka, odbiornika webhooków albo nauki tego, jak działa HTTP. Gdy potrzebujesz parametrów trasy, np. /users/:id, parsowania body w JSON, middleware i obsługi błędów, kończysz z własnym małym frameworkiem. Express to właśnie taki framework, zbudowany na tych samych obiektach req i res; routing w Express pokazuje to samo API z app.get() i app.post().