#그룹 모델ဆိုတာဘာလဲ?

그룹ဆိုတာ 비즈니스 논리 구성 요소ကိုအတိုချုံ့ ပြောထားတာဖြစ်တယ်။
သူရဲ့ အဓိက ရည်ရွယ်ချက်ကတော့ 신청하다.မှာပါတဲ့ 상업 논리ကို

တခု (သို့) တခုထက်ပိုတဲ့ 그룹တွေဆီ ရွှေ့ထားဖို့

레이어 표현(UI)မှာ ပါမနေစေဖို့

계류အသုံးပြုပြီး 입력(수신기), 출력(흐름)တွေနဲ့သုံးဖို့

플랫폼ပေါ်မှာ မှီခိုမှု မရှိအောင်

환경ပေါ်မှာ မှီခိုမှု မရှိအောင် လုပ်ထားတာဖြစ်တယ်

소형 부품တွေက 이벤트တွေကို 가라앉다တွေကနေ 그룹ဆီပို့ပေးတယ်

소형 부품တွေက 그룹ရဲ့ 시냇물ကနေတဆင့် 통지하다ကို လက်ခံရရှိတယ်

비즈니스 논리ကို 사용자 인터페이스က ဘာမှ သိနေဖို့ မလိုအပ်တော့ဘူး

상업 논리နဲ့ 사용자 인터페이스သပ်သပ်ဆီ ဖြစ်နေခြင်းအားဖြင့်

비즈니스 논리မှာ ပြောင်းလဲမှုတွေ လုပ်ခြင်းက 사용자 인터페이스မှာ သက်ရောက်မှု တော်တော်လေး နည်းသွားမယ်

사용자 인터페이스အပြောင်းအလဲလုပ်မယ်ဆို 상업 논리တွေကို ထိိဖို့မလိုတော့ဘူး

비즈니스 논리ကို 테스트လုပ်ရတာ တော်တော်လေး လွယ်ကူသွားမယ်

반신청ကိုပဲ 그룹 모델သုံးပြီး bloc_pattern: ^2.5.1 နဲ့ ရေးကြည့်မယ်ဆိုရင် ခုလိုမျိုး ထွက်လာမယ်။

import 'dart:async';
import 'package:bloc_pattern/bloc_pattern.dart';
import 'package:flutter/material.dart';

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

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter Demo',
      theme: ThemeData(
        primarySwatch: Colors.blue,
        visualDensity: VisualDensity.adaptivePlatformDensity,
      ),
      home: BlocProvider(
        blocs: [Bloc((i) => IncrementBloc())],
        child: CounterPage(),
      ),
    );
  }
}

class CounterPage extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    final bloc = BlocProvider.getBloc<IncrementBloc>();

    return Scaffold(
      appBar: AppBar(
        title: Text('Counter with Stream'),
      ),
      body: Center(
        child: StreamBuilder(
          stream: bloc.outCounter,
          initialData: 0,
          builder: (BuildContext context, AsyncSnapshot<int> snapshot) {
            return Text('You pressed me ${snapshot.data} times');
          },
        ),
      ),
      floatingActionButton: FloatingActionButton(
        child: Icon(Icons.add),
        onPressed: () {
          bloc.incrementCounter.add(null);
        },
      ),
    );
  }
}

class IncrementBloc extends BlocBase {
  int _counter;

  //
  // Stream to handle the counter
  //
  StreamController<int> _counterController = StreamController<int>();
  StreamSink<int> get _inAdd => _counterController.sink;
  Stream<int> get outCounter => _counterController.stream;

  //
  // Stream to handle the action on the counter
  //
  StreamController _actionController = StreamController();
  StreamSink get incrementCounter => _actionController.sink;

  //
  // Constructor
  //
  IncrementBloc() {
    _counter = 0;
    _actionController.stream.listen(_handleLogic);
  }

  void dispose() {
    _actionController.close();
    _counterController.close();
  }

  void _handleLogic(data) {
    _counter = _counter + 1;
    _inAdd.add(_counter);
  }
}

직책 분리

ကြည့်မယ်ဆို 대위ထဲမှာ 상업 논리လုံးဝ ပါမနေတာ တွေ့ရမယ်။ သူ့မှာ ရှိတဲ့တာဝန်က 카운터ကိုပြဖို့၊ 가치관အသစ်ပြောင်းတဲ့အခါ 리셋လုပ်ပေးဖို့နဲ့ 단추.ကို နှိပ်တဲ့အခါ 행동ကိုပို့ပေးဖို့ပဲ ရှိတော့တယ်။
상업 논리အကုန်ကလဲ 점증 그룹ထဲမှာ တစုတစည်းထဲဖြစ်သွားတယ်။ 상업 논리ပြောင်းဖို့လိုမယ်ဆို တနေရာထဲမှာ ပြောင်းပေးလိုက်ရုံပဲ ဖြစ်သွားမယ်။
테스트 가능성(678)457
상업 논리ကို 테스트လုပ်ရတာလဲ ပိုမို လွယ်ကူသွားမယ်။ 사용자 인터페이스ကနေတဆင့် လုပ်နေစရာမလိုတော့ဘဲ 점증 그룹တခုကို 테스트လုပ်ရုံနဲ့တင် ရသွားမယ်။

조직 구조의 자유

시냇물ကို အသုံးပြုထားတာ ဖြစ်တဲ့အတွက် 배치တွေကို ကြိုက်သလိုအပြောင်းအလဲလုပ်ရင်တောင် 상업 논리ကို ထိမှာမျိုး မပူရတော့ဘူး။ 신청하다.ရဲ့ ကြိုက်တဲ့နေရာကနေ 행동ကိုခေါ်ချင်ရင် 점증 계수기သုံးပြီး ခေါ်လို့ရတယ်။ ပြချင်တယ်ဆိုရင်လဲ ကြိုက်တဲ့နေရာမှာ 카운터 밖နဲ့ ပြလို့ရတယ်။

구축 감소

setState() ကိုမသုံးဘဲ StreamBuilder ကိုသုံးခြင်းအားဖြင့် 짓다လုပ်ရတဲ့ အကြိမ်အရေအတွက်ကို အများကြီး လျှော့ချပြီးသား ဖြစ်သွားတယ်။ တကယ်လိုအပ်တဲ့အချိန်မှပဲ ပြန်ပြီး 짓다လုပ်ဖို့ လိုအပ်တယ်။ 표현ဘက်က ကြည့်မယ်ဆို ဒါဟာ ကြီးမားတဲ့ တိုးတက်မှုဖြစ်တယ်။
ဒါတွေအကုန် အလုပ်လုပ်ဖို့ဆို 그룹ကို နေရာတိုင်းက အသုံးပြုလို့ရနေဖို့လိုအပ်တယ်။ ဒီလိုလုပ်ထားဖို့ နည်းလမ်း (၃)ခုရှိတယ်။

글로벌 싱글

ဒီနည်းလမ်းက သုံးလို့ရတယ်ဆိုပေမယ့် အသုံးပြုဖို့ မတိုက်တွန်းချင်ဘူး။ 던지다မှာ 분류 분석 함수မရှိတဲ့အတွက် 리소스ထဲကနေ သူ့ကို ပြန်ထုတ်လို့ ရမှာမဟုတ်ဘူး။

로컬 인스턴스

그룹ကို 로컬 인스턴스အနေနဲ့ လုပ်ပြီး သုံးလို့ရတယ်။ တချို့အခြေအနေမှာဆို ဒီလိုလုပ်ပေးတာ အသင့်တော်ဆုံးပဲ။ 로컬 인스턴스အနေနဲ့သုံးမယ်ဆို 상태 컨트롤နဲ့သုံးဖို့ စဥ်းစားသင့်တယ်။ ဒီတော့မှ dispose() ထဲမှာ 로컬 인스턴스ကို ပြန်ပြီး ဖျက်ပစ်လို့ရမယ်။

선조 제공

အသုံးအများဆုံးနည်းလမ်းကတော့ ကိုယ်သုံးချင်တဲ့ 작은 장치အထက်မှာရှိတဲ့ တခုခုကနေပြီးတော့ အသုံးပြုလို့ရအောင် လုပ်ပေးထားတာမျိုးဖြစ်တယ်။

import 'package:flutter/material.dart';

// Generic Interface for all BLoCs
abstract class BlocBase {
  void dispose();
}

// Generic BLoC Provider
class BlocProvider<T extends BlocBase> extends StatefulWidget {
  final T bloc;
  final Widget child;

  BlocProvider({
    Key key,
    @required this.child,
    @required this.bloc,
  }) : super(key: key);

  @override
  State<StatefulWidget> createState() => _BlocProviderState<T>();

  static T of<T extends BlocBase>(BuildContext context) {
    BlocProvider<T> provider =
        context.findAncestorWidgetOfExactType<BlocProvider<T>>();
    return provider.bloc;
  }
}

class _BlocProviderState<T> extends State<BlocProvider<BlocBase>> {
  @override
  void dispose() {
    widget.bloc.dispose();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    return widget.child;
  }
}

bloc 모드 라이브러리သုံးထားတဲ့နေရာမှာ ခု 그룹 모델ကို သုံးလို့ရပြီ။ ခုလိုရေးတာက 선조ကနေတဆင့် ပို့ပေးတဲ့ နည်းလမ်းကို အသုံးပြုထားခြင်းဖြစ်တယ်။

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

import 'bloc.dart';

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

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter Demo',
      theme: ThemeData(
        primarySwatch: Colors.blue,
        visualDensity: VisualDensity.adaptivePlatformDensity,
      ),
      home: BlocProvider(
        bloc: IncrementBloc(),
        child: CounterPage(),
      ),
    );
  }
}

class CounterPage extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    final bloc = BlocProvider.of<IncrementBloc>(context);

    return Scaffold(
      appBar: AppBar(
        title: Text('Counter with Stream'),
      ),
      body: Center(
        child: StreamBuilder(
          stream: bloc.outCounter,
          initialData: 0,
          builder: (BuildContext context, AsyncSnapshot<int> snapshot) {
            return Text('You pressed me ${snapshot.data} times');
          },
        ),
      ),
      floatingActionButton: FloatingActionButton(
        child: Icon(Icons.add),
        onPressed: () {
          bloc.incrementCounter.add(null);
        },
      ),
    );
  }
}

class IncrementBloc implements BlocBase {
  int _counter;

  //
  // Stream to handle the counter
  //
  StreamController<int> _counterController = StreamController<int>();
  StreamSink<int> get _inAdd => _counterController.sink;
  Stream<int> get outCounter => _counterController.stream;

  //
  // Stream to handle the action on the counter
  //
  StreamController _actionController = StreamController();
  StreamSink get incrementCounter => _actionController.sink;

  //
  // Constructor
  //
  IncrementBloc() {
    _counter = 0;
    _actionController.stream.listen(_handleLogic);
  }

  void dispose() {
    _actionController.close();
    _counterController.close();
  }

  void _handleLogic(data) {
    _counter = _counter + 1;
    _inAdd.add(_counter);
  }
}

BlocProviderကို ဘယ်လို လုပ်သလဲဆို

home: BlocProvider(
  bloc: IncrementBloc(),
  child: CounterPage(),
),

ဒီနေရာမှာ 공급자တခုကို တည်ဆောက်ပြီး အဲ့ဒီ့ 공급자ကနေ ပို့ပေးမယ့် 그룹(증가 그룹)ကို တည်ဆောက်တယ်။ IncrementBloc() ကို သုံးမယ့် CounterPage() ကိုလဲ 아이.ထဲမှာ တခါထဲ ကြေငြာသွားတယ်။
ဒီလို ကြေငြာပြီးတာနဲ့ BlocProviderအောက်မှာ ရှိတဲ့ 자수အကုန်လုံးကနေ ကြိုက်တဲ့နေရာမှာ 점증 그룹ကို ယူသုံးလို့ရပြီ။
그룹တွေအများကြီးကို သုံးလို့ရသလားဆိုရင်တော့ ရတယ်လို့ပဲ ဖြေပေးရမယ်။ အသုံးပြုဖို့ တိုက်တွန်းချင်တဲ့ နေရာတွေကတော့

비즈니스 논리ရှိတယ်ဆိုတဲ့ 페이지တိုင်းရဲ့ ထိပ်ဆုံးမှာ

어플리케이션 상태ကို 처리하다.လုပ်ဖို့ 응용 프로그램 그룹ဆိုပြီး သုံးတဲ့နေရာမှာ

구성 요소တခုအနေနဲ့ အတိုင်းအတာတခုထိ ရှုပ်ထွေးလာပြီဆို သက်ဆိုင်ရာ 그룹သုံးပြီး လုပ်တဲ့နေရာတွေမှာ အသုံးပြုပေးပါ။