The first Dagger2

Some concepts:

Dependency Injection (DI)

The component does not do location queries, but provides plain Java methods for the container to determine dependencies. Assembly of components for which the container is solely responsible, passing dependent objects to desired objects via JavaBean properties or constructors. Injection of dependencies through JavaBean properties is called Setter Injection; The practice of passing in dependencies as Constructor parameters is called Constructor Injection

Access mode:

The compile 'com. Google. Dagger: a dagger: 2.11' annotationProcessor 'com. Google. Dagger: a dagger - compiler: 2.11'Copy the code

Dagger2 Basic syntax:

• @Inject
  • Use annotations to annotate other classes that depend on the target class, and also use annotations to annotate the constructors of other classes that depend on them

• @Component

  • Associate other classes annotated (@inject) with constructors of other classes

  These are the basic accompanying annotations for Dagger2

Here’s an example:

class A{ @Inject public A{} } class B{ @Inject A a; Private public B{daggerBComponent.create ().inject(this); } } @Component interface BComponent{ inject(B b); }Copy the code

Question:

The purpose of the Module

We cannot solve the above problem by using only @inject, so how do we do it? We can encapsulate the classes of these third-party, unmodifiable constructors called Modules

• @Module
  • The annotated Module class is actually a simple factory pattern, and the methods in the Module are basically methods that create class instances

How does @Component connect @Inject and @Module?

@Component(modules={ModuleClass.class})
interface BComponent{
   inject(B b);
}Copy the code

@Component is an injector that connects to the target class on one end and the target class dependency instance on the other. It injects the target class dependency instance into the target class. Module(modules={moduleclass.class}) is a class that provides class instances, so Module should be on the instance side of Component (the side that connects the various target class dependent instances).

How do we associate the instantiation functions of Moudle classes with the @Inject dependencies of the target class? And then we’re going to use @Provides

• @Provides
  • With this annotation Component can search the @Module class for the @Provides annotated method that creates an instance of the class. This solves the Dagger problem for the third party library
    

    Lost in annotation problem

    The method return type is an interface solution that is officially provided: use @named or @qulifier

• @ Named and directly@ProvidesUsage @named (” name “)
• The difference between @qulifier and @named is simply to create a new annotation

  @qualifier @Retention(retentionPolicy. RUNTIME) public @interface AA {} Then use @qualifier @provides @aa // or @provides @Named("xxx")Copy the code