Понимание потребности в платформе DI

У меня был тот же самый вопрос, и ему ответило это:
Предоставленный, Вы могли сделать то, в чем Вы описали, "Затем Вы могли просто do:..." (давайте назовем тот "класс A"). Однако это связало бы класс A с HandSaw, или со всеми зависимостями, необходимыми от класса SawMill. Почему A должен быть связан с HandSaw - или при взятии более реалистического сценария почему моя бизнес-логика должна быть связана с реализацией соединения JDBC, необходимой для уровня DAO?
решением, которое я предложил затем, было "затем перемещение зависимости один шаг вперед" - хорошо, поэтому теперь мне связали мое представление с соединением JDBC, где я должен только иметь дело с HTML (или Swing, выберите свою разновидность).

платформа DI, настроенная XML (или JavaConfig), решает это, позволяя Вам просто "получить необходимый сервис". Вы не заботитесь, как это инициализируется, что это должно работать - Вы просто получаете объект службы и активируете его.

кроме того, у Вас есть неправильное представление там относительно "плюс": (где Вы делаете SawMill springSawMill = (SawMill)context.getBean("sawMill"); springSawMill.run();) - Вы не должны получать боб лесопилки от контекста - боб лесопилки должен был быть введен в Ваш объект (класс A) платформой DI. таким образом вместо... getBean (...), Вы просто пошли бы "sawMill.run ()", не заботясь, куда это прибыло из, кто инициализировал его и как. Для всего Вы заботитесь, это могло перейти прямо к/dev/null, или тестовому выводу или реальному механизму CNC... Точка - Вы не заботитесь. Все, о чем Вы заботитесь, является Вашим крошечным небольшим классом A, который должен сделать то, что он законтрактован, чтобы сделать - активируют лесопилку.

Внедрение зависимости является вырожденной формой неявная передача параметров , и целью является по существу то же, для решения то, что звонило проблема Конфигураций :

проблема конфигураций состоит в том, чтобы распространить предпочтения во время выполнения всюду по программе, позволив нескольким параллельным конфигурациям модели сосуществовать безопасно при статически гарантируемом разделении.

платформы Внедрения зависимости компенсируют из-за отсутствия неявные параметры , функции С приправой карри , и удобные средства для монады на языке.

Spring имеет три функции, которые одинаково важны:

1. внедрение зависимости
2. аспектно-ориентированное программирование
3. библиотека классов платформы для помощи с персистентностью, дистанционной работой, сеть mvc, и т.д.

я соглашусь, что трудно видеть преимущество для внедрения зависимости при сравнении этого с единственным вызовом к новому. В этом случае последний будет, конечно, выглядеть более простым, потому что это - одна строка кода. Конфигурация Spring будет всегда увеличивать строки кода, таким образом, это не будет аргумент победы.

Это начинает выглядеть намного лучше, когда можно взять сквозное беспокойство как транзакции из классов и использовать аспекты для установки их декларативным способом. Сравнение с единственным "новым" вызовом не то, для чего был создан Spring.

, Возможно, лучшим результатом от использования Spring является путь его рекомендуемые интерфейсы использования идиомы, разделение на уровни и хорошие принципы как DRY. Это - действительно просто дистилляция объектно-ориентированных лучших практик, которые Rod Johnson использовал на своих консультационных концертах. Он нашел, что код, который он создавал со временем, помогал ему заработать, поставляя лучшее программное обеспечение для его клиентов. Он суммировал свой опыт в "Эксперте 1:1 J2EE" и закончил открытое определение источника кода как Spring.

я сказал бы, вложились в платформу до градуса, что Вы думаете, что его опыт может помочь Вам написать лучший код, также.

я не думаю, что можно получить полную стоимость Spring, пока Вы не сочетаете все три из тех функций.

Предоставленный, это - contrieved пример, и с отношениями более сложного объекта могло бы быть более эффективно спрятать XML-файл, чем запись его программно, но конечно должно быть больше к нему, чем это?

я думаю, что имеет больше смысла поднимать "проводное соединение" в конфигурационном файле вместо того, чтобы делать его вручную в коде по нескольким причинам:

1. конфигурация является внешней к Вашему коду.
2. Изменения в обеспечении электричеством (чтобы сказать Вашему sawmill использовать другой экземпляр Saw) могут просто быть внесены во внешний файл (XML) и не требуют изменяющегося кода, перекомпиляции, повторного развертывания, и т.д.
3. , Когда у Вас есть десятки классов и несколько слоев инжекции (например: у Вас есть сеть Controller класс, который добирается Service класс, который содержит Вашу бизнес-логику, которая использует DAO для получения Saw с из базы данных, которая становится DataSource введенной в него, и т.д.), вручную обеспечение электричеством сотрудников утомительно и требует нескольких дюжин строк кода, которые делают только обеспечение электричеством.
4. Это - несколько меньше ясного "преимущества", но при наличии всего 'обеспечения электричеством', внешнего к коду, я думаю, что это помогает укрепить разработчикам идеи, которые являются в ядре внедрения зависимости, конкретно идея кодировать к интерфейсу, не реализации. С ручным обеспечением электричеством может быть легко снизиться в старые пути.

Я обычно не забочусь о XML или основанном на отражении DI, потому что в моих вариантах использования он добавляет ненужную сложность. Вместо этого я обычно иду для некоторой формы ручного DI, который, мне, кажется более естественным и обладает большинством преимуществ.

public class SawDI{
    public Saw CreateSaw(){
        return new HandSaw();
    }

    public SawMill CreateSawMill(){
        SawMill mill = new SawMill();
        mill.SetSaw(CreateSaw());
        return mill;
    }
}

// later on

SawDI di = new SawDI();
SawMill mill = di.CreateSawMill();

Это означает, что я все еще централизую связь и имею все преимущества этого без зависимости от более сложной платформы DI или конфигурационных XML-файлов.

Одной вещью, которую большинство (если не все) контейнеры/библиотеки DI приносит Вам, кроме того, является возможность прервать методы для всех экземпляров, созданных через DI.

Если Вы твердый код вставленный класс, Вам нужен тот класс, доступны во время компиляции. С конфигурационным файлом Вы могли изменить используемую пилу (в Вашем случае) во времени выполнения, не перекомпилировав и даже использовать пилу, взятую от новой банки, которую Вы просто поместили в путь к классу. Если это стоит дополнительной сложности, зависит от задачи, которую необходимо решить.

Важно понять, что Spring является существенно двумя вещами, одним созданным сверху другого:

1. легкий вес А платформа DI/МОК и классы для реализации этого (например, контексты приложения XML, и т.д.); и
2. Это легкий контейнер .

(2) объем кода Spring. В основном выберите JAVA-технологию, и Вы, вероятно, найдете, что Spring имеет классы помощника для нее. Это так, можно использовать ActiveMQ, Sun Один MQ или безотносительно и абстрагировать их являющийся Spring JmsTemplate, и то же идет для технологий доступа к данным, веб-сервисов, и т.д.

Все эти помощники использование (1) для проводного соединения их вместе.

Одно из самых больших преимуществ использования Внедрения зависимости - то, что оно делает намного легче обеспечить насмешки или тупики зависимостей класса при создании модульного теста на тот класс. Это позволяет Вам тестировать класс в изоляции без в зависимости от его сотрудников.

В Вашем примере, нет никакого способа дразнить или погасить, Видел или SawMill в классе это, где они инстанцируют. Если бы Видел, и SawMill были установлены через методы set или конструктора, то Вы могли передать в своей собственной насмешке, Видел и ложный SawMill при выполнении модульного теста.

Spring помогает Вам понять и даже поощряет модели DI. Однако я не полагаю, что у Вас должен быть Spring.

у Вас могут быть конфигурационные файлы в Java, которого можно отладить, осуществить рефакторинг и выполнить анализ кода.

я предполагаю, что Вы помещаете эти конфигурационные файлы Java в другой пакет, но они в других отношениях эквивалентны конфигурационным XML-файлам. Можно даже загрузить их файл динамично, если это важно.

Не забывайте об одном существенном недостатке инъекции зависимостей: вы теряете возможность легко узнать, откуда что-то инициализируется, используя Find Usages вашей мощной Java IDE. Это может быть очень серьезным моментом, если вы много рефакторите и хотите избежать того, чтобы тестовый код был в 10 раз больше, чем код приложения.