Micro Frontends Architecture with Module Federation · Lekcja

Zarządzanie współdzielonym stanem

Poznaj strategie zarządzania współdzielonym stanem w aplikacjach federacyjnych, takie jak Redux lub Context API.

Lekcja 2 z 411 kroki

Zarządzanie współdzielonym stanem to bezpłatna lekcja Micro Frontends Architecture with Module Federation na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Micro Frontends Architecture with Module Federation, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Micro Frontends Architecture with Module Federation zawiera 4 lekcji w sumie.

Części tej lekcji nie zostały jeszcze przetłumaczone i są wyświetlane po angielsku.

What is Shared State?

In Micro Frontends, shared state refers to data that needs to be accessible and consistent across different, independently developed and deployed applications.

Think of user authentication status, global theme settings, or shopping cart contents.
This state isn't owned by a single micro frontend but is crucial for a cohesive user experience.

Managing this state effectively is key to building complex federated applications.

Why Shared State in MFEs?

When you have multiple micro frontends making up a single user interface, they often need to react to the same global information.

User Experience: A user logs in on one MFE, and others need to know they're authenticated.
Consistency: Applying a global theme preference across all parts of the application.
Data Flow: Passing data from one MFE (e.g., product selection) to another (e.g., checkout).

Without shared state, each MFE would manage its own isolated data, leading to inconsistencies and a disjointed user journey.

Challenges of Shared State

While essential, sharing state in a Micro Frontend architecture comes with unique challenges:

Isolation: MFEs are designed to be independent. Breaking this isolation needs careful planning.
Framework Agnosticism: Different MFEs might use different JavaScript frameworks (React, Angular, Vue).
Performance: Inefficient sharing can lead to redundant data fetching or slow updates.
Complexity: Deciding ownership, update mechanisms, and preventing conflicts can be complex.

We need strategies that balance independence with the necessity of shared information.

Simple Shared State: Local Storage

For very basic, non-sensitive, and persistent state, browser's Local Storage can be a quick solution. Each MFE can read from and write to it.

However, it's not reactive, meaning MFEs don't automatically update when Local Storage changes. It's also not suitable for complex or real-time state.

Try setting and getting an item:

localStorage.setItem('appTheme', 'dark');
console.log('Theme set to dark.');

const currentTheme = localStorage.getItem('appTheme');
console.log('Current theme:', currentTheme);

// To remove:
// localStorage.removeItem('appTheme');
// console.log('Theme removed.');

Centralized State Stores

For more complex and reactive shared state, a centralized state store is a common pattern. Libraries like Redux are popular examples.

A single source of truth for your application's state.
Predictable state changes through actions and reducers.
Easier debugging and traceability of state modifications.

In a federated setup, a host or a dedicated remote MFE can expose such a store for others to consume.

Building a Simple Global Store

Let's create a basic, framework-agnostic global store. This store will hold our shared state and allow components to subscribe to changes. This mimics how a Redux store would function at a high level.

Run this code to see a simple store in action:

let sharedState = { userStatus: 'loggedOut', notifications: [] };
const subscribers = [];

function getSharedState() {
  return sharedState;
}

function dispatchAction(action) {
  switch (action.type) {
    case 'LOGIN':
      sharedState = { ...sharedState, userStatus: 'loggedIn' };
      break;
    case 'ADD_NOTIFICATION':
      sharedState = { ...sharedState, notifications: [...sharedState.notifications, action.payload] };
      break;
    default:
      return;
  }
  subscribers.forEach(cb => cb(sharedState));
}

function subscribe(callback) {
  subscribers.push(callback);
  return () => {
    const index = subscribers.indexOf(callback);
    if (index > -1) subscribers.splice(index, 1);
  };
}

// --- Example Usage ---
console.log('Initial state:', getSharedState());
const unsubscribe = subscribe(newState => {
  console.log('State updated:', newState);
});

dispatchAction({ type: 'LOGIN' });
dispatchAction({ type: 'ADD_NOTIFICATION', payload: 'Welcome!' });

unsubscribe();
console.log('Unsubscribed from updates.');

Consuming the Global Store

Now, imagine different Micro Frontends needing to react to changes in this global store. They would use the getSharedState and subscribe functions.

This example demonstrates how two 'virtual' MFEs could interact with the shared store, reacting to updates.

let sharedState = { userStatus: 'loggedOut', notifications: [] };
const subscribers = [];

function getSharedState() { return sharedState; }
function dispatchAction(action) {
  switch (action.type) {
    case 'LOGIN': sharedState = { ...sharedState, userStatus: 'loggedIn' }; break;
    case 'ADD_NOTIFICATION': sharedState = { ...sharedState, notifications: [...sharedState.notifications, action.payload] }; break;
    case 'LOGOUT': sharedState = { ...sharedState, userStatus: 'loggedOut' }; break;
    default: return;
  }
  subscribers.forEach(cb => cb(sharedState));
}
function subscribe(callback) {
  subscribers.push(callback);
  return () => { const index = subscribers.indexOf(callback); if (index > -1) subscribers.splice(index, 1); };
}

// --- MFE A (e.g., Header Component) ---
function handleUserStatusChange(state) {
  console.log('MFE A: User status is now', state.userStatus);
}
const unsubscribeMFEA = subscribe(handleUserStatusChange);

// --- MFE B (e.g., Notification Bell) ---
function handleNotificationsChange(state) {
  console.log('MFE B: Notifications:', state.notifications.length);
}
const unsubscribeMFEB = subscribe(handleNotificationsChange);

// Simulate actions from other MFEs or host
dispatchAction({ type: 'LOGIN' });
dispatchAction({ type: 'ADD_NOTIFICATION', payload: 'New message!' });
dispatchAction({ type: 'LOGOUT' });

unsubscribeMFEA();
unsubscribeMFEB();

React Context API for MFEs

If your Micro Frontends are all built with React, the Context API can be a powerful way to share state. A Context provides a way to pass data through the component tree without having to pass props down manually at every level.

Create a Context in a shared library or a host MFE.
Expose this Context via Module Federation.
Remote MFEs can then consume this Context directly.

This approach works well when all federated applications are within the same React ecosystem.

Sharing React Context (Concept)

To share React Context, you'd typically:

Define Context: Create MyContext.js in a shared utility MFE.
Expose Context: Use Module Federation to expose MyContext.Provider and useContext(MyContext).
Provide Context: The host MFE (or a parent MFE) wraps its children (including remote MFEs) with the <MyContext.Provider value={...}>.
Consume Context: Any remote MFE can then import and use useContext(MyContext) to access the shared state.

This allows a deeply nested component in a remote MFE to access state provided by a parent MFE.

Question: Shared State Benefits

You've learned about various approaches to managing shared state in Micro Frontends.

Which of the following is a primary benefit of implementing robust shared state management in a Micro Frontend architecture?

Odpowiedz w interaktywnej lekcji

Recap: Shared State Management

We've explored key strategies for managing shared state in Micro Frontends:

Need: Essential for consistent user experience and data flow across independent MFEs.
Challenges: Maintaining isolation, framework compatibility, and managing complexity.
Simple Methods: Local Storage for basic, non-reactive data.
Centralized Stores: Using patterns like Redux to create a single source of truth, accessible by all MFEs.
React Context: An effective solution for sharing state when all MFEs are within the React ecosystem.

Choosing the right strategy depends on your team's needs, framework choices, and the complexity of the shared data.

Bezpłatny start

Ucz się JavaScript dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy: 12
Lekcje: 48

Zacznij naukę bezpłatnie Wyświetl pełny kurs

Często zadawane pytania

Czy lekcja „Zarządzanie współdzielonym stanem” jest bezpłatna?

Tak — pełny tekst „Zarządzanie współdzielonym stanem” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Micro Frontends Architecture with Module Federation, przejdź na CoddyKit PRO. Kurs Micro Frontends Architecture with Module Federation zawiera 4 lekcji w sumie.

Co nauczysz się w „Zarządzanie współdzielonym stanem”?

Poznaj strategie zarządzania współdzielonym stanem w aplikacjach federacyjnych, takie jak Redux lub Context API. Ćwiczysz Micro Frontends Architecture with Module Federation z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Micro Frontends Architecture with Module Federation?

Nie wymagamy żadnego doświadczenia. Micro Frontends Architecture with Module Federation w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Zarządzanie współdzielonym stanem”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Micro Frontends Architecture with Module Federation?

Tak. Każda lekcja Micro Frontends Architecture with Module Federation zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

Magistrala zdarzeń do komunikacji między aplikacjami
Zarządzanie współdzielonym stanem
Niestandardowe rozwiązania komunikacyjne
Komunikacja za pomocą niestandardowych zdarzeń DOM

← Powrót do Micro Frontends Architecture with Module Federation