Skip to content

6. Geltungsbereiche von Daten

Eine Webanwendung bedient viele Benutzer gleichzeitig, und jeder Benutzer stellt zahlreiche Anfragen. Daten können daher auf drei Ebenen geteilt werden, die als Geltungsbereich bezeichnet werden:

  • Anwendung-Geltungsbereich: Die Daten werden von allen Benutzern während der gesamten Laufzeit des Servers gemeinsam genutzt (zum Beispiel die Liste der Ärzte);
  • Anfrage-Geltungsbereich: Die Daten existieren nur für die Dauer einer Anfrage (das Modell einer View);
  • Client-Geltungsbereich: Die Daten gehören zu einem bestimmten Benutzer und müssen von einer Anfrage zur nächsten erhalten bleiben (die gewählte Sprache, der angemeldete Benutzer).

Der ursprüngliche Kurs verwendete für diesen letzten Geltungsbereich die [ASP.NET]-Session: einen serverseitigen Speicherplatz, der für jeden Browser eigens angelegt wird. Dieses Dokument verzichtet, ebenso wie die Fallstudie, darauf: Die Daten mit Client-Geltungsbereich werden vom Browser in Cookies gespeichert. Der Server speichert zwischen zwei Anfragen desselben Benutzers nichts: Man sagt, er sei zustandslos ([stateless]). Das ermöglicht es zum Beispiel, mehrere identische Server hinter einem Load Balancer zu betreiben. Der Preis dafür: Ein Cookie unterliegt der Kontrolle des Benutzers, der es lesen und ändern kann. Kapitel 8 zeigt, wie ein signiertes Token es ermöglicht, dem Cookie trotzdem zu vertrauen.

6.1. Beispiel 23: Drei Geltungsbereiche

Die Datei [src/counter.service.ts]:

import { Injectable } from '@nestjs/common';

// Scope APPLICATION (Standard): eine einzige Instanz, beim Start erzeugt und
// von ALLEN Anfragen ALLER Benutzer gemeinsam genutzt
@Injectable()
export class CounterService {
  private total = 0;

  increment(): number {
    return ++this.total;
  }
}

Zeilen 5–6: Standardmäßig ist ein [NestJS]-Service ein Singleton: eine einzige Instanz, die beim Start erzeugt wird und von allen Anfragen gemeinsam genutzt wird. Ihr Feld [total] hat daher Anwendungs-Geltungsbereich.

Die Datei [src/request.service.ts]:

1
2
3
4
5
6
7
8
9
import { Injectable, Scope } from '@nestjs/common';

let createdInstances = 0;

// Scope REQUEST: eine NEUE Instanz für jede HTTP-Anfrage
@Injectable({ scope: Scope.REQUEST })
export class RequestService {
  readonly number = ++createdInstances;
}

Zeile 6: Die Option [scope: Scope.REQUEST] fordert für jede Anfrage eine neue Instanzan. Die Instanznummer zeigt dies. Diese Option wird selten verwendet: Sie verursacht Kosten (Objekte werden bei jeder Anfrage erzeugt) und sie überträgt sich auf abhängige Klassen – ein Controller, der von einem Service mit Anfrage-Geltungsbereich abhängt, erhält selbst diesen Geltungsbereich. [res.locals] genügt in der Regel.

Die Datei [src/scopes.controller.ts]:

import { Controller, Get, Req, Res } from '@nestjs/common';
import { Request, Response } from 'express';
import { CounterService } from './counter.service';
import { RequestService } from './request.service';

@Controller()
export class ScopesController {
  constructor(
    private readonly counter: CounterService,
    private readonly request: RequestService,
  ) {}

  @Get()
  scopes(@Req() req: Request, @Res() res: Response): void {
    // Scope CLIENT: ein vom BROWSER gespeichertes Datum (Cookie),
    // das bei jeder Anfrage an den Server zurückgesendet wird
    const myVisits = Number(req.cookies?.myVisits ?? 0) + 1;
    res.cookie('myVisits', String(myVisits), { httpOnly: true, sameSite: 'lax' });
    res.render('scopes', {
      total: this.counter.increment(),
      instance: this.request.number,
      myVisits,
    });
  }
}
  • Zeilen 8–11: Beide Services werden injiziert;
  • Zeilen 17–18: der Client-Geltungsbereich: ein in einem Cookie gespeicherter Zähler. Der Browser sendet ihn bei jeder Anfrage zurück; die Action erhöht ihn und speichert ihn wieder;
  • Zeilen 19–23: Die drei Werte werden an die View übergeben.

Die Datei [src/main.ts]:

import { NestFactory } from '@nestjs/core';
import { NestExpressApplication } from '@nestjs/platform-express';
import * as cookieParser from 'cookie-parser';
import { NextFunction, Request, Response } from 'express';
import { dirname, join } from 'path';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create<NestExpressApplication>(AppModule);
  app.useStaticAssets(join(dirname(require.resolve('bootstrap/package.json')), 'dist'), { prefix: '/bootstrap/' });
  app.setBaseViewsDir(join(__dirname, '..', 'views'));
  app.setViewEngine('hbs');
  app.use(cookieParser());
  // Scope REQUEST: res.locals entsteht und vergeht mit der Anfrage
  app.use((req: Request, res: Response, next: NextFunction) => {
    res.locals.start = new Date().toISOString().slice(11, 23);
    next();
  });
  await app.listen(3000);
  console.log('Server started on http://localhost:3000');
}

bootstrap();

Zeilen 15–18: der Anfrage-Geltungsbereich mit [res.locals]: der Zeitpunkt, zu dem die Anfrage empfangen wurde.

Die Datei [views/scopes.hbs]:

1
2
3
4
5
6
<h1 class="h3">The scopes of data</h1>
<ul>
  <li>application: {{total}} visit(s) of the site, all browsers combined</li>
  <li>request: instance no. {{instance}} of RequestService, request received at {{start}}</li>
  <li>client: {{myVisits}} visit(s) from this browser</li>
</ul>

Image

Simulieren wir zwei Browser mit [curl] und zwei Cookie-Dateien, [a.txt] und [b.txt]. Browser A stellt zwei Anfragen, dann stellt Browser B eine, und schließlich stellt A noch eine:

1
2
3
4
curl -c a.txt -b a.txt http://localhost:3000/
curl -c a.txt -b a.txt http://localhost:3000/
curl -c b.txt -b b.txt http://localhost:3000/
curl -c a.txt -b a.txt http://localhost:3000/
browser A:
application: 1 visit(s) of the site, all browsers combined
request: instance no. 1 of RequestService, request received at 14:16:07.195
client: 1 visit(s) from this browser

browser A:
application: 2 visit(s) of the site, all browsers combined
request: instance no. 2 of RequestService, request received at 14:16:07.237
client: 2 visit(s) from this browser

browser B:
application: 3 visit(s) of the site, all browsers combined
request: instance no. 3 of RequestService, request received at 14:16:07.251
client: 1 visit(s) from this browser

browser A:
application: 4 visit(s) of the site, all browsers combined
request: instance no. 4 of RequestService, request received at 14:16:07.263
client: 3 visit(s) from this browser
  • Der Anwendungszähler zählt alle Besuche: 1, 2, 3, 4;
  • jede Anfrage hat ihre eigene Instanz von [RequestService]: 1, 2, 3, 4;
  • Der Clientzähler ist für jeden Browser eigens vorhanden: A hat 3 Besuche, B hat 1.

In der Fallstudie:

Geltungsbereich
Daten
Wo?
Anwendung
Listen der Ärzte und Clients, Wörterbücher, ausstehende CAPTCHAs
Singleton-Services ([ApplicationModelService], [CaptchaService]...)
Anfrage
Sprache, Pfad, Flash-Nachricht, angemeldeter Benutzer
[res.locals]
Client
Authentifizierungs-Token, Sprache, Flash-Nachricht
Cookies