getx的controller是怎么销毁的

getx可以做到通过页面的退出自动控制controller的销毁，那么他是怎么做到的呢

当我们使用getx的路由套件时，可以看到，他的每个跳转方法都使用了自定义的 GetPageRoute 。

在 GetPageRoute 中对于此次的问题，我们需要关注的是两个方法

嗯，这里给传了一个 reference 给了 Get.reference ，这个 reference 看一下是什么玩意。。

dispose ，route退出流程里调用的方法。在这里面Get做了两件事，我们主要关注第一件事， removeDependencyByRoute() 参数是上面的页面标识。

这个方法里，我们可以看到调用了 GetInstance 的 delete 方法，这个方法就是销毁controller的方法，但是为什么呢？为啥传一个页面标识就能删除到对应的controller呢。我们接着看

我们都知道我们在使用getx的controller时，一定会有两个 *** 作，一个是 Get.put() ，一个是 Get.find() 让我们一个一个的看一下

Get.put 的本质其实是将我们传入的实例，根据类 S 和 tag 创建一个 key ，然后以key和实例作为键值对存入了全局的map中（此处是简单理解，看也看得出来不是直接传实例了）

Get.find 方法很简单的只是通过类 S 和 tag 去全局map中找一个实例返回出去， 但是 返回之前，还做了一步 *** 作，即 _initDependencies 。

看到没，就在下面Get.reference，之前在GetPageRoute的页面构建之前赋值了最近的页面，然后在此处用来做routesKey的value和前面的controller的key值进行绑定。

这也是得益于flutter是个单线程模型，才能这样无脑的通过这种方式传值。其实getx中有不少让人觉得神奇的地方都是利用了单线程的优势，比如Obx的自动刷新，也是在Obx的build方法和Rx的value的get方法之间通过一个全局指针来进行传值。

首先我们知道 GetX 组件里面 obs 状态管理有三种创建属性的方式，我们这里以 List 为例

视频讲解链接

我们声明了一个类ListController 继承自 GetxController ，用于属性创建以及状态通知的方法，首先我们用三种方式来创建属性并且通过 convertToUpperCase 方法进行对值的改变，然后我们通过调用 update()`方法来进行数据更新，最后我们使用该属性状态的值，接下来我们看一下三种使用方式的对比。

import 'dart:convert'

import 'package:get/get.dart'

class ListController extends GetxController {

// 第一种

final listOne = Rx<List<Map>>([

{

"name": "Jimi",

"age": 18

}

])

// 第二种

final listTwo = RxList([

{

"name": "Jimi",

"age": 18

}

])

// 第三种

final listThree = [{

"name": "Jimi",

"age": 18

}].obs

void convertToUpperCase() {

listOne.value[0]["name"] = listOne.value.first["name"].toUpperCase()

listTwo.toList().first["name"] = listTwo.toList().first["name"].toString().toUpperCase()

listThree.toList().first["name"] = listTwo.toList().first["name"].toString().toUpperCase()

update()

}

}

我们在页面中获取状态更新的值

import 'package:flutter/material.dart'

import 'package:flutter_getx_dvanced_example/ListController.dart'

import 'package:get/get.dart'

void main() {

runApp(MyApp())

}

class MyApp extends StatelessWidget {

ListController listController = Get.put(ListController())

@override

Widget build(BuildContext context) {

return GetMaterialApp(

title: "GetX",

home: Scaffold(

appBar: AppBar(

title: Text("GetX"),

),

body: Center(

child: Column(

mainAxisAlignment: MainAxisAlignment.center,

crossAxisAlignment: CrossAxisAlignment.center,

children: [

GetBuilder<ListController>(

init: listController,

builder: (controller) {

return Text(

"我的名字是 {controller.listTwo.first['name']}",

style: TextStyle(color: Colors.green, fontSize: 30),

)

},

),

SizedBox(height: 20,),

GetBuilder<ListController>(

init: listController,

builder: (controller) {

return Text(

"我的名字是 ${controller.listThree.first['name']}",

style: TextStyle(color: Colors.green, fontSize: 30),

)

},

),

SizedBox(height: 20,),

ElevatedButton(

onPressed: () {

listController.convertToUpperCase()

},

child: Text("转换为大写"))

],

),

),

),

)

}

}

</pre>

|`

效果展示

Rx<T> 继承自 _RxImpl<T>， _RxImpl<T>又继承 RxNotifier<T>并混合 RxObjectMixin<T> 类

RxImpl<T>它主要的作用是管理泛型的所有逻辑的。

RxObjectMixin<T> 它主要的作用是管理注册到 GetX 和 Obx 的全局对象，比如 Widget 的 Rx 值

Rx<T>它主要的作用是将自定义模型类用Rx`来进行包装，

class Rx<T>extends _RxImpl<T>{

Rx(T initial) : super(initial)

@override

dynamic toJson() {

try {

return (value as dynamic)?.toJson()

} on Exception catch (_) {

throw '$T has not method [toJson]'

}

}

}

abstract class _RxImpl<T>extends RxNotifier<T>with RxObjectMixin<T>{

_RxImpl(T initial) {

_value = initial

}

void addError(Object error, [StackTrace? stackTrace]) {

subject.addError(error, stackTrace)

}

Stream<R>map<R>(R mapper(T? data)) =>stream.map(mapper)

void update(void fn(T? val)) {

fn(_value)

subject.add(_value)

}

void trigger(T v) {

var firstRebuild = this.firstRebuild

value = v

if (!firstRebuild) {

subject.add(v)

}

}

}

</pre>

|`

RxList<E>继承自 ListMixin<E>实现了 RxInterface<List<E>>并混合了 NotifyManager<List<E>>, RxObjectMixin<List<E>>

RxList<E>它的主要作用是创建一个类似于 List<T> 的一个列表

class RxList<E>extends ListMixin<E>

with NotifyManager<List<E>>, RxObjectMixin<List<E>>

implements RxInterface<List<E>>{

RxList([List<E>initial = const []]) {

_value = List.from(initial)

}

factory RxList.filled(int length, E fill, {bool growable = false}) {

return RxList(List.filled(length, fill, growable: growable))

}

factory RxList.empty({bool growable = false}) {

return RxList(List.empty(growable: growable))

}

/// Creates a list containing all [elements].

factory RxList.from(Iterable elements, {bool growable = true}) {

return RxList(List.from(elements, growable: growable))

}

/// Creates a list from [elements].

factory RxList.of(Iterable<E>elements, {bool growable = true}) {

return RxList(List.of(elements, growable: growable))

}

/// Generates a list of values.

factory RxList.generate(int length, E generator(int index),

{bool growable = true}) {

return RxList(List.generate(length, generator, growable: growable))

}

/// Creates an unmodifiable list containing all [elements].

factory RxList.unmodifiable(Iterable elements) {

return RxList(List.unmodifiable(elements))

}

@override

Iterator<E>get iterator =>value.iterator

@override

void operator []=(int index, E val) {

_value[index] = val

refresh()

}

/// Special override to push() element(s) in a reactive way

/// inside the List,

@override

RxList<E>operator +(Iterable<E>val) {

addAll(val)

refresh()

return this

}

@override

E operator [](int index) {

return value[index]

}

@override

void add(E item) {

_value.add(item)

refresh()

}

@override

void addAll(Iterable<E>item) {

_value.addAll(item)

refresh()

}

@override

int get length =>value.length

@override

@protected

List<E>get value {

RxInterface.proxy?.addListener(subject)

return _value

}

@override

set length(int newLength) {

_value.length = newLength

refresh()

}

@override

void insertAll(int index, Iterable<E>iterable) {

_value.insertAll(index, iterable)

refresh()

}

@override

Iterable<E>get reversed =>value.reversed

@override

Iterable<E>where(bool Function(E) test) {

return value.where(test)

}

@override

Iterable<T>whereType<T>() {

return value.whereType<T>()

}

@override

void sort([int compare(E a, E b)?]) {

_value.sort(compare)

refresh()

}

}

</pre>

|`

当我们在调用 .obs 的时候其实内部的实现源码还是通过 RxList<e>(this) 进行了一层包装，设计这个主要的目的就是为了方便开发者进行使用

ListExtension<E>on List<E>{

RxList<E>get obs =>RxList<E>(this)

/// Add [item] to [List<E>] only if [item] is not null.

void addNonNull(E item) {

if (item != null) add(item)

}

// /// Add [Iterable<E>] to [List<E>] only if [Iterable<E>] is not null.

// void addAllNonNull(Iterable<E>item) {

// if (item != null) addAll(item)

// }

/// Add [item] to List<E>only if [condition] is true.

void addIf(dynamic condition, E item) {

if (condition is Condition) condition = condition()

if (condition is bool &&condition) add(item)

}

/// Adds [Iterable<E>] to [List<E>] only if [condition] is true.

void addAllIf(dynamic condition, Iterable<E>items) {

if (condition is Condition) condition = condition()

if (condition is bool &&condition) addAll(items)

}

/// Replaces all existing items of this list with [item]

void assign(E item) {

// if (this is RxList) {

// (this as RxList)._value

// }

}

/// Replaces all existing items of this list with [items]

void assignAll(Iterable<E>items) {

// if (this is RxList) {

// (this as RxList)._value

// }

clear()

addAll(items)

}

}

</pre>

|`

我们对 Rx<T>([]) 、 RxList<E>、 .obs 进行了一个总结，在我们平时的开发过程中建议大家使用 .obs 即可，因为这是最简单的方式。

public class Test{

private int x

private int y

public Test(int i,int j){

x=i

y=j

}

public int getX(){

return x

}

public int getY(){

return y

}

public static void main(String args[]){

Test t=new Test(1,2)

System.out.println(t.getX())

System.out.println(t.getY())

}

}

---