React Academy · Lektion

Delad state och routing mellan MFE:er

Dela en global eventbuss eller context mellan mikrof fronter och samordna routing på klientsidan.

Lektion 3 av 412 steg

Delad state och routing mellan MFE:er är en gratis lektion i React Academy på CoddyKit. Detta är lektion 3 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för React Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i React Academy innehåller totalt 4 lektioner.

Utmaningen med att dela state

Microfrontends i olika paket kan inte dela React-state eller context direkt. Alternativa strategier behövs: custom events, delade stores, URL:en eller en pub/sub-eventbuss.

Custom events i webbläsaren

Använd webbläsarens API CustomEvent som en enkel eventbuss mellan microfrontends utan att koppla ihop dem.

// Remote emits:
window.dispatchEvent(new CustomEvent('cart:add', { detail: { productId: '123' } }));

// Host listens:
useEffect(() => {
  const handler = (e: CustomEvent) => addToCart(e.detail.productId);
  window.addEventListener('cart:add', handler);
  return () => window.removeEventListener('cart:add', handler);
}, []);

Delat eventbussbibliotek

Ett litet delat pub/sub-bibliotek (via Module Federation eller en singleton som läses in från en URL) ger en typad eventbuss som alla MFE:er kan komma åt.

// Singleton event bus
const bus = {
  listeners: new Map<string, Function[]>(),
  emit(event: string, data: unknown) {
    this.listeners.get(event)?.forEach(fn => fn(data));
  },
  on(event: string, fn: Function) {
    if (!this.listeners.has(event)) this.listeners.set(event, []);
    this.listeners.get(event)!.push(fn);
    return () => this.off(event, fn);
  },
  off(event: string, fn: Function) {
    const list = this.listeners.get(event) || [];
    this.listeners.set(event, list.filter(f => f !== fn));
  },
};
export default bus;

URL:en som delat state

URL:en (sökväg och frågeparametrar) delas naturligt mellan alla MFE:er. Använd den för navigationstillstånd som valt objekt, aktiv flik eller filtervärden.

// Remote reads from URL:
const params = new URLSearchParams(window.location.search);
const productId = params.get('product');

// Remote navigates via history API (or exposes a navigate callback from host):
window.history.pushState({}, '', '/products?product=456');

Routingarkitektur

Vanligtvis äger shell-/host-appen routern på toppnivå. Remote-microfrontends får den aktuella sökvägen och en navigate-callback som props.

// Host passes routing control to remote:
<RemoteProductsApp
  basepath="/products"
  navigate={(path) => router.push(path)}
/>

// Remote uses basepath for its internal router:
<BrowserRouter basename={basepath}>
  <Routes>...</Routes>
</BrowserRouter>

React Router med Module Federation

Varje MFE kan köra sin egen React Router, begränsad till sin basepath. Host-routern hanterar navigation på toppnivå och varje remote hanterar undernavigation självständigt.

// Remote App component:
export function ProductsApp({ basepath = '/products' }) {
  return (
    <BrowserRouter basename={basepath}>
      <Routes>
        <Route path="/" element={<ProductList />} />
        <Route path="/:id" element={<ProductDetail />} />
      </Routes>
    </BrowserRouter>
  );
}

Delat auth-state

Auth-state (user, token) ägs vanligtvis av shell-appen och skickas vidare till remotes som props eller exponeras via en delad singleton-store.

// Host provides auth via props:
<RemoteCheckout
  userId={currentUser.id}
  token={accessToken}
  onLogout={handleLogout}
/>

Zustand som delad store

När en Zustand-store delas via Module Federation (som singleton) läser alla MFE:er från samma store-instans i minnet.

// shared/store.ts (exposed as singleton)
import { create } from 'zustand';
export const useCartStore = create(set => ({
  items: [],
  addItem: (item) => set(state => ({ items: [...state.items, item] })),
}));

// Configured as singleton in MF shared config

Antimönster för kommunikation mellan MFE:er

Undvik djupt nästlade callback-kedjor, delning av internt komponent-state och stark koppling till ett annat MFE:s interna API:er. Begränsa kommunikationen till övergripande händelser och offentliga kontrakt.

Testa interaktioner mellan MFE:er

Testa event-kontrakten (händelsenamn och datastrukturer) separat från UI:t. Använd kontraktstestning för att verifiera att producent och konsument är överens om eventschemat.

Snabbtest

Vilket är det enklaste sättet att dela navigations- eller filterstate mellan flera microfrontends utan att koppla ihop dem?

Sammanfattning

Dela state mellan MFE:er via custom events, en singleton-eventbuss, URL:en eller delade stores (Zustand/singleton). Shell-appen äger routern på toppnivå och skickar basepath och navigate till remotes. Håll kontrakten mellan MFE:er övergripande och vältypade.

Gratis att börja

Lär dig React med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser
88
Lektioner
324

Vanliga frågor

Är lektionen ”Delad state och routing mellan MFE:er” gratis?

Ja – hela texten till ”Delad state och routing mellan MFE:er” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i React Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i React Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Delad state och routing mellan MFE:er”?

Dela en global eventbuss eller context mellan mikrof fronter och samordna routing på klientsidan. Ni övar på React Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig React Academy?

Du behöver inga förkunskaper. Utbildningen i React Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.

Hur lång tid tar lektionen ”Delad state och routing mellan MFE:er”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här React Academy-lektionen?

Ja. Varje React Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

  1. Mikrofrontend-koncept och avvägningar
  2. Module Federation med Webpack 5
  3. Delad state och routing mellan MFE:er
  4. Oberoende driftsättning och CI-pipelines för MFE:er
← Tillbaka till React Academy