Get/Inject all beans of T as Set<T> or List<T>

[amirabiri]

For certain use cases I'd like to register multiple beans of SomeInterface and then get them from koin as a Set<SomeInterface> or List<SomeInterface>.

For example:

interface Command {
    ...
}

class GitClone(...) : Command {
    ...
}

class GitPull(...) : Command {
    ...
}

val ctxt = applicationContext {
    bean("clone") { GitClone(...) }
    bean("pull") { GitPull(...) }
}

fun main(args: Array<String>) {
    val koin = startKoin(listOf(ctxt))
    val cliFramework = CliFramework()
    cliFramework.registerCommands(
        koin.koinContext.getAll<Command>())
}

[arnaudgiuliani]

Ok, we'll see what we can propose for that 👍

Keep in touch.

[amirabiri]

I've implemented a proposal and added a pull request. #148

[arnaudgiuliani]

Ok, we'll check that 👍

[serandel]

I would really love this. Could you use it in Android like this?
val commands: List<Command> by inject()

[arnaudgiuliani]

I see. Not sure to include it immediately for 1.0.0, perhaps one minor version behind.

[kuFEAR]

I think It should be implemented with explicit binders instances which we expect to collect into set/list/map. I may declare some instance which shouldn't be part of set of all instances,

My current multi-binding approach:

factory("set-of-validator-binds") { mutableSetOf(ValidatorA(), ValidatorB(), ValidatorC()) }
factory<Set<Validator<Entity>>("set-of-validator", override = true) { get<MutableSet<Validator<Entity>>>("set-of-validator-binds") }
factory { MessageProcessor(get("set-of-validator"))}

additional binding:

factory("set-of-validator") { get<MutableSet<Validator<Entity>>>("set-of-validator-binds").apply { add(ValidatorE()) } }

It would be preferred to implement separated definition methods for multi-binding:

bindIntoSet<Validator<Entity>>("set-validator-a") { ValidatorA() } 
bindIntoMap<Class, Validator<Entity>>("map-validator-a") { EntityA::class to EntityValidatorA() }
bindIntoMap<Int, Validator<Entity>>("map-validator-b") { 0 to EntityValidatorB() }
bindIntoMap<String, Validator<Entity>>("map-validator-c") { "C" to EntityValidatorC() }
factory { MessageProcessor(get("set-validator-a"), get("map-validator-a"), get("map-validator-b"), get("map-validator-c")) }

or it may be placed inside current definition methods:

factory { bindIntoMap{...} }
single { bindIntoSet{...} }
scope() { bindIntoSet{...} } 

[fmobus]

I see. Not sure to include it immediately for 1.0.0, perhaps one minor version behind.

Is there any roadmap for this? I'd love to use that feature :)

[viniciusccarvalho]

Just wanted to give another +1 for this feature. Here's my use case:
I have several repositories (elastic search indices), and as we expand the project more and more are added.

One of the exposed methods to the business is the capability to run index operations (compactations, delete, recreate), and currently, every time a new index is added, we need to add a new entry to the list of index. Have we had something like
val indices: List<AbstractReposiory> by inject() it would be one less place to refactor

[arnaudgiuliani]

wait and see what I can propose in 2.0

[REPLicated]

@arnaudgiuliani : Any news on this?

[arnaudgiuliani]

not for 2.0 at least. Have to check that for next version. You can provide snippets to help around that for now.

[REPLicated]

@arnaudgiuliani , @amirabiri :

The following does the job for me. As-is it only works for single definitions in the global scope and needs kotlin-reflect due to isSubclassOf:

inline fun <reified T : Any> KoinComponent.getAllOfType(): Collection<T> =
        getKoin().let { koin ->
            koin.beanRegistry
                    .getAllDefinitions()
                    .filter { it.isKind(Single) }
                    .filter { it.primaryType.isSubclassOf(T::class)}
                    .map { koin.get<T>(clazz = it.primaryType, qualifier = null, parameters = null) }
        }

[vojtapol]

Why was this closed? This feature is essential in a mature DI framework. Spring has had this feature for years.

[blundell]

update on @REPLicated's comment
on version 2.0.1:

inline fun <reified T : Any> KoinComponent.getAllOfType(): Collection<T> =
        getKoin().let { koin ->
            koin.rootScope.beanRegistry
                .getAllDefinitions()
                .filter { it.kind == Kind.Single }
                .filter { it.primaryType.isSubclassOf(T::class)}
                .map { koin.get<T>(clazz = it.primaryType, qualifier = null, parameters = null) }
        }

---

Just spotted Scope.getAll() might be the answer

Get a all instance for given inferred class (in primary or secondary type)

[REPLicated]

@blundell : Exactly. Now you can do something like:

single { FooBarJob(get()) } bind Job::class

getKoin().getAll<Job>()

[RomanMinenok]

@REPLicated thanks, this works for me, but it still requires some boilerplate (bind Job::class), so it'd be great to have proper implementation in the future

[artemasoyan]

@RomanMinenok I'm using a less boilerplate verions, something like:

inline fun <reified T: Job> Module.job(
    crossinline job: Scope.() -> T,
): BeanDefinition<T> =
    factory<T> { job() } bind Job::class

[ESchouten]

Update on @REPLicated's comment
on version 3.1.2:

inline fun <reified T : Any> getAll(): Collection<T> =
    getKoin().let { koin ->
        koin.instanceRegistry.instances.values.map { it.beanDefinition }
            .filter { it.kind == Kind.Singleton }
            .filter { it.primaryType.isSubclassOf(T::class) }
            .map { koin.get(clazz = it.primaryType, qualifier = null, parameters = null) }
    }