Vad är change streams?

Question

Accepted Answer

**Change streams** låter applikationer **prenumerera på ändringar i realtid** i MongoDB-data — ta emot aviseringar när dokument infogas, uppdateras eller raderas. De möjliggör reaktiva, event-drivna funktioner (realtidsuppdateringar, synkronisering, utlösare) utan att avsöka databasen. Byggt på replica set oplog.

## Övervaka ändringar

```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 skickar en event för varje ändring (insert/update/delete), med detaljer om vad som ändrades — så applikationen reagerar i realtid.

## Filtrering och återuppta

```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 **filtrera** ändringar (bara övervaka vissa operationer eller dokument) och **återuppta** efter en frånkoppling (med en resume token) — vilket gör change streams motståndskraftiga.

## Vanliga användningsfall

```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 jämfört med avsökning

```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).
```

## Varför det är viktigt

Change streams är en värdefull MongoDB-funktion för att bygga **realtids-, reaktiva, event-drivna applikationer**, så att förstå dem är användbar senior-nivå kunskap för moderna applikationer som behöver live-datareaktivitet.

Kärvärdet är att möjliggöra för applikationer att **reagera på dataändringar i realtid** — ta emot push-aviseringar när dokument infogas, uppdateras eller raderas — vilket möjliggör viktiga funktioner: **realtidsfunktioner** (skicka live-uppdateringar till klienter via websockets när data ändras — ett vanligt behov för samarbetsappar, dashboards, aviseringar), **synkronisering** (hålla cachar, sökindex som Elasticsearch eller andra system i överensstämmelse med MongoDB när data ändras), **event-driven arkitektur** (utlösa arbetsflöden, aviseringar eller bearbetning vid dataändringar), och **granskning**.

Huvudfördeelen är att göra allt detta **utan avsökning** — change streams låter databasen *skicka* ändringar till applikationen omedelbar och effektivt, och ersätter det slösaktig mönstret med att upprepade gånger fråga "vad ändrades?" (vilket belastas databasen och har fördröjning).

Att förstå hur man övervakar samlingar, filtrerar ändringar (endast relevanta operationer/dokument) och återupptar efter frånkopplingar (med resume tokens för motståndskraft) täcker den praktiska användningen.

Att veta att change streams kräver en replica set är också relevant.

Eftersom realtidsreaktivitet och att hålla system synkroniserade är allt viktigare behov för applikationer, och eftersom change streams tillhandahåller ett effektivt, push-baserat sätt att reagera på MongoDB-dataändringar (långt bättre än avsökning), är förståelse för change streams — vad de gör, deras användningsfall (realtidsfunktioner, synkronisering, event-driven bearbetning), återuppta-/filtreringsfunktionerna och fördelen jämfört med avsökning — värdefull senior-nivå kunskap för att bygga moderna, reaktiva MongoDB-applikationer, en användbar funktion för det vanliga behovet att reagera på dataändringar i realtid och ett ämne som reflekterar förståelse för event-driven och realtidsapplikationsmönster med MongoDB.