Как использовать Inpendency Injection в сочетании с шаблоном Factory

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

Рассмотрим класс B, которому нужно содержимое файла product.xml. Этот класс должен будет создать экземпляр соответствующего конкретного разработчика интерфейса Parser для анализа XML-файла. Я могу делегировать создание экземпляра соответствующего конкретного реализатора на Фабрику так, чтобы у класса В была Фабрика. Тем не менее, класс B будет «зависеть» от Factory для создания конкретного реализатора. Это означает, что конструктор или метод установки в классе B должны быть переданы Factory.

Следовательно, Factory и класс B, которым необходимо проанализировать файл, будут тесно связаны друг с другом. Я понимаю, что могу ошибаться в том, что объяснил до сих пор. Я хотел бы знать, могу ли я использовать внедрение зависимостей в сценарии, где вводимая зависимость - это Фабрика, и каков будет правильный способ реализовать это, чтобы я мог использовать преимущества таких областей, как насмешка над Фабрикой в ​​моих модульных тестах.

Правильный способ сделать это - зависеть от интерфейса, а затем внедрить реализацию этого интерфейса в класс B.

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

Поэтому пусть конструктор класса B берет интерфейс с нужным ему классом, а фабрика создает этот класс как средство реализации интерфейса. Не зависит от фабрики, зависит от интерфейса, и пусть фабрика обеспечивает реализацию этой фабрики.

Так что да, вы будете использовать внедрение зависимостей, но в этом нет ничего плохого. Внедрение зависимостей - в частности, простое внедрение в конструктор - должно быть «нормальным» способом ведения дел. Просто отложите новые вещи как можно дальше назад в своем приложении (и как можно ближе к первой строке main) и скройте новый вызов в классе, предназначенном специально для создания вещей.

Итог: не стесняйтесь вводить зависимости. Это должно быть нормальным способом ведения дел.

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

Тем не менее, позвольте мне немного рассказать о внедрении зависимостей и о том, как вы обычно их используете.

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

Внедрение в конструктор - это то, где у вас есть интерфейс для зависимости и DIContainer (или фабрика), который знает конкретную реализацию для этой зависимости, и всякий раз, когда вам нужен объект, который зависит от этого интерфейса, во время создания вы передаете реализацию из фабрики в Это.

т.е.

IDbConnectionProvider connProvider = DIContainer.Get<IDbConnectionProvider>();
IUserRepository userRepo = new UserRepository(connProvider);
User currentUser = userRepo.GetCurrentUser();

Многие инфраструктуры DI могут значительно упростить это, когда ваш DIContainer будет проверять конструктор UserRepository на наличие интерфейсов, для которых он знает конкретные реализации, и автоматически передает их вам; этот метод часто называют инверсией контроля, хотя DI и IoC - термины, которые сильно взаимозаменяемы и имеют неопределенные (если таковые имеются) различия.

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

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

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

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

В инъекционных фабриках нет ничего плохого. Это стандартный способ, если вы не можете решить во время сборки родительского объекта, какая зависимость вам понадобится. Я думаю, что пример объяснит это лучше всего. Я буду использовать c #, потому что я не знаю Java.

class Parent
{
    private IParserFactory parserFactory;
    public Parent(IParserFactory factory)
    {
        parserFactory = factory
    }

    public ParsedObject ParseFrom(string filename, FileType fileType)
    {
        var parser = parserFactory.CreateFor(fileType);
        return parser.Parse(filename);
    }
}