Micro Frontends Architecture with Module Federation · Lección

Gestión del estado compartido

Explore estrategias para gestionar el estado compartido entre aplicaciones federadas, como Redux o Context API.

Gestión del estado compartido es una lección gratuita de Micro Frontends Architecture with Module Federation en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Micro Frontends Architecture with Module Federation, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Micro Frontends Architecture with Module Federation incluye 4 lecciones en total.

Partes de esta lección aún no han sido traducidas y se muestran en inglés.

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?

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.

Preguntas frecuentes

¿La lección «Gestión del estado compartido» es gratis?

Sí — el texto completo de «Gestión del estado compartido» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Micro Frontends Architecture with Module Federation, actualiza a CoddyKit PRO. El curso de Micro Frontends Architecture with Module Federation incluye 4 lecciones en total.

¿Qué aprenderé en «Gestión del estado compartido»?

Explore estrategias para gestionar el estado compartido entre aplicaciones federadas, como Redux o Context API. Practicas Micro Frontends Architecture with Module Federation con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Micro Frontends Architecture with Module Federation?

No se requiere experiencia previa. Micro Frontends Architecture with Module Federation en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Gestión del estado compartido»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Micro Frontends Architecture with Module Federation?

Sí. Cada lección de Micro Frontends Architecture with Module Federation incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

Bus de eventos para la comunicación entre aplicaciones
Gestión del estado compartido
Soluciones de comunicación personalizadas
Comunicación con eventos DOM personalizados

← Volver a Micro Frontends Architecture with Module Federation