Hogyan működik az Express middleware?

Question

Accepted Answer

A **middleware** olyan függvények, amelyek az Express request-response ciklusa során **sorrendben** futnak le. Mindegyik `(req, res, next)` paramétert kap, és megvizsgálhatja/módosíthatja a kérést és a választ, befejezhet egy választ, vagy meghívhatja a `next()` függvényt, hogy átadja a vezérlést a következő middleware-nek. Ezek az Express alkalmazások szerkezetének alapját képezik.

## A podpis és a lánc

```js
app.use((req, res, next) => {
  console.log(`${req.method} ${req.url}`); // do something
  next();                                   // ⬅ pass control to the next middleware
});
```

Kritikus szabály: **hívja meg a `next()` függvényt** a lánc folytatásához. Ha elfelejti (és nem küld választ), a kérés örökre függőben marad.

## Az áramlás

```text
Request → [logger] → [auth] → [body parser] → [route handler] → Response
            next()    next()     next()         res.send()
Each middleware runs in order; any can short-circuit by sending a response.
```

## Közös middleware típusok

```js
// 1. Application-level — runs for all (or path-matched) requests
app.use(express.json());                       // built-in: parse JSON bodies
app.use(cors());                                // third-party

// 2. Custom — e.g. authentication that can SHORT-CIRCUIT
function requireAuth(req, res, next) {
  if (!req.headers.authorization) {
    return res.status(401).json({ error: "Unauthorized" }); // STOP — don't call next()
  }
  req.user = decodeToken(req.headers.authorization);  // attach data for later handlers
  next();                                              // authorized → continue
}

// 3. Route-specific
app.get("/profile", requireAuth, (req, res) => res.json(req.user));
```

A middleware **rövid utat tud venni** (választ küld és nem hívja meg a `next()` függvényt, pl. jogosulatlan kérések blokkolása) vagy **gazdagíthatja** a kérést (a `req.user` csatolása az alábbi kezelőkhöz).

## Error-handling middleware (négy argumentum)

```js
// special signature with 4 params → Express treats it as an error handler
app.use((err, req, res, next) => {
  console.error(err);
  res.status(500).json({ error: "Server error" });
});
// triggered by next(err) or a thrown error; place it LAST
```

An error handler **négy** paramétert tartalmaz (`err` az első). Ezt a `next(err)` meghívásával érheti el; ezt utolsóként kell regisztrálni.

## A sorrend számít

```text
Middleware runs in the ORDER you register it. Body parser before routes that
read the body; auth before protected routes; error handler last.
```

## Miért fontos

A middleware az Express (és hasonló keretrendszerek) architekturális gerendája — a hitelesítés, a naplózás, a törzs elemzése, a CORS, az érvényesítés és a hibakezelés mind middleware-ek.

A `(req, res, next)` szerződés megértése (különösen, hogy meg kell hívnia a `next()` függvényt vagy választ kell küldenie), az, hogy a middleware hogyan tud rövidebb utat venni vagy gazdagíthat kéréseket, a négy argumentumos hibakezelő, valamint az, hogy **a sorrend számít**, elengedhetetlen az Express alkalmazások létrehozásához, strukturálásához és hibakereséshez.