Hvad er change streams?

Question

Accepted Answer

**Change streams** lader applikationer **abonnere på realtidsændringer** i MongoDB-data — og modtage notifikationer, når dokumenter indsættes, opdateres eller slettes. De muliggør reaktive, event-drevne funktioner (realtidsopdateringer, synkronisering, triggers) uden at skulle stemple databasen. Bygget på replica set oplog.

## Se efter ændringer

```js
// watch a collection for changes — get notified in real time
const changeStream = db.collection("orders").watch();

changeStream.on("change", (change) => {
  console.log(change.operationType);   // "insert", "update", "delete", "replace"
  console.log(change.fullDocument);     // the changed document (for inserts/updates)
  // react: push to websockets, update a cache, trigger a workflow, etc.
});
```

En change stream sender en event for hver ændring (indsættelse/opdatering/sletning), med detaljer om hvad der blev ændret — så applikationen reagerer i realtid.

## Filtrering og genoptagelse

```js
// watch only specific changes with an aggregation pipeline filter
db.collection("orders").watch([
  { $match: { operationType: "insert", "fullDocument.status": "urgent" } }
]);

// resume from where you left off (resilient to disconnections)
db.collection("orders").watch([], { resumeAfter: lastChangeToken });
```

Du kan **filtrere** ændringer (kun se på bestemte operationer eller dokumenter) og **genoptage** efter en afbrydelse (ved at bruge et resume token) — hvilket gør change streams resiliente.

## Almindelige use cases

```text
✓ REAL-TIME features — push live updates to clients (websockets) when data changes
✓ SYNCING — keep a cache, search index (Elasticsearch), or another system in sync
✓ EVENT-DRIVEN architecture — trigger workflows/notifications on data changes
✓ AUDITING — log changes; analytics on data modifications
→ All WITHOUT polling the database repeatedly (efficient, real-time)
```

## Change streams versus polling

```text
❌ POLLING — repeatedly query "what changed?" → inefficient, latency, load on the DB
✅ CHANGE STREAMS — the database PUSHES changes to you in real time → efficient, instant
→ The right way to react to data changes (requires a replica set).
```

## Hvorfor det betyder noget

Change streams er en værdifuld MongoDB-funktion til at bygge **realtids-, reaktive, event-drevne applikationer**, så at forstå dem er nyttig viden på seniorniveau for moderne applikationer, der har brug for live datareaktivitet.

Kernværdien er at gøre det muligt for applikationer at **reagere på dataændringer i realtid** — modtage push-notifikationer, når dokumenter indsættes, opdateres eller slettes — hvilket muliggør vigtige muligheder: **realtidsfunktioner** (pushe live opdateringer til klienter via websockets, når data ændres — et almindeligt behov for samarbejdsapps, dashboards, notifikationer), **synkronisering** (holde caches, søgeindekser som Elasticsearch eller andre systemer i synk med MongoDB, når data ændres), **event-dreven arkitektur** (udløse workflows, notifikationer eller behandling ved dataændringer), og **revision**.

Hovedfordelen er at gøre alt dette **uden polling** — change streams lader databasen *push* ændringer til applikationen øjeblikkeligt og effektivt, og erstatter det spildende mønster med højere latens ved gentagne gange at spørge "hvad blev ændret?" (hvilket belaster databasen og har forsinkelse).

At forstå, hvordan man ser på samlinger, filtrerer ændringer (kun relevante operationer/dokumenter), og genoptager efter afbrydelser (ved at bruge resume tokens for resiliens) dækker den praktiske brug.

At vide, at change streams kræver et replica set, er også relevant.

Da realtidsreaktivitet og at holde systemer i synk er i stigende grad vigtige behov for applikationer, og da change streams giver en effektiv, push-baseret måde at reagere på MongoDB-dataændringer på (langt bedre end polling), er det at forstå change streams — hvad de gør, deres use cases (realtidsfunktioner, synkronisering, event-dreven behandling), resume-/filtermulighederne og fordelen i forhold til polling — værdifuld viden på seniorniveau til at bygge moderne, reaktive MongoDB-applikationer, en nyttig funktion til det almindelige behov for at reagere på dataændringer i realtid og et emne, der afspejler forståelse af event-drevne og realtids-applicationsmønstre med MongoDB.