Download Full Dagger by Tutorials Dependency Injection on Android with Dagger Hilt 1st Edition Massimo Carli PDF All Chapters

Download the full version of the ebook at
https://ebookfinal.com
Dagger by Tutorials Dependency Injection on

Android with Dagger Hilt 1st Edition Massimo
Carli
https://ebookfinal.com/download/dagger-by-
tutorials-dependency-injection-on-android-with-
dagger-hilt-1st-edition-massimo-carli/
Explore and download more ebook at https://ebookfinal.com

Recommended digital products (PDF, EPUB, MOBI) that
you can download immediately if you are interested.
Lover Unleashed Black Dagger Brotherhood 09 J. R. Ward
https://ebookfinal.com/download/lover-unleashed-black-dagger-
brotherhood-09-j-r-ward/
ebookfinal.com
Lover Revealed Black Dagger Brotherhood 04 1st Edition J.

R. Ward
https://ebookfinal.com/download/lover-revealed-black-dagger-
brotherhood-04-1st-edition-j-r-ward/
ebookfinal.com
Android Programming Tutorials 3rd Edition Mark L Murphy
https://ebookfinal.com/download/android-programming-tutorials-3rd-
edition-mark-l-murphy/
ebookfinal.com
The Thief Black Dagger Brotherhood 16 First Edition, 2Nd

Printing Edition J. R. Ward
https://ebookfinal.com/download/the-thief-black-dagger-
brotherhood-16-first-edition-2nd-printing-edition-j-r-ward/
ebookfinal.com
Core Data by Tutorials iOS 8 and Swift Edition Aaron
Douglas
https://ebookfinal.com/download/core-data-by-tutorials-ios-8-and-
swift-edition-aaron-douglas/
ebookfinal.com
iOS 5 by Tutorials Volumes 1 and 2 2nd Edition Ray

Wenderlich
https://ebookfinal.com/download/ios-5-by-tutorials-
volumes-1-and-2-2nd-edition-ray-wenderlich/
ebookfinal.com
Naturoids On the Nature of the Artificial 1st Edition

Massimo Negrotti
https://ebookfinal.com/download/naturoids-on-the-nature-of-the-
artificial-1st-edition-massimo-negrotti/
ebookfinal.com
The Android Developer s Cookbook 2nd edition Building

Applications with the Android SDK Ronan Schwarz
https://ebookfinal.com/download/the-android-developer-s-cookbook-2nd-
edition-building-applications-with-the-android-sdk-ronan-schwarz/
ebookfinal.com
Dependency Theory Revisited B.N. Ghosh
https://ebookfinal.com/download/dependency-theory-revisited-b-n-ghosh/
ebookfinal.com
Dagger by Tutorials Dependency Injection on Android
with Dagger Hilt 1st Edition Massimo Carli Digital
Instant Download
Author(s): Massimo Carli, the raywenderlich Tutorial Team
ISBN(s): 9781950325177, 1950325172
Edition: 1
File Details: PDF, 20.87 MB
Year: 2020
Language: english
Dagger by Tutorials Dagger by Tutorials
Dagger by Tutorials
By Massimo Carli
Copyright ©2020 Razeware LLC.
Notice of Rights
All rights reserved. No part of this book or corresponding materials (such as text,
images, or source code) may be reproduced or distributed by any means without
prior written permission of the copyright owner.
Notice of Liability
This book and all corresponding materials (such as source code) are provided on an
“as is” basis, without warranty of any kind, express of implied, including but not
limited to the warranties of merchantability, fitness for a particular purpose, and
noninfringement. In no event shall the authors or copyright holders be liable for any
claim, damages or other liability, whether in action of contract, tort or otherwise,
arising from, out of or in connection with the software or the use of other dealing in
the software.
Trademarks
All trademarks and registered trademarks appearing in this book are the property of
their own respective owners.
raywenderlich.com 2
About the Author

Massimo Carli is the author of this book. Massimo has been
working with Java since 1995 when he co-founded the first Italian
magazine about this technology (http://www.mokabyte.it). After
many years creating Java desktop and enterprise application,
Massimo started to work in the mobile world. In 2001 he wrote his
first book about J2ME. After many J2ME and Blackberry
applications, he then started to work with Android in 2008. The
same year Massimo wrote the first Italian book about Android; best
seller on Amazon.it. That was the first of a series of 12 books.
Massimo worked at Yahoo and Facebook and he’s actually working
as Senior Engineer at Spotify. Massimo is a musical theatre lover
and a supporter of the soccer team S.P.A.L.
About the Editors

Gordan Glavaš is the tech editor of this book. Gordan is a mobile
architect with over 10 years of Android and iOS experience. He’s
also a big fan of code reusability through annotation processing
and enjoys designing programming languages. In his free time, he’s
always up for cooking, playing sports or a pint of good pale ale.
Martyn Haigh is the other tech editor of this book. Martyn started
hacking on Android in 2008 and enjoyed it so much that he went
on to make a career out of it for names like Mozilla and Meet-up.
After over a decade of consulting, he’s currently working as a
senior developer at Facebook. He loves snowboarding, banging
coffee, amazing food and his gorgeous family.
Sandra Grauschopf is the editor of this book. She is a freelance

writer, editor, and content strategist as well as the Editing Team
Lead at raywenderlich.com. She loves to untangle tortured
sentences and to travel the world with a trusty book in her hand.
raywenderlich.com 3
Dean Djermanović is final pass editor of this book. He’s an

experienced Android developer from Croatia working at the Five
agency where he worked on many interesting apps like the Rosetta
Stone app for learning languages which has over 10 million
downloads. Previously, he’s been a part of two other mobile
development agencies in Croatia where he worked on many
smaller custom mobile solutions for various industries. He’s was
also a part-time Android lecturer at the Algebra University College
in Zagreb. Very passionate about Android, software development,
and technology in general. Always trying to learn more, exchange
knowledge with others, and improve in every aspect of life. In his
free time, Dean likes to work out at the gym, ride a bike, read a
good book or watch a good movie.
About the Artist

Vicki Wenderlich is the designer and artist of the cover of this
book. She is Ray’s wife and business partner. She is a digital artist
who creates illustrations, game art and a lot of other art or design
work for the tutorials and books on raywenderlich.com. When she’s
not making art, she loves hiking, a good glass of wine and
attempting to create the perfect cheese plate.
raywenderlich.com 4
Dagger by Tutorials
Table of Contents: Overview

Book License ............................................................................................. 13
Before You Begin ................................................................ 14
What You Need ........................................................................................ 15
Book Source Code & Forums ............................................................. 16
About the Cover ...................................................................................... 17
Introduction .............................................................................................. 18
Section I: DI Fundamentals ............................................. 22
Chapter 1: Design Principles.................................................. 23
Chapter 2: Meet the Busso App ............................................ 51
Chapter 3: Dependency Injection ........................................ 77
Chapter 4: Dependency Injection & Scopes .................. 102
Chapter 5: Dependency Injection & Testability ........... 120
Section II: Introducing Dagger..................................... 148
Chapter 6: Hello, Dagger ...................................................... 149
Chapter 7: More About Injection ...................................... 173
Chapter 8: Working With Modules .................................. 197
Chapter 9: More About Modules ...................................... 218
Section III: Components & Scope Management .... 239
Chapter 10: Understanding Components...................... 240
Chapter 11: Components & Scopes .................................. 273
Chapter 12: Components Dependencies ....................... 299
raywenderlich.com 5
Dagger by Tutorials
Section IV: Advanced Dagger ...................................... 323

Chapter 13: Multibinding ..................................................... 324
Chapter 14: Multibinding With Maps.............................. 349
Chapter 15: Dagger & Modularization ............................ 366
Section V: Introducing Hilt ........................................... 388
Chapter 16: Dagger & Android........................................... 389
Chapter 17: Hilt — Dagger Made Easy ............................ 418
Chapter 18: Hilt & Architecture Components ............. 444
Chapter 19: Testing With Hilt ............................................. 470
Conclusion .............................................................................................. 497
Section VI: Appendices .................................................. 498
Appendix A: The Busso Server............................................ 499
Appendix B: Assisted Injection ........................................... 517
raywenderlich.com 6
Dagger by Tutorials
Table of Contents: Extended

Book License . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
Before You Begin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
What You Need . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
Book Source Code & Forums . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
About the Cover . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
How to read this book . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
Section I: DI Fundamentals . . . . . . . . . . . . . . . . . . . . . . . . . 22
Chapter 1: Design Principles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
What dependency means . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
Types of dependencies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
Abstraction reduces dependency . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
Using your superpower: abstraction. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
Finding the right level of abstraction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
Composition over (implementation) inheritance . . . . . . . . . . . . . . . . . . . . . 38
Interface inheritance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
Why abstraction is important . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
Challenges . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
Challenge solutions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
Key points . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
Where to go from here?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
Chapter 2: Meet the Busso App . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
The Busso App . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
Improving the Busso App . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
The Rx Module for location . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
Challenge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
raywenderlich.com 7
Dagger by Tutorials
Key points . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
Chapter 3: Dependency Injection. . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
Dependency injection. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
Types of injection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
Busso App dependency management . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
Challenge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
Key points . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
Chapter 4: Dependency Injection & Scopes . . . . . . . . . . . . . . . . 102
Adding ServiceLocator to the Navigator implementation . . . . . . . . . . 103
Going back to injection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
Key points . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
Chapter 5: Dependency Injection & Testability . . . . . . . . . . . . 120
Model View Presenter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
Model . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
View & ViewBinder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
Presenter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
Putting it all together . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
Key points . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
Where to go from here? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
Section II: Introducing Dagger . . . . . . . . . . . . . . . . . . . . 148

Chapter 6: Hello, Dagger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
What is Dagger? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
Beginning with Dagger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
Key points . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172
Chapter 7: More About Injection . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
Getting started . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
Different injection types with Dagger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178
Cleaning up the injection for MainActivity . . . . . . . . . . . . . . . . . . . . . . . . . . 194
Key points . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196
raywenderlich.com 8
Dagger by Tutorials
Where to go from here? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196

Chapter 8: Working With Modules. . . . . . . . . . . . . . . . . . . . . . . . . 197
Why use modules? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198
Using Dagger’s Lazy interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206
Resolving cycled dependencies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210
Key points . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217
Chapter 9: More About Modules . . . . . . . . . . . . . . . . . . . . . . . . . . . 218
More about the @Binds annotation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219
Providing existing objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221
Using optional bindings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224
Using qualifiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228
Modules, bindings & Android Studio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235
Key points . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 238
Section III: Components & Scope Management. . . 239

Chapter 10: Understanding Components . . . . . . . . . . . . . . . . . . 240
Migrating Busso to Dagger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241
Completing the migration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251
Handling deprecated @Modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259
Migrating BusStopFragment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259
Customizing @Component creation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265
Key points . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272
Chapter 11: Components & Scopes . . . . . . . . . . . . . . . . . . . . . . . . 273
Components and Containers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274
Fixing the Busso App . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 276
Fixing BussoEndpoint . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278
Defining an application scope . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280
Creating a custom @Scope . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 288
Key points . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 298
Chapter 12: Components Dependencies . . . . . . . . . . . . . . . . . . . 299
raywenderlich.com 9
Dagger by Tutorials
Comparing @Singleton to other scopes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300

Component dependencies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302
Your scoped Busso App. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304
Using @Subcomponents. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 307
@Subcomponents versus @Component dependencies attribute . . . 319
Using @Reusable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 320
Key points . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 322
Section IV: Advanced Dagger . . . . . . . . . . . . . . . . . . . . . 323

Chapter 13: Multibinding . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324
The information plugin framework . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325
Dagger configuration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 327
Introducing Dagger multibinding . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334
Using @JvmSuppressWildcards . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 338
Adding a new information service plugin. . . . . . . . . . . . . . . . . . . . . . . . . . . . 341
Key points . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 348
Chapter 14: Multibinding With Maps . . . . . . . . . . . . . . . . . . . . . . 349
Using multibinding with Map . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 350
Using @StringKey . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 350
Using @ClassKey . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353
Using a complex custom @MapKey . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362
Key points . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 365
Chapter 15: Dagger & Modularization . . . . . . . . . . . . . . . . . . . . . 366
What is modularization?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 367
Busso App modularization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 375
The location module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 384
Key points . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 387
Section V: Introducing Hilt . . . . . . . . . . . . . . . . . . . . . . . . 388

Chapter 16: Dagger & Android . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 389
Why Android is different for Dagger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 390
raywenderlich.com 10
Dagger by Tutorials
How Dagger Android works . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 392

Working around Dagger Android limitations . . . . . . . . . . . . . . . . . . . . . . . 403
Injecting Fragments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 407
Using Dagger Android utility classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 412
Key points . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 417
Chapter 17: Hilt — Dagger Made Easy . . . . . . . . . . . . . . . . . . . . . 418
Hilt’s architectural decisions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 419
Migrating Busso to Hilt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 420
Using a predefined @Scope for ApplicationComponent . . . . . . . . . . . . 427
Hilt’s main APIs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 437
Hilt utility APIs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 439
Key points . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 443
Chapter 18: Hilt & Architecture Components . . . . . . . . . . . . . 444
The RayTrack app. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 445
RayTrack’s architecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 447
Creating a custom @Component with @DefineComponent . . . . . . . . 461
Key points . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 469
Chapter 19: Testing With Hilt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 470
The RandomFunNumber app. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 471
Implementing RandomFunNumber’s tests . . . . . . . . . . . . . . . . . . . . . . . . . . 475
Using Robolectric & Hilt for UI tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 480
Creating a MainActivity test with Robolectric & Hilt . . . . . . . . . . . . . . . 482
Testing MainActivity with Robolectric & Hilt . . . . . . . . . . . . . . . . . . . . . . . 484
Implementing instrumented tests with Hilt & Espresso. . . . . . . . . . . . . 488
Replacing an entire @Module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 494
Key points . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 496
Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 497
Section VI: Appendices . . . . . . . . . . . . . . . . . . . . . . . . . . . 498
Appendix A: The Busso Server . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 499
Dagger by Tutorials
The BussoServer app . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 500

Using Koin in BussoServer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 504
Adding other dependencies: Logger. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 510
Key points . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 516
Appendix B: Assisted Injection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 517
What is assisted injection? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 518
Providing dependencies with assisted injection . . . . . . . . . . . . . . . . . . . . 520
Limitations to assisted injection in Dagger . . . . . . . . . . . . . . . . . . . . . . . . . . 525
Key points . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 526
L Book License
By purchasing Dagger by Tutorials, you have the following license:
• You are allowed to use and/or modify the source code in Dagger by Tutorials in as
many apps as you want, with no attribution required.
• You are allowed to use and/or modify all art, images and designs that are included
in Dagger by Tutorials in as many apps as you want, but must include this
attribution line somewhere inside your app: “Artwork/images/designs: from
Dagger by Tutorials, available at www.raywenderlich.com.
• The source code included in Dagger by Tutorials is for your personal use only. You
are NOT allowed to distribute or sell the source code in Dagger by Tutorials
without prior authorization.
• This book is for your personal use only. You are NOT allowed to sell this book
without prior authorization, or distribute it to friends, coworkers or students; they
would need to purchase their own copies.
All materials provided with this book are provided on an “as is” basis, without
warranty of any kind, express or implied, including but not limited to the warranties
of merchantability, fitness for a particular purpose and noninfringement. In no event
shall the authors or copyright holders be liable for any claim, damages or other
liability, whether in an action of contract, tort or otherwise, arising from, out of or in
connection with the software or the use or other dealings in the software.
All trademarks and registered trademarks appearing in this guide are the properties
of their respective owners.
Before You Begin
This section tells you a few things you need to know before you get started, such as
what you’ll need for hardware and software, where to find the project files for this
book, and more.
i What You Need
To follow along with this book, you’ll need the following:
• IntelliJ IDEA Community Edition 2020.2.x: Available at https://

www.jetbrains.com/idea/.
• Android Studio 4.1.x: Available at https://developer.android.com/studio/. This is

the environment in which you’ll develop most of the sample code in this book.
ii Book Source Code &
Forums
Where to download the materials for this book

The materials for this book can be cloned or downloaded from the GitHub book
materials repository:
• https://github.com/raywenderlich/dag-materials/tree/editions/1.0
Forums
We’ve also set up an official forum for the book at
https://forums.raywenderlich.com/c/books/dagger-by-tutorials/. This is a great place
to ask questions about the book or to submit any errors you may find.
iii About the Cover
Dagger by Tutorials
The cassowary is the large bird most closely related to the emu. It’s considered the
most dangerous bird in the world. The dagger-like claw on the inner toe of each foot
is what’s making cassowaries so dangerous. The cassowary can slice open any
predator or potential threat with a single swift kick.
Dagger by Tutorials illustrates the use of the Dagger library to manage dependencies
in the app. It’s not possible to create an application without dependencies. After
reading Dagger by Tutorials, you’ll be armed with Dagger and ready to make your
app testable and maintainable with a single dependency injection library.
iv Introduction
Dagger is a library for dependency injection on JVM-based systems, including

Android. Dependency injection is an important technique for building software
systems that are maintainable and testable.
You’re likely already doing dependency injection, maybe without even realizing it.
Dependency injection is nowhere near as complex as its name implies.
In this book, you’ll update an existing app named Busso to use dependency injection
with Dagger and Hilt. The Busso app is a simple app that allows you to find bus stops
near you and information about arrival times.
This book will serve you as a central point that holds all the information you need to
dive deep into Dagger and Hilt, to apply it to your personal and production level
projects.
How to read this book

The book is aimed at Android developers who aren’t familiar with dependency
injection and libraries like Dagger and Hilt, or developers who know little about the
libraries but haven’t had the chance to use it in real projects.
If you’re completely new to dependency injection, we recommend reading it one

chapter at a time, in the order of sections and chapters as available in the table of
contents.
Dagger by Tutorials Introduction
If you’re familiar with the fundamentals of dependency injection, you can skip to
“Section II: Introducing Dagger” instead, and continue learning about dependency
injection with Dagger library.
If you’re already using Dagger in your projects, but want to know more about
complex topics, jump over to “Section IV: Advanced Dagger”. You’ll build complex
use cases there on a real-world project, learn about multi-binding and
modularization.
If you’re already proficient with Dagger library, you can skip to “Section V:
Introducing Hilt” and learn about dependency injection with Hilt on Android.
This book is split into five main sections:
Section I: DI Fundamentals
In this section, you’ll get motivated to use a Dependency Injection (DI) library like
Dagger by learning all about the problem you need to solve: dependency.
You’ll understand what dependencies are and why you need to control them to
create successful apps. You’ll get to know the Busso App, which you’ll work on, and
improve throughout this book. It’s a client-server app where the server is
implemented using Ktor.
You’ll take your next step toward implementing better apps that are easier to test
and modify. You’ll keep the concept of mass of the project in mind. In the process,
you’ll learn more about Scope and see how it relates to dependency.
You’ll also use techniques that would work in a world without frameworks like
Dagger or Hilt to create a fully testable app.
Section II: Introducing Dagger

In this section, you’ll learn what Dagger is, how it works, and how it slashes the
amount of code you need to write by hand when you implement dependency
injection in your app.
You’ll learn how to deal with constructor, field and method injection with Dagger,
how to simplify the implementation of @Module by using @Binds in cases when
you have abstraction and its implementation, and how to use @Singleton to solve a
very common problem.
You’ll learn everything you need to know about Dagger @Modules and you’ll
experiment with using different fundamental annotations like @Binds, @Provides
and BindsOptionalOf as well as useful interfaces like dagger.Lazy and Provider.You’ll
also learn what qualifiers are, how to implement them with @Named and how to use
custom @Qualifiers.
Section III: Components and Scope

management
In this section, you’ll migrate the Busso App from the homemade framework to
Dagger. In the process, you’ll learn how to migrate the existing ServiceLocators and
Injectors to the equivalent Dagger @Modules and @Components, how to provide
existing objects with a customized Builder for the @Component using
@Component.Builder, and how to use @Component.Factory as a valid alternative to
@Component.Builder.
The first migration will not be optimal — there will still be some fundamental
aspects you will improve.
Later, you’ll learn even more about @Components and dependencies. In particular,
you’ll learn why @Singleton is not so different from the other @Scopes, why you
might need a different approach in managing component dependencies, what type of
dependency exist between @Components with @Singleton, @ActivityScope and
@FragmentScope scope, etc.
Section IV: Advanced Dagger

In this section, you’ll dive deeper into the advanced features of Dagger like multi-
binding. Multibinding is a very interesting feature of Dagger because it simplifies the
integration of new features using a plugin pattern you’ll learn in this section.
You’ll implement a simple framework that allows you to integrate new services in
the Busso app in a very simple and declarative way. You’ll learn all you need to know
about multi-binding with Set and Map.
Section V: Introducing Hilt

In the last section, you’ll learn everything you need to know about Hilt. Hilt is a
dependency injection library for Android that reduces the boilerplate of doing
manual dependency injection in your project.
Hilt is built on top of the DI library Dagger to benefit from the compile-time
correctness, runtime performance, scalability, and Android Studio support that
Dagger provides.
You’ll migrate the existing Busso app to use Hilt library.
Section I: DI Fundamentals
In this section, understand why you should use a dependency injection (DI) library
like Dagger by learning all about the problem you need to solve: dependency.
You’ll understand what dependencies are and why you need to control them to
create successful apps. You’ll get to know the Busso App, which you’ll work on, and
improve throughout this book. And you’ll take your next step toward implementing
better apps that are easier to test and modify.
1 Chapter 1: Design
Principles
By Massimo Carli
In this chapter, you’ll get motivated to use a Dependency Injection (DI) library like
Dagger by learning all about the problem you need to solve: dependency. You’ll
understand what dependencies are and why you need to control them to create
successful apps.
Note: This first chapter describes all the main concepts about object-oriented
programming using a dependency management focus. Go to the next chapter
if you’re already familiar with this topic.
Dependency Injection is one of the most important patterns to use in the

development of a modern professional app, and frameworks like Dagger and Hilt
help implement it in Android.
When you thoroughly understand the object-oriented principles of this chapter, the
learning curve of those frameworks, initially steep, becomes flatter and everything
gets easier.
Note: You can find all the code for this chapter in the material section of this
book. It’s a good idea to follow along by adding the code to the starter project
with IntelliJ. You can also check out the complete code in the final project.
The challenge project contains the solutions to the challenges at the end of
the chapter.
Dagger by Tutorials Chapter 1: Design Principles
What dependency means

Dependency is a fancy way of saying that one thing relies on another in order to do
its job. You can use the term in different ways for different contexts: One person
might depend on another. A project might depend on a budget. In math, given y =
f(x), you can say that y depends on x.
But what does dependency mean? In the previous examples, it means that if the
person you depend on is not available anymore, you need to change your way of life.
If the dependency is economic, you have to reduce your expenses.
Similarly, if the business cuts the budget, you have to change the requirements for
your project or cancel it.
This concept is obvious in the last example because if x changes, y changes as well.
But why are changes important? Because it takes effort to make changes.
The previous examples showed how dependencies can cause changes, and you can
even prove this using physics. Consider the famous principle, Newton’s second law,
shown in Figure 1.1:
Figure 1.1 - Newton’s second law

In that formula, F is the force you need to apply if you want the equation to be true
with a, which is acceleration. Acceleration is a change in speed that, again, is a
measure of how the position changes in time.
This doesn’t mean that change is bad. It just says that if you want to change, you
need to apply effort that’s as big or bigger than the mass m.
Hey, but this is a book about Dagger and Hilt! What does this have to do with your
code?
In the context of coding, dependency is inevitable, and applying changes will always
take some effort. But there are also ways to reduce the mass of your code, reducing
the effort, even for big changes.
This is what you’re going to learn in the following paragraphs. Mastering this skill
will allow you to use tools like Dagger and Hilt effectively and productively.
A formal definition of dependency

In the previous paragraph, you learned what dependency means in your real life, but
in the context of computer science, you need a more formal definition:
Entity A depends on entity B if a change in B can imply a change in A.
Note the “can” because this is something that could, but shouldn’t necessarily,
happen. In the previous examples, A can be you, your project or y. In the same
examples, B can be the person you depend on, the budget of your project or, simply,
x.
Figure 1.2 - Real life dependencies

It’s a relationship that, in the object-oriented (OO) context, you can represent using
the following Unified Modeling Language (UML) diagram:
Figure 1.3 - Dependency relation in UML

In UML, you represent a dependency between entity A and entity B by showing an
open arrow with a dotted line from A to B. This is how you indicate that a change in
B can result in a change of A.
In these diagrams, A and B can be different things like objects, classes or even
packages or modules. This is a model that reflects what happens in software
development, where many components interact with many others in different ways.
If a change in a component triggers a change in all its dependents, you end up

changing a lot of code — which increases the probability of introducing new bugs.
Additionally, you need to rewrite and run the tests. This takes time, which translates
into money.
On the other hand, it’s not possible to create an app without dependencies. If you
tried, you’d have the opposite problem of a monolithic app: All the code would be in
a single point, making writing code in large teams difficult and testing almost
impossible.
As a developer, one possible solution is to use patterns and practices that allow the
adoption of benign types of dependencies, which is the topic of the following
paragraphs.
Types of dependencies
Figure 1.3 above depicts a generic type of dependency, where the arrow simply
indicates that A depends on B without going into detail. It doesn’t show what A and
B are, or how the dependency looks in code.
Using object-oriented language, you can define relationships more precisely, and you
can do it in different ways for different types of dependencies. In the following
paragraphs you’ll learn about:
1. Implementation Inheritance
2. Composition
3. Aggregation
4. Interface Inheritance
You’ll also learn how abstraction can limit the impact of dependency.
Implementation inheritance
Implementation Inheritance is the strongest type of dependency. You describe it
using the UML diagram in Figure 1.4 below:
Figure 1.4 - Implementation Inheritance; the strongest level of dependency

You represent this relationship by using a continuous arrow with the tip closed and
empty. Read the previous diagram by saying that Student IS-A Person. This means
that a student has all the characteristics of a person and does all the things a person
does.
The Student class depends on the Person class because a change of the former has,
as an obvious consequence, a change in the latter — which is the very definition of
dependency.
For example, if you change the Person class by adding eat function, the Student
class now also has the ability to eat.
A Student differs from a generic Person because they study a particular subject. You
need both Person and Student classes due to two fundamental object-oriented
concepts: The first is that not all people study. The second, more important, concept
is that the fact that some people study may not interest you at all.
You have a Person class so you can generalize people of different types when the
only thing that interests you is that they are people.
For this reason, the statement Student IS-A Person is not the most correct way of
phrasing it. To be more accurate, you’d say: Person is a generalization or
abstraction of Student instead.
This app probably started with Student, then the developers added Person to limit
dependency. As you’ll see in the following paragraphs, they introduced a level of
abstraction to limit the dependency relationship.
Implementation inheritance in code
To define that Student depends on Person through an implementation

inheritance relationship, simply use the following code:
open class Person(val name: String) {

fun think() {
println("$name is thinking...")
}
}
class Student(name: String) : Person(name) {

fun study(topic: String) {
println("$name is studying $topic")
}
}
Here, you can see that Person describes objects with a name and that they can
think(). A Student IS-A Person and so they can think() but they also study some
topics. All students are persons but not all persons are students.
Abstraction reduces dependency

The discussion of when to use implementation inheritance, although interesting,
is beyond the scope of this book. It’s important to say that merely introducing
Person-type abstraction is a step toward reducing dependency. You can easily prove
it with a story.
The first implementation

Suppose you’re starting a new project from scratch and you want to print the names
of a list of students for a university. After some analysis, you write the code for
Person like this:
class Student(val name: String) {

}
fun think() {
}
}
A Student has a name, can think and studies a topic. In Figure 1.5 below, you have
its UML representation.
Figure 1.5 - Initial implementation for the Student class

Your program wants to print all the names of the students; you end up with the
following code:
fun printStudent(students: List<Student>) = students.forEach

{ println(it.name) }
You can then test printStudent() with the following code:
fun main() {
val students = listOf<Student>(
Student("Mickey Mouse"),
Student("Donald Duck"),
Student("Minnie"),
Student("Amelia")
)
printStudent(students)
}
Build and run main() and you get this output:
Mickey Mouse
Donald Duck
Minnie
Amelia
Your program works and everybody is happy… for now. But something is going to
change.
Handling change
Everything looks fine, but the university decided to hire some musicians and create a
band. They now need a program that prints the names of all the musicians in the
band.
You’re an expert now and you know how to model this new item, so you create the
Musician class like this:
class Musician(val name: String) {

fun think() {
}
fun play(instrument: String) {

println("$name is playing $instrument")
}
}
Musicians have a name, they think and play a musical instrument. The UML diagram
is now this:
Figure 1.6 - Initial implementation for the Musician class

You also write the printMusician() function like this:
fun printMusician(musicians: List<Musician>) = musicians.forEach

Then you can test it with the following code:
fun main() {
val musicians = listOf<Musician>(
Musician("Mozart"),
Musician("Andrew Lloyd Webber"),
Musician("Toscanini"),
Musician("Puccini"),
Musician("Verdi")
)
printMusician(musicians)
}
Build and run main() and you’ll get this output:
Mozart
Andrew Lloyd Webber
Toscanini
Puccini
Verdi
Everything looks fine and everybody is still happy. A good engineer should smell that
something is not ideal, though, because you copy-pasted most of the code. There’s a
lot of repetition, which violates the Don’t Repeat Yourself (DRY) principle.
Keeping up with additional changes

The university is happy with the system you created and decides to ask you to do the
same thing for the teachers, then for the teacher assistants, and so on.
Following the same approach, you ended up creating N different classes with N
different methods for printing N different lists of names.
Now, you’ve been asked to do a “simple” task. Instead of just printing the name, the
University asked you to add a Name: prefix. In code, instead of using:
println(it.name)
they asked you to use:
println("Name: $it.name")
Note: It’s curious how the customer has a different perception of what’s
simple and what isn’t.
Because of this request, you have to change N printing functions and the related
tests. You need to apply the same change in different places. You might miss some
and misspell others.
The probability of introducing bugs increases with the number of changes you need
to make.
If something bad happens, you need to spend a lot of time fixing the problem. And
even after that, you’re still not sure everything’s fine.
Using your superpower: abstraction

If you end up in the situation described above, you should immediately stop coding
and start thinking. Making the same change in many different places is a signal that
something is wrong.
Note: There’s a joke about a consultant who wanted to make their employer
dependent on them. To do that, they only needed to implement the same
feature in many different ways and in many different places. This is no bueno!
The solution, and the main weapon in your possession, is abstraction.
To print names, you’re not interested in whether you have Student or Musician. You
don’t care if they study a topic or play an instrument. The only thing that interests
you is that they have a name.
You need a way to be able to see all the entries as if they were the same type,
containing the only thing that interests you: the name.
Here, the need to remove the superfluous leads you to the definition of the following
abstraction, which you call Person:
abstract class Person(val name: String) {

fun think() {
}
}
Abstraction means considering only the aspects that interest you by eliminating
everything superfluous. Abstraction is synonymous with reduction.
Knowing how to abstract, therefore, means knowing how to eliminate those aspects
that don’t interest you and, therefore, you don’t want to depend upon.
Creating Person means that you’re interested in the fact that a person can think and
you don’t care whether this person can study.
This is an abstract class. It allows you to define the Person type as an abstraction
only, thus preventing you from having to create an instance of it.
think() is present in both classes, which makes it part of the abstraction. As

defined, every person is able to think, so it’s a logical choice.
Now, Student and Musician become the following:
class Student(name: String) : Person(name) {

}
}
class Musician(name: String) : Person(name) {

fun play(instrument: String) {
println("$name is playing $instrument")
}
}
Now that you’ve put in the effort, you can reap the benefits of simplifying the
method of displaying names, which becomes:
fun printNames(persons: List<Person>) = persons.forEach

The advantage lies in the fact that you can print the names of all the objects that can
be considered Person and, therefore, include both Student and Musician.
Because of that, you can run the following code:
fun main() {
val persons = listOf(
Student("Topolino"),
Musician("Bach"),
Student("Minnie"),
Musician("Paganini")
)
printNames(persons)
}
And that’s not all. Returning to the concept of dependency, you can see that adding a
further specialization of Person does not imply any change in the printing function.
That’s because the only thing this depends on is the generalization described by
Person.
With this, you’ve shown how the definition of an abstraction can lead to a reduction
of dependency and, therefore, to changes having a smaller impact on the existing
code.
Abstraction & UML

Explain the level of dependency using the following UML diagram, Figure 1.7:
Figure 1.7 - The abstract Person class

Here, you can see many important things:
1. printNames() now depends on the Person abstraction. Even if you add a new
Person specialization, you won’t need to change printNames().
2. Person is abstract. It’s now the description of an abstraction and not of a

specific object. In UML, you represent this using a stereotype which is the
abstract word between « ». Alternatively, you can use an italic font.
3. Student, Musician and Teacher are some of the realizations of the Person
abstract class. These are concrete classes that you can actually instantiate.
AnyOtherItem is an example of a concrete class you can add without impacting
printNames() in any way.
Finding the right level of abstraction

Reading the previous code, you’ll notice there are still some problems. That’s
because what printNames() really needs, or depends on, are objects with a name.
Right now, however, you’re forcing it to care that the name belongs to a person.
But what if you want to print the names for a list of objects for whom the IS-A
relation with Person is not true? What if you want to name cats, vehicles or food? A
cat is not a person, nor is food.
The current implementation of printNames() still has an unnecessary dependency

on the Person class. How can you remove that dependency? You already know the
answer: abstraction.
So now, define the following Named interface:
interface Named {
val name: String
}
and change Person to:
abstract class Person(override val name: String) : Named {

fun think() {
}
}
Now, each person implements the Named interface. So do the Student, Musician,
Teacher and other realizations of the Person abstract class.
Now, change printNames() to:
fun printNames(named: List<Named>) = named.forEach

The good news is that now you can create Cat like this:
class Cat(override val name: String) : Named {

fun meow() {
println("$name is meowing...")
}
}
and successfully run the following code:
fun main() {
val persons = listOf(
Student("Topolino"),
Musician("Bach"),
Student("Minnie"),
Musician("Paganini"),
Cat("Silvestro")
)
printNames(persons)
}
getting this as output:
Topolino
Bach
Minnie
Paganini
Silvestro
In the context of printing names, all the objects are exactly the same because they all
provide a name through a name property defined by the Named interface they
implement.
This is the first example of dependency on what a specific object DOES and not on
what the same component IS. You’ll learn about this in detail in the following
paragraphs.
The named interface in UML

It’s interesting to see how you represent the solution of the previous paragraph in
UML:
Figure 1.8 - The Named interface

Here you can see that:
1. printNames() now depends only on the Named interface.
2. Person implements the Named interface and you can now use each of its
realizations in printNames().
3. Cat implements the Named interface, printNames() can use it and it has nothing
to do with the Person class.
Now you can say that Cat as well as Student, Musician, Teacher and any other
realization of Person IS-A Named and printNames() can use them all.
What’s described here is an example of Open Closed Principle (https://

en.wikipedia.org/wiki/Open%E2%80%93closed_principle). It’s one of the SOLID
(https://en.wikipedia.org/wiki/SOLID) principles and it states: software entities
should be open for extension, but closed for modification.
This means that if you want to implement a new feature, you should add the new
thing without changing the existing code.
In the previous example, to add a new object compatible with printNames(), you
just need to make a new class that implements the Named interface. None of the
existing code needs to be changed.
Composition over (implementation)

inheritance
In the previous paragraph, you saw how you can remove the dependency between
printNames() and realizations for the Person abstract class by introducing the
Named interface.
This change is actually a big thing, because it’s your first example of dependency on
what an object DOES and not on what the same object IS.
In the printNames() example, this further reduced the dependency on the Person
abstraction.
This is a very important principle you should always consider in your app: Program
to an interface, not an implementation.
This principle is also true in real life. If you need a plumber, you don’t usually care
who that plumber is. What’s important is what they do. You want to hire the plumber
who can fix the pipes in your house.
Because of this, you can change who you use as your plumber if you have to. If you
need a specific plumber because of who they are, you need to consider a course of
action if they aren’t available anymore.
Composition
A classic example of dependency on what an object does is persistence
management.
Suppose you have a server that receives requests from clients, collects information
then stores it within a repository.
In this case, it would be completely wrong to say the Repository IS-A Server or the
Server IS-A Repository.
So if you were to represent the relationship between Server and Repository, you
could say that the former uses the latter, as the UML diagram in Figure 1.9 shows:
Figure 1.9 - The Server uses a Repository

This diagram just says that Server uses Repository, but it doesn’t say how.
How do different entities communicate? In this case, Server must have a reference
to Repository and then invoke one or more methods on it. Here, you can suppose it
invokes save(Data) with a parameter of type Data.
You can represent the previous description with the following code:
data class Data(val value: Int)
class Repository {
fun save(data: Data) {
// Save data
}
}
class Server {
private val repository = Repository()
fun receive(data: Data) {

repository.save(data)
}
}
Note: Data is not important; it simply represents the information Server

receives and saves into Repository without any transformation using save().
Everything looks perfect, but a problem arises as soon as you represent the previous
relationship through the UML diagram in Figure 1.10:
Figure 1.10 - Composition

The dependency between Server and Repository is a composition, which has a
UML representation of an arrow starting with a full diamond.
You can say that Server composes Repository. As you can see in the previous code,
Server has a private local variable of Repository. It initializes with an instance of
the Repository class itself.
This means that:
• Server knows exactly what the implementation of Repository is.
• Repository and Server have the same lifecycle. The Repository instance is
created at the same time as the Server instance. Repository dies when Server
does.
• A particular instance of Repository belongs to one and only one instance of

Server. Therefore, it cannot be shared.
In terms of dependency, if you wanted to modify the Repository implementation,

you’d have to modify all the classes, like Server, that use it in this way. Ring a bell?
Once again, you’re duplicating a lot of work — and running the risk of introducing
bugs.
You now understand that if a change of Repository leads to a change of Server,

then there’s a dependency between these two entities. How can you reduce that? A
different kind of dependency will help.
Random documents with unrelated
content Scribd suggests to you:
joyeux compagnon plein de franchise et d’entrain, d’un de ces
viveurs incorrigibles qui s’écrient encore à quarante ans : Il faut bien
que jeunesse se passe !
En général, les chevaliers d’industrie se connaissent d’instinct,
sinon de réputation. D’ailleurs, Cinqpoints et Blewitt, bien que volant
chacun dans une sphère différente, s’étaient rencontrés aux courses
et dans quelques réunions de joueurs. Jusqu’à ce jour, mon noble
maître, qui savait ce qu’il se devait à lui-même, n’avait point voulu se
compromettre en fréquentant un escroc de bas étage ; mais, peu de
temps après l’installation de Dakins, il commença à se montrer fort
affable envers son voisin. Le motif de ce changement de conduite
saute aux yeux : ayant deviné les intentions de Blewitt à l’égard du
nouveau locataire, Cinqpoints voulait avoir sa part du butin.
— John, quel est donc ce voisin qui a une passion si
malheureuse pour le flageolet ? me demanda-t-il un matin.
— Il se nomme Dakins, monsieur : c’est un jeune homme fort
riche et un ami intime de M. Blewitt.
Cinqpoints ne poussa pas plus loin cet interrogatoire ; il en savait
déjà assez. Un sourire diabolique dérida son visage, où je pus lire le
raisonnement que voici :
1o Un jeune homme qui cultive le flageolet est incapable

d’avoir inventé la poudre ;
2o Blewitt est un escroc ;
3o Lorsqu’un escroc et un joueur de flageolet deviennent
inséparables, c’est ce dernier qui doit payer les violons.
L’Honorable Percy Cinqpoints était bien fin ; mais je voyais aussi

clair que lui, malgré ma jeunesse. Les gentilshommes, fort
heureusement, n’ont pas accaparé tout l’esprit dont le bon Dieu a fait
ici-bas une distribution si inégale. Nous étions quatre valets dans
notre escalier, et je vous assure que nous savions bien des choses
dont personne ne se doutait au dehors. Dès que nos maîtres avaient
le dos tourné, nous furetions partout, et nous nous communiquions
nos découvertes. Nous lisions la plupart des lettres qu’ils recevaient
ou qu’ils écrivaient. Nous avions des clefs pour chaque armoire et
pour chaque meuble. Le lecteur croira sans doute que je me vante,
car on ne rend guère justice aux domestiques ; on les accuse même
de ne pas s’intéresser aux affaires de leurs maîtres. J’ignore si la
livrée a dégénéré depuis l’époque où j’ai cessé d’en faire partie ;
mais je puis affirmer que, de mon temps, nous n’avions rien de plus
à cœur que de découvrir les secrets de monsieur ou de madame.
Je retrouve dans mes papiers deux documents qui prouvent la
vérité de ce que je viens d’avancer. L’idée de dresser l’état des
finances de nos maîtres respectifs nous ayant été suggérée par le
valet de chambre d’un avocat célèbre, qui avait la manie de rédiger
des notes à propos de tout, le document no I me fut remis par le
groom de Richard Blewitt, en échange d’une copie du no II, que l’on
trouvera un peu plus loin.
No I
Résumé des dépenses de Richard Blewitt, Esq., pendant l’année

18.., d’après les notes, reçus, lettres et autres papiers trouvés dans
ses poches ou dans ses tiroirs.
Intérêt de diverses dettes contractées à Oxford F. 4,300

Loyer 1,600
Gages de M. son groom 600
Pension de notre cheval 1,750
Item d’une certaine dame, qui trompe monsieur comme si
elle avait affaire à un honnête homme 6,000
Argent de poche, environ 2,500
Mangeaille, marchand de vin, tailleur, etc., environ 5,000
Total 21,750
En fait de revenu, Richard Blewitt ne possédait qu’une rente
d’environ cinq mille francs que lui faisait son honnête homme de
père ; mais nous savons qu’un gentleman adroit, qui n’est pas trop
fier pour fréquenter les jockeys et les tripots, ne doit jamais se
trouver embarrassé pour gagner ses quinze ou vingt mille francs par
an.
Mon maître, qui voyait une meilleure société que son collègue,
dépensait naturellement beaucoup plus et payait beaucoup moins.
Les fournisseurs étaient trop heureux de faire crédit au fils d’un pair
du royaume. Les boutiquiers anglais savent honorer l’aristocratie, et
sont toujours prêts à se mettre à genoux devant un lord [5] . Ils
respectent jusqu’à la livrée d’un grand seigneur. — Je parle ici, bien
entendu, de la livrée proprement dite, et non de celle que le grand
seigneur endosse parfois lui-même en acceptant quelque fonction
bien rétribuée. Grâce au prestige de son nom, l’Honorable Percy
Cinqpoints n’a pas payé un sou à qui que ce soit, du moins à ma
connaissance, durant son séjour à Londres. Aussi, le total de ses
dettes formait-il un chiffre assez rond, ainsi que le démontre le
second document annoncé.
[5] En Angleterre, les boutiquiers n’ont pas le
monopole de cette adoration. Assez récemment on a vu
un membre du parlement dire, dans un petit speech
adressé à un colonel de cavalerie qui a servi en Crimée :
« Quoique pair d’Angleterre, vous n’avez pas hésité à
obéir à vos chefs. » Il est clair qu’aux yeux roturiers de
l’orateur, un pair d’Angleterre est un être supérieur au
commun des mortels et que s’il daigne accepter la paye
d’un colonel et remplir les devoirs de l’emploi, il a bien
mérité de la patrie.
(Note du traducteur.)
No II
Situation financière de l’Honorable Percy Cinqpoints, au mois d’août
18…
Fr. C.
Compte à notre débit au club de Crockford 68,775 »
Billets et lettres de change en circulation (nous ne les 124,075
en retirions presque jamais) »
Notes de vingt et un tailleurs 26,172 90
Item de trois marchands de chevaux 10,050 »
Item de deux carrossiers 7,836 75
Dettes oubliées à Cambridge 34,832 80
Mémoires de divers fournisseurs 12,675 35
Total 298,417
80
Le document ci-dessus m’a paru digne d’être conservé ; la plèbe,

toujours avide de savoir ce qui se passe dans le grand monde, ne
sera pas fâchée de connaître la somme à laquelle peuvent s’élever
les dettes d’un parfait gentleman.
Mais je digresse… Il est temps de retourner à notre pigeon.
Mon maître, le jour même où je lui avais donné les
renseignements en question, se trouva face à face dans l’escalier
avec Blewitt qui, debout sur le pas de sa porte, était en train
d’allumer un cigare et s’apprêtait sans doute à faire une visite
matinale à l’infortuné amateur de flageolet. Cinqpoints, au lieu de le
couper selon son habitude, s’avança avec un sourire des plus
gracieux et lui tendit sa main gantée, en disant :
— Eh parbleu ! mon cher monsieur Blewitt, puisque je suis assez
heureux pour vous rencontrer, j’ai bien envie de vous adresser des
reproches !… Entre voisins, on ne devrait point rester aussi
longtemps sans se voir.
Blewitt parut d’abord flatté, puis surpris, puis soupçonneux.
— En effet, je crois que nous aurions pu nous voir plus souvent,
répondit-il d’un ton ironique.
— Si je ne me trompe, je n’ai pas eu le plaisir de me trouver avec
vous depuis ce fameux dîner de sir Georges Lansquenet, reprit
Cinqpoints sans se laisser intimider par cette rebuffade. La
charmante soirée ! Quels vins exquis et quelles bonnes chansons
surtout !… Je me rappelle encore celle que vous nous avez chantée.
D’honneur, c’est la plus jolie chose de ce genre que j’aie entendue
de ma vie. J’en parlais encore hier au duc de Doncastre… Vous
connaissez le duc, je crois ?
— Non, répliqua Blewitt en lançant une épaisse bouffée de tabac.
— Vous m’étonnez. Je veux être pendu, Blewitt, si le duc ne sait
pas par cœur tous vos bons mots.
La bouderie de Blewitt dura quelque temps encore ; mais il finit
par faire le gros dos et par prendre pour pain bénit les atroces
flagorneries que débitait son collègue en industrie. Lorsque ce
dernier s’aperçut qu’il avait produit l’impression voulue, il s’écria :
— Ah çà, mon cher Blewitt, où donc trouvez-vous des cigares
comme celui-là ? Il a un parfum qui me donne des envies, à moi qui
ne suis pas fumeur. En auriez-vous un pareil à m’offrir ?
— Oui, parbleu ! Faites-moi donc le plaisir d’entrer chez moi.
Une heure après, Cinqpoints remonta chez nous beaucoup plus
jaune que de coutume. J’ai vu quelques chiens malades dans le
cours de mon existence, jamais je n’ai vu un animal aussi
ignoblement indisposé que mon honorable maître. Malgré l’horreur
que lui inspirait le tabac, il venait de fumer un cigare tout entier.
Vous devinez qu’il ne s’était pas livré pour rien à ce délassement
antipathique.
Lorsque notre voisin eut fermé sa porte, le bruit de la
conversation avait naturellement cessé d’arriver jusqu’à moi ; mais,
grâce aux observations de mon camarade, le groom de M. Blewitt,
j’ai pu renouer le fil de l’entretien.
Cinqpoints, après avoir caressé de nouveau la vanité de son
confrère, s’était mis à parler de ce jeune locataire qui jouait si bien
du flageolet ; puis il avait ajouté, comme en passant, que lorsqu’on
demeurait porte à porte, on devait se connaître, et que d’ailleurs il
serait très-heureux d’être présenté à un ami de M. Richard Blewitt.
Ce dernier aperçut alors le piége qu’on lui tendait, et, honteux de
s’être laissé prendre aux compliments mielleux de Cinqpoints, refusa
obstinément de donner dans le panneau.
— J’ai connu ce Dakins à l’Université, répondit-il. Entre nous, ce
n’est pas une de ces connaissances que l’on tienne beaucoup à
cultiver. Il m’a fait une visite, je la lui ai rendue, et je compte m’en
tenir là. Son père vendait des bottes, ou du fromage, ou quelque
chose de ce genre… j’ignore au juste sa spécialité ; mais il est clair
que ce garçon n’est le fils de personne, et vous sentez que je ne me
soucie guère de le fréquenter.
Bref, l’habileté de mon maître échoua ; il dut lever la séance,
ayant fumé son cigare en pure perte.
— Peste soit du butor ! s’écria-t-il en se jetant sur un divan.
C’était bien la peine de m’empoisonner avec son infernal tabac !…
Ah ! il croit plumer à loisir ce jeune homme ; mais je préviendrai sa
victime !
Cette menace m’amusa tellement que je manquai d’étouffer
(derrière la porte, bien entendu) d’une envie de rire rentrée. Dans le
langage de Cinqpoints, prévenir les gens voulait dire faire mettre un
cadenas à l’écurie, après avoir volé le cheval.
Pas plus tard que le lendemain, mon maître fit connaissance
avec Dakins, au moyen d’un petit stratagème qui donnera la mesure
de son talent. La comédie fut improvisée et représentée le même
matin.
Depuis quelque temps déjà, le droit, la poésie et le flageolet ne
suffisaient plus à remplir l’existence du jeune étudiant. Le perfide
Blewitt le conduisait par un chemin fleuri vers le gouffre du désordre.
En termes plus clairs, il le menait chaque soir dans des tavernes où
ils se livraient ensemble à des études comparées sur le porter, l’ale,
le gin, et les autres spiritueux que l’on débite dans ces sortes
d’établissements. Or, l’homme est pétri d’une argile qu’il ne faut pas
humecter outre mesure ; pour peu qu’on passe une moitié de la nuit
à l’arroser, on ressent le lendemain un certain malaise ; on a besoin,
pour se remettre, d’un petit repas bien affriolant. Aussi rencontrait-on
chaque matin dans notre escalier un garçon de restaurant qui
apportait de quoi rafraîchir le gosier desséché du jeune Dakins.
Une circonstance aussi triviale en apparence n’eût sans doute
pas frappé un esprit vulgaire, mais elle n’avait pas échappé à mon
maître. Ce fut là-dessus qu’il basa son plan d’attaque. Le lendemain
de son entrevue avec Blewitt, il m’envoya acheter un de ces pâtés
que les Français fabriquent avec certains volatiles atteints d’une
maladie de foie. Je rapportai le précieux comestible emballé dans
une espèce de tambour. Savez-vous ce que Cinqpoints me fit écrire
sur la boîte ?… J’aime mieux vous le dire tout de suite, car vous ne
devineriez jamais… J’écrivis en toutes lettres :
A l’Honorable Percy Cinqpoints, avec les compliments

empressés du prince de Talleyrand.
— Quel horrible griffonnage ! s’écria mon maître en contemplant

ma calligraphie. Mais, bah ! cela n’en vaut que mieux… Tous les
grands hommes écrivent comme des chats.
Ce jour-là, par le plus grand des hasards, Cinqpoints sortit de
bonne heure, au moment où on montait le déjeuner de Dakins.
Contre son habitude, il était gai comme un pinson, et fredonnait un
air d’opéra en faisant tourner sa canne entre ses doigts. Il
descendait très-vite, et (toujours par le plus grand des hasards) sa
canne donna au beau milieu du plateau. Voilà les assiettes, les
viandes, le vin, l’eau de Seltz qui se mettent à dégringoler de
marche en marche pour ne s’arrêter qu’au bas de l’escalier. A la vue
de ce malheur, Cinqpoints accabla d’injures le garçon ébahi, et se
hâta de remonter.
— Voilà une fâcheuse aventure, John ! me dit-il. Tâchons de
réparer ma maladresse.
Je ne devinai pas encore où il voulait en venir. Il s’assit devant
son secrétaire et écrivit quelques lignes, qu’il cacheta à ses armes.
— Tiens, continua-t-il en me tendant la lettre, porte ce billet à M.
Dakins avec le pâté que tu as acheté hier… Si tu as le malheur de
dire d’où il vient, je promets de te casser ma canne sur les épaules.
Une pénible expérience m’ayant démontré que ces sortes de
promesses étaient les seules que Cinqpoints se piquât de tenir,
j’exécutai ma commission avec zèle et discrétion. Dakins me fit
attendre la réponse un grand quart d’heure. Voici cette
correspondance, écrite à la troisième personne, ainsi que cela se
pratique dans le grand monde :
L’HONORABLE H. P. CINQPOINTS A T. DAKINS, ESQ.
« L’honorable Hector-Percy Cinqpoints, en présentant ses

compliments à Monsieur Thomas Dakins, ose espérer que
son voisin voudra bien lui pardonner sa maladresse de tantôt,
et lui permettre de chercher à la réparer. Si Monsieur T.
Dakins daigne accepter le pâté ci-joint (envoi d’un
gastronome célèbre), M. Cinqpoints n’aura pas le remords
d’avoir privé un voisin de son repas habituel.
» Mardi matin. »
RÉPONSE DE T. DAKINS, ESQ.
« M. Thomas Dakins a l’honneur de présenter ses

compliments à l’Honorable H. P. Cinqpoints, et s’empresse de
le remercier de l’aimable façon dont il vient de réparer un
accident qu’il pouvait regarder comme pardonné d’avance.
Cet accident, que l’Honorable H. P. Cinqpoints semble
regretter, serait un des plus heureux événements de la vie de
M. Thomas Dakins, si son voisin daignait mettre le comble à
sa générosité en venant partager le déjeuner dont il a fait les
frais.
» Mardi matin. »
J’ai ri plus d’une fois en relisant ces deux épîtres. La bourde à

propos du prince de Talleyrand avait complétement réussi. Le trop
jeune Dakins était devenu pourpre de plaisir en parcourant la lettre
de mon maître ; il avait déchiré plusieurs brouillons avant d’être
satisfait de sa réponse. Je ne sais s’il finit par être content de lui ;
dans tous les cas, Cinqpoints fut enchanté, sinon du style, du moins
du sens de la réplique. Inutile d’ajouter qu’il s’empressa d’accepter la
gracieuse invitation de son voisin.
Le pâté entamé, une conversation amicale ne tarda pas à
s’engager entre les deux convives. L’honorable invité s’extasia
devant le goût exquis de Dakins, admirant ses meubles, ses
connaissances classiques, la coupe de son habit et son talent sur le
flageolet. Lorsqu’il offrit à son hôte de le présenter au duc de
Doncastre, l’infortuné pigeon fut ensorcelé du coup. Pauvre garçon !
Si sa naïveté ne me faisait pas tant rire, je la respecterais. Je tiens
de bonne source qu’il se rendit le jour même chez le tailleur à la
mode, afin de commander un habillement complet pour faire son
entrée dans le monde aristocratique.
La conversation commençait à languir, lorsque Richard Blewitt
s’annonça en ouvrant la porte d’un grandissime coup de pied.
— Tom, mon vieux, comment va ce matin ? cria-t-il.
Au même instant il aperçut son collègue : sa mâchoire s’allongea
à vue d’œil ; de rouge qu’il était il devint blême, puis écarlate.
— Eh ! bonjour donc, mon cher monsieur Blewitt ! Nous parlions
justement de vous, et notre aimable voisin faisait votre éloge, dit
Cinqpoints avec un sourire et un geste pleins d’affabilité.
Blewitt se laissa tomber sur un fauteuil, ne cherchant pas à
cacher sa mauvaise humeur. Il s’agissait de savoir lequel des deux
quitterait le premier la place ; mais Blewitt n’était pas de force à ce
jeu-là contre mon maître. Inquiet, maussade, silencieux, il laissa le
champ libre à son collègue, qui se montra plein de verve et d’esprit ;
si bien que le nouveau venu abandonna bientôt la partie, et se leva
en prétextant un mal de tête. A peine fut-il dehors, que Cinqpoints le
suivit, et, lui prenant le bras, l’invita à monter chez lui. Dès qu’ils
furent installés dans le salon, j’appliquai mon oreille contre la porte.
Malgré la politesse exquise de mon maître, qui se déclarait enchanté
d’avoir renoué connaissance avec son voisin, Blewitt ne paraissait
nullement disposé à se laisser amadouer. Enfin, au moment où
Cinqpoints lui débitait une histoire à propos de l’éternel duc de
Doncastre, le butor éclata :
— Que le diable vous crève, vous et vos ducs ! Allons, allons,
monsieur Cinqpoints, votre titre ne m’en impose pas, à moi ! Je vous
connais, et je vois maintenant pourquoi il vous a plu de devenir si
poli tout d’un coup… Vous voudriez plumer ce petit Dakins ? Mais,
sacrebleu, je suis là pour déranger votre jeu !… Gardez vos amis,
monsieur, et laissez-moi les miens.
— Je vous connais tout aussi bien que vous pouvez me
connaître, répondit mon maître sans élever la voix : escroc de bas
étage, vous êtes un poltron de premier ordre. Je vous conseille donc
de ne pas parler trop haut : d’abord, cela est de fort mauvais ton ;
ensuite, vous m’obligeriez à vous souffleter…
— Sacrebleu ! interrompit Blewitt.
— A vous souffleter en public, continua tranquillement
Cinqpoints, et même à vous loger une balle dans le corps, dans le
cas, peu probable, où vous jugeriez à propos de faire le méchant. Je
vous avoue qu’il me serait fort pénible d’en venir à de pareilles
extrémités, car j’ai pour système d’éviter autant que possible les
esclandres ; mais la chose dépend de vous. Voici mes conditions :
vous avez déjà gagné deux mille écus à ce jeune homme ; eh bien,
je serai bon prince : je consens à oublier le passé, pourvu qu’à
l’avenir nous partagions les bénéfices.
Il y eut une pause dans la conversation à la suite de ces
compliments à brûle-pourpoint. Il paraît que Blewitt réfléchissait.
— Décidez-vous, reprit enfin Cinqpoints ; si vous gagnez encore
un sou à Dakins sans ma permission, je le saurai, et vous aurez
affaire à moi.
— Me décider, me décider, c’est facile à dire !… Sacrebleu ! je
trouve vos conditions fort dures… Que diable ! puisque c’est moi qui
ai levé le gibier, c’est à moi qu’il appartient.
— Monsieur Blewitt, vous prétendiez hier ne pas vouloir
fréquenter ce jeune homme, et il m’a fallu inventer toute une
comédie, afin de faire sa connaissance. Je voudrais bien savoir en
quoi l’honneur m’oblige à vous le céder ?
L’honneur ! c’était charmant d’entendre Cinqpoints prononcer ce
mot ! Je fus presque tenté de prévenir le jeune Dakins du complot
qui se tramait ; mais je ne cédai pas à cette mauvaise inspiration.
— Fi donc, John ! me dis-je ; si ces deux gentilshommes ignorent
ce que c’est que l’honneur, toi, tu le sais. L’honneur consiste à ne
pas trahir les secrets d’un maître, avant d’avoir reçu son congé…
Après, c’est autre chose, l’obligation cesse de plein droit.
Bref, le lendemain, il y eut grand dîner chez nous ; — potage à la
bisque, turbot sauce homard, gigot de pré salé, coqs de bruyère,
macaroni au gratin, plum-pudding, fruits, etc., le tout arrosé de vin de
Champagne, de Porto et de Bordeaux. Il n’y avait que trois
convives : c’est-à-dire l’Honorable H. P. Cinqpoints, Richard Blewitt
et Thomas Dakins. C’était un vrai chef-d’œuvre que ce repas, et je
vous réponds que nous autres messieurs de l’antichambre nous y
fîmes honneur. Le jeune homme de M. Blewitt mangea tant de gibier
(lorsqu’on le rapporta à la cuisine), que je crus qu’il en serait malade.
Le groom de Dakins, qui n’avait guère plus de treize ans, se régala
si copieusement de macaroni et de plum-pudding, qu’il se crut obligé
d’avaler en guise de dessert deux des pilules digestives de son
maître, qui faillirent l’achever… Mais je digresse encore : je parle de
l’office, tandis que je devrais m’occuper du salon.
Le croirait-on ? Après avoir bu huit ou dix bouteilles de vin à eux
trois, les convives se mirent à jouer à l’écarté. Ce jeu se joue à
deux ; par conséquent, lorsqu’on est trois, le troisième reste les bras
croisés à regarder les autres. On commença par jouer trois francs la
fiche et vingt-cinq francs la partie, et à minuit on ne s’était pas fait
grand mal. Dakins gagnait cinquante francs et Blewitt trente-six.
Après souper (je leur avais servi du champagne et des grillades),
les enjeux furent plus élevés. On paria vingt-cinq francs la fiche et
cent vingt-cinq francs la partie. Je songeai aux compliments que
mon maître et Blewitt avaient échangés le matin, et je crus que
l’heure de Dakins venait de sonner. Eh bien, pas du tout. Il continua
à gagner ; Blewitt pariait pour lui, l’aidait de ses conseils et jouait de
son mieux. A la fin de la soirée, qui n’arriva que vers cinq heures du
matin, je rentrai dans le salon ; Cinqpoints examinait une carte sur
laquelle il avait inscrit le nombre de parties et de points perdus.
— Je n’ai pas été en veine ce soir, disait-il… Blewitt, je vous
dois… voyons un peu… mille vingt-cinq francs, je crois ?
— Mille vingt-cinq, ni plus ni moins, répondit Blewitt.
— Je vais vous donner un mandat sur mon banquier, continua
mon honorable maître.
— Allons donc ! rien ne presse, mon cher monsieur.
— Si, les dettes de jeu se payent sur l’heure, répliqua Cinqpoints,
qui prit un carnet de banque et remplit un mandat qu’il remit à son
collègue. Maintenant je vais régler avec vous, mon cher monsieur
Dakins. Si vous aviez su profiter de votre veine, vous m’auriez
gagné une somme assez ronde… Voyons, c’est très-facile à
calculer… Treize fiches à vingt-cinq francs, cela fait trois cent vingt-
cinq francs.
Cinqpoints tira treize souverains de sa bourse et les jeta sur la
table, où ils produisirent en tombant cette musique si agréable à
l’oreille du joueur qui gagne. La joie brillait dans les yeux de Dakins,
sa main tremblait en ramassant l’or ; non qu’il fût avare, mais la
fièvre du jeu commençait déjà à s’emparer de lui.
— Permettez-moi de dire que j’ai rarement rencontré un joueur
de votre force, bien que je me pique d’avoir une certaine expérience,
ajouta mon maître.
— Vous me flattez, mon cher monsieur Cinqpoints.
Je crois bien qu’on le flattait. C’est justement ce qu’on voulait.
— Ah çà, Dakins, poursuivit Cinqpoints, il me faut une revanche ;
à vous deux vous m’avez ruiné, complétement ruiné !
— Eh bien, répondit Dakins, aussi fier que s’il eût gagné un
million, fixons le jour… Demain soir, si vous voulez ?… Vous me
ferez le plaisir de dîner avec moi, bien entendu… Cela vous
convient-il ?
Blewitt accepta de suite. Mon maître se fit un peu prier.
— Soit. Demain, chez vous, dit-il enfin. Mais, mon cher Dakins,
pas trop de vin, je vous en prie. Le vin ne me vaut rien, surtout
quand je dois jouer à l’écarté avec vous.
L’infortuné pigeon se retira plus heureux qu’un roi.
— Tiens, John, voilà pour toi, dit-il en me jetant une des pièces
d’or qu’il venait de gagner.
Pauvre diable ! je voyais déjà comment cela devait finir.
Le plus drôle de l’histoire, c’est que mon maître avait emprunté à
Blewitt l’argent qui devait servir d’appât. A la suite de l’entrevue dont
j’ai rendu compte, j’avais accompagné ce dernier jusque chez lui, et
il m’avait remis cinq cents francs en or pour son collègue.
La fin de l’aventure est facile à prévoir. Si Dakins avait eu un peu
plus de bon sens, il aurait perdu sa fortune en six semaines ou deux
mois ; mais il était si naïf qu’il ne fallut que quelques jours pour le
ruiner.
Le lendemain jeudi (mon maître n’avait fait la connaissance de
Dakins que le mardi), le jeune étudiant nous donna donc à dîner. On
se mit à table à sept heures ; à onze heures on commença à jouer.
Je devinai que cette fois la partie allait devenir sérieuse, car on nous
envoya coucher dès que nous eûmes servi le souper. Vendredi
matin, je descendis à l’heure habituelle. Cinqpoints n’était pas rentré.
Vers midi, il vint faire un peu de toilette et retourna chez Dakins,
après avoir commandé des grillades et de l’eau de Seltz.
On servit le dîner à sept heures ; mais personne ne paraissait
avoir le moindre appétit, car la plupart des plats nous revinrent
intacts. Cependant les convives demandèrent encore du vin ; ils
avaient vidé près de deux douzaines de bouteilles depuis la veille.
Vers onze heures du soir, mon maître rentra chez lui. Il
trébuchait, il chantait, il riait ; je crois même qu’il essaya de danser.
En un mot, il paraissait ivre. Il finit par se jeter tout habillé sur son lit,
après m’avoir lancé une poignée de menue monnaie. Je lui ôtai ses
bottes et ses vêtements, puis je l’abandonnai à ses réflexions.
Dès que je l’eus mis à son aise, je fis ce que doit faire tout bon
domestique ; je vidai ses poches et j’examinai les papiers qu’elles
renfermaient. C’est là une précaution que je ne saurais trop
recommander à mes confrères… dans l’intérêt de leurs maîtres, cela
va sans dire.
Je découvris, entre autres choses, le document que voici :
I. O. U.
Quatre mille sept cents livres sterling.
Thomas Dakins.
Vendredi, 13 janvier.
Cela voulait dire : « Je vous dois cent dix-sept mille cinq cents
francs. »
Ce chiffon sans prétention était aussi valable qu’un billet de
banque, car Blewitt avait eu soin de prévenir Dakins que Cinqpoints,
fort chatouilleux sur le point d’honneur, avait tué en duel deux
joueurs assez malhonnêtes pour refuser de payer une dette de jeu.
Je trouvai un autre papier du même genre signé Richard Blewitt,
pour une somme de dix mille francs ; mais je savais que celui-là ne
signifiait rien.
. . . . . . . . . . . . . . . . . . . .
Le lendemain matin, l’Honorable Percy Cinqpoints se trouva
debout dès neuf heures, aussi sobre qu’un juge. Il s’habilla et se
rendit chez Dakins. Environ une heure après, il demanda son
cabriolet, dans lequel il monta avec sa dupe.
Pauvre Dakins ! Les yeux rouges, la poitrine gonflée de sanglots
comprimés, il se laissa tomber à côté de mon maître sans prononcer
une parole, avec ce frisson fiévreux que donne une nuit d’insomnie
et de remords.
Sa fortune consistait en rentes sur l’État. Ce jour-là, il vendit tout,
à l’exception d’un capital d’une dizaine de mille francs.
. . . . . . . . . . . . . . . . . . . .
Vers deux heures, Cinqpoints était de retour. Son ami Blewitt se
présenta pour la troisième fois.
— Votre maître est rentré ? demanda-t-il.
Je répondis affirmativement.
J’annonçai sa visite ; puis, dès que j’eus refermé la porte du
salon, je regardai par le trou de la serrure, et j’ouvris l’oreille.
— Eh bien, dit Blewitt, nous avons fait un assez joli coup de filet,
mon cher Cinqpoints… Il paraît que vous avez déjà réglé avec
Dakins ?
— En effet, monsieur.
— Cent dix-sept mille cinq cents francs, je crois ?
— Mais oui… A peu près.
— Cela fait, pour ma part… voyons un peu… oui, cela fait
cinquante trois mille sept cent cinquante francs, que vous avez à me
remettre, mon cher.
— Vraiment, monsieur Blewitt, je ne vous comprends pas du tout.
— Vous ne me comprenez pas ! s’écria l’autre d’un ton de voix
impossible à décrire. N’est-il pas convenu que nous devons partager
les bénéfices ? Ne vous ai-je pas prêté de quoi payer vos pertes des
deux premières soirées ? Ne m’avez-vous pas donné votre parole
d’honneur que vous me remettriez la moitié de ce que je vous
aiderais à gagner ?
— Tout cela est parfaitement exact.
— Alors, que diable avez-vous à objecter à ma réclamation ?
— Rien… si ce n’est que je n’ai jamais eu la moindre intention de
tenir ma promesse… Ah çà, vous êtes-vous vraiment imaginé que
j’allais travailler pour vous ? Avez-vous été assez idiot pour vous
figurer que j’avais donné à dîner à ce nigaud, afin de mettre de
l’argent dans votre poche ?… Ce serait trop drôle, et j’ai meilleure
opinion de vous… Allons, monsieur, cessons cette plaisanterie. Vous
savez où est la porte… Mais attendez un instant. Je serai généreux ;
je vous donnerai dix mille francs pour la part que vous réclamez
dans cette affaire… Tenez, voici votre propre billet pour cette
somme ; je vous le rends, à condition que vous oublierez avoir
jamais connu l’Honorable Percy Cinqpoints.
Blewitt gronda, cria, gémit, pria, menaça, frappa du pied. Tantôt il
jurait et grinçait des dents ; tantôt il suppliait son cher M. Cinqpoints
d’avoir pitié de lui. Finalement, il se mit à pleurnicher comme un
enfant.
Mon maître, impatienté, ouvrit la porte du salon, où je manquai
de tomber la tête la première.
— Reconduisez monsieur, me dit Cinqpoints en regardant Blewitt
dans le blanc des yeux.
Ce dernier quitta le canapé sur lequel il s’était jeté avec un geste
de désespoir, et sortit, faisant une mine aussi piteuse qu’un chien
qu’on menace du fouet. Quelques années plus tard, il eut
l’imprudence de commettre un faux, et fut transporté à Botany-Bay.
Quant à Dakins, Dieu sait ce qu’il est devenu ; moi, je l’ignore.
. . . . . . . . . . . . . . . . . . . .
— John, dit mon maître, lorsque j’eus reconduit le visiteur, John,
je vais à Paris. Vous pouvez m’accompagner si cela vous convient.
II
IMPRESSIONS DE VOYAGE
Bien que Cinqpoints ne fût rien moins que modeste, il ne se

vanta pas de son bonheur au jeu, et ne parla à personne de la
somme qu’il avait gagnée au jeune Dakins. Il oublia même de
prévenir ses fournisseurs de son projet de voyage. Au contraire, je
reçus l’ordre de coller sur la porte une bande de papier où mon
maître avait écrit : « Je serai de retour à sept heures et demie. »
Lorsque la blanchisseuse présenta sa petite note, on lui dit de
repasser. Cette note ne s’élevait pas à une somme formidable ; mais
c’est étonnant comme certaines gens deviennent économes, quand
ils ont en poche quelques milliers de francs.
A sept heures, Cinqpoints et moi, nous roulions sur la route de
Douvres, lui dans l’intérieur, moi à l’extérieur de la malle-poste.
J’étais enchanté de voyager, car dès l’âge de raison j’avais toujours
désiré courir le monde. Cependant, je dois avouer que mes
premières impressions ne furent pas des plus agréables, attendu
que j’avais pour voisins un Italien, dont je ne comprenais pas
l’affreux baragouin, et son singe dont le langage, par compensation,
était beaucoup trop explicite : il me montrait les dents et menaçait, à
chaque cahot de la voiture, de m’égratigner le visage.
Enfin, nous arrivâmes sains et saufs à Douvres, où nous
descendîmes au Ship Hotel. J’avais toujours ouï dire que l’on
pouvait vivre à beaucoup meilleur marché en province que dans la
capitale ; mais c’est là un préjugé, et mon maître l’apprit à ses
dépens. A Douvres, tout est si cher que les pauvres aubergistes sont
obligés de faire payer une simple côtelette trois francs, un verre d’ale
vingt-cinq sous, et quelques gorgées de vin chaud deux francs
cinquante centimes. Rien que pour allumer une bougie, il vous en
coûte presque aussi cher que pour brûler la livre entière à Londres.
Du reste, Cinqpoints paya sans faire la moindre observation. Dès
qu’il s’agissait de ses besoins personnels, il ne regardait jamais à la
dépense : c’est une justice à lui rendre, et comme je n’ai pas
cherché à pallier ses défauts, je ne dois pas non plus taire ses
qualités.
Nous ne passâmes qu’une demi-journée dans cette localité
dispendieuse. Le lendemain nous nous embarquâmes pour
Boulogne-sur-mer.
En analysant le nom de cette dernière ville, je m’étais
naturellement figuré qu’elle était en effet située sur la mer. Je vous
laisse à deviner quel fut mon désappointement, lorsqu’à mon arrivée
je reconnus qu’elle se trouve non sur la mer, mais sur la côte. C’est
ainsi qu’on est trompé par les géographes !
Mais n’anticipons pas, nous ne sommes pas encore arrivés…
Quelle rude épreuve qu’une pareille traversée !… Combien je
regrettai d’avoir abandonné la terre ferme pour confier ma précieuse
existence au caprice des flots inconstants !… Compatissant lecteur,
as-tu jamais traversé la Manche ?… « O mer, vaste mer, je veux
m’endormir sur ton sein d’azur, mollement bercé par la vague qui
caresse les flancs de mon léger navire… » Cela est très-joli en
romance, mais la réalité est beaucoup moins agréable. D’ailleurs les
vagues ne sont pas bleues, elles ressemblent plutôt à de l’encre, ou
à du porter écumeux, fraîchement tiré ; et, loin de vous bercer
mollement, elles vous secouent d’une façon toute particulière.
Cependant je n’éprouvai d’abord aucune sensation désagréable.
Au contraire, j’étais fier de me sentir à flot pour la première fois de
ma vie. Lorsque les voiles se gonflèrent et que notre barque
commença à fendre l’onde amère ; lorsque je contemplai le pavillon
de l’Angleterre se déployant au haut du mât, le commis aux vivres
préparant ses cuvettes, et le capitaine arpentant le pont d’un pas
assuré ; lorsque enfin je vis disparaître dans le lointain les côtes
blanches de ma terre natale et les voitures de l’établissement des
bains — alors je me sentis grandir.
— John, me dis-je, te voilà devenu un homme. Ta majorité
précoce date du moment où tu as mis le pied sur ce navire. Sois
sage, sois prudent. Dis un long adieu aux folies de ta jeunesse. Tu
n’es plus un enfant ; rejette tes billes et ta toupie… rejette…
Ici mon discours fut soudain interrompu par une sensation
singulière, puis pénible, qui finit par me maîtriser complétement. La
délicatesse me défend d’entrer dans de plus amples détails. Je dirai
seulement que je fus bien, bien malade. Pendant quelques heures,
je restai étendu sur le pont, dans un état de prostration impossible à
décrire, souffrant le martyre, insensible à la pluie qui m’inondait le
visage et aux plaisanteries des marins qui me marchaient sur le
corps. Je crois que j’aurais béni celui d’entre eux qui aurait mis fin à
mes souffrances en me jetant à la mer. Cela dura quatre mortelles
heures, qui me parurent autant d’années.
Pendant que je subissais ainsi mon purgatoire, un des hommes
du bord s’approcha de l’endroit où nous autres domestiques nous
étions entassés.
— Eh ! John ! cria-t-il.
— Qu’est-ce qu’il y a ? répliquai-je d’une voix affaiblie.
— On vous demande.
— Laissez-moi tranquille.
— Votre maître est malade ; il a besoin de vous.
— Qu’il aille au diable ! répondis-je en me retournant de l’autre
côté et en poussant un gémissement.
Je n’aurais pas bougé pour vingt mille maîtres.
Depuis lors, j’ai sillonné plus d’une fois la vaste profondeur des
mers ; mais jamais je n’ai fait une aussi horrible traversée qu’en l’an
de grâce 18… Les paquebots à vapeur étaient rares à cette époque,
et nous avions dû prendre passage à bord d’un petit bâtiment à
voiles. Enfin, au moment où je me croyais aux portes de la mort, on
m’annonça que nous touchions au terme de notre voyage. Avec
quelle allégresse j’aperçus les lumières qui brillaient sur la côte dont
nous approchions ! Avec quelle joie je sentis diminuer l’odieux roulis
Welcome to our website – the ideal destination for book lovers and
knowledge seekers. With a mission to inspire endlessly, we offer a
vast collection of books, ranging from classic literary works to
specialized publications, self-development books, and children's
literature. Each book is a new journey of discovery, expanding
knowledge and enriching the soul of the reade
Our website is not just a platform for buying books, but a bridge
connecting readers to the timeless values of culture and wisdom. With
an elegant, user-friendly interface and an intelligent search system,
we are committed to providing a quick and convenient shopping
experience. Additionally, our special promotions and home delivery
services ensure that you save time and fully enjoy the joy of reading.
Let us accompany you on the journey of exploring knowledge and

personal growth!
ebookfinal.com

Download Full Dagger by Tutorials Dependency Injection on Android with Dagger Hilt 1st Edition Massimo Carli PDF All Chapters

Uploaded by

Copyright:

Available Formats

Download Full Dagger by Tutorials Dependency Injection on Android with Dagger Hilt 1st Edition Massimo Carli PDF All Chapters

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Download Full Dagger by Tutorials Dependency Injection on Android with Dagger Hilt 1st Edition Massimo Carli PDF All Chapters

Uploaded by

Copyright:

Available Formats

Download the full version of the ebook at

Dagger by Tutorials Dependency Injection on

Explore and download more ebook at https://ebookfinal.com

Lover Unleashed Black Dagger Brotherhood 09 J. R. Ward

Lover Revealed Black Dagger Brotherhood 04 1st Edition J.

Android Programming Tutorials 3rd Edition Mark L Murphy

The Thief Black Dagger Brotherhood 16 First Edition, 2Nd

iOS 5 by Tutorials Volumes 1 and 2 2nd Edition Ray

Naturoids On the Nature of the Artificial 1st Edition

The Android Developer s Cookbook 2nd edition Building

Dependency Theory Revisited B.N. Ghosh

Copyright ©2020 Razeware LLC.

About the Author

About the Editors

Sandra Grauschopf is the editor of this book. She is a freelance

Dean Djermanović is final pass editor of this book. He’s an

About the Artist

Table of Contents: Overview

Section IV: Advanced Dagger ...................................... 323

Table of Contents: Extended

Section II: Introducing Dagger . . . . . . . . . . . . . . . . . . . . 148

Where to go from here? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196

Section III: Components & Scope Management. . . 239

Comparing @Singleton to other scopes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300

Section IV: Advanced Dagger . . . . . . . . . . . . . . . . . . . . . 323

Section V: Introducing Hilt . . . . . . . . . . . . . . . . . . . . . . . . 388

How Dagger Android works . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 392

The BussoServer app . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 500

By purchasing Dagger by Tutorials, you have the following license:

To follow along with this book, you’ll need the following:

• IntelliJ IDEA Community Edition 2020.2.x: Available at https://

• Android Studio 4.1.x: Available at https://developer.android.com/studio/. This is

Where to download the materials for this book

Dagger is a library for dependency injection on JVM-based systems, including

How to read this book

If you’re completely new to dependency injection, we recommend reading it one

This book is split into five main sections:

Section II: Introducing Dagger

Section III: Components and Scope

Section IV: Advanced Dagger

Section V: Introducing Hilt

You’ll migrate the existing Busso app to use Hilt library.

Dependency Injection is one of the most important patterns to use in the

What dependency means

Figure 1.1 - Newton’s second law

A formal definition of dependency

Entity A depends on entity B if a change in B can imply a change in A.

Figure 1.2 - Real life dependencies

Figure 1.3 - Dependency relation in UML

If a change in a component triggers a change in all its dependents, you end up

Figure 1.4 - Implementation Inheritance; the strongest level of dependency

Implementation inheritance in code

To define that Student depends on Person through an implementation

open class Person(val name: String) {

class Student(name: String) : Person(name) {

Abstraction reduces dependency

The first implementation

class Student(val name: String) {

Figure 1.5 - Initial implementation for the Student class

fun printStudent(students: List<Student>) = students.forEach