Краткое введение во внедрение зависимостей: что это и когда это необходимо использовать | by Sergey Ufocoder

Вольный перевод статьи Bhavya Karia: A quick intro to Dependency Injection: what it is, and when to use it.

Введение

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

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

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

Зависимость или зависимое — означает полагаться на что-то. Это все равно что, если сказать, что мы слишком много полагаемся на мобильные телефоны — это означает, что мы зависим от них.

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

Когда класс A использует некоторую функциональность из класса B, тогда говорят, что класс A зависим от класса B.

Демонстрация зависимости между классами

В Java, прежде чем мы сможем использовать методы других классов, нам необходимо для начала создать экземпляры этого класса (то есть класс А должен создать экземпляр класса В).

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

Если бы код умел разговаривать

Так почему следует использовать внедрение зависимостей?

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

Без использования внедрения зависимостей

Перед вами класс Car, отвечающий за создание всех объектов зависимостей. Теперь, что если мы решим избавиться колес компании MRFWheels и хотим использовать колеса от Yokohama в будущем?

Нам нужно будет воссоздать объект класса Car с новой зависимостью от Yokohama. Но при использовании внедрении зависимостей мы можем изменить колеса во время выполнения программы (потому что зависимости можно внедрять во время выполнения, а не во время компиляции).

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

Это делает наш класс автомобилей независимым от создания объектов таких как колеса, аккумулятор и т.д.

Существует три основных типа внедрения зависимостей:

1. constructor injection: все зависимости передаются через конструктор класса.
2. setter injection: разработчик добавляет setter-метод, с помощью которого инжектор внедряет зависимость
3. interface injection: зависимость предоставляет инжектору метод, с помощью которого инжектор передаст зависимость. Разработчики должны реализовать интерфейс, предоставляющий setter-метод, который принимает зависимости

Внедрение зависимостей ответственно за:

1. Создание объектов;
2. Представление о том, какие классы требуются этим объектам;
3. И предоставление зависимостей этим объектам.

Если есть какие-либо изменения в объектах, то DI смотрит на него, и он не должен относиться к классу с использованием этих объектов.

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

Инверсия управления — концепция, лежащая в основе внедрения зависимости

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

Это пятый принцип S.O.L.I.D из пяти основных принципов объектно-ориентированного программирования и разработки от дяди Боба, в котором говорится, что класс должен зависеть от абстракции, а не от чего-то конкретного (простыми словами, жестко закодированного).

Согласно принципам, класс должен полностью сосредоточиться на выполнении своих обязанностей, а не на создании объектов, необходимых для выполнения этих обязанностей. И именно здесь начинается внедрение зависимостей: она предоставляет классу требуемые объекты.

Замечание: Если вы хотите узнать больше о принципах SOLID от дяди Боба вы можете перейти по этой ссылке.

Преимущества использования внедрения зависимостей

1. Помогает в модульном тестировании
2. Количество шаблонного кода сокращается, поскольку инициализация зависимостей выполняется компонентом инжектора;
3. Расширение приложения становится еще проще;
4. Помогает уменьшить связность кода, что важно при разработке приложений.

Недостатки использования внедрения зависимостей

1. Это несколько сложновато для изучения, а чрезмерное использование может привести к проблемам управления или другим проблемам.
2. Многие возможные ошибки из процесса компиляции перемещаются в процесс выполнения программы.
3. Внедрения зависимостей во фреймворках реализовано с помощью рефлексии или динамического программирования. Это может помешать использованию автоматизации разработки с помощью IDE, например, будет сложно воспользоваться функциями «найти ссылки», «показать иерархию вызовов» и будет сложно заниматься безопасно рефакторингом.

Тем не менее вы вполне можете реализовать внедрение зависимостей самостоятельно без использования сторонних библиотек и фреймворков или используя их.

Библиотеки и фреймворки, реализующие внедрение зависимостей

• Spring (Java)
• Google Guice (Java)
• http://square.github.io/dagger/ (Java and Android)
• Castle Windsor (.NET)
• Unity(.NET)

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

• Java Dependency Injection — DI Design Pattern Example Tutorial — JournalDev
• Using dependency injection in Java — Introduction — Tutorial — Vogella
• Inversion of Control Containers and the Dependency Injection pattern — Martin Fowler

Надеюсь, это вам помогло!

Что такое Внедрение зависимостей и как это использовать в разработке?

Что такое Внедрение зависимостей (Dependency injection, DI)? Согласно Википедии:

Внедрение зависимости — процесс предоставления внешней зависимости программному компоненту. Является специфичной формой «инверсии управления» (Inversion of control, IoC), когда она применяется к управлению зависимостями. В полном соответствии с принципом единственной обязанности объект отдаёт заботу о построении требуемых ему зависимостей внешнему, специально предназначенному для этого общему механизму.

Внедрение зависимостей

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

Внедрение внедрения зависимостей дает вам следующие преимущества:

• Возможность повторного использования кода
• Легкость рефакторинга
• Легкость тестирования

Основы внедрения зависимостей

Прежде чем конкретно рассматривать внедрение зависимостей в той или иной платформе, давайте поймем, как работает внедрение зависимостей в общем смысле.

Классы часто требуют ссылок на другие классы. Например, классу Car может потребоваться ссылка на класс Engine. Эти обязательные классы называются зависимостями, и в этом примере класс Car зависит от наличия экземпляра класса Engine для запуска.

У класса есть три способа получить нужный объект:

1. Класс конструирует нужную ему зависимость. В приведенном выше примере Car создаст и инициализирует собственный экземпляр Engine.
2. Перехватит его откуда-то еще. Некоторые Android API, такие как методы получения Context и getSystemService(), работают таким образом.
3. Укажет его как параметр. Приложение может предоставить эти зависимости при создании класса или передать их функциям, которым нужна каждая зависимость. В приведенном выше примере конструктор Car получит Engine в качестве параметра.

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

Вот пример. Без внедрения зависимостей представление Car, которое создает свою собственную зависимость Engine в коде, выглядит следующим образом:

class Car {

    private val engine = Engine()

    fun start() {
        engine. start()
    }
}

fun main(args: Array) {
    val car = Car()
    car.start()
}

Это не пример внедрения зависимостей, потому что класс Car создает свой собственный Engine. Это может быть проблематично, потому что:

• Car и Engine тесно связаны — экземпляр Car использует один тип Engine, и подклассы или альтернативные реализации использовать уже сложно. Если бы Car конструировал собственный Engine, вам пришлось бы создать два типа автомобилей вместо того, чтобы просто повторно использовать один и тот же автомобиль для двигателей типа Gas и Electric.
• Жесткая зависимость от Engine затрудняет тестирование. Car использует реальный экземпляр Engine, что не позволяет вам использовать тестовый двойник для изменения Engine в различных тестовых случаях.

Как выглядит код с внедрением зависимостей? Вместо того, чтобы каждый экземпляр Car конструировал свой собственный объект Engine при инициализации, он получает объект Engine в качестве параметра в своем конструкторе:

class Car(private val engine: Engine) {
    fun start() {
        engine. start()
    }
}

fun main(args: Array) {
    val engine = Engine()
    val car = Car(engine)
    car.start()
}

Функция main использует Car. Поскольку Car зависит от Engine, приложение создает экземпляр Engine, а затем использует его для создания экземпляра Car.

Преимущества этого подхода на основе DI:

• Возможность повторного использования Car. Вы можете перейти от Engine к Car. Например, вы можете определить новый подкласс Engine под названием ElectricEngine, который вы хотите использовать в Car. Если вы используете DI, все, что вам нужно сделать, это передать экземпляр обновленного подкласса ElectricEngine, и Car по-прежнему будет работать без каких-либо дальнейших изменений.
• Простое тестирование Car. Вы можете передать тестовые двойники, чтобы проверить свои различные сценарии. Например, вы можете создать тестовый двойник Engine под названием FakeEngine и настроить его для различных тестов.

Есть два основных способа внедрения зависимостей в Android:

• Constructor Injection (инъекция конструктора). Это способ, описанный выше. Вы передаете зависимости класса его конструктору.
• Field Injection (или Setter Injection, полевая инъекция). Некоторые экземпляры определенных классов платформы Android, таких как активити или фрагменты, создает сама система, поэтому внедрение конструктора невозможно. При полевой инъекции зависимости создаются после создания класса. Код будет выглядеть так:

class Car {
    lateinit var engine: Engine

    fun start() {
        engine.start()
    }
}

fun main(args: Array) {
    val car = Car()
    car.engine = Engine()
    car.start()
}

Автоматическая инъекция зависимостей

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

• В случае больших приложений для правильного использования всех зависимостей и их правильного подключения может потребоваться большой объем стандартного кода. В многоуровневой архитектуре, чтобы создать объект для верхнего уровня, вы должны предоставить все зависимости нижележащих слоев. Например, чтобы построить настоящий автомобиль, вам могут понадобиться двигатель, трансмиссия, шасси и другие детали; а двигателю, в свою очередь, нужны цилиндры и свечи зажигания.
• Когда вы не можете построить зависимости перед их передачей — например, при использовании ленивых инициализаций или при привязке объектов к потокам вашего приложения — вам необходимо написать и поддерживать настраиваемый контейнер (или граф зависимостей), который управляет временем жизни зависимостей в памяти.

Существуют библиотеки, которые решают эту проблему, автоматизируя процесс создания и предоставления зависимостей. Их можно разделить на две категории:

• Решения на основе отражения, которые связывают зависимости во время выполнения.
• Статические решения, которые генерируют код для подключения зависимостей во время компиляции.

Dagger — это популярная библиотека внедрения зависимостей для Java, Kotlin и Android, поддерживаемая Google. Dagger упрощает использование DI в вашем приложении, создавая и управляя графом зависимостей для вас. Он обеспечивает полностью статические зависимости и зависимости во время компиляции, решая многие проблемы разработки и производительности решений на основе отражения, таких как Guice.

Альтернативы внедрению зависимостей

Альтернативой внедрению зависимостей является использование локатора служб. Шаблон проектирования локатора служб также улучшает отделение классов от конкретных зависимостей. Вы создаете класс, известный как локатор сервисов, который создает и хранит зависимости, а затем предоставляет эти зависимости по запросу.

object ServiceLocator {
    fun getEngine(): Engine = Engine()
}

class Car {
    private val engine = ServiceLocator. getEngine()

    fun start() {
        engine.start()
    }
}

fun main(args: Array) {
    val car = Car()
    car.start()
}

Локатор сервисов отличается от внедрения зависимостей способом потребления элементов. С локатора сервисов классы получают контроль и запрашивают объекты для внедрения а с внедрением зависимостей приложение получает контроль и активно внедряет необходимые объекты.

По сравнению с внедрением зависимостей:

• Набор зависимостей, требуемый локатору сервисов, затрудняет тестирование кода, поскольку все тесты должны взаимодействовать с одним и тем же глобальным локатором сервисов.
• Зависимости кодируются в реализации класса, а не на поверхности API. В результате извне сложнее узнать, что нужно классу. В результате изменения в Car или зависимостях, доступных в локаторе служб, могут привести к сбоям во время выполнения или тестирования, вызывая сбои ссылок.
• Управлять временем жизни объектов сложнее, если вы хотите ограничиться чем-либо, кроме времени жизни всего приложения.

Заключение

Внедрение зависимостей дает вашему приложению следующие преимущества:

• Возможность повторного использования классов и разделение зависимостей: проще поменять местами реализации зависимости. Повторное использование кода улучшено благодаря инверсии управления, и классы больше не контролируют создание своих зависимостей, а вместо этого работают с любой конфигурацией.
• Легкость рефакторинга: зависимости становятся проверяемой частью поверхности API, поэтому их можно проверять во время создания объекта или во время компиляции, а не скрывать как детали реализации.
• Легкость тестирования: класс не управляет своими зависимостями, поэтому, когда вы его тестируете, вы можете передавать различные реализации для тестирования всех ваших различных случаев.

Что еще почитать про внедрение зависимостей

• Внедрение зависимости и реализация единицы работы с помощью Castle Windsor и NHibernate
• Знакомимся с Needle, системой внедрения зависимостей на Swift
• Dagger 2 для начинающих Android разработчиков. Внедрение зависимостей. Часть 1 и Часть 2
• Как уменьшить время холодного старта Android-приложения на 28%
• Внедрение зависимостей с DITranquillity
• Изучение внедрение зависимостей в Android – Dagger, Koin и Kodein
• Внедрение зависимостей (dependency injection) в Swift 5.1

Источник

Если вы нашли опечатку — выделите ее и нажмите Ctrl + Enter! Для связи с нами вы можете использовать [email protected].

Что такое зависимость? Определение зависимости и примеры

Что такое зависимость?

💬

Определение зависимости

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

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

Получите нашу электронную книгу Mastering Prioritization eBook

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

Получить электронную книгу

Примеры зависимостей

Для настройки зависимости тип зависимости между парой может быть дополнительно определен одной из следующих моделей отношений: Зависимость запуска — это наиболее распространенная связь между двумя задачами. Предшествующая задача должна быть завершена до того, как может начаться другая задача, последующая.

Start-to-start 

Перед запуском зависимой задачи должна быть запущена предшествующая задача. Финиш любой задачи не связан.

Окончательная отделка

Последующий может закончить только после того, как предшественник закончил. Начало преемника не зависит от предшественника и может начинаться раньше, позже или одновременно с ним.

Начало-окончание

Начало-окончание — это наименьшее общее отношение между двумя задачами. Преемник уже начал и не может закончить, пока предшественник также не начал.

Зависимости могут возникать между командами, инициативами или результатами.

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

Проблемы

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

Преимущества сопоставления зависимостей

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

Как управлять зависимостью

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

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

Эффективное составление дорожных карт — один из самых действенных способов снизить любые потенциальные риски зависимостей.

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

Что такое отображение зависимостей продукта?

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

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

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

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

От чего зависят продукты?

Продукты могут зависеть от различных факторов, некоторые из которых находятся под вашим контролем, а другие нет. Общие среди них:

• Общие программные библиотеки или компоненты, интегрированные в ваш продукт

• Специальное оборудование, необходимое для работы вашего продукта

• Персонал со специальными знаниями, без которого вы не сможете обойтись

1 9 Сторонние потоки данных или базы данных, используемые вашим продуктом

• Стороннее программное обеспечение, такое как надстройки или подключаемые модули, встроенные в ваш продукт

В зависимости от вашего продукта и организации могут быть другие. При отображении зависимостей продуктов важно просмотреть все возможные типы зависимостей.

Пример сопоставления зависимостей продукта

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

У менеджера проекта есть несколько способов снизить этот риск. Они могут обратиться к третьей стороне и получить гарантии того, что подача будет продолжена, или, если будут изменения, договориться о том, что они уведомят об этом руководителя проекта заблаговременно.

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

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

Основные советы по сопоставлению зависимостей продуктов

1.       При сопоставлении зависимостей продуктов учитывайте отдельные типы зависимостей, чтобы не пропустить ни одного. Не стесняйтесь начинать с нашего списка и добавлять любые другие типы, которые относятся к вашему продукту:

• Аппаратное обеспечение

•  Общие программные библиотеки

• Программное обеспечение сторонних производителей (т. е. подключаемые модули, приложения и т. д. )

• Персонал

• Источники данных

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

 3.       Не останавливайтесь на отображении зависимостей. Значение сопоставления зависимостей продуктов помогает командам избегать проблем до их возникновения и быстрее выявлять причины непредвиденных проблем. Потратьте время, чтобы понять и записать, кто контролирует зависимости, как ваш продукт взаимодействует с зависимостями, нужна ли зависимость и какое влияние окажет нарушение зависимости.

Получите нашу электронную книгу «Как добиться успеха в качестве современного менеджера по продукту»

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

Получить электронную книгу

Что такое зависимости в программировании

В этой статье объясняется, что означают зависимости в программировании.

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

СОДЕРЖАНИЕ:

• Каковы зависимости
• Опасность использования зависимостей
• Почему мы используем зависимости
• Выбор правой зависимости
• Дальнейшее считывание

What Are ARE AREDINDIENTIONS

9

What ARE ARE ARE

98 9013 ЯРДЕРЕНИЯ 9013. Термин программной инженерии, используемый для обозначения того, что часть программного обеспечения зависит от другой. Проще говоря, если программа A требует, чтобы программа B могла работать, программа A зависит от программы B. Это делает программу B зависимостью от программы A.

Вы можете спросить, зачем программе А вообще нужна программа Б или любая другая программа в этом отношении? Это будет более подробно рассмотрено в разделе «Почему мы используем зависимости» в этой статье, но если коротко, то программе А требуется специальная служба или функция, которые есть у программы Б.

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

Если вы программист Python и читаете эту статью, я рекомендую вам также ознакомиться с этой статьей о Pyinstaller. Это также имеет много общего с зависимостями, преобразованием файлов python в exe и распространением программного обеспечения, в целом очень информативная статья.

Опасности использования зависимостей

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

1. Зависимости, которые мы контролируем
2. Зависимости, которые мы делаем не контроль

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

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

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

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

Почему мы используем зависимости

В этот момент вы можете задаться вопросом: «Зачем мы вообще используем зависимости, если существует такой большой риск?». Это хороший вопрос, и ответ на него довольно прост и ясен.

С каждым днем ​​приложения становятся все более и более сложными. Средний объем кода приложения также увеличивается день ото дня. Если бы каждый из нас каждый раз начинал с нуля, мы едва ли добились бы какого-либо прогресса.

Что мы делаем, так это развиваем то, что уже было опробовано и проверено, а затем развиваем это. По сути, мы экономим время, используя предварительно написанный и протестированный код, а затем используем сэкономленное время для создания новых и лучших вещей.

На самом деле это одна из основных причин популярности Python. Существует так много библиотек Python с предварительно написанным кодом для различных сценариев, что новый программист может создавать сложные и сложные приложения в течение нескольких недель, используя эти библиотеки.

Новое изобретение колеса

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

Причина этого довольно проста. Если широко протестированный и принятый сервис/библиотека уже существует, зачем тратить время и усилия на создание собственной версии, которая, вероятно, будет ниже той, которая уже существует.

Подводя итог, мы используем зависимости, чтобы не изобретать велосипед, чтобы ускорить процесс кодирования, сэкономить время и повысить эффективность. Допустим, у вас есть программное обеспечение, которому требуются данные о местоположении для определенной части. Собираетесь ли вы создать целую службу, предоставляющую данные о местоположении? Конечно, нет, вы собираетесь использовать уже существующую службу определения местоположения, чтобы предоставить вам эти данные. Это может быть разница между написанием 10 и 10 000 строк кода.

Что нужно искать в зависимости

Пара важных моментов, о которых следует помнить при выборе зависимости.

1. Переносимость: Последнее, что вам нужно, это зависимость, которая работает только на определенных системах и платформах. Если вы не планируете выпускать свое приложение только на определенной платформе, вам определенно следует тщательно изучить свою зависимость и даже предварительно протестировать ее на платформах, к которым вы стремитесь.
2. Управление версиями: Помните о версии, которую вы выбираете для своей зависимости. Вы уже должны это знать, но каждая новая версия приносит новые функции. Если вы используете последнюю версию этой зависимости, а ваши клиенты/клиенты имеют более старую версию, могут возникнуть проблемы. Вы также должны подумать о том, как вы будете управлять расписанием обновлений.
3. Регулярные обновления: Это одновременно и проблема безопасности, и указание на то, что в будущем от этой зависимости можно полностью отказаться. Если зависимость, которую вы хотите использовать, не обновлялась в течение года, лучше ее избегать.
4. Уровень принятия и использования: Обычно вы найдете несколько различных возможных зависимостей, которые вы можете использовать для своей программы. Вы должны стремиться к тому, который был широко принят в соответствующей области и активно используется. Это не только показывает, что зависимость надежна и заслуживает доверия, но также указывает на то, что сообщество для этой зависимости будет большим. Популярные зависимости тщательно задокументированы и обсуждаются в Интернете, что упрощает устранение неполадок или обращение за помощью.
5. Совместимость: Последнее, что вам нужно, — это выбрать зависимость, не изучив ее должным образом, а затем обнаружив, что она несовместима со всеми платформами, к которым вы стремились. Эта проблема встречается чаще, чем вы думаете. Есть все виды проблем, которые могут быть связаны, поэтому обязательно проведите исследование заранее. Еще одно предложение: во время написания кода продолжайте тестировать свой код на разных платформах и в разных настройках. Вам не нужно оставлять все тестирование на то, когда вы закончите.

Примером хорошей сторонней зависимости могут быть Карты Google. Если вы создаете приложение, которому требуются службы определения местоположения, вы можете использовать API Карт Google для получения данных о местоположении. Я говорю, что это хорошая зависимость, потому что:

1. Карты Google управляются крупной компанией Google.
2. Карты Google как сервис используются во всем мире, поэтому вы можете ожидать, что они будут надежными и согласованными. Вам не нужно беспокоиться о том, что эта услуга исчезнет за ночь или что-то в этом роде.
3. API Карт Google прост и удобен в использовании. У него есть бесплатная версия с ограниченным количеством запросов, а также премиум (платная) версия. В большинстве случаев бесплатная версия вполне подойдет.

Если вы какое-то время программировали, вы, несомненно, также использовали множество библиотек. Около 95% времени использование этих библиотек программирования в качестве ваших зависимостей совершенно нормально из-за того, насколько широко они используются. В качестве бонуса эти библиотеки несложно объединить в скомпилированную программу либо с помощью конвертера файлов в исполняемые файлы, например pyinstaller (для программ на Python).

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

Будьте умнее и выбирайте с умом!

Другие ресурсы

Зависимости в программировании — это тема, по которой можно написать целую книгу. Это гораздо больше, чем то, что было описано в этой статье, поэтому, если вам интересно, мы включили сюда некоторые ресурсы для дальнейшего чтения.

Если вам интересно узнать больше о зависимостях и их опасностях в программировании, я предлагаю вам прочитать эту статью.

This entry was posted in Популярное