Койн андроид что это такое

Обновлено: 27.03.2023

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

С точки зрения программирования, когда класс A использует некоторые функции класса B, мы говорим, что класс A имеет зависимость от класса B. Передача задачи создания объекта кому-то другому и непосредственное использование зависимости называется внедрением зависимости.

Поскольку принципы S.O.L.I.D и чистая архитектура играют большую роль в современной разработке программного обеспечения, существует тесная связь между внедрением зависимостей и принципом инверсии управления. По принципу:

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

До появления Kotlin Dagger в течение некоторого времени был стандартом де-факто для DI в мире Android. Поддерживаемый Google, он использует аннотации и генерацию кода во время компиляции для создания графа зависимостей и предоставления зависимостей. В этом нет ничего плохого, я тоже использовал его в течение достаточно долгого времени, но, как оказалось, это фреймворк, разработанный в мире Java. С другой стороны, Koin построен с использованием природы функционального программирования Kotlin, используя только функциональное программирование, поэтому мы можем попрощаться с генерацией кода, отражением и долгим временем компиляции.

Простота монет

Если вы когда-либо использовали Dagger 2, я уверен, что вы уже ненавидите пример Thermosiphon. Даже прочитав его несколько раз, вы все еще не уверены, как начать с ним работать. Что ж, интегрировать Koin довольно просто.

Добавьте Koin в файл Gradle

Создайте свой модуль и объявите для него factory

Запустите Koin внутри класса приложения

Теперь вы уже можете начать использовать экземпляр класса Controller внутри своей деятельности.

Легко и безболезненно, верно? Нет необходимости в дополнительных компонентах, провайдерах и интерфейсах. Добро пожаловать в Коин!

Если вы беспокоитесь о внедрении своих ViewModels, Koin вас прикроет. Он изначально поддерживает внедрение ViewModels, и это очень просто!

Давайте рассмотрим некоторые недостатки фреймворка

В следующем примере у нас есть класс AccountRepository, для работы которого требуется RemoteRepository для аутентификации пользователя и LocalRepository для последующего локального сохранения.

Модуль Koin будет выглядеть примерно так:

Хотя Koin уже знает, как создавать необходимые объекты для AccountRepository, нам потребуется добавить еще немного шаблонного кода и явно объявить ключевое слово get(), чтобы все заработало.

Следующий недостаток заключается в отсутствии ошибки внедрения зависимостей во время компиляции. В Dagger он сообщит вам, что вы забыли предоставить экземпляр, если он не может выполнить инъекцию. В Koin вы узнаете о проблеме только во время выполнения.

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

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

Процесс обучения

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

Коин довольно новый, и материалов для него не так много, как для Dagger 2, но не воспринимайте это как огромное препятствие. Простота Koin — это то, что привлекло меня больше всего. Вы можете начать с изучения их официальной документации, которая также является еще одним отличным местом для улучшения ваших навыков работы с Android. Вы можете сделать это с помощью видеоуроков на Caster IO, где есть совершенно новый курс по Koin, который поможет вам узнать много интересных функций о нем.

С Koin очень легко начать работу, а документация проста и понятна. Просто добавьте пару строк кода, и вы готовы начать! Это очень полезно, если вы работаете над новым сторонним проектом и не хотите тратить часы на настройку Dagger 2 и его компонентов. С Koin вы можете начать создавать свои объекты с помощью нескольких строк кода. Насколько это круто?

Заключение

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

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

Пожалуйста, оставьте свои мысли, если вы экспериментировали с этим.

Мы нанимаем!

Если вы увлечены Android, присоединяйтесь к нам в Adeva! Мы всегда ищем новые таланты, которые присоединятся к нашей сети.

Виктор Петровский

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

Внедрение зависимостей — это метод программирования, который делает класс независимым от его зависимостей. Это стало возможным благодаря отделению использования объекта от его создания. Многие разработчики Android знакомы с платформами внедрения зависимостей на основе Java, такими как Dagger и Guice.

Однако некоторые фреймворки полностью написаны на Kotlin для Kotlin. Эти фреймворки включают Koin и Kodein. В этой статье рассказывается, как управлять зависимостями в Android с помощью новой платформы внедрения зависимостей — Koin.

Предпосылки

Чтобы выполнить это руководство, вам необходимо:

Установите Android Studio.
Обладать базовыми знаниями по созданию приложений для Android.
Обладать базовыми знаниями языка программирования Kotlin.

Начнем!

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

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

Насколько это важно? Я когда-нибудь использовал его? Что ж, ответ на последний вопрос довольно прост. У вас есть, но без какой-либо инфраструктуры внедрения зависимостей.

Рассмотрите следующий сценарий. У вас есть два класса, A и B. Классу B требуется экземпляр A для выполнения определенной задачи. Правильно будет сказать, что класс B напрямую зависит от класса A.

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

Однако по мере масштабирования проекта обслуживание и тестирование усложняются. Здесь в игру вступают фреймворки внедрения зависимостей.

Среда внедрения зависимостей помогает нам создавать зависимости и управлять ими. Как упоминалось ранее, существует множество основанных на Java сред внедрения зависимостей Android. Однако с ростом популярности Kotlin для Android растет спрос на библиотеки, полностью написанные на Kotlin для Kotlin.

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

Начало работы с Коином

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

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

Давайте создадим несколько классов.

Создание компонентов проекта

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

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

Они нужны для вызова или доступа к функциям study() и play(), содержащимся в классах Course и Friend соответственно. Чтобы устранить эту зависимость, мы добавляем два класса в качестве параметров.

Это означает, что экземпляр класса Student не может быть создан без экземпляров классов Course и Friend.

Откройте файл MainActivity и замените функцию onCreate следующим кодом.

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

Код создает экземпляры всех классов.

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

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

Создание модуля Koin

Koin использует модули для создания зависимостей. Создайте новый файл Kotlin с именем «модуль» и добавьте следующий код.

Функция модуля, как следует из названия, используется для создания модуля. single используется для создания экземпляра singleton. Это означает, что Koin вернет тот же экземпляр класса, когда потребуется зависимость.

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

Мы использовали фабрику для классов Friend и Student, поскольку нам нужен новый экземпляр всякий раз, когда мы их вызываем. Функция get используется для получения требуемой зависимости только в том случае, если она была указана в модуле.

Он определяет тип зависимости, который нам нужен, и извлекает его для нас. Это все, что нам нужно для модуля. Давайте продолжим и запустим Koin.

Запуск Коина

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

Мы используем функцию startKoin для запуска Koin.

И все! Коин полностью настроен. Теперь давайте используем Koin в нашей MainActivity.

Замените метод onCreate объекта MainActivity этим.

Заметно сокращение количества строк кода. by inject delegate используется для ленивой инъекции зависимостей. Мы также можем использовать функцию get для неленивого получения зависимости.

Запустите приложение еще раз.

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

Заключение

В этой статье мы рассмотрели внедрение зависимостей и управление зависимостями с помощью внедрения зависимостей Kotlin, известного как Koin. Мы увидели, как легко настроить и работать с Koin.

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

Инверсия управления (IoC) – это общий термин для описания того, как ответственность за некоторые аспекты системы переносится с пользовательского кода, написанного конечным разработчиком, на платформу. Мартин Фаулер описывает структуру с точки зрения IoC:

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

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

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

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

В этом посте мы рассмотрим простое приложение, использующее преимущества Koin для внедрения зависимостей в наши пользовательские классы.

Предпосылки

Для создания примера приложения вам потребуется JDK 11 или более поздней версии, который доступен во многих источниках, включая OpenJDK, AdoptOpenJDK, Azul или Oracle.

Код примера приложения Koin можно найти здесь.

Определение проекта Gradle

Мы начинаем с файла сборки Gradle, который включает в себя зависимости для Kotlin и Koin и использует теневой плагин для создания автономных uberjar:

Чтобы собрать uberjar, запустите эту команду из Bash или PowerShell:

Регистрация одиночек

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

Этот класс запускается командой:

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

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

Далее мы вызываем функцию startKoin, которая является частью объекта GlobalContext. GlobalContext является одноэлементным (определяемым как объявление объекта) и обычно используется в качестве контекста по умолчанию для приложений. Здесь мы регистрируем наш модуль в глобальном контексте:

Теперь мы можем запрашивать экземпляры любого из наших зарегистрированных объектов с помощью app . коин . получать . Чтобы продемонстрировать, что наши отдельные определения работают должным образом, мы трижды получаем экземпляр класса SingleInstance и выводим на консоль сообщение, содержащее количество экземпляров:

Выходные данные показывают, что каждый раз мы получали один и тот же объект SingleInstance:

Регистрация фабрики

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

Этот класс запускается командой:

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

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

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

Регистрация интерфейсов

В предыдущих двух примерах в Koin были зарегистрированы конкретные классы, но хорошей практикой объектно-ориентированного подхода является работа с интерфейсами, а не с классами. Пример ниже из файловых интерфейсов. kt показывает, как зарегистрировать класс через его базовый интерфейс с Koin:

Этот класс запускается командой:

Начнем с базового интерфейса:

Затем мы реализуем интерфейс в классе:

Чтобы сделать класс доступным для Koin через его интерфейс, мы приводим новый объект обратно к интерфейсу с помощью оператора as при создании модуля:

Затем мы извлекаем зависимость из его интерфейса:

Разрешение вложенных зависимостей

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

Этот класс запускается командой:

Начнем с класса данных, определяющего строковое свойство:

Как и в предыдущем примере, мы определяем интерфейс, а затем реализуем интерфейс с помощью класса. Однако на этот раз у класса есть конструктор, который принимает экземпляр HelloMessageData:

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

Создание KoinComponent

Ранее мы отмечали, что Koin создает глобальный контекст по умолчанию, в котором регистрируются наши зависимости.Koin использует этот глобальный контекст в сочетании с делегированными свойствами Kotlin через интерфейс KoinComponent, чтобы позволить классам разрешать свои собственные зависимости без явной ссылки на KoinApplication, возвращаемую startKoin. Пример этого показан в файле koinComponent. кт :

Этот класс запускается командой:

В этом примере используются функции, продемонстрированные в предыдущих разделах, для определения класса GoodbyeServiceImpl с вложенной зависимостью от класса данных GoodbyeMessageData, который реализует интерфейс GoodbyeService :

Затем мы определяем класс GoodbyeApplication, реализующий интерфейс KoinComponent. Этот класс имеет свойство делегата с именем goodbyService, инициализированное функцией внедрения, доступной через интерфейс KoinComponent:

Модуль определяется почти так же, как и в предыдущих примерах. Однако обратите внимание, что класс GoodbyeApplication не определен в модуле:

Затем мы создаем новый экземпляр класса GoodbyeApplication и вызываем его функцию sayGoodbye. Реализуя интерфейс KoinComponent, класс GoodbyeApplication может разрешать свои собственные зависимости от глобального контекста и разрешать свою зависимость GoodbyeService для вывода сообщения на консоль:

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

Заключение

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

Мэттью Касперсон

Менеджер по продукту в Octopus Deploy

Я увлекаюсь технологиями со времен моего первого C64. Мне нравится писать о новых идеях и работать с замечательными людьми.

Мэттью Касперсон

Менеджер по продукту в Octopus Deploy

Веб-разработка Mean Stack, Laravel, Wordpress

Разработка игр Unity 2D/3D

UI/UX HTML5/CSS3, Bootstrap

Разработка мобильных приложений iOS, Android

Разработка блокчейна Hyperledger, Steem, Corda, Ethereum

Разработка AR/VR HTC Vive, Oculus

Искусственный интеллект Машинное обучение, глубокое обучение, голосовые решения

Мы

Что такое KOIN: внедрение зависимостей KOtlin

Автор: Джиннеш Шакья

Обзор

Koin — это платформа внедрения зависимостей для kotlin. Он полностью написан на чистом kotlin, поэтому он такой эффективный и легкий, а также имеет очень хорошую поддержку Android. Вы новичок в ДИ? Начнем снизу…

Темы

Что такое DI (внедрение зависимостей)?

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

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

Надеюсь, вы поняли DI и немного о коинах.

Как работает Коин

Коин работает по простой модели DSL. Здесь мы должны сначала создать модуль. В этом модуле есть все зависимые объекты, значит надо загрузить один или несколько модулей в коин. Теперь мы готовы использовать этот объект. Обычно мы загружаем модуль в коин в классе приложения, вызывая метод startKoin, затем мы можем внедрить объект туда, куда захотим, так работает коин.

Читайте также: