Micro Frontends Architecture with Module Federation · Pelajaran

Pengelolaan Status Bersama

Jelajahi strategi untuk mengelola status bersama di seluruh aplikasi federasi, seperti Redux atau Context API.

Pelajaran 2 dari 411 langkah

Pengelolaan Status Bersama adalah pelajaran Micro Frontends Architecture with Module Federation gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Micro Frontends Architecture with Module Federation, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Micro Frontends Architecture with Module Federation mencakup 4 pelajaran total.

Bagian dari pelajaran ini belum diterjemahkan dan ditampilkan dalam bahasa Inggris.

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?

Jawab di pelajaran interaktif

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.

Gratis untuk memulai

Belajar JavaScript dengan tutor AI — gratis

Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.

Kursus: 12
Pelajaran: 48

Mulai belajar gratis Lihat kursus lengkapnya

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Pengelolaan Status Bersama” gratis?

Ya — teks lengkap “Pengelolaan Status Bersama” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Micro Frontends Architecture with Module Federation, upgrade ke CoddyKit PRO. Kursus Micro Frontends Architecture with Module Federation mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Pengelolaan Status Bersama”?

Jelajahi strategi untuk mengelola status bersama di seluruh aplikasi federasi, seperti Redux atau Context API. Kamu berlatih Micro Frontends Architecture with Module Federation dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Micro Frontends Architecture with Module Federation?

Tidak diperlukan pengalaman sebelumnya. Micro Frontends Architecture with Module Federation di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.

Berapa lama pelajaran “Pengelolaan Status Bersama” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Micro Frontends Architecture with Module Federation ini?

Ya. Setiap pelajaran Micro Frontends Architecture with Module Federation menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

Bus Peristiwa untuk Komunikasi Antar-Aplikasi
Pengelolaan Status Bersama
Solusi Komunikasi Khusus
Berkomunikasi dengan Peristiwa DOM Khusus

← Kembali ke Micro Frontends Architecture with Module Federation