Dagger2 使用教程（二）

一、新建项目，新增和业务逻辑相关的类。

1、新增Test01类：

public class Test1 {

    public Test1() {
    }

    public void sayHelloWorld() {
        Log.d("Test1", "Hello World");
    }
}

这个类构造方法无参数，只有一个sayHelloWorld方法，在控制台打印日志信息Hello World。

2、新增Test02类：

public class Test2 {
    private Context context;
    public Test2(Context context) {
        this.context = context;
    }

    public void sayHelloWorld() {
        if(context != null){
            Log.d("Test2", "Hello World");
        }
    }
}

这个类和Test01相比，构造方法新增了一个Context类型的参数，且sayHelloWorld会根据context是否为空来决定是否打印日志信息Hello World。

3、新增Test03类：

public class Test3 {

    private Context context;
    @Inject
    public Test3(Context context) {
        this.context = context;
    }
    public void sayHelloWorld() {
        if (context != null) {
            Log.d("Test3", "Hello World");
        }
    }
}

这个类和Test02相比，只是多了一个@Inject注解。

4、MainActivity类：

public class MainActivity extends AppCompatActivity {

    @Inject
    Test1 test1;
    @Inject
    Test2 test2;
    @Inject
    Test3 test3;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        test1.sayHelloWorld();
        test2.sayHelloWorld();
        test3.sayHelloWorld();
    }
}

把上面新增的Test1 、Test2、Test3作为MainActivity的属性变量，添加@Inject注解，然后再onCreate方法中分别调用它们的sayHelloWorld方法，看看是否能够在控制台打印出来日志信息。现在如果直接这么调用，肯定会报错，在调用三个Test对象的sayHelloWorld方法之前，我们需要做一些辅助操作，让Dagger2框架知道如何进行把MainActivity和Test01，Test02，Test03关联起来，并完成依赖注入。

二、新增和业务逻辑相关、和Dagger2依赖注入有关的类：

1、新增AndroidModule类：

@Module
public class AndroidModule {

    private final Context context;

    public AndroidModule(Context context) {
        this.context = context;
    }

    @Provides
    @Singleton
    Context getContext() {
        return context;
    }


    @Provides
    @Singleton
    Test1 provideTest1() {
        return new Test1();
    }

    @Provides
    @Singleton
    Test2 provideTest2() {
        return new Test2(context);
    }
}

AndroidModule类首先是被@Module注解标记；然后此类的构造方法需要传入Context类型的参数；有三个内部方法，getContext返回Context，provideTest1方法返回Test1实例对象，provideTest2方法返回Test2实例对象，这三个方法刚返回的三个实例对象，后续我们是可以在其他地方直接拿到的。

2、新增MainActivityComponent类：

@Singleton
@Component(modules = AndroidModule.class)
public interface MainActivityComponent{

    void inject(MainActivity mainActivity);

}

此类被@Singleton和@Component注解标记，@Singleton会让Dagger2再生成这个接口的实现类的时候，该是将类的获取方式将会是个单例模式，@Component是告诉Dagger2这个类是个连接器，由于我们需要在MainActivity类中进行依赖注入，所以这里提供了inject(MainActivity mainActivity)供MainActivity来调用，以达到通过依赖注入的方式获取Test1、Test2、Test3这些类的实例对象需求。

3、修改MainActivity类的onCreate方法：

public class MainActivity extends AppCompatActivity {

    @Inject
    Test1 test1;
    @Inject
    Test2 test2;
    @Inject
    Test3 test3;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        //调用下面的代码实现依赖注入
        DaggerMainActivityComponent.builder()
                .androidModule(new AndroidModule(this))
                .build().inject(this);

        test1.sayHelloWorld();
        test2.sayHelloWorld();
        test3.sayHelloWorld();
    }
}

4、成功运行代码，日志信息如下所示：

2022-11-12 15:58:03.586  4531-4531  Test1                   com.example.dagger2application       D  Hello World
2022-11-12 15:58:03.586  4531-4531  Test2                   com.example.dagger2application       D  Hello World
2022-11-12 15:58:03.586  4531-4531  Test3                   com.example.dagger2application       D  Hello World

三、查看使用Dagger2新增了那些临时类

打开build/generated/ap_generaed_sources/debug/out/com/example/dagger2application目录：

image.png

可以发现该目录新增了六个类。

1、AndroidModule_GetApplicationContextFactory类：

public final class AndroidModule_GetApplicationContextFactory implements Factory<Context> {
  private final AndroidModule module;

  public AndroidModule_GetApplicationContextFactory(AndroidModule module) {
    this.module = module;
  }

  @Override
  public Context get() {
    return getApplicationContext(module);
  }

  public static AndroidModule_GetApplicationContextFactory create(AndroidModule module) {
    return new AndroidModule_GetApplicationContextFactory(module);
  }

  public static Context getApplicationContext(AndroidModule instance) {
    return Preconditions.checkNotNullFromProvides(instance.getApplicationContext());
  }
}

2、AndroidModule_ProvideTest1Factory类：

public final class AndroidModule_ProvideTest1Factory implements Factory<Test1> {
  private final AndroidModule module;

  public AndroidModule_ProvideTest1Factory(AndroidModule module) {
    this.module = module;
  }

  @Override
  public Test1 get() {
    return provideTest1(module);
  }

  public static AndroidModule_ProvideTest1Factory create(AndroidModule module) {
    return new AndroidModule_ProvideTest1Factory(module);
  }

  public static Test1 provideTest1(AndroidModule instance) {
    return Preconditions.checkNotNullFromProvides(instance.provideTest1());
  }
}

3、AndroidModule_ProvideTest2Factory类：

public final class AndroidModule_ProvideTest2Factory implements Factory<Test2> {
  private final AndroidModule module;

  public AndroidModule_ProvideTest2Factory(AndroidModule module) {
    this.module = module;
  }

  @Override
  public Test2 get() {
    return provideTest2(module);
  }

  public static AndroidModule_ProvideTest2Factory create(AndroidModule module) {
    return new AndroidModule_ProvideTest2Factory(module);
  }

  public static Test2 provideTest2(AndroidModule instance) {
    return Preconditions.checkNotNullFromProvides(instance.provideTest2());
  }
}

4、DaggerMainActivityComponent类：

public final class DaggerMainActivityComponent {
  private DaggerMainActivityComponent() {
  }

  public static Builder builder() {
    return new Builder();
  }

  public static final class Builder {
    private AndroidModule androidModule;

    private Builder() {
    }

    public Builder androidModule(AndroidModule androidModule) {
      this.androidModule = Preconditions.checkNotNull(androidModule);
      return this;
    }

    public MainActivityComponent build() {
      Preconditions.checkBuilderRequirement(androidModule, AndroidModule.class);
      return new MainActivityComponentImpl(androidModule);
    }
  }

  private static final class MainActivityComponentImpl implements MainActivityComponent {
    private final MainActivityComponentImpl mainActivityComponentImpl = this;

    private Provider<Test1> provideTest1Provider;

    private Provider<Test2> provideTest2Provider;

    private Provider<Context> getApplicationContextProvider;

    private MainActivityComponentImpl(AndroidModule androidModuleParam) {

      initialize(androidModuleParam);

    }

    private Test3 test3() {
      return new Test3(getApplicationContextProvider.get());
    }

    @SuppressWarnings("unchecked")
    private void initialize(final AndroidModule androidModuleParam) {
      this.provideTest1Provider = DoubleCheck.provider(AndroidModule_ProvideTest1Factory.create(androidModuleParam));
      this.provideTest2Provider = DoubleCheck.provider(AndroidModule_ProvideTest2Factory.create(androidModuleParam));
      this.getApplicationContextProvider = DoubleCheck.provider(AndroidModule_GetApplicationContextFactory.create(androidModuleParam));
    }

    @Override
    public void inject(MainActivity mainActivity) {
      injectMainActivity(mainActivity);
    }

    private MainActivity injectMainActivity(MainActivity instance) {
      MainActivity_MembersInjector.injectTest1(instance, provideTest1Provider.get());
      MainActivity_MembersInjector.injectTest2(instance, provideTest2Provider.get());
      MainActivity_MembersInjector.injectTest3(instance, test3());
      return instance;
    }
  }
}

5、MainActivity_MembersInjector类：

public final class MainActivity_MembersInjector implements MembersInjector<MainActivity> {
  private final Provider<Test1> test1Provider;

  private final Provider<Test2> test2Provider;

  private final Provider<Test3> test3Provider;

  public MainActivity_MembersInjector(Provider<Test1> test1Provider, Provider<Test2> test2Provider,
      Provider<Test3> test3Provider) {
    this.test1Provider = test1Provider;
    this.test2Provider = test2Provider;
    this.test3Provider = test3Provider;
  }

  public static MembersInjector<MainActivity> create(Provider<Test1> test1Provider,
      Provider<Test2> test2Provider, Provider<Test3> test3Provider) {
    return new MainActivity_MembersInjector(test1Provider, test2Provider, test3Provider);
  }

  @Override
  public void injectMembers(MainActivity instance) {
    injectTest1(instance, test1Provider.get());
    injectTest2(instance, test2Provider.get());
    injectTest3(instance, test3Provider.get());
  }

  @InjectedFieldSignature("com.example.dagger2application.MainActivity.test1")
  public static void injectTest1(MainActivity instance, Test1 test1) {
    instance.test1 = test1;
  }

  @InjectedFieldSignature("com.example.dagger2application.MainActivity.test2")
  public static void injectTest2(MainActivity instance, Test2 test2) {
    instance.test2 = test2;
  }

  @InjectedFieldSignature("com.example.dagger2application.MainActivity.test3")
  public static void injectTest3(MainActivity instance, Test3 test3) {
    instance.test3 = test3;
  }
}

6、Test3_Factory类：

public final class Test3_Factory implements Factory<Test3> {
  private final Provider<Context> contextProvider;

  public Test3_Factory(Provider<Context> contextProvider) {
    this.contextProvider = contextProvider;
  }

  @Override
  public Test3 get() {
    return newInstance(contextProvider.get());
  }

  public static Test3_Factory create(Provider<Context> contextProvider) {
    return new Test3_Factory(contextProvider);
  }

  public static Test3 newInstance(Context context) {
    return new Test3(context);
  }
}

四、总结

1、结合Dagger2框架新增的六个类我们可以发现，在MainActivity的onCreate方法中，Dagger2框架实现依赖注入的流程如下所示：


image.png

2、MainActivity的onCreate方法关键代码：

public class MainActivity extends AppCompatActivity {
    ...代码省略...
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        ...代码省略...
        //调用下面的代码实现依赖注入
        DaggerMainActivityComponent.builder()
                .androidModule(new AndroidModule(this))
                .build().inject(this);
        ...代码省略...
    }
}

3、DaggerMainActivityComponent的builder方法关键代码：

public final class DaggerMainActivityComponent {
  public static Builder builder() {
    return new Builder();
  }
}

4、DaggerMainActivityComponent内部类Builder的androidModule方法和build方法关键代码：

public final class DaggerMainActivityComponent {
 public static final class Builder {
    private AndroidModule androidModule;

    ...代码省略...

    public Builder androidModule(AndroidModule androidModule) {
      this.androidModule = Preconditions.checkNotNull(androidModule);
      return this;
    }

    public MainActivityComponent build() {
      Preconditions.checkBuilderRequirement(androidModule, AndroidModule.class);
      return new MainActivityComponentImpl(androidModule);
    }
  }
}

5、DaggerMainActivityComponent内部类MainActivityComponentImpl的inject方法：

public final class DaggerMainActivityComponent{
  private static final class MainActivityComponentImpl implements MainActivityComponent {
    private final MainActivityComponentImpl mainActivityComponentImpl = this;

    private Provider<Test1> provideTest1Provider;//可以获取Test1实例
    private Provider<Test2> provideTest2Provider;//可以获取Test3实例
    private Provider<Context> getApplicationContextProvider;//可以获取Context实例

    private MainActivityComponentImpl(AndroidModule androidModuleParam) {
      initialize(androidModuleParam);
    }

    //创建Test3实例
    private Test3 test3() {
      return new Test3(getApplicationContextProvider.get());
    }

    //这个方法很关键，会对provideTest1Provider、provideTest2Provider、getApplicationContextProvider进行初始化
    @SuppressWarnings("unchecked")
    private void initialize(final AndroidModule androidModuleParam) {
      this.provideTest1Provider = DoubleCheck.provider(AndroidModule_ProvideTest1Factory.create(androidModuleParam));
      this.provideTest2Provider = DoubleCheck.provider(AndroidModule_ProvideTest2Factory.create(androidModuleParam));
      this.getApplicationContextProvider = DoubleCheck.provider(AndroidModule_GetApplicationContextFactory.create(androidModuleParam));
    }

    @Override
    public void inject(MainActivity mainActivity) {
      injectMainActivity(mainActivity);
    }

    private MainActivity injectMainActivity(MainActivity instance) {
      MainActivity_MembersInjector.injectTest1(instance, provideTest1Provider.get());
      MainActivity_MembersInjector.injectTest2(instance, provideTest2Provider.get());
      MainActivity_MembersInjector.injectTest3(instance, test3());
      return instance;
    }
  }
}

inject会进一步调用injectMainActivity方法，injectMainActivity内部分别调用MainActivity_MembersInjector的injectTest1、injectTest2、injectTest3方法，对MainActivity中的test1、test2、test3进行赋值。

6、MainActivity_MembersInjector的injectTest1、injectTest2、injectTest3方法如下所示

public final class MainActivity_MembersInjector implements MembersInjector<MainActivity> {
  ...代码省略...
  @InjectedFieldSignature("com.example.dagger2application.MainActivity.test1")
  public static void injectTest1(MainActivity instance, Test1 test1) {
    instance.test1 = test1;
  }

  @InjectedFieldSignature("com.example.dagger2application.MainActivity.test2")
  public static void injectTest2(MainActivity instance, Test2 test2) {
    instance.test2 = test2;
  }

  @InjectedFieldSignature("com.example.dagger2application.MainActivity.test3")
  public static void injectTest3(MainActivity instance, Test3 test3) {
    instance.test3 = test3;
  }
}

以上就是在MainActivity中，Dagger2实现依赖注入的整个流程。

©著作权归作者所有,转载或内容合作请联系作者
【社区内容提示】社区部分内容疑似由AI辅助生成，浏览时请结合常识与多方信息审慎甄别。
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

相关阅读更多精彩内容

友情链接更多精彩内容