Я (думаю, я) понимаю цель инъекции зависимостей, но я просто не понимаю, зачем мне нужно что-то вроде Guice, чтобы это сделать (ну, очевидно, мне не нужен Guice, но я имею в виду, почему это было бы полезно использовать его). Скажем, у меня есть существующий (не-Guice) код, что-то вроде этого:
public SomeBarFooerImplementation(Foo foo, Bar bar) {
this.foo = foo;
this.bar = bar;
}
public void fooThatBar() {
foo.fooify(bar);
}
И где-то более высокий уровень, возможно, в моей main(), у меня есть:
public static void main(String[] args) {
Foo foo = new SomeFooImplementation();
Bar bar = new SomeBarImplementation();
BarFooer barFooer = new SomeBarFooerImplementation(foo, bar);
barFooer.fooThatBar();
}
Теперь у меня в основном есть преимущества инъекции зависимостей, правильно? Легкость тестирования и т.д.? Конечно, если вы хотите, вы можете легко изменить main(), чтобы получить имена классов реализации из конфигурации вместо hardcoding.
Как я понимаю, сделать то же самое в Guice, я бы сделал что-то вроде:
public SomeModule extends AbstractModule {
@Override
protected void configure() {
bind(Foo.class).to(SomeFooImplementation.class);
bind(Bar.class).to(SomeBarImplementation.class);
bind(BarFooer.class).to(SomeBarFooerImplementation.class);
}
}
@Inject
public SomeBarFooerImplementation(Foo foo, Bar, bar) {
this.foo = foo;
this.bar = bar;
}
public static void main(String[] args) {
Injector injector = Guice.createInjector(new SomeModule());
Foo foo = injector.getInstance(Foo.class);
barFooer.fooThatBar();
}
Это так? Мне кажется, что это просто синтаксический сахар, а не особенно полезный синтаксический сахар. И если есть преимущество в том, чтобы разбить "новый XxxImplementation()" материал на отдельный модуль, а не делать это непосредственно в main(), что легко сделать без Guice в любом случае.
У меня такое ощущение, что я пропустил что-то очень основное. Не могли бы вы объяснить мне, как выгодно использовать Guice?
Спасибо заранее.
