Fight against circular dependency with get_it on flutter? - flutter

Question

GetIt is Service Locator for Dart and Flutter projects (https://github.com/fluttercommunity/get_it)
I think GetIt should give us some details about circular dependency.
When I run my tests for example there is an infinite loop and they never end.

Answer 1

The get_it is for defining global objects and services, and for providing a locator functionality with which to access them. If you have a circular dependency among your global services, there's a good chance that you have designed those services to be tightly coupled with each other. For example:
class ServiceA {
final ServiceB b;
ServiceA(this.b);
void foo() {
b.bar();
}
void bar() { ... }
}
class ServiceB {
final ServiceA a;
ServiceB(this.a);
void foo() {
a.bar();
}
void bar() { ... }
}
// GetIt Initialization
GetIt g = GetIt.instance;
g.registerLazySingleton<ServiceA>(() => ServiceA(g.get<ServiceB>()));
g.registerLazySingleton<ServiceB>(() => ServiceB(g.get<ServiceA>()));
After this, calling GetIt.I.get targeting either ServiceA or ServiceB could create the infinite loop caused by circular dependency. With this implementation, there's no real way to prevent the loop without going down a rabbit hole of checks and deferred execution.
The real solution to circular dependency is often simple: design your app to not have it in the first place. For example, in the above example, ServiceA has a rigid dependency on ServiceB in the constructor and vice versa. Instead, the services could use a service locator to instead fetch the reference to the necessary service during execution of the method that needs it. To put that another way, we already are using get_it, so why not use it here?
class ServiceA {
ServiceA();
void foo() {
final b = GetIt.I.get<ServiceB>();
b.bar();
}
void bar() { ... }
}
class ServiceB {
ServiceB();
void foo() {
final a = GetIt.I.get<ServiceA>();
a.bar();
}
}
// GetIt Initialization
GetIt g = GetIt.instance;
g.registerLazySingleton<ServiceA>(() => ServiceA());
g.registerLazySingleton<ServiceB>(() => ServiceB());
Now the dependencies that ServiceA and ServiceB have on each other is much more dynamic and is not tied to their respective constructors. There is no longer a circular dependency problem, and the get_it initializer will have no problem initializing the singletons when they are accessed.

Answer 2

To solve this problem. Here a part solution with this example:
Some interfaces and implementations:
abstract class SuperLetter {}
abstract class A implements SuperLetter {}
class AC implements A {
final B b;
AC({this.b});
#override
String toString() {
if (b == null) {
return "Im an A.";
}
return "Im an A and my B is: $b";
}
}
abstract class B implements SuperLetter {}
class BC implements B {
final C c;
BC({this.c});
#override
String toString() {
if (c == null) {
return "Im a B.";
}
return "Im a B and my C: $c";
}
}
abstract class C implements SuperLetter {}
class CC implements C {
final SuperLetter a;
CC({this.a});
#override
String toString() {
if (a == null) {
return "Im a C.";
}
return "Im a C and my A: $a"; // might never be reached because of circular dependency
}
}
A new Exception to throw when circular dependency is detected.
class CircularDependencyException implements Exception {
final wantedType;
final calledTypes;
CircularDependencyException({
this.wantedType,
this.calledTypes,
});
#override
String toString() {
String message = '🔺 Circular dependency ';
for (final e in calledTypes) {
message += '${e.toString()}';
if (e == calledTypes.last) {
message += ' -> $wantedType';
} else {
message += ' -> ';
}
}
return message;
}
}
To fight against circular dependency:
class GetItProtector {
var _wantedType;
Set _calledTypes;
final GetIt getIt;
GetItProtector(this.getIt);
_check<T>() {
if (_wantedType == null) {
_wantedType = T;
_calledTypes = Set()..add(T);
} else {
if (_calledTypes.contains(T)) {
throw CircularDependencyException(wantedType: T, calledTypes: _calledTypes);
}
_calledTypes.add(T);
}
}
T call<T>() {
_check<T>();
final instance = getIt<T>();
if (instance.runtimeType == _wantedType) {
_wantedType = null;
_calledTypes.clear();
}
return instance;
}
}
Example with A -> B -> C -> A circular dependency:
void main() {
GetIt g = GetIt.instance;
final myGet = GetItProtector(g);
g.registerLazySingleton<A>(() => AC(
b: myGet(),
));
g.registerLazySingleton<B>(() => BC(
c: myGet(),
));
g.registerLazySingleton<C>(() => CC(
a: myGet<A>(),
));
A a = myGet();
print(a);
}
Output:
Error while creating C
Stack trace: ......
Error while creating B
Stack trace: ......
Error while creating A
Stack trace: ......
Unhandled exception:
🔺 Circular dependency A -> B -> C -> A
....
Example with A -> B -> C -> B
void main() {
GetIt g = GetIt.instance;
final myGet = GetItProtector(g);
g.registerLazySingleton<A>(() => AC(
b: myGet(),
));
g.registerLazySingleton<B>(() => BC(
c: myGet(),
));
g.registerLazySingleton<C>(() => CC(
a: myGet<B>(),
));
A a = myGet();
print(a);
}
Output
Error while creating C
Stack trace: ......
Error while creating B
Stack trace: ......
Error while creating A
Stack trace: ......
Unhandled exception:
🔺 Circular dependency A -> B -> C -> B
....
In this solution I don't test if type is a real type and not Object or dynamic.