Az első HTTP-szerver Node-dal

1Az első szerver — hat sor

Hozz létre egy új projektet (az 1. blokk 3. fejezetéből ismert módon), és benne egy szerver.js fájlt:

import http from "node:http";

const server = http.createServer((keres, valasz) => {
  valasz.end("Szia a szerverről!");
});

server.listen(3000, () => {
  console.log("A szerver fut: http://localhost:3000");
});

Futtatás:

node --watch szerver.js

Amit látnod kell:

A szerver fut: http://localhost:3000

Nyisd meg a böngészőben a http://localhost:3000 címet — megjelenik a szöveg.

Mi micsoda?

2Mi fut le egyszer, mi minden kérésnél?

Ez a fejezet legfontosabb gondolata — sokan itt csúsznak el.

console.log("1. Ez a program indulásakor fut le, EGYSZER.");

const server = http.createServer((req, res) => {
  console.log("3. Ez MINDEN KÉRÉSNÉL lefut újra.");
  res.end("ok");
});

server.listen(3000, () => {
  console.log("2. Ez is egyszer, amikor a szerver elindult.");
});

Indítás után a terminálban:

1. Ez a program indulásakor fut le, EGYSZER.
2. Ez is egyszer, amikor a szerver elindult.

…és a program nem lép ki. Vár. Amikor megnyitod a böngészőben:

3. Ez MINDEN KÉRÉSNÉL lefut újra.
3. Ez MINDEN KÉRÉSNÉL lefut újra.

A szerver nem „fut le”, hanem fut. Egy hagyományos program elindul, dolgozik, kilép. A szerver elindul, és vár — a listen() hívás után a Node életben tartja a folyamatot, mert tudja, hogy kérésekre kell figyelnie. Leállítás: Ctrl + C.

3A kérés: mit tudunk meg?

A req objektumból három dolog érdekel minket most:

const server = http.createServer((req, res) => {
  console.log("Metódus:", req.method);        // GET, POST, PUT…
  console.log("Útvonal:", req.url);           // /api/products?categoryId=3
  console.log("Fejlécek:", req.headers);      // objektum: { host: …, accept: … }
  res.end("ok");
});

Ha a http://localhost:3000/api/products?categoryId=3&page=2 címet hívod meg, a terminálban ez jelenik meg:

Metódus: GET
Útvonal: /api/products?categoryId=3&page=2

Amire figyelj

4A válasz: hogyan válaszolunk?

Egy HTTP-válasz három részből áll (1. blokk, 2. fejezet): státuszkód, fejlécek, törzs. Mindhármat mi állítjuk be:

const server = http.createServer((req, res) => {
  res.statusCode = 200;                                             // 1) státuszkód
  res.setHeader("Content-Type", "application/json; charset=utf-8");   // 2) fejléc
  res.end(JSON.stringify({ uzenet: "Szia!" }));                      // 3) törzs + lezárás
});

Rövidebb írásmód

Ugyanez egy sorral kevesebből:

res.writeHead(200, { "Content-Type": "application/json; charset=utf-8" });
res.end(JSON.stringify({ uzenet: "Szia!" }));

A writeHead egyszerre állítja a státuszkódot és a fejléceket. Utána viszont már nem változtathatod meg őket — erről a következő fejezetekben lesz még szó.

5Útvonalak — kézzel

A http modul nem ismeri az útvonalakat. Nekünk kell szétválogatnunk a kéréseket:

import http from "node:http";

const server = http.createServer((req, res) => {
  res.setHeader("Content-Type", "application/json; charset=utf-8");

  if (req.method === "GET" && req.url === "/api/products") {
    res.statusCode = 200;
    res.end(JSON.stringify([{ id: 42, nev: "Billentyűzet" }]));
    return;                                   // ← FONTOS: itt kilépünk!
  }

  if (req.method === "GET" && req.url === "/api/categories") {
    res.statusCode = 200;
    res.end(JSON.stringify([{ id: 3, nev: "Perifériák" }]));
    return;
  }

  // ha idáig eljutottunk, egyik feltétel sem illeszkedett
  res.statusCode = 404;
  res.end(JSON.stringify({ error: { message: "Nincs ilyen végpont." } }));
});

server.listen(3000, () => console.log("Fut: http://localhost:3000"));

Ilyenkor ezt kapod, és a szerver folyamata le is áll:

Error [ERR_HTTP_HEADERS_SENT]: Cannot set headers after they are sent to the client
    at ServerResponse.setHeader (node:_http_outgoing:684:11)
    …
  code: 'ERR_HTTP_HEADERS_SENT'

Magyarul: „a fejléceket már elküldtük a kliensnek, nem lehet újat beállítani”. Egy kérésre egy válasz jut — ez a HTTP alapszabálya. A hibával és a mögötte álló szabállyal az 5. fejezetben foglalkozunk részletesen; itt elég annyit megjegyezned, hogy a hiányzó return okozza.

És a query string?

A req.url a query stringet is tartalmazza, ezért a fenti szigorú összehasonlítás (req.url === "/api/products") elbukik, amint a kliens szűrni akar:

/api/products?categoryId=3   ≠   /api/products

A megoldás a beépített URL osztály:

const cim = new URL(req.url, `http://${req.headers.host}`);

console.log(cim.pathname);                       // "/api/products"
console.log(cim.searchParams.get("categoryId")); // "3"
console.log(cim.searchParams.get("page"));       // "2"

Ami itt már fájni kezd

Mi van a GET /api/products/42 végponttal? Az azonosító az útvonal része, tehát így kellene kezelni:

const reszek = cim.pathname.split("/");        // ["", "api", "products", "42"]

if (req.method === "GET" && reszek[1] === "api" && reszek[2] === "products" && reszek[3]) {
  const id = Number(reszek[3]);
  // …
}

Ezt minden végponthoz meg kellene írni, kézzel. Az Expressben ez így néz majd ki:

app.get("/api/products/:id", (req, res) => {
  const id = Number(req.params.id);
  // …
});

6A kérés törzse — darabokban érkezik

POST és PUT kérésnél a kliens adatot is küld. Ez nem áll rendelkezésre azonnal: a törzs darabokban (chunk) érkezik a hálózaton, ezért meg kell várni a végét.

A modern, olvasható megoldás — és itt jön jól az előző fejezet:

const server = http.createServer(async (req, res) => {
  if (req.method === "POST" && req.url === "/api/products") {
    let torzs = "";

    for await (const darab of req) {     // a req „aszinkron bejárható”
      torzs += darab;                    // darabonként összefűzzük
    }

    const adat = JSON.parse(torzs);      // szövegből objektum

    res.statusCode = 201;
    res.setHeader("Content-Type", "application/json; charset=utf-8");
    res.end(JSON.stringify({ letrehozva: adat }));
    return;
  }

  res.statusCode = 404;
  res.end();
});

Kipróbálás REST Clienttel (1. blokk, 5. fejezet — .http fájl):

POST http://localhost:3000/api/products
Content-Type: application/json

{ "name": "Teszt", "price": 100 }

A válasz:

{ "letrehozva": { "name": "Teszt", "price": 100 } }

Miért nem egyszerűen req.body?

Mert nincs olyan. A http modul nem olvassa be helyetted a törzset — te döntöd el, mikor és hogyan. Ez rugalmas (nagy fájlfeltöltésnél nem is akarnád a memóriába tölteni), de a mindennapi JSON-nál csak macera.

A régi írásmód

Régebbi példákban eseménykezelőkkel találkozol — ugyanaz, csak nehezebben olvasható:

let torzs = "";
req.on("data", (darab) => { torzs += darab; });
req.on("end", () => {
  const adat = JSON.parse(torzs);
  // …
});

7Mi hiányzik még ebből?

Írjuk össze, mi mindent kellene még megvalósítanunk egy valódi API-hoz:

Ez a lista nem elrettentés: pontosan ezeket kapjuk meg az Expressben. Ezért éri meg keretrendszert használni — nem azért, mert a http modul rossz, hanem mert a fenti listát senki nem akarja minden projektben újraírni.

Ugyanaz a feladat kétféleképpen

„Adj vissza egy JSON-listát a GET /api/products címen”:

import http from "node:http";

const server = http.createServer((req, res) => {
  const cim = new URL(req.url,
    `http://${req.headers.host}`);

  if (req.method === "GET" &&
      cim.pathname === "/api/products") {
    res.statusCode = 200;
    res.setHeader("Content-Type",
      "application/json; charset=utf-8");
    res.end(JSON.stringify(termekek));
    return;
  }

  res.statusCode = 404;
  res.setHeader("Content-Type",
    "application/json; charset=utf-8");
  res.end(JSON.stringify(
    { error: "Nincs ilyen végpont." }));
});

server.listen(3000);

import express from "express";
const app = express();

app.get("/api/products", (req, res) => {
  res.json(termekek);
});

app.listen(3000);

Ugyanaz a működés — a második változatban a státuszkód, a Content-Type és a JSON.stringify mind automatikus. Ráadásul a 404-es ágat sem kell megírni: az Express magától válaszol, ha egyik útvonal sem illeszkedik.

8Gyakori hibák

EADDRINUSE — a port foglalt

Ez a leggyakoribb hiba a szerverekkel való ismerkedés során. Ha egyszerre kétszer indítod el a szervert (vagy elfelejtetted leállítani az előzőt), ezt kapod:

node:events:505
      throw er; // Unhandled 'error' event
      ^

Error: listen EADDRINUSE: address already in use :::3000
    at Server.setupListenHandle [as _listen2] (node:net:2324:16)
    at listenInCluster (node:net:2433:12)
    at Server.listen (node:net:2558:7)

A böngésző pörög, de nem jön válasz

const server = http.createServer((req, res) => {
  res.statusCode = 200;
  res.setHeader("Content-Type", "text/plain");
  // ❌ hiányzik a res.end()
});

Nincs hibaüzenet — a szerver csendben vár, a böngésző pedig pörög, amíg időtúllépésre nem fut. Parancssorból kipróbálva ugyanez: a curl egyszerűen nem kap választ, és időtúllépéssel áll le.

Ha „nem válaszol a szerver”, először a res.end() hívást keresd meg. Minden ágon le kell zárni a választ — a hibaágakon is.

Az ékezetek krix-kraxok

res.setHeader("Content-Type", "text/plain");            // ❌ hiányzik a charset
res.end("Árvíztűrő tükörfúrógép");

Megoldás: "text/plain; charset=utf-8".

A query paraméter szövegként érkezik

const oldal = cim.searchParams.get("page");   // "2" — SZÖVEG!
if (oldal === 2) { /* soha nem fut le */ }    // ❌
if (Number(oldal) === 2) { /* így jó */ }     // ✅

9Feladatok

http://localhost:3000/api/products/42?reszletes=true#ertekelesek

if (req.url === "/api/products") {
  res.end(JSON.stringify(termekek));
}
if (req.url === "/api/categories") {
  res.end(JSON.stringify(kategoriak));
}
res.statusCode = 404;
res.end("Nincs ilyen");

10Önellenőrző kvíz

11Összegzés

12Fogalomtár