Using Dagger in a Clean Architecture project

Using Dagger in a
Clean Architecture project
Fabio Collini

@fabioCollini
linkedin.com/in/fabiocollini
github.com/fabioCollini
medium.com/@fabioCollini
Android programmazione avanzata
Android Developers Italia
Ego slide

entitiesentities
Layered

Architecture
Clean

Architecture
Dagger
Modularization

https://www.youtube.com/watch?v=PZBg5DIzNww

https://jeroenmols.com/blog/2019/03/06/modularizationwhy/

1. Speeds up builds
2. Enable on demand delivery
3. Simplify development
4. Reuse modules across apps
5. Experiment with new technologies
6. Scale development teams
7. Enables refactoring
8. Simpliﬁes test automation
Modularization - Why you should care
https://jeroenmols.com/blog/2019/03/06/modularizationwhy/

dynamic
feature3
App
feature1 feature2

App
dynamic
feature3
feature1 feature2
Feature1App

Main app
BUILD SUCCESSFUL in 1m 12s

847 actionable tasks: 266 executed, 542 from cache, 39 up-to-date

Feature app
BUILD SUCCESSFUL in 43s


Feature module


Core module


Utils

Poorman'sbenchmark

Activity
Repository
api1
UseCase
ViewModel

entitiesentitiesentitiesentities
domain
repository
UI
data source
presenter
Activity
Repository
api1
UseCase
ViewModel

RepositoryImplRepositoryUseCase

domain repository
UseCase
RepositoryImpl
Repository

domain repository
Repository RepositoryImpl
UseCase

Inversion
Of Control
The “I” in S.O.L.I.D.

TDD
Pros
Framework
independence
entitiesentitiesentitiesentities
domain
repository
UI
data source
presenter

https://www.youtube.com/watch?v=GlDsfq3xHvo&t=

App
dynamic
feature3
feature1 feature2
Feature1App
Dagger Dagger
Dagger
Dagger
Dagger
Dagger
Dagger
Dagger
Dagger
Dagger
Dagger
Dagger

Component dependencies
Subcomponents
Dagger Android
Daggerpatterns

https://medium.com/androiddevelopers/dependency-injection-in-a-multi-module-project-1a09511c14b7
https://proandroiddev.com/using-dagger-in-a-multi-module-project-1e6af8f06ﬀc

DaggerTip#1
@Component
interface Component1
@Component(dependencies = [Component1::class])
fun main() {
DaggerComponent2.builder()
.build()
}1

DaggerTip#1
Exception in thread "main" java.lang.IllegalStateException: Component1 must be set
at dagger.internal.Preconditions.checkBuilderRequirement(Preconditions.java:95)
at DaggerComponent2$Builder.build(DaggerComponent2.java:35)
@Component
fun main() {
.build()
}1

DaggerTip#1
Exception in thread "main" java.lang.IllegalStateException: Component1 must be set
at dagger.internal.Preconditions.checkBuilderRequirement(Preconditions.java:95)
at DaggerComponent2$Builder.build(DaggerComponent2.java:35)
@Component
fun main() {
.component1(DaggerComponent1.create())
.build()
}1

DaggerTip#1
@Component
interface Component2 {
@Component.Factory
interface Factory {
fun create(component1: Component1): Component2
}2
}3
fun main() {
DaggerComponent2.factory()
.create(DaggerComponent1.create())
}1

DaggerTip#2
@Module
class Module1 {
@Provides
fun pattern() = "#,###.00"
@Provides
fun format(pattern: String) =
DecimalFormat(pattern)
}1
Module1
pattern
format

DaggerTip#2
@Module
class Module1 {
@Provides
fun pattern() = "#,###.00"
@Provides
}1
@Component(modules = [Module1::class])
val format: DecimalFormat
}2
Module1
Component1
pattern
format
format

DaggerTip#2 @Module
class Module1 {
@Provides
fun pattern() = "#,###.00"
@Provides
}1
}2
@Module
class Module2 {
}3
@Component(
modules = [Module2::class],
dependencies = [Component1::class]
)5
}4
Module2
Component2
Module1
Component1
pattern
format
format

DaggerTip#2 @Module
class Module1 {
@Provides
fun pattern() = "#,###.00"
}1
}2
@Module
class Module2 {
@Provides
}3
@Component(
)5
}4
Module2
Component2
format
Module1
Component1
pattern
format
error: [Dagger/MissingBinding] String cannot be provided without an @Inject constructor or
an @Provides-annotated method.
public abstract interface Component2 {
^
String is injected at
Module2.format(pattern)
DecimalFormat is provided at
Component2.getFormat()

DaggerTip#2 @Module
class Module1 {
@Provides
fun pattern() = "#,###.00"
}1
val pattern: String
}2
@Module
class Module2 {
@Provides
}3
@Component(
)5
}4
Module2
Component2
format
Module1
Component1
patternpattern
format

DaggerTip#3
val pattern: String
}2
@Module
class Module2 {
@Provides
}3
@Component(
)5
}4

DaggerTip#3 interface Component1 {
val pattern: String
}2
@Module
class Module2 {
@Provides
}3
@Component(
)5
}4
fun main() {
val component1 = object : Component1 {
override val pattern ="#,###.0000"
}3
val component2 = DaggerComponent2.factory().create(component1)
}4

@Module
class LibModule {
@Provides
fun provideMyLibObject() = MyLibObject()
}3
@Component(modules = [LibModule::class])
interface LibComponent {
val myLibObject: MyLibObject
}1
Lib

@Module
class LibModule {
@Provides
}3
}1
Lib
feature2
Lib
feature1

feature2
Lib
feature1
@Component(dependencies = [LibComponent::class])
interface Feature1Component
@Module
class LibModule {
@Provides
}3
}1
feat1feat2Lib

feature2
Lib
feature1
@Singleton
@Singleton
@Module
class LibModule {
@Singleton
@Provides
}3
@Singleton
}1
Libfeat1feat2

feature2
Lib
feature1
@Scope annotation class Feature1SingletonScope
@Feature1SingletonScope
@Scope annotation class Feature2SingletonScope
@Scope annotation class LibSingletonScope
@Module
class LibModule {
@LibSingletonScope
@Provides
}3
@LibSingletonScope
}1
Libfeat1feat2

DaggerTip#4
@Module
class LibModule {
@Singleton
@Provides
}3
@Singleton
}1

DaggerTip#4
@Module
class LibModule {
@Singleton
@Provides
}3
@Singleton
}1
fun main() {
val obj1 = DaggerLibComponent.create().myLibObject
val obj2 = DaggerLibComponent.create().myLibObject
println(obj1 === obj2)
//false :(
}2

DaggerTip#4
@Module
class LibModule {
@Singleton
@Provides
}3
@Singleton
}1
fun main() {
val component = DaggerLibComponent.create()
val obj1 = component.myLibObject
val obj2 = component.myLibObject
println(obj1 === obj2)
//true :)
}2

interface LibComponentProvider {
val libComponent: LibComponent
}8
Lib

interface Feature1Provider {
val feature1Component: Feature1Component
}7
}8
feature1Lib

class MyApp : Application(), LibComponentProvider, Feature1Provider {
override val libComponent =
DaggerLibComponent.create()
override val feature1Component =
DaggerFeature1Component.factory().create(libComponent)
}6
}7
}8
feature1LibApp

}6
}7
fun Application.feature1Component() =
(this as Feature1Provider).feature1Component
}8
fun Application.libComponent() =
(this as LibComponentProvider).libComponent
Libfeature1App

}6
class MyFeature1App : Application(), LibComponentProvider, Feature1Provider {
}3
}7
fun Application.feature1Component() =
}8
fun Application.libComponent() =
Libfeature1Feature1AppApp

interface ComponentHolder {
val map: MutableMap<KClass<*>, Any>
}1
open class ComponentHolderApp : Application(), ComponentHolder {
override val map = mutableMapOf<KClass<*>, Any>()
}2
inline fun <reified C : Any> ComponentHolder.getOrCreate(factory: () -> C): C =
map.getOrPut(C::class, factory) as C
A “real” implementation is available here:
https://github.com/fabioCollini/CleanWeather/blob/dagger/kotlinUtils/
src/main/java/it/codingjam/cleanweather/kotlinutils/ComponentHolder.kt

class MyApp : ComponentHolderApp(), LibComponentProvider, Feature1Provider {
}6
class MyFeature1App : ComponentHolderApp(), LibComponentProvider, Feature1Provider {
}3
}7
fun ComponentHolderApp.feature1Component() =
}8
fun ComponentHolderApp.libComponent() =

class MyApp : ComponentHolderApp(), LibComponentProvider, Feature1Provider {
}6
class MyFeature1App : ComponentHolderApp(), LibComponentProvider, Feature1Provider {
}3
}7
fun ComponentHolderApp.feature1Component() = getOrCreate {
}1
}8
fun ComponentHolderApp.libComponent() = getOrCreate {
}2

class MyApp : ComponentHolderApp(), LibComponentProvider, Feature1Provider
class MyFeature1App : ComponentHolderApp(), LibComponentProvider, Feature1Provider
}7
DaggerFeature1Component.factory()
.create(libComponent())
}1
}8
}2
Feature1App
App Libfeature1

class MyApp : ComponentHolderApp()
class MyFeature1App : ComponentHolderApp()
DaggerFeature1Component.factory()
.create(libComponent())
}1
}2
Libfeature1
Feature1App
App

@Component(dependencies = [Lib1Component::class, Lib2Component::class])
interface Feature1Component {
//...
}
DaggerTip#5
error: @Feature1SingletonScope Feature1Component depends on more than one scoped component:
@dagger.Component(dependencies = {Lib1Component.class, Lib2Component.class})
^
@Lib1SingletonScope Lib1Component
@Lib2SingletonScope Lib2Component

@Lib1SingletonScope
@Component(modules = [Lib1Module::class])
interface Lib1Component {
}2
DaggerTip#5

}2
@Lib1SingletonScope
interface Lib1ComponentImpl : Lib1Component
DaggerTip#5

@Scope
annotation class Lib1SingletonScope
@Module
class Lib1Module {
@Lib1SingletonScope
@Provides
}1
}2
@Lib1SingletonScope
interface Lib1ComponentImpl : Lib1Component
fun ComponentHolderApp.lib1Component(): Lib1Component =
getOrCreate { DaggerLib1ComponentImpl.create() }
DaggerTip#5

@Scope
internal annotation class Lib1SingletonScope
@Module
internal class Lib1Module {
@Lib1SingletonScope
@Provides
}1
}2
@Lib1SingletonScope
internal interface Lib1ComponentImpl : Lib1Component
DaggerTip#5

DaggerTip#5
}2

NODaggerTip
}2

NODaggerTip
}2
private class Lib1ComponentImpl : Lib1Component {
override val myLibObject by lazy {
MyLibObject()
}3
}4
getOrCreate { Lib1ComponentImpl() }

class UseCase @Inject constructor(
val repository: Repository) {
//...
}9
domain
domain repository
UseCase

//...
}9
@Component
interface DomainComponent {
val useCase: UseCase
}2
domain
domain repository
UseCase
Domain
Component

//...
}9
@Module
class DomainModule {
@Provides
fun provideRepository(): Repository =
RepositoryImpl()
}1
@Component(modules = [DomainModule::class])
}2
domain
domain repository
UseCase
Domain
Component

@Component
}2
domain
domain repository
UseCase
Domain
Component

interface DomainDependencies {
val repository: Repository
}3
@Component(
dependencies = [DomainDependencies::class]
)9
}2
domain
domain repository
UseCase
Domain
Dependencies
Domain
Component

}3
@Component(
dependencies = [DomainDependencies::class]
)9
}2
@Component
interface RepositoryComponent : DomainDependencies
domainrepo
domain repository
UseCase
Repository
Component
Domain
Dependencies
Domain
Component

fun ComponentHolderApp.domainComponent() = getOrCreate {
DaggerDomainComponent.factory().create(
???
)3
}4
domain repository
UseCase
Repository
Component
Domain
Dependencies
Domain
Component
domain

map[DomainDependencies::class]
as DomainDependencies
)3
}4
domain repository
UseCase
Repository
Component
Domain
Dependencies
Domain
Component
domain

class MyApp : ComponentHolderApp() {
override fun onCreate() {
map[DomainDependencies::class] =
DaggerRepositoryComponent.create()
}1
}21
map[DomainDependencies::class]
as DomainDependencies
)3
}4
domain repository
UseCase
Repository
Component
Domain
Dependencies
Domain
Component
domainApp

}2
@Component(dependencies = [DomainDependencies::class])
}3
???
)4
}5
@Component
domainrepo
domain repository
UseCase
Repository
Component
Domain
Dependencies
Domain
Component

}2
@get:InversionDef
val ComponentHolderApp.domainDependencies
by Inversion.of(DomainDependencies::class)
}3
???
)4
}5
@Component
domainrepo
domain repository
UseCase
Repository
Component
Domain
Dependencies
Domain
Component

}2
@get:InversionDef
}3
domainDependencies()
)4
}5
@Component
domainrepo
domain repository
UseCase
Repository
Component
Domain
Dependencies
Domain
Component

}2
@get:InversionDef
}3
domainDependencies()
)4
}5
@Component
@InversionProvider
fun ComponentHolderApp.provideDomainDependencies():
DomainDependencies = getOrCreate {
DaggerRepositoryComponent.create()
}6
domainrepo
domain repository
UseCase
Repository
Component
Domain
Dependencies
Domain
Component

class MainActivity : AppCompatActivity() {
@Inject
lateinit var useCase: UseCase
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
val activityComponent = DaggerMainActivityComponent.factory().create(
(application as ComponentHolderApp).domainComponent(),
this
)1
activityComponent.inject(this)
setContentView(R.layout.activity_main)
findViewById<TextView>(R.id.text).text = useCase.retrieve()
}2
}3

class MainActivityTest {
@get:Rule
val rule = ActivityTestRule(MainActivity::class.java, false, false)
private val useCaseMock = mock<UseCase>()
}4

@get:Rule
@Before
fun setUp() {
}2
}4

@get:Rule
@Before
fun setUp() {
val app = ApplicationProvider.getApplicationContext<ComponentHolderApp>()
app.map.clear()
app.map[DomainComponent::class] = object : DomainComponent {
override val useCase = useCaseMock
}1
}2
}4

@get:Rule
@Before
fun setUp() {
val app = ApplicationProvider.getApplicationContext<ComponentHolderApp>()
app.map.clear()
app.map[DomainComponent::class] = object : DomainComponent {
override val useCase = useCaseMock
}1
}2
@Test
fun launchActivity() {
whenever(useCaseMock.retrieve()) doReturn "ABCDEF"
rule.launchActivity(null)
onView(withId(R.id.text))
.check(matches(withText("ABCDEF")))
}3
}4

Wrappingup
Component dependencies
Each module exposes:
a Component interface
a method to create the Component
A map in the App can be useful to:
manage singletons
replace real objects with fakes/mocks

Links
Demo Project
github.com/fabioCollini/CleanWeather/tree/dagger
Droidcon Italy talk - SOLID principles in practice: the Clean Architecture
youtube.com/watch?v=GlDsfq3xHvo&t=
Implementing Dependency Inversion using Dagger components
medium.com/google-developer-experts/implementing-dependency-inversion-using-dagger-components-d6b0fb3b6b5e
Inversion library
github.com/fabioCollini/Inversion
Yigit Boyar, Florina Muntenescu - Build a Modular Android App Architecture (Google I/O'19)
youtube.com/watch?v=PZBg5DIzNww
Jeroen Mols - Modularization - Why you should care
jeroenmols.com/blog/2019/03/06/modularizationwhy/
Ben Weiss - Dependency injection in a multi module project
medium.com/androiddevelopers/dependency-injection-in-a-multi-module-project-1a09511c14b7
Marcos Holgado - Using Dagger in a multi-module project
proandroiddev.com/using-dagger-in-a-multi-module-project-1e6af8f06ffc

Using Dagger in a Clean Architecture project

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

Similaire à Using Dagger in a Clean Architecture project

Similaire à Using Dagger in a Clean Architecture project (20)

Plus de Fabio Collini

Plus de Fabio Collini (20)

Dernier

Dernier (20)

Using Dagger in a Clean Architecture project