State management merupakan tantangan utama dalam pengembangan Flutter. Riverpod dan BLoC mendominasi ekosistem, masing-masing menawarkan filosofi yang berbeda. Panduan ini membandingkan kedua solusi melalui implementasi konkret untuk membantu memilih sesuai kebutuhan proyek.

Prasyarat

Panduan ini mengasumsikan keakraban dengan Flutter dan dasar-dasar state management. Contoh menggunakan Riverpod 3.x dan flutter_bloc 9.x, versi stabil saat ini pada tahun 2026.

Filosofi Inti dari Kedua Pendekatan

Riverpod dan BLoC memecahkan masalah yang sama dengan paradigma berlawanan. Memahami perbedaan konseptual ini memungkinkan pemilihan alat yang tepat untuk setiap konteks.

Riverpod mengadopsi pendekatan deklaratif dan reaktif. Provider mendefinisikan sumber data yang diamati oleh widget. Framework mengelola siklus hidup, caching, dan dependensi antar provider secara otomatis. Versi 3.0 membawa peningkatan signifikan: automatic retry untuk provider yang gagal, pause/resume listener berdasarkan visibilitas widget, dan dukungan eksperimental untuk offline persistence.

BLoC (Business Logic Component) menerapkan arsitektur ketat berbasis event. Komponen memancarkan event, Bloc memprosesnya dan menghasilkan state baru. Pemisahan eksplisit ini memudahkan pelacakan aliran data. Versi 9.x memperkenalkan EmittableStateStreamableSource untuk fleksibilitas pengujian yang lebih baik.

riverpod_philosophy.dartdart

// Riverpod 3.x: Notifier replaces StateNotifier as the standard pattern
@riverpod
class Counter extends _$Counter {
  @override
  int build() => 0;
  
  void increment() => state++;
}

// Usage in a widget
class CounterWidget extends ConsumerWidget {
  @override
  Widget build(BuildContext context, WidgetRef ref) {
    // Reactive read: automatic rebuild if value changes
    final count = ref.watch(counterProvider);
    return Text('$count');
  }
}

bloc_philosophy.dartdart

// BLoC 9.x: explicit events/states separation
sealed class CounterEvent {}
final class IncrementPressed extends CounterEvent {}

class CounterBloc extends Bloc<CounterEvent, int> {
  CounterBloc() : super(0) {
    // Each event has its dedicated handler
    on<IncrementPressed>((event, emit) => emit(state + 1));
  }
}

// Usage in a widget
class CounterWidget extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return BlocBuilder<CounterBloc, int>(
      builder: (context, count) => Text('$count'),
    );
  }
}

Pilihan antara pendekatan ini bergantung pada preferensi tim dan batasan proyek. Untuk gambaran umum opsi state management termasuk GetX, lihat perbandingan lengkap state management Flutter untuk 2026.

Konfigurasi Awal

Konfigurasi awal mengungkap perbedaan ergonomi antara kedua solusi. Riverpod mengutamakan kesederhanaan, BLoC menawarkan lebih banyak struktur.

Instalasi Riverpod

Riverpod membutuhkan satu paket dan wrapper di akar aplikasi. Code generation dengan riverpod_generator adalah pendekatan yang direkomendasikan pada versi 3.x.

main.dartdart

// Riverpod configuration: single wrapper at root
import 'package:flutter_riverpod/flutter_riverpod.dart';

void main() {
  runApp(
    // ProviderScope wraps the entire application
    const ProviderScope(
      child: MyApp(),
    ),
  );
}

class MyApp extends StatelessWidget {
  const MyApp({super.key});

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: HomeScreen(),
    );
  }
}

Instalasi BLoC

BLoC membutuhkan beberapa paket dan konfigurasi yang lebih rinci dengan BlocProvider untuk setiap Bloc yang digunakan.

main.dartdart

// BLoC configuration: explicit providers for each Bloc
import 'package:flutter_bloc/flutter_bloc.dart';

void main() {
  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({super.key});

  @override
  Widget build(BuildContext context) {
    // MultiBlocProvider for multiple Blocs
    return MultiBlocProvider(
      providers: [
        BlocProvider(create: (_) => AuthBloc()),
        BlocProvider(create: (_) => ThemeBloc()),
      ],
      child: MaterialApp(
        home: HomeScreen(),
      ),
    );
  }
}

Konfigurasi BLoC membutuhkan lebih banyak kode awal namun membuat dependensi eksplisit sejak awal.

State Management Sederhana: Counter dan Toggle

Kasus sederhana menggambarkan ergonomi sehari-hari setiap solusi. Riverpod unggul dalam keringkasan, BLoC mempertahankan struktur berbasis event-nya.

Counter dengan Riverpod (Pola Notifier)

Riverpod 3.x menghapus StateProvider dan StateNotifierProvider demi API Notifier yang terunifikasi. Pola baru ini lebih bersih dan bekerja mulus dengan code generation.

counter_riverpod.dartdart

// Notifier pattern: the standard in Riverpod 3.x
@riverpod
class Counter extends _$Counter {
  @override
  int build() => 0;

  void increment() => state++;
  void decrement() => state--;
  void reset() => state = 0;
}

class CounterScreen extends ConsumerWidget {
  const CounterScreen({super.key});

  @override
  Widget build(BuildContext context, WidgetRef ref) {
    // watch for reactive value
    final count = ref.watch(counterProvider);

    return Scaffold(
      body: Center(child: Text('Count: $count')),
      floatingActionButton: FloatingActionButton(
        // read for actions (no rebuild)
        onPressed: () => ref.read(counterProvider.notifier).increment(),
        child: const Icon(Icons.add),
      ),
    );
  }
}

Counter dengan BLoC

counter_bloc.dartdart

// Typed events for each possible action
sealed class CounterEvent {}
final class CounterIncremented extends CounterEvent {}
final class CounterDecremented extends CounterEvent {}
final class CounterReset extends CounterEvent {}

// Bloc with handlers for each event
class CounterBloc extends Bloc<CounterEvent, int> {
  CounterBloc() : super(0) {
    on<CounterIncremented>((event, emit) => emit(state + 1));
    on<CounterDecremented>((event, emit) => emit(state - 1));
    on<CounterReset>((event, emit) => emit(0));
  }
}

class CounterScreen extends StatelessWidget {
  const CounterScreen({super.key});

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      body: Center(
        child: BlocBuilder<CounterBloc, int>(
          builder: (context, count) => Text('Count: $count'),
        ),
      ),
      floatingActionButton: FloatingActionButton(
        // Event dispatch to modify state
        onPressed: () => context.read<CounterBloc>().add(CounterIncremented()),
        child: const Icon(Icons.add),
      ),
    );
  }
}

Untuk kasus sederhana, Riverpod secara signifikan mengurangi boilerplate. BLoC menjadi relevan ketika logika bertambah kompleks atau ketika keterlacakan event penting.

Legacy Provider di Riverpod 3.x

StateProvider dan StateNotifierProvider masih berfungsi namun memerlukan import dari flutter_riverpod/legacy.dart. Untuk kode baru, gunakan Notifier atau AsyncNotifier.

State Management Asinkron: Panggilan API

Operasi asinkron mengungkap kekuatan setiap solusi. Mengelola state loading, error, dan data merupakan tantangan besar. Riverpod 3.x memperkenalkan automatic retry dengan exponential backoff untuk provider yang gagal.

Data Asinkron dengan Riverpod

async_riverpod.dartdart

// AsyncNotifier: automatic loading/error/data management with retry
@riverpod
class Users extends _$Users {
  @override
  Future<List<User>> build() async {
    // autoDispose releases resources when provider is no longer used
    // Automatic retry on failure (exponential backoff: 200ms to 6.4s)
    final repository = ref.watch(userRepositoryProvider);
    return repository.fetchUsers();
  }

  Future<void> refresh() async {
    state = const AsyncLoading();
    state = await AsyncValue.guard(() => build());
  }
}

class UsersScreen extends ConsumerWidget {
  const UsersScreen({super.key});

  @override
  Widget build(BuildContext context, WidgetRef ref) {
    final usersAsync = ref.watch(usersProvider);

    // when handles all 3 possible states
    return usersAsync.when(
      loading: () => const Center(child: CircularProgressIndicator()),
      error: (error, stack) => Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: [
            Text('Error: $error'),
            ElevatedButton(
              // invalidate forces reload
              onPressed: () => ref.invalidate(usersProvider),
              child: const Text('Retry'),
            ),
          ],
        ),
      ),
      data: (users) => ListView.builder(
        itemCount: users.length,
        itemBuilder: (context, index) => UserTile(user: users[index]),
      ),
    );
  }
}

Data Asinkron dengan BLoC

async_bloc.dartdart

// Explicit states for each loading phase
sealed class UsersState {}
final class UsersInitial extends UsersState {}
final class UsersLoading extends UsersState {}
final class UsersLoaded extends UsersState {
  final List<User> users;
  UsersLoaded(this.users);
}
final class UsersError extends UsersState {
  final String message;
  UsersError(this.message);
}

// Events to trigger actions
sealed class UsersEvent {}
final class UsersFetchRequested extends UsersEvent {}
final class UsersRefreshRequested extends UsersEvent {}

class UsersBloc extends Bloc<UsersEvent, UsersState> {
  final UserRepository _repository;

  UsersBloc(this._repository) : super(UsersInitial()) {
    on<UsersFetchRequested>(_onFetchRequested);
    on<UsersRefreshRequested>(_onRefreshRequested);
  }

  Future<void> _onFetchRequested(
    UsersFetchRequested event,
    Emitter<UsersState> emit,
  ) async {
    emit(UsersLoading());
    try {
      final users = await _repository.fetchUsers();
      emit(UsersLoaded(users));
    } catch (e) {
      emit(UsersError(e.toString()));
    }
  }

  Future<void> _onRefreshRequested(
    UsersRefreshRequested event,
    Emitter<UsersState> emit,
  ) async {
    // Keep current state during refresh
    final currentState = state;
    try {
      final users = await _repository.fetchUsers();
      emit(UsersLoaded(users));
    } catch (e) {
      // Restore previous state on error
      if (currentState is UsersLoaded) {
        emit(currentState);
      } else {
        emit(UsersError(e.toString()));
      }
    }
  }
}

users_screen_bloc.dartdart

// Widget with pattern matching on states
class UsersScreen extends StatelessWidget {
  const UsersScreen({super.key});

  @override
  Widget build(BuildContext context) {
    return BlocBuilder<UsersBloc, UsersState>(
      builder: (context, state) {
        return switch (state) {
          UsersInitial() => Center(
              child: ElevatedButton(
                onPressed: () => context.read<UsersBloc>().add(UsersFetchRequested()),
                child: const Text('Load'),
              ),
            ),
          UsersLoading() => const Center(child: CircularProgressIndicator()),
          UsersError(:final message) => Center(
              child: Column(
                mainAxisAlignment: MainAxisAlignment.center,
                children: [
                  Text('Error: $message'),
                  ElevatedButton(
                    onPressed: () => context
                        .read<UsersBloc>()
                        .add(UsersFetchRequested()),
                    child: const Text('Retry'),
                  ),
                ],
              ),
            ),
          UsersLoaded(:final users) => ListView.builder(
              itemCount: users.length,
              itemBuilder: (context, index) => UserTile(user: users[index]),
            ),
        };
      },
    );
  }
}

BLoC menawarkan kontrol granular atas setiap transisi state. Riverpod mengotomatiskan lebih banyak melalui AsyncValue dan logika retry bawaan.

Siap menguasai wawancara Flutter Anda?

Berlatih dengan simulator interaktif, flashcards, dan tes teknis kami.

Jelajahi Flutter

Dependensi antar State: Komposisi dan Injeksi

Aplikasi nyata melibatkan state yang saling bergantung. Pengelolaan dependensi ini membedakan kedua pendekatan secara signifikan.

Komposisi dengan Riverpod

composition_riverpod.dartdart

// Base provider: configuration
@riverpod
ApiClient apiClient(Ref ref) {
  final baseUrl = ref.watch(environmentProvider).apiUrl;
  return ApiClient(baseUrl: baseUrl);
}

// Dependent provider: repository
@riverpod
ProductRepository productRepository(Ref ref) {
  // Automatic client injection
  final client = ref.watch(apiClientProvider);
  return ProductRepository(client);
}

// Provider with parameter: product by ID
@riverpod
Future<Product> product(Ref ref, String productId) async {
  final repository = ref.watch(productRepositoryProvider);
  return repository.getProduct(productId);
}

// Derived provider: filtered products
@riverpod
List<Product> filteredProducts(Ref ref) {
  final products = ref.watch(productsProvider).valueOrNull ?? [];
  final filter = ref.watch(productFilterProvider);

  return products.where((p) => p.category == filter.category).toList();
}

// Usage with parameter
class ProductDetailScreen extends ConsumerWidget {
  final String productId;

  const ProductDetailScreen({super.key, required this.productId});

  @override
  Widget build(BuildContext context, WidgetRef ref) {
    // family allows passing parameters
    final productAsync = ref.watch(productProvider(productId));

    return productAsync.when(
      loading: () => const ProductSkeleton(),
      error: (e, _) => ErrorWidget(error: e),
      data: (product) => ProductDetails(product: product),
    );
  }
}

Komposisi dengan BLoC

composition_bloc.dartdart

// Repository injected into the Bloc
class ProductBloc extends Bloc<ProductEvent, ProductState> {
  final ProductRepository _repository;
  final CartBloc _cartBloc;
  late final StreamSubscription _cartSubscription;

  ProductBloc({
    required ProductRepository repository,
    required CartBloc cartBloc,
  })  : _repository = repository,
        _cartBloc = cartBloc,
        super(ProductInitial()) {
    on<ProductFetchRequested>(_onFetchRequested);
    on<ProductAddedToCart>(_onAddedToCart);

    // Listen to cart changes
    _cartSubscription = _cartBloc.stream.listen((cartState) {
      // React to cart changes
      if (cartState is CartUpdated) {
        add(ProductCartSyncRequested(cartState.items));
      }
    });
  }

  Future<void> _onFetchRequested(
    ProductFetchRequested event,
    Emitter<ProductState> emit,
  ) async {
    emit(ProductLoading());
    try {
      final product = await _repository.getProduct(event.productId);
      // Check if product is in cart
      final isInCart = _cartBloc.state.contains(product.id);
      emit(ProductLoaded(product, isInCart: isInCart));
    } catch (e) {
      emit(ProductError(e.toString()));
    }
  }

  @override
  Future<void> close() {
    _cartSubscription.cancel();
    return super.close();
  }
}

// Configuration with dependency injection
class ProductsPage extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return BlocProvider(
      create: (context) => ProductBloc(
        repository: context.read<ProductRepository>(),
        cartBloc: context.read<CartBloc>(),
      )..add(ProductFetchRequested()),
      child: const ProductsView(),
    );
  }
}

Riverpod mengelola dependensi secara deklaratif. BLoC memerlukan pengelolaan manual atas subscription antar Bloc.

Kemudahan Pengujian dan Mocking

Pengujian merupakan kriteria penentu untuk proyek profesional. Kedua solusi unggul dalam bidang ini dengan pendekatan berbeda. Keterampilan pengujian sering dievaluasi dalam wawancara Flutter.

Pengujian dengan Riverpod

test_riverpod.dartdart

import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:mocktail/mocktail.dart';

class MockUserRepository extends Mock implements UserRepository {}

void main() {
  group('UserProvider Tests', () {
    late MockUserRepository mockRepository;

    setUp(() {
      mockRepository = MockUserRepository();
    });

    test('returns users from repository', () async {
      // Arrange
      final expectedUsers = [User(id: '1', name: 'Test')];
      when(() => mockRepository.fetchUsers())
          .thenAnswer((_) async => expectedUsers);

      // ProviderContainer.test auto-disposes after test
      final container = ProviderContainer.test(
        overrides: [
          userRepositoryProvider.overrideWithValue(mockRepository),
        ],
      );

      // Act
      final users = await container.read(usersProvider.future);

      // Assert
      expect(users, expectedUsers);
      verify(() => mockRepository.fetchUsers()).called(1);
    });

    test('handles repository errors', () async {
      when(() => mockRepository.fetchUsers())
          .thenThrow(Exception('Network error'));

      final container = ProviderContainer.test(
        overrides: [
          userRepositoryProvider.overrideWithValue(mockRepository),
        ],
      );

      expect(
        () => container.read(usersProvider.future),
        throwsException,
      );
    });
  });
}

Pengujian dengan BLoC

test_bloc.dartdart

import 'package:bloc_test/bloc_test.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:mocktail/mocktail.dart';

class MockUserRepository extends Mock implements UserRepository {}

void main() {
  group('UsersBloc Tests', () {
    late MockUserRepository mockRepository;

    setUp(() {
      mockRepository = MockUserRepository();
    });

    // blocTest simplifies state sequence testing
    blocTest<UsersBloc, UsersState>(
      'emits [Loading, Loaded] when fetch succeeds',
      build: () {
        when(() => mockRepository.fetchUsers())
            .thenAnswer((_) async => [User(id: '1', name: 'Test')]);
        return UsersBloc(mockRepository);
      },
      act: (bloc) => bloc.add(UsersFetchRequested()),
      expect: () => [
        isA<UsersLoading>(),
        isA<UsersLoaded>().having(
          (s) => s.users.length,
          'users count',
          1,
        ),
      ],
    );

    blocTest<UsersBloc, UsersState>(
      'emits [Loading, Error] when fetch fails',
      build: () {
        when(() => mockRepository.fetchUsers())
            .thenThrow(Exception('Network error'));
        return UsersBloc(mockRepository);
      },
      act: (bloc) => bloc.add(UsersFetchRequested()),
      expect: () => [
        isA<UsersLoading>(),
        isA<UsersError>(),
      ],
    );
  });
}

Paket bloc_test menawarkan sintaks khusus untuk menguji urutan state. Riverpod 3.x menambahkan ProviderContainer.test() untuk disposal otomatis dan NotifierProvider.overrideWithBuild() untuk mocking hanya method build.

Cakupan Pengujian

Menguji hanya kasus nominal tidak cukup. Pengujian harus mencakup error jaringan, timeout, state batas, dan transisi state yang tak terduga. Untuk praktik pengujian komprehensif, lihat panduan pengujian Flutter.

Performa dan Optimasi Rebuild

Performa berdampak langsung pada pengalaman pengguna. Kedua solusi menawarkan mekanisme optimasi yang berbeda.

Optimasi dengan Riverpod

perf_riverpod.dartdart

// select to rebuild only if targeted value changes
class UserNameWidget extends ConsumerWidget {
  @override
  Widget build(BuildContext context, WidgetRef ref) {
    // Rebuilds only if user.name changes
    final name = ref.watch(userProvider.select((user) => user.name));
    return Text(name);
  }
}

// Provider with automatic caching
@riverpod
ExpensiveResult expensiveComputation(Ref ref) {
  final input = ref.watch(inputProvider);
  // Computation automatically cached
  return performExpensiveComputation(input);
}

// keepAlive with timer for temporary caching
@riverpod
Future<List<Product>> searchResults(Ref ref, String query) async {
  // Temporary keepAlive during typing
  final link = ref.keepAlive();

  // Timer to release after inactivity
  final timer = Timer(const Duration(seconds: 30), link.close);
  ref.onDispose(timer.cancel);

  return searchProducts(query);
}

Optimasi dengan BLoC

perf_bloc.dartdart

// buildWhen limits rebuilds conditionally
class UserNameWidget extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return BlocBuilder<UserBloc, UserState>(
      // Rebuilds only if name changes
      buildWhen: (previous, current) {
        if (previous is UserLoaded && current is UserLoaded) {
          return previous.user.name != current.user.name;
        }
        return true;
      },
      builder: (context, state) {
        if (state is UserLoaded) {
          return Text(state.user.name);
        }
        return const SizedBox.shrink();
      },
    );
  }
}

// BlocSelector to extract a specific value
class UserAvatarWidget extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return BlocSelector<UserBloc, UserState, String?>(
      // Select only the avatar URL
      selector: (state) => state is UserLoaded ? state.user.avatarUrl : null,
      builder: (context, avatarUrl) {
        if (avatarUrl == null) return const DefaultAvatar();
        return NetworkImage(avatarUrl);
      },
    );
  }
}

Kedua solusi menawarkan optimasi granular. Riverpod dengan select, BLoC dengan buildWhen dan BlocSelector. Untuk teknik performa lanjutan, lihat panduan optimasi performa Flutter.

Studi Kasus Praktis: Autentikasi Lengkap

Sistem autentikasi menggambarkan pola nyata untuk setiap solusi. Kasus ini menggabungkan state persisten, panggilan API, dan navigasi.

Autentikasi dengan Riverpod

auth_riverpod.dartdart

// Authentication state with sealed class
sealed class AuthState {
  const AuthState();
}
final class AuthInitial extends AuthState {
  const AuthInitial();
}
final class AuthLoading extends AuthState {
  const AuthLoading();
}
final class AuthAuthenticated extends AuthState {
  final User user;
  const AuthAuthenticated(this.user);
}
final class AuthUnauthenticated extends AuthState {
  final String? error;
  const AuthUnauthenticated([this.error]);
}

// Notifier to manage auth state
@riverpod
class Auth extends _$Auth {
  @override
  Future<AuthState> build() async {
    final storage = ref.watch(secureStorageProvider);
    final repository = ref.watch(authRepositoryProvider);
    
    final token = await storage.getToken();
    if (token != null) {
      try {
        final user = await repository.getCurrentUser(token);
        return AuthAuthenticated(user);
      } catch (_) {
        await storage.deleteToken();
        return const AuthUnauthenticated();
      }
    }
    return const AuthUnauthenticated();
  }

  Future<void> login(String email, String password) async {
    state = const AsyncLoading();
    final repository = ref.read(authRepositoryProvider);
    final storage = ref.read(secureStorageProvider);
    
    try {
      final result = await repository.login(email, password);
      await storage.saveToken(result.token);
      state = AsyncData(AuthAuthenticated(result.user));
    } catch (e) {
      state = AsyncData(AuthUnauthenticated(e.toString()));
    }
  }

  Future<void> logout() async {
    final storage = ref.read(secureStorageProvider);
    await storage.deleteToken();
    state = const AsyncData(AuthUnauthenticated());
  }
}

// Redirect based on auth state
@riverpod
GoRouter router(Ref ref) {
  final authState = ref.watch(authProvider);

  return GoRouter(
    redirect: (context, state) {
      final isAuth = authState.valueOrNull is AuthAuthenticated;
      final isAuthRoute = state.matchedLocation.startsWith('/auth');

      if (!isAuth && !isAuthRoute) return '/auth/login';
      if (isAuth && isAuthRoute) return '/home';
      return null;
    },
    routes: [...],
  );
}

Autentikasi dengan BLoC

auth_bloc.dartdart

// Exhaustive states for authentication
sealed class AuthState {
  const AuthState();
}
final class AuthInitial extends AuthState {
  const AuthInitial();
}
final class AuthCheckInProgress extends AuthState {
  const AuthCheckInProgress();
}
final class AuthLoginInProgress extends AuthState {
  const AuthLoginInProgress();
}
final class AuthSuccess extends AuthState {
  final User user;
  const AuthSuccess(this.user);
}
final class AuthFailure extends AuthState {
  final String error;
  const AuthFailure(this.error);
}
final class AuthLoggedOut extends AuthState {
  const AuthLoggedOut();
}

// Authentication events
sealed class AuthEvent {
  const AuthEvent();
}
final class AuthCheckRequested extends AuthEvent {
  const AuthCheckRequested();
}
final class AuthLoginSubmitted extends AuthEvent {
  final String email;
  final String password;
  const AuthLoginSubmitted(this.email, this.password);
}
final class AuthLogoutRequested extends AuthEvent {
  const AuthLogoutRequested();
}

class AuthBloc extends Bloc<AuthEvent, AuthState> {
  final AuthRepository _repository;
  final SecureStorage _storage;

  AuthBloc({
    required AuthRepository repository,
    required SecureStorage storage,
  })  : _repository = repository,
        _storage = storage,
        super(const AuthInitial()) {
    on<AuthCheckRequested>(_onCheckRequested);
    on<AuthLoginSubmitted>(_onLoginSubmitted);
    on<AuthLogoutRequested>(_onLogoutRequested);
  }

  Future<void> _onCheckRequested(
    AuthCheckRequested event,
    Emitter<AuthState> emit,
  ) async {
    emit(const AuthCheckInProgress());
    final token = await _storage.getToken();

    if (token == null) {
      emit(const AuthLoggedOut());
      return;
    }

    try {
      final user = await _repository.getCurrentUser(token);
      emit(AuthSuccess(user));
    } catch (_) {
      await _storage.deleteToken();
      emit(const AuthLoggedOut());
    }
  }

  Future<void> _onLoginSubmitted(
    AuthLoginSubmitted event,
    Emitter<AuthState> emit,
  ) async {
    emit(const AuthLoginInProgress());
    try {
      final result = await _repository.login(event.email, event.password);
      await _storage.saveToken(result.token);
      emit(AuthSuccess(result.user));
    } catch (e) {
      emit(AuthFailure(e.toString()));
    }
  }

  Future<void> _onLogoutRequested(
    AuthLogoutRequested event,
    Emitter<AuthState> emit,
  ) async {
    await _storage.deleteToken();
    emit(const AuthLoggedOut());
  }
}

Kedua implementasi menangani fungsionalitas yang sama dengan gaya berbeda. BLoC membuat setiap transisi eksplisit, Riverpod menyederhanakan sintaks.

Tabel Perbandingan Ringkasan

Kriteria	Riverpod 3.x	BLoC 9.x
Kurva Belajar	Sedang	Lebih curam
Boilerplate	Minim (dengan codegen)	Signifikan
Type Safety	Sangat baik	Sangat baik
Kemudahan Pengujian	Sangat baik	Sangat baik
Automatic Retry	Bawaan	Implementasi manual
Offline Persistence	Dukungan eksperimental	Paket eksternal
Pelacakan	Melalui DevTools	Events/States eksplisit
Komposisi	Otomatis	Manual
Code Generation	Direkomendasikan	Tidak diperlukan
Ukuran Tim	Fleksibel	Tim besar

Rekomendasi Berdasarkan Konteks

Pemilihan antara Riverpod dan BLoC bergantung pada beberapa faktor kontekstual.

Pilih Riverpod ketika:

Tim mengutamakan keringkasan dan produktivitas
Proyek memerlukan komposisi state yang fleksibel
Developer berasal dari React atau framework reaktif lain
Automatic retry dan pemulihan error penting
Offline persistence menjadi kebutuhan

Pilih BLoC ketika:

Tim menghargai pola yang ketat dan dapat diprediksi
Proyek memerlukan pelacakan event yang lengkap untuk audit
Junior developer diuntungkan dari arsitektur yang dipaksakan
Debugging memerlukan riwayat transisi detail
Industri membutuhkan audit trail (fintech, healthcare)

Sumber

Riverpod 3.0 What's New: automatic retry, pause/resume, offline persistence
Riverpod 3.0 Migration Guide: Notifier menggantikan StateNotifier
flutter_bloc 9.0.0 Changelog: EmittableStateStreamableSource, peningkatan pengujian
BLoC Documentation: pola resmi dan best practice

Hal yang Perlu Diingat tentang Riverpod vs BLoC di 2026

Riverpod dan BLoC secara efektif menangani kebutuhan state management Flutter. Riverpod 3.x unggul dalam ergonomi, penanganan error otomatis, dan komposisi fleksibel. BLoC 9.x memimpin dalam struktur, keterprediksiaan, dan keterlacakan tingkat enterprise. Kedua solusi menawarkan kemudahan pengujian yang sangat baik dan performa optimal.

Daftar Periksa Keputusan

Evaluasi ukuran dan pengalaman tim
Pertimbangkan kompleksitas aliran data
Analisis kebutuhan pelacakan dan debugging
Uji kedua solusi pada prototipe
Verifikasi konsistensi dengan arsitektur yang ada

Mulai berlatih!

Uji pengetahuan Anda dengan simulator wawancara dan tes teknis kami.

Buat akun gratis saya

Pilihan terbaik tetap yang dikuasai dan dipelihara tim secara efektif. Konsistensi dalam penerapan lebih utama daripada pemilihan solusinya itu sendiri. Untuk pola khusus Dart seperti isolate dan concurrency, lihat panduan isolate dan concurrency Dart.

State Management Flutter: Riverpod vs BLoC - Panduan Perbandingan Lengkap