콘텐츠 대표 이미지 - Flutter 상태 관리: 춘추전국시대 완벽 가이드

Flutter 상태 관리: 춘추전국시대 완벽 가이드

안녕! Flutter 개발의 세계에 발을 들인 걸 환영해. 아마 코딩을 좀 해봤다면 '상태 관리'라는 말을 지겹도록 들었을 거야. 맞아, 바로 그 상태 관리! 어떤 사람에겐 애증의 대상이고, 어떤 사람에겐 예술의 경지이며, 또 어떤 사람에겐 그냥 '돌아가게만 해줘'의 대상이지. 😂

Flutter 앱을 만든다는 건, 마치 살아있는 유기체를 만드는 것과 같아. 사용자의 터치 한 번, 데이터 로딩 한 번에 따라 화면이 실시간으로 바뀌어야 하거든. 이때 앱의 '상태'를 어떻게 관리하느냐가 앱의 성능, 안정성, 그리고 무엇보다 너의 정신 건강을 좌우하게 돼. 정말이야!

이 글에서는 Flutter 상태 관리의 춘추전국시대를 함께 여행해볼 거야. 왕초보 시절 누구나 거쳐 가는 `setState()`부터, Flutter 공식 문서가 추천하는 `Provider`, 대규모 프로젝트의 구원자 `BLoC`, 그리고 혜성처럼 등장한 `Riverpod`와 `GetX`까지. 각 선수들의 특징과 장단점을 친구에게 설명하듯 쉽고 재미있게, 하지만 깊이 있게 파헤쳐 볼게. 이 글을 다 읽고 나면, 더 이상 상태 관리 앞에서 작아지지 않는 너 자신을 발견하게 될 거야. 자, 준비됐어? 그럼 시작해보자!

🤔そもそも '상태(State)'가 뭔데? 왜 이렇게 중요해?

상태 관리 라이브러리를 파헤치기 전에, 우리 잠시 숨을 고르고 '상태' 그 자체에 대해 이야기해보자. 개발자들이 '상태', '상태' 노래를 부르는데, 대체 그게 뭘까? 아주 간단해. 상태는 '언제든지 변할 수 있는 데이터'야.

네가 지금 보고 있는 화면의 모든 것이 상태를 기반으로 하고 있어. 유튜브 영상의 '좋아요' 개수, 인스타그램의 팔로워 수, 쇼핑몰 앱의 장바구니 목록, 게임 캐릭터의 HP와 MP... 이 모든 게 다 상태야. 사용자가 '좋아요' 버튼을 누르면 숫자가 올라가고, 친구를 팔로우하면 팔로워 수가 늘어나지. 이렇게 데이터가 변하면, 화면도 그에 맞춰서 바뀌어야 해. 바로 이 지점에서 상태 관리의 중요성이 폭발하는 거야.

Flutter는 선언형(Declarative) UI 프레임워크야. 이게 무슨 말이냐면, "버튼을 눌렀을 때, 저기 있는 텍스트를 '안녕'으로 바꿔줘!" 라고 명령하는 게 아니라, "이 텍스트는 항상 '인사말'이라는 상태 값을 보여줘야 해." 라고 선언하는 방식이야. 그리고 우리는 '인사말'이라는 상태 값만 '안녕'으로 바꿔주면 돼. 그러면 Flutter가 알아서 "어? 상태가 바뀌었네? 그럼 이 텍스트를 다시 그려야겠다!" 하고 화면을 업데이트해주는 거지.

이 유명한 공식을 기억해둬. UI = f(state). 즉, UI는 상태의 결과물(함수)이라는 뜻이야. 이 공식 하나만 제대로 이해해도 Flutter 개발의 절반은 먹고 들어가는 셈이야.

UI = f(State) Flutter의 핵심 원리: UI는 상태(State)를 기반으로 그려진다! State (상태) 앱의 현재 데이터를 나타내는 객체 const state = { isLoggedIn : true , userName : '재능러' , cartItems : 3 }; f (Build Function) UI (화면) 상태를 기반으로 그려진 시각적 결과 My App '재능러'님 환영합니다! 장바구니: 3개 상태(State)가 변경되면 UI를 다시 그린다 (Rebuild)

임시 상태(Ephemeral State) vs 앱 상태(App State)

모든 상태가 똑같이 취급되진 않아. Flutter에서는 상태를 크게 두 종류로 나눠서 생각해. 이건 정말 중요한 개념이니 꼭 기억해둬!

1. 임시 상태 (Ephemeral State 또는 Local State)

이름 그대로 '임시적인' 상태야. 특정 위젯 하나에만 국한된 상태를 말해. 예를 들면,

  • 페이지네이션에서 현재 보고 있는 페이지 번호
  • `BottomNavigationBar`에서 현재 선택된 탭
  • 애니메이션의 현재 진행 상태
  • `TextField`에 입력 중인 텍스트

이런 데이터들은 다른 위젯들이 굳이 알 필요가 없어. `BottomNavigationBar`의 현재 탭 정보가 프로필 페이지나 설정 페이지에 영향을 주진 않잖아? 이렇게 한 위젯 안에서만 생성되고 사용되고 사라지는 상태는 임시 상태라고 해. 이런 건 보통 `StatefulWidget`과 `setState()`를 사용해서 간단하게 처리할 수 있어.

2. 앱 상태 (App State 또는 Shared State)

이게 바로 우리가 앞으로 깊게 다룰 '진짜' 문제야. 앱 상태는 여러 위젯, 심지어 앱의 여러 화면에 걸쳐 공유되어야 하는 상태를 말해. 예를 들면,

  • 사용자의 로그인 정보
  • 앱의 테마 설정 (다크 모드 / 라이트 모드)
  • 쇼핑몰 앱의 장바구니 목록
  • 소셜 미디어 앱의 알림 목록

생각해봐. 사용자가 로그인하면 '홈 화면'에도, '마이페이지'에도, '설정 화면'에도 로그인된 상태가 반영되어야 하잖아. 장바구니에 상품을 담으면, '상품 상세 페이지'에서도, '장바구니 페이지'에서도, 상단의 '미니 카트 아이콘'에도 그 정보가 똑같이 보여야 하고. 이런 상태를 임시 상태처럼 관리하려고 하면... 끔찍한 '코드 스파게티'가 펼쳐질 거야. 🍝

바로 이 앱 상태를 어떻게 효율적이고 깔끔하게 관리할 것인가? 이것이 Flutter 상태 관리의 핵심 질문이자, 수많은 라이브러리들이 탄생한 이유야.

👑 기본 중의 기본: StatefulWidget과 setState()

모든 여정에는 시작점이 있는 법! Flutter 상태 관리의 첫걸음은 바로 프레임워크에 내장된 `StatefulWidget`과 `setState()`야. 다른 라이브러리를 배우기 전에 이걸 확실히 이해하고 넘어가야 해. 왜냐하면 모든 상태 관리의 기본 원리가 여기에 녹아있거든.

`StatelessWidget`은 말 그대로 상태가 없는, 한 번 그려지면 바뀌지 않는 정적인 위젯이야. 반면 `StatefulWidget`은 '상태'를 가질 수 있고, 그 상태가 변함에 따라 스스로를 다시 그릴 수 있는 동적인 위젯이지.

어떻게 다시 그리냐고? 바로 `setState()` 메소드를 통해서야. `setState()`가 호출되면, Flutter 프레임워크에게 이렇게 외치는 것과 같아. "야! 나 상태 바뀌었어! 다음 프레임에 나 좀 다시 그려줘!" 그러면 Flutter는 해당 위젯의 `build` 메소드를 다시 실행해서 변경된 상태가 반영된 새로운 UI를 그려주는 거지.

카운터 앱으로 보는 setState()의 작동 방식

백문이 불여일견! 가장 클래식한 카운터 예제로 `setState()`를 만나보자.


import 'package:flutter/material.dart';

class CounterPage extends StatefulWidget {
  const CounterPage({super.key});

  @override
  State<CounterPage> createState() => _CounterPageState();
}

class _CounterPageState extends State<CounterPage> {
  // 1. 상태 변수 선언 (이 위젯의 '임시 상태')
  int _counter = 0;

  // 2. 상태를 변경하는 메소드
  void _incrementCounter() {
    // 3. setState() 호출!
    setState(() {
      // 이 블록 안에서 상태를 변경해야 Flutter가 알아챔
      _counter++;
    });
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: const Text('setState Counter'),
      ),
      body: Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: <Widget>[
            const Text('You have pushed the button this many times:'),
            Text(
              '$_counter', // 4. 변경된 상태를 UI에 표시
              style: Theme.of(context).textTheme.headlineMedium,
            ),
          ],
        ),
      ),
      floatingActionButton: FloatingActionButton(
        onPressed: _incrementCounter, // 5. 버튼을 누르면 메소드 호출
        tooltip: 'Increment',
        child: const Icon(Icons.add),
      ),
    );
  }
}
        

코드를 하나씩 뜯어보자.

  1. `_counter` 변수: 이 `_CounterPageState` 클래스가 소유한 상태야. 이 숫자가 변하면 화면도 변해야 해.
  2. `_incrementCounter()` 메소드: 상태를 직접적으로 바꾸는 로직이 담겨있어.
  3. `setState(() { ... })` 호출: 이게 핵심이야! 그냥 `_counter++`만 하면 데이터 값은 바뀌지만, Flutter는 그 사실을 몰라. 화면은 절대 바뀌지 않아. 반드시 `setState()`로 감싸줘야 "나 바뀌었으니 다시 그려줘!"라는 신호가 전달돼.
  4. `Text('$_counter')` 위젯: `build` 메소드가 다시 실행될 때마다, 이 위젯은 새로운 `_counter` 값을 가지고 다시 그려져.
  5. `onPressed: _incrementCounter`: 사용자가 버튼을 누르는 행위(이벤트)가 상태 변경을 촉발하는 시작점이야.

👍 장점

  • 단순함: Flutter에 내장되어 있어 별도의 라이브러리 설치가 필요 없고, 개념이 아주 직관적이야.
  • 명확함: 상태 변경과 UI 업데이트의 흐름을 이해하기 쉬워.
  • 임시 상태에 최적: 위에서 말한 '임시 상태'를 다루는 데는 이보다 더 좋은 방법이 없을 정도야. 괜히 복잡한 라이브러리를 쓰는 건 오버 엔지니어링일 수 있어.

👎 단점

  • 상태의 위치: 상태가 UI 코드(위젯) 안에 직접적으로 존재해. 앱이 복잡해지면 비즈니스 로직과 UI가 뒤섞여서 코드를 유지보수하기 어려워져.
  • Prop Drilling (속성 전달 지옥): 이게 가장 큰 문제야. 만약 최상위 위젯의 상태가 저~기 아래 깊숙한 곳에 있는 위젯에게 필요하다면? 그 상태를 사용하지도 않는 중간의 모든 위젯들을 거쳐서 일일이 전달해줘야 해. 이건 정말 끔찍한 경험이야.
  • 불필요한 리빌드: `setState()`는 기본적으로 해당 `State` 객체가 속한 위젯 전체를 다시 빌드해. 만약 아주 큰 위젯 트리에서 작은 텍스트 하나만 바꾸려고 `setState()`를 호출하면, 그 큰 위젯 트리가 통째로 리빌드될 수 있어. 물론 Flutter가 똑똑해서 실제 픽셀을 다시 그리는 건 최소화하지만, `build` 메소드 자체는 실행되므로 성능에 영향을 줄 수 있어.

결론적으로, `StatefulWidget`과 `setState()`는 Flutter 개발의 기초 체력이야. 이걸 모르면 다음 단계로 나아갈 수 없어. 하지만 이걸로 모든 걸 해결하려는 순간, 당신의 코드는 걷잡을 수 없이 복잡해질 거야. 이제 이 `Prop Drilling` 문제를 해결하기 위한 Flutter의 첫 번째 대답을 만나러 가보자.

🏛️ 구조의 시작: InheritedWidget

자, `setState()`의 가장 큰 단점이 'Prop Drilling'이라고 했지? 상태를 저 아래 있는 자식 위젯에게 전달하기 위해 중간에 있는 모든 위젯들을 괴롭혀야 하는 바로 그 문제 말이야. Flutter 개발자들도 당연히 이 문제를 알고 있었고, 그래서 프레임워크 내에 해결책을 마련해 뒀어. 그 이름은 바로 `InheritedWidget`!

`InheritedWidget`은 이름 그대로 '상속되는 위젯'이야. 위젯 트리의 특정 위치에 `InheritedWidget`을 배치하면, 그 아래에 있는 모든 자손 위젯들이 `BuildContext`를 통해 아주 쉽게 `InheritedWidget`의 데이터에 접근할 수 있게 돼. 중간 위젯들을 거칠 필요 없이 말이지! 마치 와이파이 공유기 같아. 공유기(`InheritedWidget`)를 설치해두면, 그 범위 안에 있는 어떤 기기(`자손 위젯`)든 비밀번호(`BuildContext`)만 알면 바로 인터넷(`데이터`)에 접속할 수 있는 거지.

Flutter 상태 관리 비교 Prop Drilling vs Provider / InheritedWidget 문제점: Prop Drilling Widget A [ state ] Widget B (상태 불필요, 단순 전달) Widget C (상태 불필요, 단순 전달) Widget D ✨ state 사용! 상태가 필요 없는 중간 위젯들을 모두 거쳐야 하는 비효율 발생 해결책: 상태 관리 패턴 Provider / InheritedWidget [ state 제공 ] Widget B Widget C Widget D ✨ state 직접 사용! 중간 위젯을 건너뛰고 필요한 곳에 직접 상태를 전달하여 효율성 증대

어떻게 사용하는데? (보일러플레이트 주의)

개념은 정말 환상적이지? 그런데 `InheritedWidget`은 치명적인 단점이 있어. 바로 작성해야 할 코드가 너무 많고 복잡하다는 거야. 이걸 '보일러플레이트(Boilerplate) 코드'라고 불러. 기능에 비해 반복적으로 작성해야 하는 코드가 많은 거지. 직접 코드를 보면 바로 이해될 거야.


// 1. InheritedWidget을 상속하는 클래스 생성
class MyDataProvider extends InheritedWidget {
  // 공유하고 싶은 데이터
  final int data;

  const MyDataProvider({
    super.key,
    required this.data,
    required super.child,
  });

  // 2. 자식 위젯이 데이터에 접근할 수 있게 해주는 static 메소드
  // 이게 핵심! context.dependOnInheritedWidgetOfExactType<T>()
  static MyDataProvider? of(BuildContext context) {
    return context.dependOnInheritedWidgetOfExactType<MyDataProvider>();
  }

  // 3. 위젯이 업데이트되어야 하는지를 결정하는 메소드
  @override
  bool updateShouldNotify(MyDataProvider oldWidget) {
    // 이전 데이터와 현재 데이터가 다르면 true를 반환하여
    // 이 위젯에 의존하는 자식 위젯들을 리빌드함
    return data != oldWidget.data;
  }
}

// 사용 예시
class MyParentWidget extends StatefulWidget {
  const MyParentWidget({super.key});

  @override
  State<MyParentWidget> createState() => _MyParentWidgetState();
}

class _MyParentWidgetState extends State<MyParentWidget> {
  int _count = 0;

  @override
  Widget build(BuildContext context) {
    // 4. 위젯 트리에 InheritedWidget을 주입
    return MyDataProvider(
      data: _count,
      child: Column(
        children: [
          ElevatedButton(
            onPressed: () => setState(() => _count++),
            child: const Text('증가'),
          ),
          const MyChildWidget(), // 데이터를 사용하지 않는 중간 위젯
          const MyGrandChildWidget(), // 데이터를 사용하는 최종 위젯
        ],
      ),
    );
  }
}

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

  @override
  Widget build(BuildContext context) {
    // 5. of() 메소드를 통해 데이터에 접근!
    final provider = MyDataProvider.of(context);
    return Text('손자 위젯이 받은 데이터: ${provider?.data ?? 0}');
  }
}
        

어때? 그냥 숫자 하나 공유하려고 했는데 코드가 꽤 길지? `InheritedWidget`을 상속받고, `of` 메소드를 만들고, `updateShouldNotify`를 구현하고... 이걸 매번 하기는 너무 번거로워.

특히 `updateShouldNotify`는 성능의 핵심이야. 여기서 `true`를 반환하면, `MyDataProvider.of(context)`를 호출한 모든 자손 위젯들이 리빌드돼. 만약 데이터가 바뀌지 않았는데도 `true`를 반환하면 불필요한 리빌드가 발생하고, 반대로 데이터가 바뀌었는데 `false`를 반환하면 화면이 업데이트되지 않는 끔찍한 버그가 생기겠지.

💡 `dependOnInheritedWidgetOfExactType`의 비밀

이름이 길어서 무섭게 생겼지만, 사실 두 가지 중요한 일을 해.

  1. 위젯 트리에서 가장 가까운 `MyDataProvider`를 찾아서 그 인스턴스를 반환해줘.
  2. 이 메소드를 호출한 위젯을 `MyDataProvider`의 '구독자'로 등록해. 그래서 나중에 `MyDataProvider`가 업데이트되면(정확히는 `updateShouldNotify`가 true를 반환하면), Flutter는 이 구독자 목록을 보고 "아, 얘네들 리빌드해줘야겠다!"라고 알게 되는 거야. 이게 `InheritedWidget`이 효율적인 이유지.

👍 장점

  • 고성능: Flutter 프레임워크의 가장 낮은 레벨에서 작동하기 때문에 매우 빠르고 효율적이야. 데이터가 변경되었을 때 정말로 그 데이터에 의존하는 위젯만 리빌드해.
  • Prop Drilling 해결: `InheritedWidget`의 존재 이유! 위젯 트리를 깔끔하게 유지할 수 있어.
  • 모든 것의 기초: `Provider`, `Riverpod`, `flutter_bloc` 등 우리가 앞으로 배울 대부분의 인기 있는 상태 관리 라이브러리들이 내부적으로 `InheritedWidget`을 사용하거나 그 원리를 차용하고 있어. 이걸 이해하면 다른 라이브러리들의 작동 방식을 더 깊이 이해할 수 있게 돼.

👎 단점

  • 엄청난 보일러플레이트: 위 코드에서 봤듯이, 간단한 기능을 위해 작성해야 할 코드가 너무 많아. 생산성이 떨어지지.
  • 상태와 UI의 결합: 여전히 상태(데이터)와 그 상태를 제공하는 로직(`InheritedWidget`)이 위젯 트리에 묶여 있어. 상태 로직을 분리하고 재사용하기가 어려워.
  • 상태 분리/결합의 어려움: 여러 종류의 데이터를 제공하려면 여러 `InheritedWidget`을 중첩해야 하는데, 코드가 지저분해지기 쉬워.

결론적으로, 현대 Flutter 개발에서 `InheritedWidget`을 직접 사용하는 경우는 거의 없어. 마치 우리가 자동차를 운전하기 위해 엔진의 연소 과정을 직접 제어하지 않는 것과 같아. 하지만 엔진의 원리를 알면 운전을 더 잘할 수 있듯이, `InheritedWidget`을 이해하면 다른 상태 관리 솔루션들을 훨씬 더 잘 활용할 수 있게 돼. 이제 이 `InheritedWidget`의 불편함을 해소하기 위해 등장한 영웅, `Provider`를 만나보자!

🏆 대중의 선택: Provider

`InheritedWidget`의 강력함은 인정하지만, 그 보일러플레이트는 정말이지... 너무 부담스러웠어. 바로 그때, 구글 개발자이자 Flutter 커뮤니티의 슈퍼스타인 Remi Rousselet이 나타나 `Provider`라는 패키지를 만들었어. `Provider`는 `InheritedWidget`을 아주 사용하기 쉽고 편하게 포장한 '래퍼(Wrapper)' 라이브러리야.

`Provider`의 등장은 가히 혁명적이었어. 복잡했던 상태 관리를 몇 줄의 코드로 줄여주었고, 그 덕분에 수많은 개발자들이 상태 관리의 고통에서 해방될 수 있었지. 심지어 Flutter 공식 문서에서도 상태 관리 입문용으로 `Provider`를 추천할 정도니, 그 위상을 짐작할 수 있겠지? 지금도 수많은 앱들이 `Provider`를 기반으로 만들어지고 있어.

`Provider`의 핵심 철학은 '필요한 것만, 필요할 때에'야. 데이터를 필요한 위젯에 효율적으로 제공하고, 불필요한 리빌드를 최소화하는 `InheritedWidget`의 장점은 그대로 가져오면서, 개발자가 사용하기는 훨씬 쉽게 만든 거지.

Provider의 핵심 삼총사: ChangeNotifier, ChangeNotifierProvider, Consumer

Provider를 제대로 사용하려면 이 세 친구와 친해져야 해. 라디오 방송에 비유하면 아주 쉬워!

  1. `ChangeNotifier` (라디오 방송국 스태프): 상태(데이터)를 가지고 있고, 상태가 변경되면 "모두 주목! 새로운 소식입니다!"라고 외치는 역할을 해. 이 외침이 바로 `notifyListeners()` 메소드야. 상태 로직은 이 클래스 안에 작성하게 돼.
  2. `ChangeNotifierProvider` (라디오 송출탑): 위에서 만든 `ChangeNotifier`를 위젯 트리 전체에 방송해주는 송출탑이야. 이 위젯 아래에 있는 모든 자손 위젯들은 이 방송을 들을 수 있는 상태가 돼.
  3. `Consumer` / `context.watch` (라디오 청취자): 송출탑이 보내는 방송을 듣고 있다가, 새로운 소식(`notifyListeners()` 호출)이 들리면 즉각 반응(리빌드)하는 열혈 청취자야.

카운터 앱을 `Provider` 버전으로 바꿔보면서 이 삼총사가 어떻게 협력하는지 직접 확인해보자.


import 'package:flutter/material.dart';
import 'package:provider/provider.dart';

// 1. ChangeNotifier (방송국 스태프)
class Counter with ChangeNotifier {
  int _count = 0;
  int get count => _count; // 외부에서는 이 getter를 통해 값을 읽기만 가능

  void increment() {
    _count++;
    notifyListeners(); // "나 상태 변했어!" 라고 구독자들에게 알림
  }
}

void main() {
  runApp(
    // 2. ChangeNotifierProvider (송출탑)
    // 앱의 최상단에서 Counter를 제공.
    ChangeNotifierProvider(
      create: (context) => Counter(),
      child: const MyApp(),
    ),
  );
}

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

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        appBar: AppBar(
          title: const Text('Provider Counter'),
        ),
        body: Center(
          child: Column(
            mainAxisAlignment: MainAxisAlignment.center,
            children: [
              const Text('You have pushed the button this many times:'),
              // 3. Consumer (청취자)
              Consumer<Counter>(
                builder: (context, counter, child) {
                  // counter 객체의 count 값이 바뀔 때마다 이 builder 부분만 리빌드됨
                  return Text(
                    '${counter.count}',
                    style: Theme.of(context).textTheme.headlineMedium,
                  );
                },
              ),
            ],
          ),
        ),
        floatingActionButton: FloatingActionButton(
          // 4. context.read (일회성 호출)
          // 버튼을 누를 때는 상태 변화를 감지할 필요 없이,
          // 단지 increment 메소드를 호출하기만 하면 됨.
          onPressed: () => context.read<Counter>().increment(),
          child: const Icon(Icons.add),
        ),
      ),
    );
  }
}
        

`watch` vs `read` vs `select`: 효율적인 청취의 기술

Provider를 좀 더 깊게 사용하다 보면, `Consumer` 외에도 `context.watch`와 `context.read`를 만나게 될 거야. 이건 청취자가 라디오를 듣는 방식을 조절하는 것과 같아. 이걸 잘 구분해서 쓰는 게 Provider를 효율적으로 사용하는 핵심이야.

  • context.watch<T>(): `Consumer`와 똑같아. "나는 T 타입의 데이터가 바뀔 때마다 항상 리빌드될 거야!"라고 선언하는 것. `build` 메소드 안에서 UI를 그리는 부분에 사용돼.
  • context.read<T>(): "나는 T 타입의 데이터가 지금 당장 딱 한 번만 필요해. 앞으로 바뀌든 말든 신경 안 쓸 거야."라는 의미. 리빌드되지 않아. 주로 `onPressed`나 `initState`처럼 어떤 함수를 호출해야 할 때 사용돼. 위 예제의 `FloatingActionButton`에서 `increment` 함수를 부르기만 하면 되는데, 굳이 `watch`를 써서 버튼까지 리빌드 시킬 필요는 없겠지?
  • context.select<T, R>((value) => R): "나는 T 타입의 데이터 전체가 아니라, 그중에서도 특정 값(R)이 바뀔 때만 리빌드될 거야."라는 의미. 아주 정밀하게 리빌드 대상을 제어하고 싶을 때 사용해. 예를 들어 `User` 모델에 `name`과 `age`가 있는데, `age`가 바뀔 때는 리빌드하고 싶지 않고 `name`이 바뀔 때만 리빌드하고 싶을 때 쓸 수 있어.

🚨 Provider 사용 시 흔한 실수: Nesting Hell

앱이 커져서 여러 Provider를 사용해야 할 때, 많은 사람들이 이렇게 코드를 작성해.


MultiProvider(
  providers: [
    ChangeNotifierProvider(create: (_) => AuthProvider()),
    ChangeNotifierProvider(create: (_) => CartProvider()),
    ChangeNotifierProvider(create: (_) => ProductProvider()),
    // ... 10개 더 ...
  ],
  child: MyApp(),
)
        

이건 `MultiProvider`를 사용해서 그나마 나은 경우야. `MultiProvider`가 없었다면 Provider들을 피라미드처럼 계속 중첩해야 했을 거야. 이걸 'Provider Nesting Hell'이라고 부르기도 해. 코드가 깊어지고 가독성이 떨어지는 문제가 생길 수 있지. 이건 Provider의 단점 중 하나로 꼽혀.

👍 장점

  • 쉬운 학습 곡선: `InheritedWidget`에 비해 훨씬 직관적이고 배우기 쉬워.
  • 보일러플레이트 감소: 상태 관리에 필요한 코드를 획기적으로 줄여줘.
  • 관심사 분리: `ChangeNotifier`를 통해 UI 로직과 비즈니스 로직을 분리하기 시작할 수 있어.
  • 유연성: `ChangeNotifierProvider` 외에도 `FutureProvider`, `StreamProvider` 등 다양한 종류의 Provider를 제공해서 비동기 데이터도 쉽게 다룰 수 있어.
  • 강력한 커뮤니티와 생태계: 오랫동안 사랑받아온 만큼 관련 자료나 예제가 정말 많아. 문제가 생겼을 때 해결책을 찾기 쉽지.

👎 단점

  • `BuildContext` 의존성: Provider를 사용하려면 항상 `BuildContext`가 필요해. 위젯 트리 바깥의 서비스 레이어 같은 곳에서 상태에 접근하기가 까다로워.
  • 런타임 에러: `Provider`를 잘못된 위치에 선언했거나 타입을 잘못 지정하면, 앱이 실행된 후에야 `ProviderNotFoundException` 같은 런타임 에러를 만나게 돼. 컴파일 시점에는 알 수 없어.
  • Provider 중첩 문제: 위에서 언급한 것처럼, 많은 Provider를 사용하면 코드가 깊어지고 지저분해질 수 있어.
  • 가변 상태(Mutable State): `ChangeNotifier`는 내부 상태를 직접 변경(`_count++`)하는 가변적인 방식이야. 이건 코드가 복잡해졌을 때 상태가 어디서 어떻게 변하는지 추적하기 어렵게 만들 수 있어. (물론 이건 개발 철학의 차이일 수도 있어.)

Provider는 정말 훌륭한 상태 관리 솔루션이야. 특히 Flutter를 처음 시작하거나 중간 규모의 프로젝트를 진행한다면 최고의 선택이 될 수 있어. 하지만 더 큰 규모의 프로젝트, 더 엄격한 아키텍처, 더 높은 수준의 테스트 용이성을 원한다면? 이제 건축가의 선택, `BLoC`을 만나볼 시간이야.

🏗️ 건축가의 선택: BLoC (Business Logic Component)

자, 이제 좀 더 본격적인 '아키텍처 패턴'의 세계로 들어가 보자. `BLoC`은 단순히 상태 관리 라이브러리를 넘어, 애플리케이션의 구조를 설계하는 하나의 방법론이야. 2018년 구글 I/O에서 처음 소개되었고, 특히 복잡하고 거대한 애플리케이션을 만드는 개발자들 사이에서 큰 지지를 받고 있어.

BLoC의 핵심 철학은 'UI와 비즈니스 로직의 완전한 분리'야. UI는 오직 사용자 입력(이벤트)을 BLoC에 전달하고, BLoC이 보내주는 상태를 화면에 그리는 역할만 충실히 수행해. 모든 계산, 데이터 처리, API 통신 등의 '비즈니스 로직'은 BLoC 안에서만 이루어져. 이렇게 역할을 완벽하게 나누면 어떤 장점이 있을까? 코드가 훨씬 깔끔해지고, 테스트하기 쉬워지며, 여러 개발자가 협업하기에도 좋아져. 마치 레스토랑에서 주방과 홀의 역할이 명확히 구분된 것과 같아.

이벤트와 상태의 댄스: BLoC의 작동 원리

BLoC은 '스트림(Stream)'이라는 개념을 기반으로 작동해. 스트림은 비동기적인 데이터의 흐름이야. 수도꼭지를 틀면 물이 계속 흘러나오는 것처럼, 스트림에서는 데이터 이벤트가 시간의 흐름에 따라 계속 전달돼.

BLoC의 작동 방식을 아주 간단하게 표현하면 이래:

UI → Events → BLoC → States → UI

  1. (Event) 사용자가 버튼을 누르는 등 어떤 행동을 하면, UI는 BLoC에게 "이런 이벤트가 발생했어!"라고 알려줘.
  2. (BLoC) BLoC은 이벤트를 받아서, 그에 맞는 비즈니스 로직을 처리해. (예: API 호출, 데이터베이스 조회 등)
  3. (State) 로직 처리가 끝나면, BLoC은 새로운 '상태'를 만들어내. 이 상태는 UI가 어떻게 보여야 하는지에 대한 정보를 담고 있어. (예: 로딩 중 상태, 데이터 로딩 성공 상태, 에러 발생 상태 등)
  4. (UI) UI는 BLoC이 보내주는 상태의 스트림을 '구독'하고 있다가, 새로운 상태가 전달되면 그에 맞게 자신을 다시 그려.
Flutter 상태 관리: BLoC 패턴 아키텍처 UI - 비즈니스 로직 - 데이터의 명확한 분리 Events States Data Request Data Response UI Layer 사용자 인터페이스 (Widgets) BLoC 비즈니스 로직 (Business Logic Component) Data Layer 데이터 소스 (Repository, API, DB)

`flutter_bloc` 패키지로 날개 달기

순수하게 Stream만으로 BLoC 패턴을 구현하는 건 꽤나 번거로운 일이야. 다행히도 `flutter_bloc`이라는 아주 훌륭한 패키지가 있어서, BLoC 패턴을 훨씬 쉽고 구조적으로 구현할 수 있게 도와줘. 이 패키지는 `bloc`(순수 Dart 로직)과 `flutter_bloc`(Flutter 위젯과 연결)으로 나뉘어 있어.

카운터 앱을 `flutter_bloc`으로 만들어보자. 코드가 `Provider`보다 길어지는 걸 보고 놀라지 마. 이 구조가 주는 이점을 생각해야 해.


import 'package:flutter/material.dart';
import 'package:flutter_bloc/flutter_bloc.dart';

// 1. Events: BLoC에 전달될 이벤트 정의
abstract class CounterEvent {}
class IncrementEvent extends CounterEvent {}
class DecrementEvent extends CounterEvent {}

// 2. States: BLoC이 출력할 상태 정의
// 이 예제는 간단해서 상태가 int 하나지만, 보통은 클래스로 정의함
// ex) class CounterState { final int count; ... }

// 3. BLoC: 이벤트와 상태를 연결하는 비즈니스 로직
class CounterBloc extends Bloc<CounterEvent, int> {
  // 초기 상태를 0으로 설정
  CounterBloc() : super(0) {
    // 이벤트가 들어왔을 때 어떻게 상태를 바꿀지 정의
    on<IncrementEvent>((event, emit) => emit(state + 1));
    on<DecrementEvent>((event, emit) => emit(state - 1));
  }
}

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

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

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: BlocProvider( // 4. BlocProvider로 CounterBloc 제공
        create: (context) => CounterBloc(),
        child: const CounterPage(),
      ),
    );
  }
}

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

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: const Text('BLoC Counter')),
      body: Center(
        // 5. BlocBuilder로 상태 변화 감지 및 UI 리빌드
        child: BlocBuilder<CounterBloc, int>(
          builder: (context, count) {
            return Text(
              '$count',
              style: Theme.of(context).textTheme.headlineMedium,
            );
          },
        ),
      ),
      floatingActionButton: Column(
        mainAxisAlignment: MainAxisAlignment.end,
        children: [
          FloatingActionButton(
            // 6. 이벤트를 BLoC에 전달
            onPressed: () => context.read<CounterBloc>().add(IncrementEvent()),
            child: const Icon(Icons.add),
          ),
          const SizedBox(height: 8),
          FloatingActionButton(
            onPressed: () => context.read<CounterBloc>().add(DecrementEvent()),
            child: const Icon(Icons.remove),
          ),
        ],
      ),
    );
  }
}
        

코드를 보면 `Event`, `State`, `Bloc` 클래스가 명확하게 분리되어 있는 걸 볼 수 있어. UI(`CounterPage`)는 `context.read().add(...)`를 통해 이벤트를 던지기만 할 뿐, 숫자를 어떻게 더하고 빼는지 전혀 몰라. 그리고 `BlocBuilder`를 통해 BLoC이 주는 새로운 상태(`count`)를 받아서 그리기만 해. 이게 바로 BLoC가 추구하는 '관심사의 분리'야.

💡 Cubit: BLoC의 더 간단한 버전

이벤트와 상태를 모두 클래스로 정의하는 게 좀 과하게 느껴질 때도 있어. 특히 간단한 상태 관리에는 말이지. 그래서 `flutter_bloc` 패키지에는 `Cubit`이라는 더 가벼운 대안이 포함되어 있어. `Cubit`은 이벤트를 사용하지 않고, 대신 함수를 직접 호출해서 상태를 변경해. `Provider`의 `ChangeNotifier`와 비슷하지만, 상태를 스트림으로 관리한다는 점이 달라.


// Cubit 버전
class CounterCubit extends Cubit<int> {
  CounterCubit() : super(0);

  void increment() => emit(state + 1);
  void decrement() => emit(state - 1);
}

// 사용할 때는
// context.read<CounterCubit>().increment();
        

훨씬 간단하지? 복잡한 비즈니스 로직이 필요 없다면 `Cubit`이 훌륭한 선택이 될 수 있어.

👍 장점

  • 뛰어난 관심사 분리: UI, 비즈니스 로직, 데이터 레이어를 완벽하게 분리할 수 있어 코드의 구조가 매우 명확해져.
  • 높은 테스트 용이성: 비즈니스 로직이 UI와 완전히 분리되어 있기 때문에, BLoC 로직만 따로 떼어내서 테스트하기가 매우 쉬워. "이런 이벤트를 넣으면 저런 상태가 나온다"를 검증하면 되거든.
  • 예측 가능한 상태 흐름: 모든 상태 변경은 이벤트를 통해서만 일어나기 때문에, 상태가 언제, 왜 변했는지 추적하기가 쉬워. `BlocObserver`를 사용하면 모든 이벤트와 상태 변화를 로그로 남길 수도 있어. 디버깅에 아주 강력해.
  • 확장성: 규칙이 명확하고 구조가 잡혀있어서, 여러 개발자가 함께 작업하는 대규모 프로젝트에 매우 적합해.

👎 단점

  • 가파른 학습 곡선: 스트림, 이벤트, 상태 등 익숙해져야 할 개념이 많아서 초보자에게는 어렵게 느껴질 수 있어.
  • 많은 보일러플레이트: 간단한 기능을 구현하는 데도 `Event`, `State`, `Bloc` 파일을 각각 만들어야 해서 코드가 길어지고 파일 수가 늘어나. (물론 `Cubit`을 쓰면 완화되지만)
  • 과한 설계(Over-engineering): 작은 프로젝트에 BLoC을 적용하는 것은 소 잡는 칼로 닭 잡는 격일 수 있어. 배보다 배꼽이 더 커지는 거지.

BLoC은 확실히 강력한 도구야. 하지만 그만큼의 학습 비용과 코드량을 요구하지. 만약 당신이 'Provider의 편리함'과 'BLoC의 구조적인 장점'을 모두 취하고 싶다면? 바로 다음 주자인 `Riverpod`에 주목해야 해.

🚀 차세대 주자: Riverpod

`Provider`를 만들었던 바로 그 개발자, Remi Rousselet이 다시 한번 세상을 놀라게 했어. 그는 `Provider`를 만들고 운영하면서 느꼈던 한계점들을 극복하기 위해 완전히 새로운 상태 관리 라이브러리를 만들었는데, 그게 바로 `Riverpod`야. `Riverpod`은 'Provider'의 철자는 그대로 둔 채 순서만 바꾼 이름인데, 'Provider 2.0' 또는 'Provider의 완전체'라고 불리기도 해.

`Riverpod`의 목표는 명확해. Provider의 장점은 계승하되, 단점은 해결한다! `Provider`가 `InheritedWidget`의 '사용하기 쉬운 버전'이었다면, `Riverpod`은 `Provider`의 '더 안전하고, 더 유연하고, 더 강력한 버전'이라고 할 수 있어.

가장 큰 변화는 `BuildContext`로부터의 해방이야. `Provider`는 위젯 트리 내에서 `BuildContext`를 통해서만 상태에 접근할 수 있었지만, `Riverpod`은 위젯 트리에 전혀 의존하지 않아. 덕분에 순수 Dart로만 이루어진 비즈니스 로직 코드에서도 상태를 읽거나 조작하는 게 가능해졌어. 이건 정말 거대한 패러다임의 전환이야!

Riverpod의 핵심 개념: Provider와 Ref

Riverpod의 세계에서는 모든 것이 'Provider'야. 여기서 말하는 Provider는 `provider` 패키지의 `Provider`와는 다른, Riverpod 고유의 개념이야. 데이터를 제공하는 모든 것을 Provider라고 불러. 그리고 이 Provider들은 전역(global)에 선언되기 때문에 어디서든 접근할 수 있어.

  • `Provider`: 가장 기본적인 Provider. 변경되지 않는 값이나 객체를 제공할 때 사용해. (예: `Repository` 인스턴스)
  • `StateProvider`: 간단한 상태(숫자, 문자열, bool 등)를 외부에 노출하고 변경할 수 있게 해줘. `setState`의 전역 버전이라고 생각하면 쉬워.
  • `StateNotifierProvider`: `StateProvider`보다 복잡한 상태 로직을 다룰 때 사용해. `Provider`의 `ChangeNotifierProvider`와 비슷한 역할을 하지만, 상태를 불변(immutable) 객체로 다루도록 권장한다는 큰 차이가 있어.
  • `FutureProvider` / `StreamProvider`: 비동기 데이터를 다루는 데 특화된 Provider. `Future`나 `Stream`을 제공하면, 로딩/데이터/에러 상태를 알아서 관리해줘.

그리고 이 Provider들을 위젯에서 사용하기 위해 `ref`라는 객체를 사용해. `ConsumerWidget` 안에서는 `ref.watch`와 `ref.read`를, `ConsumerStatefulWidget` 안에서는 `ref`를 통해 Provider에 접근할 수 있어.

카운터 앱을 `Riverpod`의 `StateNotifierProvider`로 만들어보자. `Provider`나 `BLoC`과 어떻게 다른지 비교해보는 재미가 있을 거야.


import 'package:flutter/material.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';

// 1. 상태 로직을 담을 Notifier (BLoC의 Cubit과 유사)
// 상태는 불변(immutable)으로 관리하는 것이 좋음
class CounterNotifier extends StateNotifier<int> {
  // 초기 상태를 0으로 설정
  CounterNotifier() : super(0);

  void increment() {
    // 상태를 직접 변경하는 것이 아니라, 새로운 상태를 생성해서 교체함
    state = state + 1;
  }
}

// 2. 전역에 Provider 선언
// 이 provider를 통해 어디서든 CounterNotifier에 접근 가능
final counterProvider = StateNotifierProvider<CounterNotifier, int>((ref) {
  return CounterNotifier();
});

// 3. ProviderScope로 앱을 감싸줘야 함
void main() {
  runApp(
    const ProviderScope(
      child: MyApp(),
    ),
  );
}

// 4. StatelessWidget 대신 ConsumerWidget을 사용
class MyApp extends ConsumerWidget {
  const MyApp({super.key});

  @override
  Widget build(BuildContext context, WidgetRef ref) {
    // 5. ref.watch로 상태를 구독
    // counterProvider의 상태(int 값)가 바뀔 때마다 리빌드됨
    final count = ref.watch(counterProvider);

    return MaterialApp(
      home: Scaffold(
        appBar: AppBar(title: const Text('Riverpod Counter')),
        body: Center(
          child: Text(
            '$count',
            style: Theme.of(context).textTheme.headlineMedium,
          ),
        ),
        floatingActionButton: FloatingActionButton(
          onPressed: () {
            // 6. ref.read로 Notifier의 메소드 호출
            // .notifier를 붙여야 CounterNotifier 인스턴스에 접근 가능
            ref.read(counterProvider.notifier).increment();
          },
          child: const Icon(Icons.add),
        ),
      ),
    );
  }
}
        

코드를 보면 몇 가지 중요한 특징이 보여.

  • 전역 Provider: `counterProvider`가 `main` 함수나 클래스 바깥에 선언되어 있지? 이게 바로 `BuildContext`로부터의 자유를 의미해.
  • `ConsumerWidget`과 `WidgetRef`: `StatelessWidget` 대신 `ConsumerWidget`을 상속받으면 `build` 메소드에서 `WidgetRef` 타입의 `ref` 객체를 얻을 수 있어. 이 `ref`가 바로 Provider와 소통하는 창구야.
  • `ref.watch` vs `ref.read`: `Provider` 패키지와 개념은 같아. `ref.watch`는 상태가 바뀔 때마다 위젯을 리빌드하고, `ref.read`는 상태를 한 번만 읽어와.
  • 불변성(Immutability): `StateNotifier`에서는 `state = newState` 형태로 상태를 통째로 교체해. 이는 상태가 예측 가능하게 변경되도록 돕고, 버그를 줄여주는 아주 좋은 습관이야.

💡 Riverpod의 진정한 힘: Provider 조합

Riverpod의 가장 강력한 기능 중 하나는 Provider들을 서로 조합할 수 있다는 거야. 예를 들어, 인증 상태를 제공하는 `authProvider`와, 그 인증 상태를 기반으로 사용자 정보를 가져오는 `userProvider`를 만들 수 있어.


// 1. 인증 상태를 제공하는 Provider (예: 로그인 여부)
final authProvider = Provider<AuthService>((ref) => AuthService());

// 2. authProvider의 상태를 'watch'하고 있다가,
//    로그인되면 사용자 정보를 가져오는 FutureProvider
final userProvider = FutureProvider<User>((ref) async {
  final authService = ref.watch(authProvider);
  final userId = await authService.getCurrentUserId();
  if (userId == null) throw Exception('Not logged in');
  
  // 다른 Provider(apiProvider)를 사용해 데이터를 가져옴
  final api = ref.read(apiProvider);
  return api.fetchUser(userId);
});
        

이렇게 하면 `authProvider`의 상태가 바뀔 때(예: 로그아웃) `userProvider`가 자동으로 다시 실행돼. 이런 의존성 관리를 Riverpod이 알아서 해주기 때문에, 우리는 각 Provider의 로직에만 집중하면 돼. 정말 우아하지 않아?

만약 이런 기능을 직접 구현해야 한다면, 혹은 다른 상태관리 라이브러리로 구현해야 한다면 꽤나 복잡한 코드가 필요할거야. 하지만 Riverpod을 사용하면 이렇게 간단하게 해결할 수 있지. 만약 당신이 Flutter 개발 실력을 한 단계 업그레이드하고 싶다면, 혹은 더 복잡한 프로젝트에 도전하고 싶다면, 재능넷과 같은 플랫폼에서 Riverpod 전문가의 멘토링을 받아보는 것도 좋은 방법이야. 전문가의 노하우는 당신의 성장 속도를 몇 배나 빠르게 만들어 줄 수 있거든.

👍 장점

  • 컴파일 타임 세이프티: `Provider`와 달리, 존재하지 않는 Provider를 호출하면 런타임이 아닌 컴파일 시점에 에러를 잡아줘. `ProviderNotFoundException` 안녕!
  • `BuildContext`로부터의 독립: 위젯 트리 밖에서도 상태에 접근할 수 있어 비즈니스 로직을 훨씬 깔끔하게 분리하고 테스트할 수 있어.
  • 선언적이고 조합 가능한 Provider: Provider들이 서로를 의존하고 조합하는 방식이 매우 선언적이고 우아해. 복잡한 의존성 관리를 쉽게 만들어줘.
  • 더 이상 Nesting Hell은 없다: `Provider`의 중첩 문제를 해결했어. `ProviderScope` 하나만 있으면 돼.
  • 다양하고 강력한 Provider: `StateNotifierProvider`, `FutureProvider` 등 다양한 시나리오에 맞는 최적의 Provider를 제공해줘.

👎 단점

  • 새로운 개념: `Provider`에 익숙한 사람도 `ref`, 전역 Provider 등 새로 배워야 할 개념들이 있어 약간의 학습 곡선이 존재해.
  • 조금 더 많은 코드: `Provider`의 `ChangeNotifier`에 비하면 `StateNotifier`와 `StateNotifierProvider`를 설정하는 코드가 조금 더 길게 느껴질 수 있어. (하지만 BLoC보다는 훨씬 간결해)

Riverpod은 `Provider`의 철학을 계승하면서도 구조적인 안정성과 유연성을 극대화한, 현존하는 가장 진보된 상태 관리 솔루션 중 하나로 평가받고 있어. 많은 숙련된 Flutter 개발자들이 새로운 프로젝트에 Riverpod을 채택하는 이유지. 하지만... 만약 당신이 "이것도 복잡해! 난 그냥 빠르고 간단한 게 최고야!"라고 외친다면? 당신을 위한 마지막 주자가 남아있어.

⚡️ 미니멀리스트의 선택: GetX

지금까지 살펴본 `Provider`, `BLoC`, `Riverpod`가 각자의 철학과 구조를 가지고 '정도(正道)'를 걷는 느낌이었다면, `GetX`는 좀 다른 길을 가는 친구야. `GetX`의 모토는 '생산성, 성능, 그리고 조직화'야. 그리고 이 목표를 달성하기 위해 '최소한의 코드'와 '최고의 편리함'을 추구해.

`GetX`는 단순한 상태 관리 라이브러리가 아니야. 라우팅(화면 이동), 의존성 주입, 다국어 지원, 테마 관리, 간단한 유틸리티 등 Flutter 개발에 필요한 거의 모든 것을 담고 있는 '마이크로 프레임워크'에 가까워. "이거 하나만 있으면 다 돼!"라고 외치는 느낌이랄까? 이 올인원(All-in-one) 접근 방식 덕분에 많은 개발자, 특히 빠르게 프로토타입을 만들거나 소규모 프로젝트를 진행하는 개발자들에게 폭발적인 인기를 얻었어.

하지만 `GetX`의 이런 '마법 같은' 편리함은 Flutter 커뮤니티에서 가장 뜨거운 논쟁거리이기도 해. 어떤 개발자들은 `GetX`가 Flutter의 기본 원칙(예: `BuildContext`의 중요성)을 무시하고, 코드를 너무 숨겨서 오히려 유지보수를 어렵게 만든다고 비판하기도 해. 반면, 다른 개발자들은 압도적인 생산성과 간결함에 열광하지. `GetX`는 이처럼 호불호가 명확하게 갈리는, 아주 매력적이면서도 논쟁적인 솔루션이야.

GetX의 두 가지 상태 관리 방식

GetX는 두 가지 스타일의 상태 관리 방법을 제공해. 취향에 따라 골라 쓸 수 있어.

1. 단순 상태 관리자 (Simple State Manager)

이건 `setState`와 `ChangeNotifier`를 합쳐놓은 듯한 방식이야. `GetxController`를 만들고, 상태가 바뀐 후에 `update()` 메소드를 호출해주면, `GetBuilder` 위젯으로 감싸진 부분이 리빌드돼. 매우 직관적이고 가벼워.

2. 반응형 상태 관리자 (Reactive State Manager)

이게 바로 GetX의 '마법'이 빛을 발하는 부분이야. 변수 뒤에 `.obs`를 붙여주기만 하면 그 변수는 '반응형(Observable)' 변수가 돼. 그리고 `Obx` 위젯으로 UI를 감싸두면, 그 안에서 사용된 `.obs` 변수의 값이 바뀔 때마다 `Obx` 위젯이 *자동으로* 리빌드돼. `update()` 같은 메소드를 호출할 필요조차 없어!

카운터 앱을 GetX의 반응형 방식으로 만들어보자. 코드의 양이 얼마나 줄어드는지 보면 깜짝 놀랄 거야.


import 'package:flutter/material.dart';
import 'package:get/get.dart';

// 1. Controller 클래스 생성
class CounterController extends GetxController {
  // 변수 뒤에 .obs를 붙여 반응형 변수로 만듦
  var count = 0.obs;

  void increment() {
    count++; // 그냥 값을 증가시키기만 하면 됨! update() 호출 불필요
  }
}

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

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

  @override
  Widget build(BuildContext context) {
    // MaterialApp 대신 GetMaterialApp 사용
    return GetMaterialApp(
      home: HomePage(),
    );
  }
}

class HomePage extends StatelessWidget {
  HomePage({super.key});

  // 2. 컨트롤러 인스턴스화 (의존성 주입)
  // Get.put()을 사용하면 이 컨트롤러는 앱의 다른 곳에서도 쉽게 찾을 수 있음
  final CounterController controller = Get.put(CounterController());

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: const Text('GetX Counter')),
      body: Center(
        // 3. Obx 위젯으로 UI를 감쌈
        child: Obx(() {
          // 이 블록 안에서 사용된 .obs 변수가 바뀌면 자동으로 리빌드
          return Text(
            '${controller.count.value}', // .value로 실제 값에 접근
            style: Theme.of(context).textTheme.headlineMedium,
          );
        }),
      ),
      floatingActionButton: FloatingActionButton(
        onPressed: controller.increment, // 컨트롤러의 메소드를 직접 호출
        child: const Icon(Icons.add),
      ),
    );
  }
}
        

어때? `Provider`나 `BLoC`에 비해 보일러플레이트가 거의 없다시피 하지? `Event`, `State`, `Notifier` 같은 클래스도 필요 없고, `ProviderScope`나 `BlocProvider` 같은 설정도 거의 필요 없어. 그냥 컨트롤러 만들고, 변수에 `.obs` 붙이고, `Obx`로 감싸면 끝이야. 이 극단적인 간결함이 바로 GetX의 가장 큰 무기야.

🚨 GetX를 둘러싼 논쟁: 마법인가, 함정인가?

GetX는 `Get.to(NextScreen())`처럼 `BuildContext` 없이 화면을 이동시키거나, `Get.snackbar()`로 컨텍스트 없이 스낵바를 띄우는 등 Flutter의 기본 방식을 우회하는 기능을 많이 제공해. 이게 편리하긴 하지만, 몇 가지 문제를 낳을 수 있어.

  • 강한 결합(Tight Coupling): 당신의 코드가 GetX 프레임워크에 너무 깊게 의존하게 돼. 나중에 다른 상태 관리로 바꾸거나 GetX를 제거하기가 매우 어려워질 수 있어.
  • 예측 불가능성: `BuildContext`는 위젯 트리의 '현재 위치'를 알려주는 중요한 정보야. 이걸 무시하면 앱이 복잡해졌을 때 위젯이 어디서, 어떻게 상호작용하는지 파악하기 어려워질 수 있어.
  • 테스트의 어려움: `Get.find()`와 같은 정적 메소드에 의존하는 코드는 단위 테스트를 할 때 의존성을 주입하거나 Mock 객체를 만들기가 까다로워.

물론 GetX를 만든 개발자와 지지자들은 이런 문제들에 대한 해결책과 가이드라인을 제시하고 있어. 중요한 건 GetX를 사용할 때 이런 장단점과 논쟁거리를 명확히 인지하고, '왜' GetX를 선택하는지에 대한 자신만의 기준을 갖는 거야.

👍 장점

  • 압도적인 생산성: 보일러플레이트가 거의 없어 개발 속도가 매우 빨라.
  • 극도의 간결함: 코드가 매우 짧고 직관적이야. (적어도 GetX에 익숙하다면)
  • 고성능: 필요한 위젯만 최소한으로 리빌드하고, 리소스를 효율적으로 관리하여 높은 성능을 보여준다고 주장해.
  • 올인원 솔루션: 상태 관리, 라우팅, 의존성 관리 등을 하나의 패키지로 해결할 수 있어 편리해.

👎 단점

  • 커뮤니티의 호불호: Flutter의 기본 원칙을 따르지 않는다는 비판이 많아 커뮤니티가 양분되어 있어.
  • 높은 결합도: 앱이 GetX에 강하게 종속될 수 있어.
  • '마법' 같은 코드: 내부적으로 어떻게 동작하는지 알기 어려운 '블랙박스'처럼 느껴질 수 있어, 문제가 생겼을 때 디버깅이 어려울 수 있어.
  • 대규모 프로젝트에서의 불확실성: 구조적인 엄격함이 부족해서, 여러 사람이 참여하는 대규모 프로젝트에서는 코드가 복잡해지고 일관성을 유지하기 어려울 수 있다는 우려가 있어.

GetX는 '빠르고 쉽게'라는 가치를 최우선으로 두는 개발자에게는 최고의 선택일 수 있어. 하지만 '구조, 안정성, 유지보수성'을 더 중요하게 생각한다면 다른 솔루션이 더 적합할 수 있지. 결국 선택은 당신의 몫이야!

📊 그래서 뭘 써야 할까? 최종 정리 및 선택 가이드

자, 지금까지 Flutter 상태 관리의 춘추전국시대를 대표하는 강자들을 모두 만나봤어. `setState`부터 `GetX`까지, 각자의 뚜렷한 개성과 장단점을 가지고 있었지. 아마 지금 머릿속이 조금 복잡할 거야. "그래서 결론이 뭔데? 내 프로젝트에는 뭘 써야 하지?" 라는 질문이 맴돌고 있겠지.

정답부터 말하자면, "최고의 상태 관리란 없다. 오직 당신의 상황에 맞는 최적의 상태 관리만 있을 뿐이다."야. 프로젝트의 규모, 팀원의 숙련도, 개발 철학, 그리고 개인적인 취향까지 고려해서 가장 적합한 도구를 선택하는 것이 중요해. 아래 가이드를 보면서 당신의 상황에 맞는 솔루션을 찾아보자.

한눈에 보는 비교표

Flutter 상태 관리 솔루션 비교 항목 Provider BLoC Riverpod GetX setState 학습 곡선 쉬움 어려움 보통 매우 쉬움 매우 쉬움 코드 양 적음 많음 보통 매우 적음 적음 확장성 보통 매우 높음 매우 높음 보통 낮음 테스트 용이성 보통 매우 높음 높음 낮음 낮음 핵심 철학 DI + 단순함 관심사 분리 안전성 + 유연성 생산성 + 간결함 위젯 내부 상태 추천 대상 입문자, 중소형 앱 대형 앱, 팀 프로젝트 모든 규모, 안정성 중시 빠른 개발, 개인 프로젝트 단일 위젯 상태

상황별 추천 시나리오

👶 "이제 막 Flutter를 시작한 완전 초보예요!"

➡️ `Provider`로 시작하세요. `setState` 다음 단계로 넘어가기에 가장 이상적입니다. `BuildContext`와 `InheritedWidget`의 개념을 자연스럽게 익힐 수 있고, 커뮤니티가 커서 자료 찾기도 쉽습니다. 여기서 기본기를 탄탄히 다진 후 다른 솔루션으로 넘어가는 것이 좋습니다.

🏃 "개인 프로젝트나 해커톤처럼 빠르게 만들어야 해요!"

➡️ `GetX` 또는 `Riverpod`을 고려해보세요. `GetX`는 최소한의 코드로 가장 빠르게 결과물을 만들 수 있게 해줍니다. `Riverpod`의 `StateProvider`나 `FutureProvider`도 보일러플레이트가 적고 강력해서 빠른 개발에 유리합니다. 생산성을 최우선으로 둔다면 `GetX`, 약간의 구조를 챙기면서 빠르게 가고 싶다면 `Riverpod`이 좋은 선택입니다.

🏢 "회사에서 여러 명의 팀원과 함께 대규모 앱을 만들 거예요."

➡️ `BLoC` 또는 `Riverpod`가 정답에 가깝습니다. `BLoC`은 엄격한 규칙과 구조를 강제하기 때문에 여러 개발자가 일관된 스타일로 코드를 작성하게 만들어줍니다. 테스트 용이성이 매우 높아 앱의 안정성을 확보하는 데에도 유리합니다. `Riverpod` 역시 뛰어난 확장성과 테스트 용이성을 제공하면서도 `BLoC`보다 유연하고 코드량이 적어 최근 많은 팀에서 채택하고 있습니다. 팀원들의 성향과 경험을 고려하여 둘 중 하나를 선택하세요.

🧘 "안정성과 유지보수성이 가장 중요해요. 미래를 보고 선택하고 싶어요."

➡️ `Riverpod`를 강력하게 추천합니다. 컴파일 타임 안정성, `BuildContext`로부터의 독립, 테스트 용이성, 뛰어난 확장성 등 현대적인 소프트웨어 아키텍처가 요구하는 많은 장점을 갖추고 있습니다. `Provider`의 개발자가 만든 만큼 Flutter의 철학을 잘 이해하고 있으며, 커뮤니티도 빠르게 성장하고 있어 미래가 매우 밝습니다.

🤔 "아직도 잘 모르겠어요. 딱 하나만 골라주세요!"

➡️ 만약 정말 하나만 골라야 한다면, 2024년 현재 시점에서는 `Riverpod`가 가장 균형 잡힌 선택일 가능성이 높습니다. 배우기 너무 어렵지도 않으면서, 작은 프로젝트부터 거대한 프로젝트까지 모두 커버할 수 있는 유연성과 강력함을 갖추고 있기 때문입니다. 하지만 이건 어디까지나 일반적인 추천일 뿐, 가장 좋은 방법은 각 솔루션으로 작은 카운터 앱이라도 직접 만들어보고 '손맛'을 느껴보는 것입니다.

💡 기타 상태 관리 솔루션들

이 글에서 다룬 솔루션 외에도 Flutter 생태계에는 다양한 상태 관리 기법들이 존재합니다.

  • Redux: 웹 프론트엔드에서 유래한 전통적인 상태 관리 패턴입니다. 단일 스토어, 순수 함수 등 예측 가능한 상태 관리를 강조하지만, Flutter에서는 보일러플레이트가 너무 많아 최근에는 인기가 줄었습니다.
  • MobX: Redux와 마찬가지로 웹에서 유래했으며, 반응형 프로그래밍을 기반으로 합니다. 어노테이션(`@observable`, `@action`)을 사용하여 코드가 비교적 깔끔하지만, 코드 생성기를 사용해야 하는 번거로움이 있습니다.
  • Stacked: `Provider`와 `GetIt`(서비스 로케이터)을 기반으로 만들어진 아키텍처 프레임워크입니다. `ViewModel` 개념을 도입하여 `BLoC`과 유사한 구조를 더 쉽게 구현할 수 있도록 돕습니다.

이런 다양한 선택지가 있다는 것 자체가 Flutter 생태계가 얼마나 활발한지를 보여주는 증거입니다.

마치며: 상태 관리 너머의 길

정말 긴 여정이었습니다. Flutter 상태 관리라는, 어찌 보면 개발의 가장 골치 아픈 주제 중 하나를 끝까지 함께 탐험해주셔서 감사합니다. 이제 여러분은 각 상태 관리 솔루션이 어떤 철학을 가지고 있고, 어떤 상황에 어울리는지에 대한 훌륭한 지도를 갖게 되었습니다.

하지만 가장 중요한 것을 잊지 마세요. 상태 관리는 도구일 뿐, 목적이 아닙니다. 우리의 진짜 목적은 사용자에게 가치 있는, 훌륭한 앱을 만드는 것입니다. 어떤 도구를 선택하든 그 도구에 얽매이지 말고, 앱의 본질에 집중하세요. "이 도구가 내 문제를 어떻게 해결해줄 수 있을까?"를 항상 고민하는 것이 좋은 개발자로 성장하는 지름길입니다.

이제 이론은 충분합니다. 지금 바로 코드를 열고, 오늘 배운 것 중 가장 마음에 드는 솔루션 하나를 골라 작은 프로젝트를 시작해보세요. 직접 부딪히고, 에러를 만나고, 해결해나가는 과정 속에서만 진짜 '내 것'이 될 수 있습니다. 만약 그 과정에서 막히거나 더 깊은 지식이 필요하다면, 주저하지 말고 도움을 구하세요. **재능넷**과 같은 지식 공유 플랫폼에는 여러분의 성장을 도와줄 수많은 전문가들이 기다리고 있습니다.

여러분의 Flutter 여정에 행운이 가득하기를 바랍니다. Happy Coding! 🚀

댓글 작성

이 글에 대한 여러분의 생각을 들려주세요

댓글 0
댓글을 불러오는 중입니다.

아직 댓글이 없습니다.