im debating if its better for my team to learn dagger vs just using a singleton container that would provide the dependencies. this is how it was done in the 'old days'. I am dealing specifically with android and here is an example i found on the web of using a factory container for dependency injection:
public class Container {
private static Container instance;
private FavoriteAdder favoriteAdder;
private FavoriteRepo favoriteRepo;
private FavoritesGetter favoritesGetter;
private FavoriteRemover favoritesRemover;
private Container() {}
public static Container getInstance() {
if (instance == null) {
instance = new Container();
}
return instance;
}
public FavoriteAdder getFavoriteAdder() {
if (favoriteAdder == null) {
favoriteAdder = new FavoriteAdder(getFavoriteRepo());
}
return favoriteAdder;
}
public FavoritesGetter getFavoritesGetter() {
if (favoritesGetter == null) {
favoritesGetter = new FavoritesGetter(getFavoriteRepo());
}
return favoritesGetter;
}
public FavoriteRemover getFavoritesRemover() {
if (favoritesRemover == null) {
favoritesRemover = new FavoriteRemover(getFavoriteRepo());
}
return favoritesRemover;
}
public FavoriteRepo getFavoriteRepo() {
if (favoriteRepo == null) {
CachingFavoriteRepo inMemoryRepo = new InMemoryFavoriteRepo();
FavoriteRepo remoteRepo = new SlowFavoriteRepoWrapper(new MockRemoteFavoriteRepo(), 1000);
favoriteRepo = new FavoriteReadThroughCache(inMemoryRepo, remoteRepo);
}
return favoriteRepo;
}
}
and then to use it in an activity we can do this:
public class FavoriteActivity extends ActionBarActivity {
private FavoriteAdder favoriteAdder = Container.getInstance().getFavoriteAdder();
private FavoritesGetter favoritesGetter = Container.getInstance().getFavoritesGetter();
private FavoriteRemover favoritesRemover = Container.getInstance().getFavoritesRemover();
private FavoriteCrudPresenter presenter;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
presenter = new FavoriteCrudPresenter(favoriteAdder, favoritesGetter, favoritesRemover, Schedulers.io(), AndroidSchedulers.mainThread(), backgroundExecutor, foregroundExecutor);
//...
}}
it seems easier then using dagger and im wondering what the benefits would be of dagger over this way ? Why do we even bother with dagger i guess its easier to make singletons in dagger could be one scenario.
