Provide an Instance as its interface in Koin

Question

Lets say I have two interfaces like:

interface LetterClassifier
interface NumberClassifier

Then these interfaces would be applied to this class:

class Classifier() : LetterClassifier, NumberClassifier

Now, I want to provide these instances only as LetterClassifier and NumberClassifier and not as Classifier in Koin.

The way I think of doing this is by doing:

module {
    val classifier = Classifier()

    single<NumberClassifier> { classifier }
    single<LetterClassifier> { classifier }
}

But I don't think this is the right way. Can someone guide me?

score 32 · Accepted Answer · answered Sep 18 '19 at 10:03

You could bind types to your definition like it is described on official article:

single { Classifier() } binds arrayOf(LetterClassifier::class, NumberClassifier::class)

If you want to exclude Classifier type at all you could do something like:

single<LetterClassifier> { Classifier() } bind NumberClassifier::class

score 6 · Answer 2 · answered Sep 06 '19 at 06:10

The way you're doing it is in fact the right way! Here's another example from the Koin docs, doing the same thing:

class DataRepository()
interface Presenter
class MyPresenter(val repository : Repository) : Presenter

val myModule = module {
    // Define a singleton for type  DataRepository
    single { DataRepository() }

    // Define a factory (create a new instance each time) for type Presenter (infered parameter in <>) 
    // Resolve constructor dependency with get()
    factory<Presenter> { MyPresenter(get()) }
}

One small thing to note when doing this: your approach immediately creates an instance at the time the module declaration is being processed, while placing the constructor calls in the single lambdas would create instances when needed:

single<NumberClassifier> { Classifier() }
single<LetterClassifier> { Classifier() }

Although this would create a separate single instance for both of the interfaces.

But I the same Instance. It is possible to do so without immediately creating the instance? Or should I simply make the instantiation lazy so it would create it immediately? — Archie G. Quiñones, Sep 06 '19 at 06:17

score 0 · Answer 3 · edited Dec 28 '21 at 02:32

0

You can have a function or a Singleton to provide instance,

single<NumberClassifier> { Singleton.createClassifier() }
single<LetterClassifier> { Singleton.createClassifier() }

edited Dec 28 '21 at 02:32

cigien

57,834
11
73
112

answered Dec 27 '21 at 23:37

Songzhw

131
1
3

1

This isn't a good idea. You'll be defining 3 singleton for just 1 instance. The selected answer is the correct answer. – Archie G. Quiñones Dec 28 '21 at 04:27

Provide an Instance as its interface in Koin

3 Answers3