Dependency Injection

Question 1

singleton

Answer 1

The singleton pattern is a software design pattern that restricts the instantiation of a class to one “single” instance. This is useful when exactly one object is needed to coordinate actions across the system.

Question 2

dependency injection replaces the…

Answer 2

“new” keyword to create an instance

Question 3

is a singleton a service?

Answer 3

yes - annotate a singleton service with @Service - we didn’t learn this yet for Dagger

Question 4

Dagger component

Answer 4

Dagger can create a graph of the dependencies in your project that it can use to find out where to get those dependencies when they are needed. To make Dagger do this, you have to create an interface and annotate it with @Component.

Question 5

modules (in dependency injection)

Answer 5

classes where dependencies are defined for the class: ie CarModule contains definitions of dependencies for Car, like Engine or Wheels
-----
import
..
public class CarModule extends --- {
     @Provides
     public Engine providesEngine() {
          return new Engine();
     }
}

Question 6

@Provides annotation

Answer 6

this annotation preceeding a methods tells Dagger that this method describes a dependency

Question 7

@Inject

Answer 7

annotation for the constructor
@Inject
public Car(Engine engine) {
     this.engine = engine;
}

Question 8

dependency injection …

Answer 8

…decouples your class’s construction from the construction of its dependencies

Question 9

core idea of dependency injection:

Answer 9

provide the member variables for a class through its constructor, rather than letting the class instantiate its own objects –> using the @Inject annotated constructor

Question 10

when classes instantiate their own dependency objects…

Answer 10

…the dependency instantiation logic is mixed up with the actual class logic (hence, dependency injection)

Question 11

dependency injection separates the instantiation logic from…

Answer 11

…from the code that uses the instantiated object to get its work done. (We can code the instantiation logic any way we please in a separate “injection” class: locality, edge cases, happy case, etc)

Question 12

True or false: Dependence injection benefits unit testing as a kind of side effect.

Answer 12

True. By accepting the classes we need as arguments to our constructor, we can pass mocks in our unit tests, narrowing the scope of what our unit tests actually check to only the class functions we are testing.

Question 13

Dagger allows us to specify how to provide dependency objects using …..

Answer 13

…annotations (rather than full methods or classes - think App() ) that are in the familiar Java annotation format, i.e. JUnit’s @Test, @BeforeEach

Question 14

Dagger @Component

Answer 14

provider of the root object(s)

use provide* method(s) in the @Component interface to “start” the domino effect of instantiations

Question 15

Dagger @Inject

Answer 15

specify how to construct dependencies
Dagger will look at the return type of the provide* method(s) in the @Component interface, go to that class and use the constructor which is annotated with @Inject

Question 16

Dagger requires us to annotate the specific constructor that it should use to instantiate an object of the class using which annotation?

Answer 16

@Inject
public ObjectConstructor(ObjectType1 objectType1, …
–>finds the class ObjectType1 and looks for the @Inject constructor, etc…
Note: no specific dagger method used! Just @Inject

Question 17

The interface provide* method…

Answer 17

returns the root object that your application needs

Question 18

@Component
public interface AppComponent {
public IceCreamService provideIceCreamService();
}
In the application, write two lines of code that a)retrieves the Dagger-generated component class, and b)returns an instance of the root class

Answer 18

//retrieve the Dagger-generated component class
AppComponent dagger= DaggerIceCreamService.create()

//return an instance of the root class
IceCreamService iceCreamService = dagger.provideIceCreamService();

Question 19

What is dependency injection with a real time example?

Answer 19

DI can exist between two objects, for instance, a flashlight and a battery. The flashlight needs the battery to function. However, any changes made to the battery, such as switching it another brand/set of batteries, does not ean the dependent object (flashlight) also needs to be changed.

Question 20

Is dependency injection used in Production?

Answer 20

Yes. Dependency Injection is an architecture pattern, not a testing one. So it is intended to be used when building production code.

Question 21

When we have a @Singleton in the dependency graph we need to annotate the @Component interface with @Singleton as well.
True or False?

Answer 21

True