improve multipart post

 ![](https://raw.githubusercontent.com/jonataslaw/getx-community/master/get.png)
 
-_Languages: [영어](README.md), [중국어](README.zh-cn.md), [브라질 포르투칼어](README.pt-br.md), [스페인어](README-es.md), [러시아어](README.ru.md), [폴란드어](README.pl.md), 한국어(이파일)._
+**언어: [영어](README.md), [중국어](README.zh-cn.md), [브라질 포르투칼어](README.pt-br.md), [스페인어](README-es.md), [러시아어](README.ru.md), [폴란드어](README.pl.md), 한국어(이파일).**
 
 [![pub package](https://img.shields.io/pub/v/get.svg?label=get&color=blue)](https://pub.dev/packages/get)
 [![likes](https://badges.bar/get/likes)](https://pub.dev/packages/get/score)
@@ -35,6 +35,17 @@ _Languages: [영어](README.md), [중국어](README.zh-cn.md), [브라질 포르
       - [지역 변경](#지역-변경)
       - [시스템 지역](#시스템-지역)
   - [테마 변경](#테마-변경)
+  - [GetConnect](#getconnect)
+    - [기본 구성](#기본-구성)
+    - [커스텀 구성](#커스텀-구성)
+  - [GetPage Middleware](#getpage-middleware)
+    - [Priority](#priority)
+    - [Redirect](#redirect)
+    - [onPageCalled](#onpagecalled)
+    - [OnBindingsStart](#onbindingsstart)
+    - [OnPageBuildStart](#onpagebuildstart)
+    - [OnPageBuilt](#onpagebuilt)
+    - [OnPageDispose](#onpagedispose)
   - [기타 고급 API](#기타-고급-API)
     - [선택적 전역 설정과 수동 구성](#선택적-전역-설정과-수동-구성)
     - [지역 상태 위젯들](#지역-상태-위젯들)
@@ -228,7 +239,7 @@ GetMaterialApp( // Before: MaterialApp(
 Get.to(NextScreen());
 ```
 
-명칭으로 새로운 화면으로 이동합니다. 명칭으로 라우트하는 더 자세한 사항은 [여기](./documentation/en_US/route_management.md#navigation-with-named-routes) 있습니다.
+명칭으로 새로운 화면으로 이동합니다. 명칭으로 라우트하는 더 자세한 사항은 [여기](./documentation/kr_KO/route_management.md#이름있는-라우트-탐색) 있습니다.
 
 ```dart
 
@@ -257,7 +268,7 @@ Get.offAll(NextScreen());
 
 ### 라우트 관리에 대한 자세한 내용
 
-**Get은 명명된 라우트로 작업하고 더 쉬운 방식으로 라우트의 제어를 제공합니다! [여기](./documentation/en_US/route_management.md)에 더 자세한 문서가 있습니다.**
+**Get은 명명된 라우트로 작업하고 더 쉬운 방식으로 라우트의 제어를 제공합니다! [여기](./documentation/kr_KO/route_management.md)에 더 자세한 문서가 있습니다.**
 
 ## 종속성 관리
 
@@ -278,7 +289,7 @@ Controller controller = Get.put(Controller()); // Rather Controller controller =
 controller.fetchApi();
 ```
 
-여러 경로를 통해 이동했고 controller에 남아있는 데이터가 필요가 있다고 가정하십시오. Get_it이나 Provider와 조합된 상태 관리자가 필요합니다. 맞습니까? Get은 아닙니다. 다른 추가적인 종속성이 필요없이 controller를 Get의 "find"로 찾으면 됩니다:
+여러 경로들을 탐색했고 controller에 남아있는 데이터가 필요가 있다고 가정하십시오. Get_it이나 Provider와 조합된 상태 관리자가 필요합니다. 맞습니까? Get은 아닙니다. 다른 추가적인 종속성이 필요없이 controller를 Get의 "find"로 찾으면 됩니다:
 
 ```dart
 Controller controller = Get.find();
@@ -293,7 +304,7 @@ Text(controller.textFromApi);
 
 ### 종속성 관리에 대한 자세한 내용
 
-**종속성 관리에 대한 더 제사한 사항은 [여기](./documentation/en_US/dependency_management.md)에 있습니다.**
+**종속성 관리에 대한 더 제사한 사항은 [여기](./documentation/kr_KO/dependency_management.md)에 있습니다.**
 
 # 기능들
 
@@ -380,6 +391,157 @@ Get.changeTheme(Get.isDarkMode? ThemeData.light(): ThemeData.dark());
 
 `.darkmode`가 활성활 될때 _light theme_ 로 바뀔것 이고 _light theme_ 가 활성화되면 _dark theme_ 로 변경될 것입니다.
 
+## GetConnect
+GetConnect는 http나 websockets으로 프론트와 백엔드의 통신을 위한 쉬운 방법입니다.
+
+### 기본 구성
+GetConnect를 간단하게 확장하고 Rest API나 websockets의 GET/POST/PUT/DELETE/SOCKET 메서드를 사용할 수 있습니다.
+
+```dart
+class UserProvider extends GetConnect {
+  // Get request
+  Future<Response> getUser(int id) => get('http://youapi/users/$id');
+  // Post request
+  Future<Response> postUser(Map data) => post('http://youapi/users', body: data);
+  // Post request with File
+  Future<Response<CasesModel>> postCases(List<int> image) {
+    final form = FormData({
+      'file': MultipartFile(image, filename: 'avatar.png'),
+      'otherFile': MultipartFile(image, filename: 'cover.png'),
+    });
+    return post('http://youapi/users/upload', form);
+  }
+
+  GetSocket userMessages() {
+    return socket('https://yourapi/users/socket');
+  }
+}
+```
+### 커스텀 구성
+GetConnect는 고도로 커스텀화 할 수 있습니다. base Url을 정의하고 응답자 및 요청을 수정하고 인증자를 정의할 수 있습니다. 그리고 인증 횟수까지 정의 할 수 있습니다. 더해서 추가 구성없이 모델로 응답을 변형시킬 수 있는 표준 디코더 정의도 가능합니다.
+
+```dart
+class HomeProvider extends GetConnect {
+  @override
+  void onInit() {
+    // 모든 요청은 jsonEncode로 CasesModel.fromJson()를 거칩니다.
+    httpClient.defaultDecoder = CasesModel.fromJson;
+    httpClient.baseUrl = 'https://api.covid19api.com';
+    // baseUrl = 'https://api.covid19api.com'; // [httpClient] 인스턴트 없이 사용하는경우 Http와 websockets의 baseUrl 정의
+    
+    // 모든 요청의 헤더에 'apikey' 속성을 첨부합니다.
+    httpClient.addRequestModifier((request) {
+      request.headers['apikey'] = '12345678';
+      return request;
+    });
+
+    // 서버가 "Brazil"이란 데이터를 보내더라도
+    // 응답이 전달되기 전에 응답의 데이터를 지우기 때문에 
+    // 사용자에게 표시되지 않을 것입니다.
+    httpClient.addResponseModifier<CasesModel>((request, response) {
+      CasesModel model = response.body;
+      if (model.countries.contains('Brazil')) {
+        model.countries.remove('Brazilll');
+      }
+    });
+
+    httpClient.addAuthenticator((request) async {
+      final response = await get("http://yourapi/token");
+      final token = response.body['token'];
+      // 헤더 설정
+      request.headers['Authorization'] = "$token";
+      return request;
+    });
+
+    // 인증자가 HttpStatus가 HttpStatus.unauthorized이면
+    // 3번 호출됩니다.
+    httpClient.maxAuthRetries = 3;
+  }
+  }
+
+  @override
+  Future<Response<CasesModel>> getCases(String path) => get(path);
+}
+```
+
+## GetPage Middleware
+
+GetPage는 GetMiddleWare의 목록을 특정 순서로 실행하는 새로운 프로퍼티를 가집니다.
+
+**주석**: GetPage가 Middleware를 가질때 페이지의 모든 하위는 같은 Middleware를 자동적으로 가지게 됩니다.
+
+### Priority
+
+Middleware의 실행 순서는 GetMiddleware안의 priority에 따라서 설정할 수 있습니다.
+
+```dart
+final middlewares = [
+  GetMiddleware(priority: 2),
+  GetMiddleware(priority: 5),
+  GetMiddleware(priority: 4),
+  GetMiddleware(priority: -8),
+];
+```
+이 Middleware는 다음 순서로 실행됩니다. **-8 => 2 => 4 => 5**
+
+### Redirect
+
+이 함수는 호출된 라우트의 페이지를 검색할때 호출됩니다. 리다이렉트한 결과로 RouteSettings을 사용합니다. 또는 null을 주면 리다이렉트 하지 않습니다.
+
+```dart
+GetPage redirect( ) {
+  final authService = Get.find<AuthService>();
+  return authService.authed.value ? null : RouteSettings(name: '/login')
+}
+```
+
+### onPageCalled
+
+이 함수는 생성되지 않은 페이지가 호출될 때 호출됩니다.
+페이지에 대한 어떤것을 변경하는데 사용하거나 새로운 페이지를 줄 수 있습니다.
+
+```dart
+GetPage onPageCalled(GetPage page) {
+  final authService = Get.find<AuthService>();
+  return page.copyWith(title: 'Welcome ${authService.UserName}');
+}
+```
+
+### OnBindingsStart
+
+이 함수는 Bindings가 초기화되기 바로 직전에 호출됩니다.
+여기에서 이 페이지를 위해 Bindings을 변경할 수 있습니다.
+
+```dart
+List<Bindings> onBindingsStart(List<Bindings> bindings) {
+  final authService = Get.find<AuthService>();
+  if (authService.isAdmin) {
+    bindings.add(AdminBinding());
+  }
+  return bindings;
+}
+```
+
+### OnPageBuildStart
+
+이 함수는 Bindings가 초기화된 직후에 호출됩니다.
+여기에서 bindings를 생성한 후 페이지 위젯을 생성하기 전에 무엇이든 할 수 있습니다.
+
+```dart
+GetPageBuilder onPageBuildStart(GetPageBuilder page) {
+  print('bindings are ready');
+  return page;
+}
+```
+
+### OnPageBuilt
+
+이 함수는 GetPage.page 함수가 호출된 직후에 호출며 함수의 결과를 제공합니다. 그리고 표시될 위젯을 가져옵니다.
+
+### OnPageDispose
+
+이 함수는 페이지의 연관된 모든 오브젝트들(Controllers, views, ...)이 해제된 직후에 호출됩니다.
+
 ## 기타 고급 API
 
 ```dart
@@ -444,7 +606,7 @@ Get.context
 // 코드 어디에서든지 foreground에서 snackbar/dialog/bottomsheet의 context를 제공
 Get.contextOverlay
 
-// 주석: 다음 메소드는 context의 확장입니다.
+// 주석: 다음 메서드는 context의 확장입니다.
 // UI의 모든 위치에서 컨텍스트에 액세스 할 수 있으므로 UI 코드의 어느 곳에서나 사용할 수 있습니다.
 
 // 변경되는 height/width(데스크탑이나 브라우저와 같이 늘어날 수 있는 것)가 필요하면 context를 사용해야함
@@ -612,7 +774,7 @@ ObxValue((data) => Switch(
 
 ## 유용한 팁
 
-`.obs`(_Rx_ 타입이라고 알려진)는 다양한 내부 메소드와 연산자가 있습니다.
+`.obs`(_Rx_ 타입이라고 알려진)는 다양한 내부 메서드와 연산자가 있습니다.
 
 > `.obs`프로퍼티가 **실제 값**이라고 _믿는_ 것은 일반적이지만 실수하지 마십시오!
 > 다트의 컴파일러는 충분히 똑똑하고 코드가 깔끔하기 때문에 변수의 타입 선언을 하지 않습니다.
@@ -733,7 +895,7 @@ print( user );
    Widget build(BuildContext context) {
      return Container(
        padding: EdgeInsets.all(20),
-       child: Text( controller.title ), // 단지 `controller.something`을 호출합니다.
+       child: Text(controller.title), // 단지 `controller.something`을 호출합니다.
      );
    }
  }

@@ -11,6 +11,7 @@
     - [How to use](#how-to-use)
     - [BindingsBuilder](#bindingsbuilder)
     - [SmartManagement](#smartmanagement)
+      - [How to change](#How-to-change)
       - [SmartManagement.full](#smartmanagementfull)
       - [SmartManagement.onlyBuilders](#smartmanagementonlybuilders)
       - [SmartManagement.keepFactory](#smartmanagementkeepfactory)
@@ -216,11 +217,11 @@ But if you want to opt for using `permanent:true`, then the controller will not
 
 Proceeding with the differences between methods:
 
-- Get.put and Get.putAsync follows the same creation order, with the difference that the second uses an asynchronous method: those two methods creates and initializes the instance. That one is inserted directly in the memory, using the internal method `insert` with the parameters `permanent: false` and `isSingleton: true` (this isSingleton parameter only porpuse is to tell if it is to use the dependency on `dependency` or if it is to use the dependency on `FcBuilderFunc`). After that, `Get.find()` is called that immediately initialize the instances that are on memory.
+- Get.put and Get.putAsync follows the same creation order, with the difference that the second uses an asynchronous method: those two methods creates and initializes the instance. That one is inserted directly in the memory, using the internal method `insert` with the parameters `permanent: false` and `isSingleton: true` (this isSingleton parameter only purpose is to tell if it is to use the dependency on `dependency` or if it is to use the dependency on `FcBuilderFunc`). After that, `Get.find()` is called that immediately initialize the instances that are on memory.
 
 - Get.create: As the name implies, it will "create" your dependency! Similar to `Get.put()`, it also calls the internal method `insert` to instancing. But `permanent` became true and `isSingleton` became false (since we are "creating" our dependency, there is no way for it to be a singleton instace, that's why is false). And because it has `permanent: true`, we have by default the benefit of not losing it between screens! Also, `Get.find()` is not called immediately, it wait to be used in the screen to be called. It is created this way to make use of the parameter `permanent`, since then, worth noticing, `Get.create()` was made with the goal of create not shared instances, but don't get disposed, like for example a button in a listView, that you want a unique instance for that list - because of that, Get.create must be used together with GetWidget.
 
-- Get.lazyPut: As the name implies, it is a lazy proccess. The instance is create, but it is not called to be used immediately, it remains waiting to be called. Contrary to the other methods, `insert` is not called here. Instead, the instance is inserted in another part of the memory, a part responsable to tell if the instance can be recreated or not, let's call it "factory". If we want to create something to be used later, it will not be mix with things been used right now. And here is where `fenix` magic enters: if you opt to leaving `fenix: false`, and your `smartManagement` are not `keepFactory`, then when using `Get.find` the instance will change the place in the memory from the "factory" to common instance memory area. Right after that, by default it is removed from the "factory". Now, if you opt for `fenix: true`, the instance continues to exist in this dedicated part, even going to the common area, to be called again in the future.
+- Get.lazyPut: As the name implies, it is a lazy proccess. The instance is create, but it is not called to be used immediately, it remains waiting to be called. Contrary to the other methods, `insert` is not called here. Instead, the instance is inserted in another part of the memory, a part responsible to tell if the instance can be recreated or not, let's call it "factory". If we want to create something to be used later, it will not be mix with things been used right now. And here is where `fenix` magic enters: if you opt to leaving `fenix: false`, and your `smartManagement` are not `keepFactory`, then when using `Get.find` the instance will change the place in the memory from the "factory" to common instance memory area. Right after that, by default it is removed from the "factory". Now, if you opt for `fenix: true`, the instance continues to exist in this dedicated part, even going to the common area, to be called again in the future.
 
 ## Bindings
 

+# 종속성 관리
+- [종속성 관리](#종속성-관리)
+  - [인스턴스 메서드](#인스턴스-메서드)
+    - [Get.put()](#getput)
+    - [Get.lazyPut](#getlazyput)
+    - [Get.putAsync](#getputasync)
+    - [Get.create](#getcreate)
+  - [인스턴스화 된 메서드/클래스 사용](#인스턴스화-된-메서드/클래스-사용)
+  - [메서드간의 차이점](#메서드간의-차이점)
+  - [바인딩](#바인딩)
+    - [사용 방법](#사용-방법)
+    - [BindingsBuilder](#bindingsbuilder)
+    - [SmartManagement](#smartmanagement)
+      - [변경하는 방법](#변경하는-방법)
+      - [SmartManagement.full](#smartmanagementfull)
+      - [SmartManagement.onlyBuilders](#smartmanagementonlybuilders)
+      - [SmartManagement.keepFactory](#smartmanagementkeepfactory)
+    - [바인딩이 작동하는 자세한 설명](#바인딩이-작동하는-자세한-설명)
+  - [주석](#주석)
+
+Get은 Provider context, inheritedWidget 없이 단 1줄의 코드로 Bloc 나 Controller 같은 클래스를 찾을수 있는 간단하고 강력한 종속성 관리자가 있습니다.
+
+```dart
+Controller controller = Get.put(Controller()); // Controller controller = Controller(); 대체
+```
+
+사용중인 클래스 내에서 클래스를 인스턴스화하는 대신 Get 인스턴스 내에서 인스턴스화하여 앱 전체에서 사용할 수 있습니다.
+그러고나면 컨트롤러 (또는 Bloc 클래스)를 정상적으로 사용할 수 있습니다.
+
+- 주석: Get의 상태 관리자를 사용하는 경우 [바인딩](#바인딩) api에 더 많은 주의를 기울여야합니다. 그러면 뷰를 컨트롤러에 더 쉽게 연결할 수 있습니다.
+- 주석²: Get의 종속성 관리는 패키지의 다른 부분에서 분리되므로 예를 들어 앱이 이미 상태 관리자를 사용하고있는 경우라도(하나라도 상관 없음) 변경할 필요가 없습니다. 아무 문제 없이 종속성 주입 관리자를 사용할 수 있습니다.
+
+## 인스턴스 메서드
+메서드와 구성 파라미터는 다음과 같습니다:
+
+### Get.put()
+
+종속성 인스턴스화의 가장 흔한 방법 입니다. 예를 들어 뷰의 controller들에 좋습니다.
+
+```dart
+Get.put<SomeClass>(SomeClass());
+Get.put<LoginController>(LoginController(), permanent: true);
+Get.put<ListItemController>(ListItemController, tag: "some unique string");
+```
+
+put 사용시 설정 가능한 모든 사항:
+```dart
+Get.put<S>(
+  // 필수: cotroller나 어떤것이든 get에 저장하려는 클래스  
+  // 주석: "S"는 모든 유형의 클래스가 가능합니다.
+  S dependency
+
+  // 선택: 동일한 유형의 여러 클래스를 사용하기를 원하면
+  // 일반적으로 Get.find<Controller>() 로 클래스를 가져오므로
+  // 어떤 인스턴스인지 구분을 위해 tag를 사용해야합니다.
+  // 고유한 string 이여야 합니다.
+  String tag,
+
+  // 선택: 기본적으로 get은 더이상 사용하지 않는 인스턴스는 dispose 합니다. by default, get will dispose instances after they are not used anymore (example,
+  // (예를 들어 뷰의 controller가 닫힌 경우) 하지만 sharedPreferences와 같은 인스턴스는 앱 전체에서 유지되어야 할 필요가 있습니다.
+  // 이런 경우 사용합니다.
+  // 기본값은 false
+  bool permanent = false,
+
+  // 선택: 테스트에서 추상 클래스를 사용한 후에 다른 클래스로 교체하고 테스트를 수행합니다.
+  // 기본값은 false
+  bool overrideAbstract = false,
+
+  // 선택: 자체 종속성 대신에 함수로 종속성을 생성합니다.
+  // 이것은 일반적으로 사용되지 않습니다.
+  InstanceBuilderCallback<S> builder,
+)
+```
+
+### Get.lazyPut
+인스턴스하게 사용하는 경우에만 의존성을 lazyLoad 할 수 있습니다. 계산 비용이 많이 드는 클래스나 한곳에서 다양한 클래스를 당장 사용하지 않으면서 인스턴스화 하기를 원한다면(Bindings 클래스처럼) 매우 유용합니다.
+
+```dart
+/// ApiMock은 처음으로 Get.find<ApiMock>을 사용하는 경우에만 호출됩니다.
+Get.lazyPut<ApiMock>(() => ApiMock());
+
+Get.lazyPut<FirebaseAuth>(
+  () => {
+  // 어떤 로직이 필요하다면 ...
+    return FirebaseAuth()
+  },
+  tag: Math.random().toString(),
+  fenix: true
+)
+
+Get.lazyPut<Controller>( () => Controller() )
+```
+
+lazyPut을 사용시 설정 가능한 모든 사항:
+```dart
+Get.lazyPut<S>(
+  // 필수: 이 메서드는 처음으로 클래스가 호출할 때 실행될 것입니다
+  InstanceBuilderCallback builder,
+  
+  // 선택: Get.put()과 같이 같은 클래스를 다중으로 인스턴스할 경우 사용합니다.
+  // 고유값이어야 합니다.
+  String tag,
+
+  // 선택: "permanent"와 유사합니다. 차이점은 인스턴스가 사용되지 않으면 폐기되지만
+  // 다시 사용할 때 Get이 바인딩 api의 "SmartManagement.keepFactory"와 동일하게 인스턴스를 재생성한다는 것입니다.
+  // 기본값은 false
+  bool fenix = false
+  
+)
+```
+
+### Get.putAsync
+만약 비동기로 인스턴스를 등록하길 원하면 `Get.putAsync`를 사용할 수 있습니다.:
+
+```dart
+Get.putAsync<SharedPreferences>(() async {
+  final prefs = await SharedPreferences.getInstance();
+  await prefs.setInt('counter', 12345);
+  return prefs;
+});
+
+Get.putAsync<YourAsyncClass>( () async => await YourAsyncClass() )
+```
+
+putAsync 사용시 설정 가능한 모든 사항:
+```dart
+Get.putAsync<S>(
+
+  // 필수: 클래스를 인스턴스화 하기 위해 실행되는 비동기 메서드입니다.
+  AsyncInstanceBuilderCallback<S> builder,
+
+  // 선택: Get.put()과 같이 같은 클래스를 다중으로 인스턴스할 경우 사용합니다.
+  // 고유값이어야 합니다.
+  String tag,
+
+  // 선택: Get.put()과 같이 앱 유지중에 인스턴스가 활성되어야 하는 경우 사용합니다.
+  // 기본값은 false
+  bool permanent = false
+)
+```
+
+### Get.create
+
+이것은 까다롭습니다. 이것이 무엇인지 상세한 설명과 다른것과의 차이점에 대해서는 [메서드간의 차이점:](#메서드간의-차이점) 섹션에서 확인할 수 있습니다.
+
+```dart
+Get.Create<SomeClass>(() => SomeClass());
+Get.Create<LoginController>(() => LoginController());
+```
+
+create 사용시 설정 가능한 모든 사항:
+
+```dart
+Get.create<S>(
+  // 필수: `Get.find()`가 호출 될 때마다 만들어진 클래스를 반환하는 메서드입니다.
+  // 예시: Get.create<YourClass>(() => YourClass())
+  FcBuilderFunc<S> builder,
+
+  // 선택: Get.put()과 거의 동일하지만 동일 클래스의 여러 인스턴스가 필요할 때 사용합니다.
+  // 개개의 리스트별로 controller가 필요한 경우 유용합니다.
+  // 고유값이어야 합니다. 단지 tag에서 name으로 변경되었습니다.
+  String name,
+
+  // 선택: Get.put()과 같이 앱 유지중에 인스턴스가 활성되어야 하는 경우 사용합니다.
+  // Get.create에서 다른점은
+  // permanent의 기본값이 true 입니다.
+  bool permanent = true
+```
+
+## 인스턴스화 된 메서드/클래스 사용
+
+여러 경로를 탐색했고 controller에 남겨진 데이터가 필요하다고 상상해보세요. Provider 또는 Get_it과 결합된 상태 관리자가 필요합니다. 맞습니까? Get은 아닙니다.
+어떤 종속적인 추가가 필요 없고 단지 Get에게 controller를 "find"하라고 하면 됩니다:
+
+```dart
+final controller = Get.find<Controller>();
+// OR
+Controller controller = Get.find();
+
+// 그렇습니다. 마법 같아요. Get은 controller를 찾고 배달해 줍니다.
+// Get은 백만개의 contrller를 인스턴스화해서 가질수 있고 항상 올바르게 전달해 줍니다.
+```
+
+그리고 나서 얻어낸 controller에서 데이터를 가져올 수 있습니다:
+
+```dart
+Text(controller.textFromApi);
+```
+
+반환된 값은 일반 클래스라서 무엇이든 할 수 있습니다:
+
+```dart
+int count = Get.find<SharedPreferences>().getInt('counter');
+print(count); // out: 12345
+```
+
+Get의 인스턴스에서 삭제합니다:
+
+```dart
+Get.delete<Controller>(); // 보통 GetX는 미사용 controller를 삭제하기 때문에 수행할 필요가 없습니다
+```
+
+## 메서드간의 차이점
+
+첫째, Get.lazyPut의 `fenix`와 다른 메서드들의 `permanent`을 살펴보겠습니다.
+
+`permanent`와 `fenix` 사이의 근본적인 다른점은 인스턴스를 저장하는 방법입니다.
+
+보강: 기본적으로 GetX는 사용하지 않을때 인스턴스를 삭제합니다.
+의미: 만약 화면 1이 컨트롤러 1을 가지고 있고 화면 2가 컨트롤러 2를 가졌을때 스택에서 첫번째 경로가 제거되면(`Get.off()`나 `Get.offNamed()`를 사용하는 경우) 컨트롤러 1은 사용하지 않아 지워질 것입니다.
+
+하지만 `permanent:true`를 설정하면 컨르롤러가 이런 전환에서 손실되지 않을 것입니다. - 어플리케이션 실행되는 동안에 계속 유지하려고 하는 서비스에 매우 유용합니다.
+
+`fenix` in the other hand is for services that you don't worry in losing between screen changes, but when you need that service, you expect that it is alive. So basically, it will dispose the unused controller/service/class, but when you need it, it will "recreate from the ashes" a new instance.
+반면 `fenix`는 화면 전환 사이에 손실이 없어야 하는 서비스를 위해 있습니다. 이 서비스가 필요할 때 그것이 살아 있다고 기대할 것입니다. 그래서 기본적으로 사용하지 않는 controller/service/class를 폐기하지만 필요한 경우 새 인스턴스에서 흔적으로부터 다시 생성합니다.
+
+메서드간 차이점 진행:
+
+- Get.put과 Get.putAsync는 동일한 생성 명령을 따르지만 두번째가 비동기 메서드를 사용하는 것이 차이점입니다: 두 메서드는 인스턴스를 생성하고 초기화 합니다. 이것은 `permanent: false`와 `isSingleton: true` 파라미터들과 내부 `insert` 메서드를 사용하여 메모리에 직접 추가됩니다.(여기의 isSingleton 파라미터의 목적은 `dependency`에 의한 종속성을 사용할 것인지 `FcBuilderFunc`에 의한 종속성을 사용할 것인지 알려주는 것입니다.) 이후에 `Get.find()`는 즉시 초기화한 메모리안의 인스턴스를 호출합니다.
+
+- Get.create: 이름 그대로 종속성을 "생성"합니다! `Get.put()`과 마찬가지로 내부 메서드 `insert`를 호출하여 인스턴스화 합니다. 그러나 `permanent`가 true가 되고 `isSingleton`이 false가 됩니다(종속성을 "생성중"인 상태라 싱글톤 인스턴스가 될 방법이 없어서 false 입니다.) 그리고 `permanent: true`이기 때문에 기본적으로 화면 전환간에 손실되지 않는 장점이 있습니다! 또한 `Get.find()`는 즉시 호출되지 않으며 호출될 화면에서 사용되기를 기다립니다. `permanent` 파라미터를 사용하기 위한 방법으로 만들어졌습니다. 다음의 가치를 가지고 있습니다. 생성을 위한 목적으로 `Get.create()`는 공유되는 인스턴스가 아니지만 폐기되지 않습니다. 예를들어 리스트뷰 안의 버튼은 리스트를 위한 고유한 인스턴스입니다. - 이때문에 Get.create는 GetWidget과 함께 사용되어야만 합니다.
+
+- Get.lazyPut: 이름 그대로 lazy 처리됩니다. 인스턴스가 만들어지나 즉시 사용되도록 호출되지 않고 호출되기를 기다립니다. 다른 메서드와 다르게 `insert`가 여기에서 호출되지 않습니다. 대신 인스턴스는 메모리의 다른 부분에 추가됩니다. 인스턴스가 재생성 가능한지 아닌지를 책임지는 부분으로 "factory"라고 부릅니다. 나중에 사용할 어떤 것을 생성하기 원한다면 지금 사용했던 것과 섞이지 않아야 할 것입니다. 그리고 여기에서 `fenix` 마법이 시작됩니다: `fenix: false`를 그대로두고 `smartManagement`는 `keepFactory`가 아니면 `Get.find`를 사용할 때 인스턴스는 "factory"에서 공통 인스턴스 메모리 영역으로 위치가 변경됩니다. 바로 그뒤에 기본적으로 "factory"에서 제거됩니다. 이제 `fenix: true`로 설정하면 인스턴스는 전용부분에서 계속 존재하며 공통 영역으로 이동하여 미래에 다시 호출됩니다.
+
+## 바인딩
+
+이 패키지의 가장 큰 특이한점 중 하나는 아마도 라우트, 상태 관리자, 종속성 관리자의 완전한 통합의 가능성 일 것입니다.
+스택에서 라우트가 삭제되면 모든 컨르롤러, 변수 및 관련된 인스턴스 오브젝트가 메모리에서 제거됩니다. 스트림이나 타이머를 사용중이면 자동적으로 종료되고 이것에 대한 어떤 걱정도 할 필요가 없습니다.
+Get의 2.10 버전에는 Bindings API를 완전히 구현했습니다.
+이제 init 메서드는 더 이상 사용할 필요가 없습니다. 원하지 않으며 컨트롤러 타입도 필요 없습니다. 컨트롤러와 서비스를 위한 적절한 위치에서 시작할 수 있습니다.
+바인딩 클래스는 상태 관리자와 종속성 관리자에 라우트를 "결합"하는 동시에 종속성 주입을 분리하는 클래스입니다.
+이를 통해 Get은 특정 컨트롤러가 사용될때 표시되는 스크린을 알고 어디서 어떻게 이것이 제거 되는지 알수 있습니다.
+추가로 Binding 클래스로 SmartManager 구성을 제어 할 수 있습니다. 스택에서 경로를 제거하거나 경로를 사용한 위젯이 배치되거나 둘 다 배치되지 않을 때 정렬되도록 종속성을 설정 할 수 있습니다. 지능적으로 종속성 관리가 동작하지만 원하는대로 구성 할 수 있습니다.
+
+### 사용 방법
+
+- class를 생성하고 Binding 포함합니다.
+
+```dart
+class HomeBinding implements Bindings {}
+```
+
+IDE가 자동적으로 "종속적인" 메서드를 재정의할지 요청하며 램프를 클릭하기만 하면 됩니다. 그리고 메서드를 재정의하고 해당 경로에 사용할 모든 클래스들을 추가하면 됩니다:
+
+```dart
+class HomeBinding implements Bindings {
+  @override
+  void dependencies() {
+    Get.lazyPut<HomeController>(() => HomeController());
+    Get.put<Service>(()=> Api());
+  }
+}
+
+class DetailsBinding implements Bindings {
+  @override
+  void dependencies() {
+    Get.lazyPut<DetailsController>(() => DetailsController());
+  }
+}
+```
+
+이제 라우트에 라우트, 종속성, 상태 관리자 사이를 연결하는데 해당 바인딩을 사용할 것이라고 알리기만 하면 됩니다.
+
+- 명명된 라우트 사용법:
+
+```dart
+getPages: [
+  GetPage(
+    name: '/',
+    page: () => HomeView(),
+    binding: HomeBinding(),
+  ),
+  GetPage(
+    name: '/details',
+    page: () => DetailsView(),
+    binding: DetailsBinding(),
+  ),
+];
+```
+
+- 일반 라우트 사용법:
+
+```dart
+Get.to(Home(), binding: HomeBinding());
+Get.to(DetailsView(), binding: DetailsBinding())
+```
+
+이제 어플리케이션의 어디서도 메모리 관리에 대해서 걱정하지 않아도 됩니다. Get이 그것을 처리 할 것입니다.
+
+Binding 클래스는 라우트가 호출될 때 불려집니다. GetMaterialApp의 "initialBinding"에서 모든 종속성을 추가하여 생성할 수 있습니다.
+
+```dart
+GetMaterialApp(
+  initialBinding: SampleBind(),
+  home: Home(),
+);
+```
+
+### BindingsBuilder
+
+바인딩을 생성하는 기본 방법은 바인딩을 구현한 클래스를 만드는 것 입니다.
+하지만 대안으로 `BindingsBuilder` 콜백을 사용하여 간단하게 원하는 것을 인스턴스화하는 함수를 사용할 수 있습니다.
+
+예시:
+
+```dart
+getPages: [
+  GetPage(
+    name: '/',
+    page: () => HomeView(),
+    binding: BindingsBuilder(() => {
+      Get.lazyPut<ControllerX>(() => ControllerX());
+      Get.put<Service>(()=> Api());
+    }),
+  ),
+  GetPage(
+    name: '/details',
+    page: () => DetailsView(),
+    binding: BindingsBuilder(() => {
+      Get.lazyPut<DetailsController>(() => DetailsController());
+    }),
+  ),
+];
+```
+
+이 방법은 각 라우트에 대해 한개의 바인딩 클래스 만드는 것을 피할수 있어서 더 간단하게 할 수 있습니다.
+
+두 방법 모두 완벽하게 작동하며 취향에 맞춰서 사용하시면 됩니다.
+
+### SmartManagement
+
+GetX는 기본적으로 메모리에서 사용되지 않는 컨트롤러들을 제거합니다. 문제가 생기거나 적절히 사용하지 않는 위젯도 마찬가지 입니다.
+이것이 종속성 관리의 `full`모드 입니다.
+하지만 GetX 클래스의 제거를 제어하는 방식을 변경하기 원한다면 `SmartManagement` 클래스로 다른 행동을 설정할 수 있습니다.
+
+#### 변경하는 방법
+
+구성을 변경(보통은 필요 없습니다)하려면 이렇게 하세요:
+
+```dart
+void main () {
+  runApp(
+    GetMaterialApp(
+      smartManagement: SmartManagement.onlyBuilders // 이곳
+      home: Home(),
+    )
+  )
+}
+```
+
+#### SmartManagement.full
+
+이것이 기본입니다. permanent가 설정되지 않으면 사용되지 않는 클래스를 제거합니다. 대부분의 경우 이 구성을 변경하지 않고 유지하십시오. GetX가 처음이라면 바꾸지 마십시오.
+
+#### SmartManagement.onlyBuilders
+이 옵션은 오직 컨트롤러가 `init:`에서 시작되었거나 `Get.lazyPut()`으로 바인딩되어 로드되면 제거됩니다.
+
+`Get.put()`이나 `Get.putAsync()` 또는 다른 접근을 를 사용하면 SmartManagement는 종속성 제거를 위한 권한을 가지지 못합니다.
+
+기본 동작은 SmartManagement.onlyBuilders와 다르게 "Get.put"으로 인스턴스화된 위젯들도 삭제됩니다.
+
+#### SmartManagement.keepFactory
+
+SmartManagement.full과 같이 더이상 사용되지 않으면 종속성이 제거됩니다. 하지만 factory가 유지되어 다시 인스턴스가 필요하면 종속성이 재생성됩니다.
+
+### 바인딩이 작동하는 자세한 설명
+바인딩은 다른 화면으로 이동하려고 클릭하는 순간에 임시 factory를 생성합니다. 그리고 화면 전환 애니메이션이 발생하는 즉시 제거됩니다.
+이 행위는 매우 빨라 분석기에 등록도 되지 않습니다.
+다시 화면으로 이동하면 새로운 임시 factory를 호출하므로 SmartManagement.keepFactory 사용을 선택할 수도 있습니다. 그러나 바인딩을 생성하지 않거나 동일한 바인딩에 대해 모든 종속성을 유지하고 싶다면 도움이 됩니다.
+Factory는 적은 메모리만 사용하고 인스턴스를 가지지 않지만 원하는 클래스의 "형태"를 가진 함수를 가집니다.
+메모리에서 매우 적은 비용을 가지지만 이 라이브러리의 목적이 최소 리소스를 사용하여 가능한 최대 성능을 가지는 것이라 GetX는 기본적으로 factory를 제거합니다.
+가장 편한방법을 취하십시오.
+
+## 주석
+
+- 다중 바인딩을 사용한다면 SmartManagement.keepFactory를 사용하지 마세요. 바인딩을 사용하지 않거나 GetMaterialApp의 initialBinding에 연결한 1개의 바인딩만 설계하세요.
+
+- 바인딩의 사용은 완전히 선택사항입니다. 클래스에서 `Get.put()`과 `Get.find()`를 사용하면 아무 문제없이 컨트롤러가 주어집니다.
+그러나 서비스나 다른 추상적인 동작을 원하면 더 나은 구성의 바인딩을 추천합니다.

+- [라우트 관리](#라우트-관리)
+  - [사용하는 방법](#사용하는-방법)
+  - [이름없는 라우트 탐색](#이름없는-라우트-탐색)
+  - [이름있는 라우트 탐색](#이름있는-라우트-탐색)
+    - [이름있는 라우트에 데이터 보내기](#이름있는-라우트에-데이터-보내기)
+    - [동적 url 링크](#동적-url-링크)
+    - [미들웨어](#미들웨어)
+  - [context 없이 탐색](#context-없이-탐색)
+    - [SnackBars](#snackbars)
+    - [Dialogs](#dialogs)
+    - [BottomSheets](#bottomsheets)
+  - [중첩된 탐색](#중첩된-탐색)
+
+# 라우트 관리
+
+라우트 관리가 문제 있는 경우 GetX가 모든 것을 완벽히 설명해줍니다.
+
+## 사용하는 방법
+
+pubspec.yaml 파일에 추가:
+
+```yaml
+dependencies:
+  get:
+```
+
+context 없이 routes/snackbars/dialogs/bottomsheets을 사용하거나 고급 GetX API를 사용하려면 MaterialApp 앞에 "Get"만 추가하여 GetMaterialApp으로 바꿔서 이용하세요!
+
+```dart
+GetMaterialApp( // 이전: MaterialApp(
+  home: MyHome(),
+)
+```
+
+## 이름없는 라우트 탐색
+
+새 화면으로 이동:
+
+```dart
+Get.to(NextScreen());
+```
+
+snackbars, dialogs, bottomsheets 또는 Navigator.pop(context);로 보통 닫았던 것들을 닫기
+
+```dart
+Get.back();
+```
+
+다음 화면으로 이동하고 이전 화면에서 돌아오지 않는 경우 (스플래시나 로그인 화면 등을 사용하는 경우)
+
+```dart
+Get.off(NextScreen());
+```
+
+다음 화면으로 이동하고 이전 화면이 모두 닫히는 경우 (장바구니, 투표, 테스트에 유용함)
+
+```dart
+Get.offAll(NextScreen());
+```
+
+다음 화면으로 이동하고 돌아올때 바로 데이터를 받거나 업데이트할 경우:
+
+```dart
+var data = await Get.to(Payment());
+```
+
+다른 화면에서 이전화면으로 데이터를 전달할때:
+
+```dart
+Get.back(result: 'success');
+```
+
+그리고 사용방법:
+
+예시:
+
+```dart
+if(data == 'success') madeAnything();
+```
+
+우리의 문법을 배우고 싶지 않습니까?
+Navigator를 navigator로 바꾸시면 됩니다. 그리고 context를 사용하지 않아도 표준 navigator의 모든 기능이 가능합니다.
+예시:
+
+```dart
+
+// 기본 Flutter navigator
+Navigator.of(context).push(
+  context,
+  MaterialPageRoute(
+    builder: (BuildContext context) {
+      return HomePage();
+    },
+  ),
+);
+
+// GetX는 context 필요 없이 Flutter 문법을 사용
+navigator.push(
+  MaterialPageRoute(
+    builder: (_) {
+      return HomePage();
+    },
+  ),
+);
+
+// GetX 문법 (이것은 동의하지 않겠지만 더 좋습니다)
+Get.to(HomePage());
+
+
+```
+
+## 이름있는 라우트 탐색
+
+- namedRoutes로 탐색하기를 선호하면 GetX도 지원합니다.
+
+nextScreen으로 이동
+
+```dart
+Get.toNamed("/NextScreen");
+```
+
+다음으로 이동하고 트리에서 이전 화면을 지웁니다.
+
+```dart
+Get.offNamed("/NextScreen");
+```
+
+다음으로 이동하고 트리에서 이전 화면 전체를 지웁니다.
+
+```dart
+Get.offAllNamed("/NextScreen");
+```
+
+GetMaterialApp를 사용하여 라우트들을 정의:
+
+```dart
+void main() {
+  runApp(
+    GetMaterialApp(
+      initialRoute: '/',
+      getPages: [
+        GetPage(name: '/', page: () => MyHomePage()),
+        GetPage(name: '/second', page: () => Second()),
+        GetPage(
+          name: '/third',
+          page: () => Third(),
+          transition: Transition.zoom  
+        ),
+      ],
+    )
+  );
+}
+```
+
+정의 안된 라우트로 이동시 제어 (404 에러), GetMaterialApp에 unknownRoute를 정의할 수 있습니다.
+
+```dart
+void main() {
+  runApp(
+    GetMaterialApp(
+      unknownRoute: GetPage(name: '/notfound', page: () => UnknownRoutePage()),
+      initialRoute: '/',
+      getPages: [
+        GetPage(name: '/', page: () => MyHomePage()),
+        GetPage(name: '/second', page: () => Second()),
+      ],
+    )
+  );
+}
+```
+
+### 이름있는 라우트에 데이터 보내기
+
+무엇이든 인수를 통해 전달합니다. GetX는 String, Map, List, 클래스 인스턴스등 모든 것을 허용합니다.
+
+```dart
+Get.toNamed("/NextScreen", arguments: 'Get is the best');
+```
+
+클래스 또는 컨트롤러에서:
+
+```dart
+print(Get.arguments);
+// 출력: Get is the best
+```
+
+### 동적 url 링크
+
+GetX는 웹과 같이 향상된 동적 url을 제공합니다. 웹 개발자들은 아마 Flutter에서 이미 이 기능을 원하고 있을 것 입니다. 대부분의 경우 패키지가 이 기능을 약속하고 URL이 웹에서 제공하는 것과 완전히 다른 구문을 제공하는 것을 보았을 것입니다. 하지만 GetX는 이 기능을 해결합니다.
+
+```dart
+Get.offAllNamed("/NextScreen?device=phone&id=354&name=Enzo");
+```
+
+controller/bloc/stateful/stateless 클래스에서:
+
+```dart
+print(Get.parameters['id']);
+// 출력: 354
+print(Get.parameters['name']);
+// 출력: Enzo
+```
+
+GetX는 쉽게 NamedParameters 전달을 할 수 있습니다:
+
+```dart
+void main() {
+  runApp(
+    GetMaterialApp(
+      initialRoute: '/',
+      getPages: [
+      GetPage(
+        name: '/',
+        page: () => MyHomePage(),
+      ),
+      GetPage(
+        name: '/profile/',
+        page: () => MyProfile(),
+      ),
+       //You can define a different page for routes with arguments, and another without arguments, but for that you must use the slash '/' on the route that will not receive arguments as above.
+       GetPage(
+        name: '/profile/:user',
+        page: () => UserProfile(),
+      ),
+      GetPage(
+        name: '/third',
+        page: () => Third(),
+        transition: Transition.cupertino  
+      ),
+     ],
+    )
+  );
+}
+```
+
+경로 명으로 데이터 보냄
+
+```dart
+Get.toNamed("/profile/34954");
+```
+
+다음 화면에서 파라미터로 데이터를 가져옴
+
+```dart
+print(Get.parameters['user']);
+// 출력: 34954
+```
+
+이제 Get.toNamed()를 사용하여 어떤 context도 없이 명명된 라우트를 탐색하고 (BLoC 또는 Controller 클래스로 부터 직접 라우트를 호출할 수 있음) 앱이 웹으로 컴파일되면 경로는 url에 표시됩니다. <3
+
+### 미들웨어
+
+만약 GetX 이벤트를 받아서 행동을 트리거 하려면 routingCallback을 사용하면 가능합니다.
+
+```dart
+GetMaterialApp(
+  routingCallback: (routing) {
+    if(routing.current == '/second'){
+      openAds();
+    }
+  }
+)
+```
+
+GetMaterialApp을 사용하지 않는다면 수동 API를 사용해서 Middleware observer를 추가할 수 있습니다.
+
+```dart
+void main() {
+  runApp(
+    MaterialApp(
+      onGenerateRoute: Router.generateRoute,
+      initialRoute: "/",
+      navigatorKey: Get.key,
+      navigatorObservers: [
+        GetObserver(MiddleWare.observer), // 여기 !!!
+      ],
+    ),
+  );
+}
+```
+
+MiddleWare class 생성
+
+```dart
+class MiddleWare {
+  static observer(Routing routing) {
+    /// 각 화면의 routes, snackbars, dialogs와 bottomsheets에서 추가하여 받을 수 있습니다.
+    /// If you need to enter any of these 3 events directly here,
+    /// you must specify that the event is != Than you are trying to do.
+    if (routing.current == '/second' && !routing.isSnackbar) {
+      Get.snackbar("Hi", "You are on second route");
+    } else if (routing.current == '/third'){
+      print('last route called');
+    }
+  }
+}
+```
+
+이제, 코드에서 Get을 사용하세요:
+
+```dart
+class First extends StatelessWidget {
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      appBar: AppBar(
+        leading: IconButton(
+          icon: Icon(Icons.add),
+          onPressed: () {
+            Get.snackbar("hi", "i am a modern snackbar");
+          },
+        ),
+        title: Text('First Route'),
+      ),
+      body: Center(
+        child: RaisedButton(
+          child: Text('Open route'),
+          onPressed: () {
+            Get.toNamed("/second");
+          },
+        ),
+      ),
+    );
+  }
+}
+
+class Second extends StatelessWidget {
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      appBar: AppBar(
+        leading: IconButton(
+          icon: Icon(Icons.add),
+          onPressed: () {
+            Get.snackbar("hi", "i am a modern snackbar");
+          },
+        ),
+        title: Text('second Route'),
+      ),
+      body: Center(
+        child: RaisedButton(
+          child: Text('Open route'),
+          onPressed: () {
+            Get.toNamed("/third");
+          },
+        ),
+      ),
+    );
+  }
+}
+
+class Third extends StatelessWidget {
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      appBar: AppBar(
+        title: Text("Third Route"),
+      ),
+      body: Center(
+        child: RaisedButton(
+          onPressed: () {
+            Get.back();
+          },
+          child: Text('Go back!'),
+        ),
+      ),
+    );
+  }
+}
+```
+
+## context 없이 탐색
+
+### SnackBars
+
+Flutter로 간단한 SnackBar를 사용하려면 Scaffold의 context가 반드시 주어지거나 Scaffold에 GlobalKey를 추가해서 사용해야만 합니다.
+
+```dart
+final snackBar = SnackBar(
+  content: Text('Hi!'),
+  action: SnackBarAction(
+    label: 'I am a old and ugly snackbar :(',
+    onPressed: (){}
+  ),
+);
+// 위젯 트리에서 Scaffold를 찾아서 사용하면
+// SnackBar가 보여집니다.
+Scaffold.of(context).showSnackBar(snackBar);
+```
+
+Get을 사용할때:
+
+```dart
+Get.snackbar('Hi', 'i am a modern snackbar');
+```
+
+Get을 사용하면 코드의 어디에서든지 Get.snackbar를 호출하거나 원하는데로 수정하기만 하면 됩니다!
+
+```dart
+Get.snackbar(
+  "Hey i'm a Get SnackBar!", // title
+  "It's unbelievable! I'm using SnackBar without context, without boilerplate, without Scaffold, it is something truly amazing!", // message
+  icon: Icon(Icons.alarm),
+  shouldIconPulse: true,
+  onTap:(){},
+  barBlur: 20,
+  isDismissible: true,
+  duration: Duration(seconds: 3),
+);
+
+
+  ////////// ALL FEATURES //////////
+  //     Color colorText,
+  //     Duration duration,
+  //     SnackPosition snackPosition,
+  //     Widget titleText,
+  //     Widget messageText,
+  //     bool instantInit,
+  //     Widget icon,
+  //     bool shouldIconPulse,
+  //     double maxWidth,
+  //     EdgeInsets margin,
+  //     EdgeInsets padding,
+  //     double borderRadius,
+  //     Color borderColor,
+  //     double borderWidth,
+  //     Color backgroundColor,
+  //     Color leftBarIndicatorColor,
+  //     List<BoxShadow> boxShadows,
+  //     Gradient backgroundGradient,
+  //     FlatButton mainButton,
+  //     OnTap onTap,
+  //     bool isDismissible,
+  //     bool showProgressIndicator,
+  //     AnimationController progressIndicatorController,
+  //     Color progressIndicatorBackgroundColor,
+  //     Animation<Color> progressIndicatorValueColor,
+  //     SnackStyle snackStyle,
+  //     Curve forwardAnimationCurve,
+  //     Curve reverseAnimationCurve,
+  //     Duration animationDuration,
+  //     double barBlur,
+  //     double overlayBlur,
+  //     Color overlayColor,
+  //     Form userInputForm
+  ///////////////////////////////////
+```
+
+기존 스낵바를 선호하거나 한 줄만 추가하는 것을 포함하여 처음부터 커스텀하려는 경우(Get.snackbar는 필수로 제목과 메시지를 사용함) 다음을 사용할 수 있습니다.
+Get.snackbar가 빌드된 RAW API를 제공하는`Get.rawSnackbar ();`.
+
+### Dialogs
+
+dialog 열기:
+
+```dart
+Get.dialog(YourDialogWidget());
+```
+
+default dialog 열기:
+
+```dart
+Get.defaultDialog(
+  onConfirm: () => print("Ok"),
+  middleText: "Dialog made in 3 lines of code"
+);
+```
+
+showGeneralDialog 대신에 Get.generalDialog를 사용할 수 있습니다.
+
+cupertinos를 포함한 다른 모든 Flutter 대화 상자 위젯의 경우 context 대신 Get.overlayContext를 사용하고 코드의 어느 곳에서나 열 수 있습니다.
+오버레이를 사용하지 않는 위젯의 경우 Get.context를 사용할 수 있습니다.
+이 두 context는 탐색 context 없이 inheritedWidget이 사용되는 경우를 제외하고 99%의 경우에 UI의 context를 대체하여 동작합니다.
+
+### BottomSheets
+
+Get.bottomSheet는 showModalBottomSheet와 같지만 context가 필요 없습니다.
+
+```dart
+Get.bottomSheet(
+  Container(
+    child: Wrap(
+      children: <Widget>[
+        ListTile(
+          leading: Icon(Icons.music_note),
+          title: Text('Music'),
+          onTap: () => {}
+        ),
+        ListTile(
+          leading: Icon(Icons.videocam),
+          title: Text('Video'),
+          onTap: () => {},
+        ),
+      ],
+    ),
+  )
+);
+```
+
+## 중첩된 탐색
+
+GetX는 Fultter의 중첩된 탐색을 더 쉽게 만듭니다.
+context가 필요 없고 Id로 탐색 스택을 찾을 수 있습니다.
+
+- 주석: 병렬 탐색 스택을 만드는 것은 위험 할 수 있습니다. 이상적인 것은 NestedNavigators를 사용하지 않거나 아껴서 사용하는 것입니다. 프로젝트에 필요한 경우 여러 탐색 스택을 메모리에 유지하는 것이 RAM 소비에 좋지 않을 수 있음을 명심하십시오.
+
+간단합니다:
+
+```dart
+Navigator(
+  key: Get.nestedKey(1), // index로 key를 생성
+  initialRoute: '/',
+  onGenerateRoute: (settings) {
+    if (settings.name == '/') {
+      return GetPageRoute(
+        page: () => Scaffold(
+          appBar: AppBar(
+            title: Text("Main"),
+          ),
+          body: Center(
+            child: FlatButton(
+              color: Colors.blue,
+              onPressed: () {
+                Get.toNamed('/second', id:1); // index로 중첩된 경로를 탐색
+              },
+              child: Text("Go to second"),
+            ),
+          ),
+        ),
+      );
+    } else if (settings.name == '/second') {
+      return GetPageRoute(
+        page: () => Center(
+          child: Scaffold(
+            appBar: AppBar(
+              title: Text("Main"),
+            ),
+            body: Center(
+              child:  Text("second")
+            ),
+          ),
+        ),
+      );
+    }
+  }
+),
+```

+- [State Management](#state-management)
+  - [Reactive State Manager](#reactive-state-manager)
+    - [Advantages](#advantages)
+    - [Maximum performance:](#maximum-performance)
+    - [Declaring a reactive variable](#declaring-a-reactive-variable)
+        - [Having a reactive state, is easy.](#having-a-reactive-state-is-easy)
+    - [Using the values in the view](#using-the-values-in-the-view)
+    - [Conditions to rebuild](#conditions-to-rebuild)
+    - [Where .obs can be used](#where-obs-can-be-used)
+    - [Note about Lists](#note-about-lists)
+    - [Why i have to use .value](#why-i-have-to-use-value)
+    - [Obx()](#obx)
+    - [Workers](#workers)
+  - [Simple State Manager](#simple-state-manager)
+    - [Advantages](#advantages-1)
+    - [Usage](#usage)
+    - [How it handles controllers](#how-it-handles-controllers)
+    - [You won't need StatefulWidgets anymore](#you-wont-need-statefulwidgets-anymore)
+    - [Why it exists](#why-it-exists)
+    - [Other ways of using it](#other-ways-of-using-it)
+    - [Unique IDs](#unique-ids)
+  - [Mixing the two state managers](#mixing-the-two-state-managers)
+  - [GetBuilder vs GetX vs Obx vs MixinBuilder](#getbuilder-vs-getx-vs-obx-vs-mixinbuilder)
+
+# State Management
+
+GetX does not use Streams or ChangeNotifier like other state managers. Why? In addition to building applications for android, iOS, web, linux, macos and linux, with GetX you can build server applications with the same syntax as Flutter/GetX. In order to improve response time and reduce RAM consumption, we created GetValue and GetStream, which are low latency solutions that deliver a lot of performance, at a low operating cost. We use this base to build all of our resources, including state management.
+
+- _Complexity_: Some state managers are complex and have a lot of boilerplate. With GetX you don't have to define a class for each event, the code is highly clean and clear, and you do a lot more by writing less. Many people have given up on Flutter because of this topic, and they now finally have a stupidly simple solution for managing states.
+- _No code generators_: You spend half your development time writing your application logic. Some state managers rely on code generators to have minimally readable code. Changing a variable and having to run build_runner can be unproductive, and often the waiting time after a flutter clean will be long, and you will have to drink a lot of coffee.
+With GetX everything is reactive, and nothing depends on code generators, increasing your productivity in all aspects of your development.
+- _It does not depend on context_: You probably already needed to send the context of your view to a controller, making the View's coupling with your business logic high. You have probably had to use a dependency for a place that has no context, and had to pass the context through various classes and functions. This just doesn't exist with GetX. You have access to your controllers from within your controllers without any context. You don't need to send the context by parameter for literally nothing.
+- _Granular control_: most state managers are based on ChangeNotifier. ChangeNotifier will notify all widgets that depend on it when notifyListeners is called. If you have 40 widgets on one screen, which have a variable of your ChangeNotifier class, when you update one, all of them will be rebuilt.
+With GetX, even nested widgets are respected. If you have Obx watching your ListView, and another watching a checkbox inside the ListView, when changing the CheckBox value, only it will be updated, when changing the List value, only the ListView will be updated.
+- _It only reconstructs if its variable REALLY changes_: GetX has flow control, that means if you display a Text with 'Paola', if you change the observable variable to 'Paola' again, the widget will not be reconstructed. That's because GetX knows that 'Paola' is already being displayed in Text, and will not do unnecessary reconstructions.
+Most (if not all) current state managers will rebuild on the screen.
+
+## Reactive State Manager
+
+Reactive programming can alienate many people because it is said to be complicated. GetX turns reactive programming into something quite simple:
+
+- You won't need to create StreamControllers.
+- You won't need to create a StreamBuilder for each variable
+- You will not need to create a class for each state.
+- You will not need to create a get for an initial value.
+
+Reactive programming with Get is as easy as using setState.
+
+Let's imagine that you have a name variable and want that every time you change it, all widgets that use it are automatically changed.
+
+This is your count variable:
+
+```dart
+var name = 'Jonatas Borges';
+```
+
+To make it observable, you just need to add ".obs" to the end of it:
+
+```dart
+var name = 'Jonatas Borges'.obs;
+```
+
+That's all. It's *that* simple.
+
+From now on, we might refer to this reactive-".obs"(ervables) variables as _Rx_.   
+
+What did we do under the hood? We created a `Stream` of `String`s, assigned the initial value `"Jonatas Borges"`, we notified all widgets that use `"Jonatas Borges"` that they now "belong" to this variable, and when the _Rx_ value changes, they will have to change as well. 
+
+This is the **magic of GetX**, thanks to Dart's capabilities.
+
+But, as we know, a `Widget` can only be changed if it is inside a function, because static classes do not have the power to "auto-change". 
+
+You will need to create a `StreamBuilder`, subscribe to this variable to listen for changes, and create a "cascade" of nested `StreamBuilder` if you want to change several variables in the same scope, right?
+
+No, you don't need a `StreamBuilder`, but you are right about static classes.
+
+Well, in the view, we usually have a lot of boilerplate when we want to change a specific Widget, that's the Flutter way. 
+With **GetX** you can also forget about this boilerplate code. 
+
+`StreamBuilder( … )`? `initialValue: …`? `builder: …`? Nope, you just need to place this variable inside an `Obx()` Widget.
+
+```dart
+Obx (() => Text (controller.name));
+```
+
+_What do you need to memorize?_  Only `Obx(() =>`. 
+
+You are just passing that Widget through an arrow-function into an `Obx()` (the "Observer" of the _Rx_). 
+
+`Obx` is pretty smart, and will only change if the value of `controller.name` changes. 
+
+If `name` is `"John"`, and you change it to `"John"` (`name.value = "John"`), as it's the same `value` as before, nothing will change on the screen, and `Obx`, to save resources, will simply ignore the new value and not rebuild the Widget. **Isn't that amazing?**
+
+> So, what if I have 5 _Rx_ (observable) variables within an `Obx`?
+
+It will just update when **any** of them changes. 
+
+> And if I have 30 variables in a class, when I update one, will it update **all** the variables that are in that class?
+
+Nope, just the **specific Widget** that uses that _Rx_ variable.
+
+So, **GetX** only updates the screen, when the _Rx_ variable changes it's value.
+
+```
+final isOpen = false.obs;
+
+// NOTHING will happen... same value.
+void onButtonTap() => isOpen.value=false;
+```
+### Advantages
+
+**GetX()** helps you when you need **granular** control over what's being updated.
+
+If you do not need `unique IDs`, because all your variables will be modified when you perform an action, then use `GetBuilder`, 
+because it's a Simple State Updater (in blocks, like `setState()`), made in just a few lines of code.
+It was made simple, to have the least CPU impact, and just to fulfill a single purpose (a _State_ rebuild) and spend the minimum resources possible.
+
+If you need a **powerful** State Manager, you can't go wrong with **GetX**.
+
+It doesn't work with variables, but __flows__, everything in it are `Streams` under the hood. 
+You can use _rxDart_ in conjunction with it, because everything are `Streams`, 
+you can listen the `event` of each "_Rx_ variable", 
+because everything in it are `Streams`. 
+
+It is literally a _BLoC_ approach, easier than _MobX_, and without code generators or decorations.
+You can turn **anything** into an _"Observable"_ with just a `.obs`.
+
+### Maximum performance:
+
+In addition to having a smart algorithm for minimal rebuilds, **GetX** uses comparators 
+to make sure the State has changed. 
+
+If you experience any errors in your app, and send a duplicate change of State, 
+**GetX** will ensure it will not crash.
+
+With **GetX** the State only changes if the `value` change. 
+That's the main difference between **GetX**, and using _`computed` from MobX_. 
+When joining two __observables__, and one changes; the listener of that _observable_ will change as well.
+
+With **GetX**, if you join two variables, `GetX()` (similar to `Observer()`) will only rebuild if it implies a real change of State.
+
+### Declaring a reactive variable
+
+You have 3 ways to turn a variable into an "observable".
+
+
+1 - The first is using **`Rx{Type}`**.
+
+```dart
+// initial value is recommended, but not mandatory
+final name = RxString('');
+final isLogged = RxBool(false);
+final count = RxInt(0);
+final balance = RxDouble(0.0);
+final items = RxList<String>([]);
+final myMap = RxMap<String, int>({});
+```
+
+2 - The second is to use **`Rx`** and use Darts Generics, `Rx<Type>`
+
+```dart
+final name = Rx<String>('');
+final isLogged = Rx<Bool>(false);
+final count = Rx<Int>(0);
+final balance = Rx<Double>(0.0);
+final number = Rx<Num>(0)
+final items = Rx<List<String>>([]);
+final myMap = Rx<Map<String, int>>({});
+
+// Custom classes - it can be any class, literally
+final user = Rx<User>();
+```
+
+3 - The third, more practical, easier and preferred approach, just add **`.obs`** as a property of your `value`:
+
+```dart
+final name = ''.obs;
+final isLogged = false.obs;
+final count = 0.obs;
+final balance = 0.0.obs;
+final number = 0.obs;
+final items = <String>[].obs;
+final myMap = <String, int>{}.obs;
+
+// Custom classes - it can be any class, literally
+final user = User().obs;
+```
+
+##### Having a reactive state, is easy.
+
+As we know, _Dart_ is now heading towards _null safety_.
+To be prepared, from now on, you should always start your _Rx_ variables with an **initial value**.
+
+> Transforming a variable into an _observable_ + _initial value_ with **GetX** is the simplest, and most practical approach.
+
+You will literally add a "`.obs`" to the end of your variable, and **that’s it**, you’ve made it observable,
+and its `.value`, well, will be the _initial value_).
+
+
+### Using the values in the view
+
+```dart
+// controller file
+final count1 = 0.obs;
+final count2 = 0.obs;
+int get sum => count1.value + count2.value;
+```
+
+```dart
+// view file
+GetX<Controller>(
+  builder: (controller) {
+    print("count 1 rebuild");
+    return Text('${controller.count1.value}');
+  },
+),
+GetX<Controller>(
+  builder: (controller) {
+    print("count 2 rebuild");
+    return Text('${controller.count2.value}');
+  },
+),
+GetX<Controller>(
+  builder: (controller) {
+    print("count 3 rebuild");
+    return Text('${controller.sum}');
+  },
+),
+```
+
+If we increment `count1.value++`, it will print:
+- `count 1 rebuild` 
+- `count 3 rebuild`
+
+because `count1` has a value of `1`, and `1 + 0 = 1`, changing the `sum` getter value.
+
+If we change `count2.value++`, it will print:
+- `count 2 rebuild` 
+- `count 3 rebuild`
+
+because `count2.value` changed, and the result of the `sum` is now `2`.
+
+- NOTE: By default, the very first event will rebuild the widget, even if it is the same `value`.
+ This behavior exists due to Boolean variables.
+
+Imagine you did this:
+
+```dart
+var isLogged = false.obs;
+```
+
+And then, you checked if a user is "logged in" to trigger an event in `ever`.
+
+```dart
+@override
+onInit(){
+  ever(isLogged, fireRoute);
+  isLogged.value = await Preferences.hasToken();
+}
+
+fireRoute(logged) {
+  if (logged) {
+   Get.off(Home());
+  } else {
+   Get.off(Login());
+  }
+}
+```
+
+if `hasToken` was `false`, there would be no change to `isLogged`, so `ever()` would never be called.
+To avoid this type of behavior, the first change to an _observable_ will always trigger an event, 
+even if it contains the same `.value`.
+
+You can remove this behavior if you want, using:
+`isLogged.firstRebuild = false;`
+
+### Conditions to rebuild
+
+In addition, Get provides refined state control. You can condition an event (such as adding an object to a list), on a certain condition.
+
+```dart
+// First parameter: condition, must return true of false
+// Second parameter: the new value to aplly if the condition is true
+list.addIf(item < limit, item);
+```
+
+Without decorations, without a code generator, without complications :smile:
+
+Do you know Flutter's counter app? Your Controller class might look like this:
+
+```dart
+class CountController extends GetxController {
+  final count = 0.obs;
+}
+```
+
+With a simple:
+
+```dart
+controller.count.value++
+```
+
+You could update the counter variable in your UI, regardless of where it is stored.
+
+### Where .obs can be used
+
+You can transform anything on obs. Here are two ways of doing it:
+
+* You can convert your class values to obs
+```dart
+class RxUser {
+  final name = "Camila".obs;
+  final age = 18.obs;
+}
+```
+
+* or you can convert the entire class to be an observable
+```dart
+class User {
+  User({String name, int age});
+  var name;
+  var age;
+}
+
+// when instantianting:
+final user = User(name: "Camila", age: 18).obs;
+```
+
+### Note about Lists
+
+Lists are completely observable as are the objects within it. That way, if you add a value to a list, it will automatically rebuild the widgets that use it.
+
+You also don't need to use ".value" with lists, the amazing dart api allowed us to remove that.
+Unfortunaly primitive types like String and int cannot be extended, making the use of .value mandatory, but that won't be a problem if you work with gets and setters for these.
+
+```dart
+// On the controller
+final String title = 'User Info:'.obs
+final list = List<User>().obs;
+
+// on the view
+Text(controller.title.value), // String need to have .value in front of it
+ListView.builder (
+  itemCount: controller.list.length // lists don't need it
+)
+```
+
+When you are making your own classes observable, there is a different way to update them:
+
+```dart
+// on the model file
+// we are going to make the entire class observable instead of each attribute
+class User() {
+  User({this.name = '', this.age = 0});
+  String name;
+  int age;
+}
+
+
+// on the controller file
+final user = User().obs;
+// when you need to update the user variable:
+user.update( (user) { // this parameter is the class itself that you want to update
+user.name = 'Jonny';
+user.age = 18;
+});
+// an alternative way of update the user variable:
+user(User(name: 'João', age: 35));
+
+// on view:
+Obx(()=> Text("Name ${user.value.name}: Age: ${user.value.age}"))
+// you can also access the model values without the .value:
+user().name; // notice that is the user variable, not the class (variable has lowercase u)
+```
+
+You don't have to work with sets if you don't want to. you can use the "assign 'and" assignAll "api.
+The "assign" api will clear your list, and add a single object that you want to start there.
+The "assignAll" api will clear the existing list and add any iterable objects that you inject into it.
+
+### Why i have to use .value
+
+We could remove the obligation to use 'value' to `String` and `int` with a simple decoration and code generator, but the purpose of this library is precisely avoid external dependencies. We want to offer an environment ready for programming, involving the essentials (management of routes, dependencies and states), in a simple, lightweight and performant way, without a need of an external package.
+
+You can literally add 3 letters to your pubspec (get) and a colon and start programming. All solutions included by default, from route management to state management, aim at ease, productivity and performance.
+
+The total weight of this library is less than that of a single state manager, even though it is a complete solution, and that is what you must understand.
+
+If you are bothered by `.value`, and like a code generator, MobX is a great alternative, and you can use it in conjunction with Get. For those who want to add a single dependency in pubspec and start programming without worrying about the version of a package being incompatible with another, or if the error of a state update is coming from the state manager or dependency, or still, do not want to worrying about the availability of controllers, whether literally "just programming", get is just perfect.
+
+If you have no problem with the MobX code generator, or have no problem with the BLoC boilerplate, you can simply use Get for routes, and forget that it has state manager. Get SEM and RSM were born out of necessity, my company had a project with more than 90 controllers, and the code generator simply took more than 30 minutes to complete its tasks after a Flutter Clean on a reasonably good machine, if your project it has 5, 10, 15 controllers, any state manager will supply you well. If you have an absurdly large project, and code generator is a problem for you, you have been awarded this solution.
+
+Obviously, if someone wants to contribute to the project and create a code generator, or something similar, I will link in this readme as an alternative, my need is not the need for all devs, but for now I say, there are good solutions that already do that, like MobX.
+
+### Obx()
+
+Typing in Get using Bindings is unnecessary. you can use the Obx widget instead of GetX which only receives the anonymous function that creates a widget.
+Obviously, if you don't use a type, you will need to have an instance of your controller to use the variables, or use `Get.find<Controller>()` .value or Controller.to.value to retrieve the value.
+
+### Workers
+
+Workers will assist you, triggering specific callbacks when an event occurs.
+
+```dart
+/// Called every time `count1` changes.
+ever(count1, (_) => print("$_ has been changed"));
+
+/// Called only first time the variable $_ is changed
+once(count1, (_) => print("$_ was changed once"));
+
+/// Anti DDos - Called every time the user stops typing for 1 second, for example.
+debounce(count1, (_) => print("debouce$_"), time: Duration(seconds: 1));
+
+/// Ignore all changes within 1 second.
+interval(count1, (_) => print("interval $_"), time: Duration(seconds: 1));
+```
+All workers (except `debounce`) have a `condition` named parameter, which can be a `bool` or a callback that returns a `bool`.
+This `condition` defines when the `callback` function executes.
+
+All workers returns a `Worker` instance, that you can use to cancel ( via `dispose()` ) the worker.
+ 
+- **`ever`**
+ is called every time the _Rx_ variable emits a new value.
+
+- **`everAll`**
+ Much like `ever`, but it takes a `List` of _Rx_ values Called every time its variable is changed. That's it.
+
+
+- **`once`**
+'once' is called only the first time the variable has been changed.
+
+- **`debounce`**
+'debounce' is very useful in search functions, where you only want the API to be called when the user finishes typing. If the user types "Jonny", you will have 5 searches in the APIs, by the letter J, o, n, n, and y. With Get this does not happen, because you will have a "debounce" Worker that will only be triggered at the end of typing.
+
+- **`interval`**
+'interval' is different from the debouce. debouce if the user makes 1000 changes to a variable within 1 second, he will send only the last one after the stipulated timer (the default is 800 milliseconds). Interval will instead ignore all user actions for the stipulated period. If you send events for 1 minute, 1000 per second, debounce will only send you the last one, when the user stops strafing events. interval will deliver events every second, and if set to 3 seconds, it will deliver 20 events that minute. This is recommended to avoid abuse, in functions where the user can quickly click on something and get some advantage (imagine that the user can earn coins by clicking on something, if he clicked 300 times in the same minute, he would have 300 coins, using interval, you you can set a time frame for 3 seconds, and even then clicking 300 or a thousand times, the maximum he would get in 1 minute would be 20 coins, clicking 300 or 1 million times). The debounce is suitable for anti-DDos, for functions like search where each change to onChange would cause a query to your api. Debounce will wait for the user to stop typing the name, to make the request. If it were used in the coin scenario mentioned above, the user would only win 1 coin, because it is only executed, when the user "pauses" for the established time.
+
+- NOTE: Workers should always be used when starting a Controller or Class, so it should always be on onInit (recommended), Class constructor, or the initState of a StatefulWidget (this practice is not recommended in most cases, but it shouldn't have any side effects).
+
+## Simple State Manager
+
+Get has a state manager that is extremely light and easy, which does not use ChangeNotifier, will meet the need especially for those new to Flutter, and will not cause problems for large applications.
+
+GetBuilder is aimed precisely at multiple state control. Imagine that you added 30 products to a cart, you click delete one, at the same time that the list is updated, the price is updated and the badge in the shopping cart is updated to a smaller number. This type of approach makes GetBuilder killer, because it groups states and changes them all at once without any "computational logic" for that. GetBuilder was created with this type of situation in mind, since for ephemeral change of state, you can use setState and you would not need a state manager for this.
+
+That way, if you want an individual controller, you can assign IDs for that, or use GetX. This is up to you, remembering that the more "individual" widgets you have, the more the performance of GetX will stand out, while the performance of GetBuilder should be superior, when there is multiple change of state.
+
+### Advantages
+
+1. Update only the required widgets.
+
+2. Does not use changeNotifier, it is the state manager that uses less memory (close to 0mb).
+
+3. Forget StatefulWidget! With Get you will never need it. With the other state managers, you will probably have to use a StatefulWidget to get the instance of your Provider, BLoC, MobX Controller, etc. But have you ever stopped to think that your appBar, your scaffold, and most of the widgets that are in your class are stateless? So why save the state of an entire class, if you can only save the state of the Widget that is stateful? Get solves that, too. Create a Stateless class, make everything stateless. If you need to update a single component, wrap it with GetBuilder, and its state will be maintained.
+
+4. Organize your project for real! Controllers must not be in your UI, place your TextEditController, or any controller you use within your Controller class.
+
+5. Do you need to trigger an event to update a widget as soon as it is rendered? GetBuilder has the property "initState", just like StatefulWidget, and you can call events from your controller, directly from it, no more events being placed in your initState.
+
+6. Do you need to trigger an action like closing streams, timers and etc? GetBuilder also has the dispose property, where you can call events as soon as that widget is destroyed.
+
+7. Use streams only if necessary. You can use your StreamControllers inside your controller normally, and use StreamBuilder also normally, but remember, a stream reasonably consumes memory, reactive programming is beautiful, but you shouldn't abuse it. 30 streams open simultaneously can be worse than changeNotifier (and changeNotifier is very bad).
+
+8. Update widgets without spending ram for that. Get stores only the GetBuilder creator ID, and updates that GetBuilder when necessary. The memory consumption of the get ID storage in memory is very low even for thousands of GetBuilders. When you create a new GetBuilder, you are actually sharing the state of GetBuilder that has a creator ID. A new state is not created for each GetBuilder, which saves A LOT OF ram for large applications. Basically your application will be entirely Stateless, and the few Widgets that will be Stateful (within GetBuilder) will have a single state, and therefore updating one will update them all. The state is just one.
+
+9. Get is omniscient and in most cases it knows exactly the time to take a controller out of memory. You should not worry about when to dispose of a controller, Get knows the best time to do this.
+
+### Usage
+
+```dart
+// Create controller class and extends GetxController
+class Controller extends GetxController {
+  int counter = 0;
+  void increment() {
+    counter++;
+    update(); // use update() to update counter variable on UI when increment be called
+  }
+}
+// On your Stateless/Stateful class, use GetBuilder to update Text when increment be called
+GetBuilder<Controller>(
+  init: Controller(), // INIT IT ONLY THE FIRST TIME
+  builder: (_) => Text(
+    '${_.counter}',
+  ),
+)
+//Initialize your controller only the first time. The second time you are using ReBuilder for the same controller, do not use it again. Your controller will be automatically removed from memory as soon as the widget that marked it as 'init' is deployed. You don't have to worry about that, Get will do it automatically, just make sure you don't start the same controller twice.
+```
+
+**Done!**
+
+- You have already learned how to manage states with Get.
+
+- Note: You may want a larger organization, and not use the init property. For that, you can create a class and extends Bindings class, and within it mention the controllers that will be created within that route. Controllers will not be created at that time, on the contrary, this is just a statement, so that the first time you use a Controller, Get will know where to look. Get will remain lazyLoad, and will continue to dispose Controllers when they are no longer needed. See the pub.dev example to see how it works.
+
+If you navigate many routes and need data that was in your previously used controller, you just need to use GetBuilder Again (with no init):
+
+```dart
+class OtherClass extends StatelessWidget {
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      body: Center(
+        child: GetBuilder<Controller>(
+          builder: (s) => Text('${s.counter}'),
+        ),
+      ),
+    );
+  }
+
+```
+
+If you need to use your controller in many other places, and outside of GetBuilder, just create a get in your controller and have it easily. (or use `Get.find<Controller>()`)
+
+```dart
+class Controller extends GetxController {
+
+  /// You do not need that. I recommend using it just for ease of syntax.
+  /// with static method: Controller.to.counter();
+  /// with no static method: Get.find<Controller>().counter();
+  /// There is no difference in performance, nor any side effect of using either syntax. Only one does not need the type, and the other the IDE will autocomplete it.
+  static Controller get to => Get.find(); // add this line
+
+  int counter = 0;
+  void increment() {
+    counter++;
+    update();
+  }
+}
+```
+
+And then you can access your controller directly, that way:
+
+```dart
+FloatingActionButton(
+  onPressed: () {
+    Controller.to.increment(),
+  } // This is incredibly simple!
+  child: Text("${Controller.to.counter}"),
+),
+```
+
+When you press FloatingActionButton, all widgets that are listening to the 'counter' variable will be updated automatically.
+
+### How it handles controllers
+
+Let's say we have this:
+
+`Class a => Class B (has controller X) => Class C (has controller X)`
+
+In class A the controller is not yet in memory, because you have not used it yet (Get is lazyLoad). In class B you used the controller, and it entered memory. In class C you used the same controller as in class B, Get will share the state of controller B with controller C, and the same controller is still in memory. If you close screen C and screen B, Get will automatically take controller X out of memory and free up resources, because Class a is not using the controller. If you navigate to B again, controller X will enter memory again, if instead of going to class C, you return to class A again, Get will take the controller out of memory in the same way. If class C didn't use the controller, and you took class B out of memory, no class would be using controller X and likewise it would be disposed of. The only exception that can mess with Get, is if you remove B from the route unexpectedly, and try to use the controller in C. In this case, the creator ID of the controller that was in B was deleted, and Get was programmed to remove it from memory every controller that has no creator ID. If you intend to do this, add the "autoRemove: false" flag to class B's GetBuilder and use adoptID = true; in class C's GetBuilder.
+
+### You won't need StatefulWidgets anymore
+
+Using StatefulWidgets means storing the state of entire screens unnecessarily, even because if you need to minimally rebuild a widget, you will embed it in a Consumer/Observer/BlocProvider/GetBuilder/GetX/Obx, which will be another StatefulWidget.
+The StatefulWidget class is a class larger than StatelessWidget, which will allocate more RAM, and this may not make a significant difference between one or two classes, but it will most certainly do when you have 100 of them!
+Unless you need to use a mixin, like TickerProviderStateMixin, it will be totally unnecessary to use a StatefulWidget with Get.
+
+You can call all methods of a StatefulWidget directly from a GetBuilder.
+If you need to call initState() or dispose() method for example, you can call them directly;
+
+```dart
+GetBuilder<Controller>(
+  initState: (_) => Controller.to.fetchApi(),
+  dispose: (_) => Controller.to.closeStreams(),
+  builder: (s) => Text('${s.username}'),
+),
+```
+
+A much better approach than this is to use the onInit() and onClose() method directly from your controller.
+
+```dart
+@override
+void onInit() {
+  fetchApi();
+  super.onInit();
+}
+```
+
+- NOTE: If you want to start a method at the moment the controller is called for the first time, you DON'T NEED to use constructors for this, in fact, using a performance-oriented package like Get, this borders on bad practice, because it deviates from the logic in which the controllers are created or allocated (if you create an instance of this controller, the constructor will be called immediately, you will be populating a controller before it is even used, you are allocating memory without it being in use, this definitely hurts the principles of this library). The onInit() methods; and onClose(); were created for this, they will be called when the Controller is created, or used for the first time, depending on whether you are using Get.lazyPut or not. If you want, for example, to make a call to your API to populate data, you can forget about the old-fashioned method of initState/dispose, just start your call to the api in onInit, and if you need to execute any command like closing streams, use the onClose() for that.
+
+### Why it exists
+
+The purpose of this package is precisely to give you a complete solution for navigation of routes, management of dependencies and states, using the least possible dependencies, with a high degree of decoupling. Get engages all high and low level Flutter APIs within itself, to ensure that you work with the least possible coupling. We centralize everything in a single package, to ensure that you don't have any kind of coupling in your project. That way, you can put only widgets in your view, and leave the part of your team that works with the business logic free, to work with the business logic without depending on any element of the View. This provides a much cleaner working environment, so that part of your team works only with widgets, without worrying about sending data to your controller, and part of your team works only with the business logic in its breadth, without depending on no element of the view.
+
+So to simplify this:
+You don't need to call methods in initState and send them by parameter to your controller, nor use your controller constructor for that, you have the onInit() method that is called at the right time for you to start your services.
+You do not need to call the device, you have the onClose() method that will be called at the exact moment when your controller is no longer needed and will be removed from memory. That way, leave views for widgets only, refrain from any kind of business logic from it.
+
+Do not call a dispose method inside GetxController, it will not do anything, remember that the controller is not a Widget, you should not "dispose" it, and it will be automatically and intelligently removed from memory by Get. If you used any stream on it and want to close it, just insert it into the close method. Example:
+
+```dart
+class Controller extends GetxController {
+  StreamController<User> user = StreamController<User>();
+  StreamController<String> name = StreamController<String>();
+
+  /// close stream = onClose method, not dispose.
+  @override
+  void onClose() {
+    user.close();
+    name.close();
+    super.onClose();
+  }
+}
+```
+
+Controller life cycle:
+
+- onInit() where it is created.
+- onClose() where it is closed to make any changes in preparation for the delete method
+- deleted: you do not have access to this API because it is literally removing the controller from memory. It is literally deleted, without leaving any trace.
+
+### Other ways of using it
+
+You can use Controller instance directly on GetBuilder value:
+
+```dart
+GetBuilder<Controller>(
+  init: Controller(),
+  builder: (value) => Text(
+    '${value.counter}', //here
+  ),
+),
+```
+
+You may also need an instance of your controller outside of your GetBuilder, and you can use these approaches to achieve this:
+
+```dart
+class Controller extends GetxController {
+  static Controller get to => Get.find();
+[...]
+}
+// on you view:
+GetBuilder<Controller>(  
+  init: Controller(), // use it only first time on each controller
+  builder: (_) => Text(
+    '${Controller.to.counter}', //here
+  )
+),
+```
+
+or
+
+```dart
+class Controller extends GetxController {
+ // static Controller get to => Get.find(); // with no static get
+[...]
+}
+// on stateful/stateless class
+GetBuilder<Controller>(  
+  init: Controller(), // use it only first time on each controller
+  builder: (_) => Text(
+    '${Get.find<Controller>().counter}', //here
+  ),
+),
+```
+
+- You can use "non-canonical" approaches to do this. If you are using some other dependency manager, like get_it, modular, etc., and just want to deliver the controller instance, you can do this:
+
+```dart
+Controller controller = Controller();
+[...]
+GetBuilder<Controller>(
+  init: controller, //here
+  builder: (_) => Text(
+    '${controller.counter}', // here
+  ),
+),
+
+```
+
+### Unique IDs
+
+If you want to refine a widget's update control with GetBuilder, you can assign them unique IDs:
+
+```dart
+GetBuilder<Controller>(
+  id: 'text'
+  init: Controller(), // use it only first time on each controller
+  builder: (_) => Text(
+    '${Get.find<Controller>().counter}', //here
+  ),
+),
+```
+
+And update it this form:
+
+```dart
+update(['text']);
+```
+
+You can also impose conditions for the update:
+
+```dart
+update(['text'], counter < 10);
+```
+
+GetX does this automatically and only reconstructs the widget that uses the exact variable that was changed, if you change a variable to the same as the previous one and that does not imply a change of state , GetX will not rebuild the widget to save memory and CPU cycles (3 is being displayed on the screen, and you change the variable to 3 again. In most state managers, this will cause a new rebuild, but with GetX the widget will only is rebuilt again, if in fact his state has changed).
+
+## Mixing the two state managers
+
+Some people opened a feature request, as they wanted to use only one type of reactive variable, and the other mechanics, and needed to insert an Obx into a GetBuilder for this. Thinking about it MixinBuilder was created. It allows both reactive changes by changing ".obs" variables, and mechanical updates via update(). However, of the 4 widgets he is the one that consumes the most resources, since in addition to having a Subscription to receive change events from his children, he subscribes to the update method of his controller.
+
+Extending GetxController is important, as they have life cycles, and can "start" and "end" events in their onInit() and onClose() methods. You can use any class for this, but I strongly recommend you use the GetxController class to place your variables, whether they are observable or not.
+
+
+## GetBuilder vs GetX vs Obx vs MixinBuilder
+
+In a decade working with programming I was able to learn some valuable lessons.
+
+My first contact with reactive programming was so "wow, this is incredible" and in fact reactive programming is incredible.
+However, it is not suitable for all situations. Often all you need is to change the state of 2 or 3 widgets at the same time, or an ephemeral change of state, in which case reactive programming is not bad, but it is not appropriate.
+
+Reactive programming has a higher consumption of RAM consumption that can be compensated for by the individual workflow, which will ensure that only one widget is rebuilt and when necessary, but creating a list with 80 objects, each with several streams is not a good one idea. Open the dart inspect and check how much a StreamBuilder consumes, and you'll understand what I'm trying to tell you.
+
+With that in mind, I created the simple state manager. It is simple, and that is exactly what you should demand from it: updating state in blocks in a simple way, and in the most economical way.
+
+GetBuilder is very economical in RAM, and there is hardly a more economical approach than him (at least I can't imagine one, if it exists, please let us know).
+
+However, GetBuilder is still a mechanical state manager, you need to call update() just like you would need to call Provider's notifyListeners().
+
+There are other situations where reactive programming is really interesting, and not working with it is the same as reinventing the wheel. With that in mind, GetX was created to provide everything that is most modern and advanced in a state manager. It updates only what is necessary and when necessary, if you have an error and send 300 state changes simultaneously, GetX will filter and update the screen only if the state actually changes.
+
+GetX is still more economical than any other reactive state manager, but it consumes a little more RAM than GetBuilder. Thinking about it and aiming to maximize the consumption of resources that Obx was created. Unlike GetX and GetBuilder, you will not be able to initialize a controller inside an Obx, it is just a Widget with a StreamSubscription that receives change events from your children, that's all. It is more economical than GetX, but loses to GetBuilder, which was to be expected, since it is reactive, and GetBuilder has the most simplistic approach that exists, of storing a widget's hashcode and its StateSetter. With Obx you don't need to write your controller type, and you can hear the change from multiple different controllers, but it needs to be initialized before, either using the example approach at the beginning of this readme, or using the Bindings class.

@@ -11,6 +11,7 @@
     - [Bindings类](#Bindings类)
     - [BindingsBuilder](#BindingsBuilder)
     - [智能管理](#智能管理)
+      - [如何改变](#如何改变)
       - [SmartManagement.full](#smartmanagementfull)
       - [SmartManagement.onlyBuilders](#SmartManagement.onlyBuilders)
       - [SmartManagement.keepFactory](#smartmanagementkeepFactory)

-import 'dart:io';
-
 import 'package:flutter/material.dart';
 import 'package:get/get.dart';
 import 'routes/app_pages.dart';
 import 'shared/logger/logger_utils.dart';
 
-void main() async {
-  final client = GetConnect();
-  final form = FormData({
-    'file': MultipartFile(
-      File('README.md').readAsBytesSync(),
-      filename: 'readme.md',
-    ),
-  });
-  final response = await client.post('http://localhost:8080/upload', form);
-
-  print(response.body);
-  WidgetsFlutterBinding.ensureInitialized();
+void main() {
   runApp(MyApp());
 }
 

@@ -110,7 +110,7 @@ class GetConnect extends GetConnectInterface {
     Decoder<T> decoder,
   }) {
     _checkIfDisposed();
-    return httpClient.get(
+    return httpClient.get<T>(
       url,
       headers: headers,
       contentType: contentType,
@@ -149,7 +149,7 @@ class GetConnect extends GetConnectInterface {
     Decoder<T> decoder,
   }) {
     _checkIfDisposed();
-    return httpClient.put(
+    return httpClient.put<T>(
       url,
       body: body,
       headers: headers,
@@ -170,7 +170,7 @@ class GetConnect extends GetConnectInterface {
     Decoder<T> decoder,
   }) {
     _checkIfDisposed();
-    return httpClient.request(
+    return httpClient.request<T>(
       url,
       method,
       body: body,

@@ -129,14 +129,15 @@ class GetHttpClient {
     }
 
     final uri = _createUri(url, query);
-    print(headers);
-    return Request(
+
+    return Request<T>(
       method: method,
       url: uri,
       headers: headers,
       bodyBytes: bodyStream,
       followRedirects: followRedirects,
       maxRedirects: maxRedirects,
+      decoder: decoder,
     );
   }
 
@@ -171,7 +172,7 @@ class GetHttpClient {
       if (HttpStatus.unauthorized == response.statusCode &&
           _modifier.authenticator != null &&
           requestNumber <= maxAuthRetries) {
-        return _performRequest(
+        return _performRequest<T>(
           handler,
           authenticate: true,
           requestNumber: requestNumber + 1,
@@ -238,7 +239,7 @@ class GetHttpClient {
       body,
       'post',
       query,
-      decoder,
+      decoder ?? (defaultDecoder as Decoder<T>),
     );
   }
 
@@ -250,7 +251,14 @@ class GetHttpClient {
     @required Map<String, dynamic> query,
     Decoder<T> decoder,
   }) {
-    return _requestWithBody(url, contentType, body, method, query, decoder);
+    return _requestWithBody<T>(
+      url,
+      contentType,
+      body,
+      method,
+      query,
+      decoder ?? (defaultDecoder as Decoder<T>),
+    );
   }
 
   Future<Request<T>> _put<T>(
@@ -260,7 +268,14 @@ class GetHttpClient {
     @required Map<String, dynamic> query,
     Decoder<T> decoder,
   }) {
-    return _requestWithBody(url, contentType, body, 'put', query, decoder);
+    return _requestWithBody<T>(
+      url,
+      contentType,
+      body,
+      'put',
+      query,
+      decoder ?? (defaultDecoder as Decoder<T>),
+    );
   }
 
   Request<T> _delete<T>(
@@ -274,7 +289,11 @@ class GetHttpClient {
     final uri = _createUri(url, query);
 
     return Request<T>(
-        method: 'delete', url: uri, headers: headers, decoder: decoder);
+      method: 'delete',
+      url: uri,
+      headers: headers,
+      decoder: decoder ?? (defaultDecoder as Decoder<T>),
+    );
   }
 
   Future<Response<T>> post<T>(
@@ -322,8 +341,8 @@ class GetHttpClient {
     Decoder<T> decoder,
   }) async {
     try {
-      var response = await _performRequest(
-        () => _request(
+      var response = await _performRequest<T>(
+        () => _request<T>(
           url,
           method,
           contentType: contentType,
@@ -356,8 +375,8 @@ class GetHttpClient {
     Decoder<T> decoder,
   }) async {
     try {
-      var response = await _performRequest(
-        () => _put(
+      var response = await _performRequest<T>(
+        () => _put<T>(
           url,
           contentType: contentType,
           query: query,
@@ -414,7 +433,7 @@ class GetHttpClient {
     Decoder<T> decoder,
   }) async {
     try {
-      var response = await _performRequest(
+      var response = await _performRequest<T>(
         () async => _delete<T>(url, contentType, query, decoder),
         headers: headers,
       );

@@ -54,7 +54,7 @@ class Request<T> {
     int maxRedirects = 4,
     FormData files,
     bool persistentConnection = true,
-    final Decoder<T> decoder,
+    Decoder<T> decoder,
   }) {
     assert(url != null);
     assert(method != null);