Java Dagger 2-注入非Android类

我正在我的Android应用程序中安装

dagger2

。我按以下方式进行设置：

AppComponent.java

@Singleton
@Component(modules = {
  AndroidInjectionModule.class,
  AndroidSupportInjectionModule.class,
  ActivityBuilder.class,
  AppModule.class,
  DataBaseDaoModule.class
})

public interface AppComponent {
  @Component.Builder
  interface Builder {
    @BindsInstance
    Builder application(Application aApplication);

    AppComponent build();
  }

  Application application();
  void inject(MyApplication aApplication);
}

ublic class AppInjector {

  public static void init(MyApplication aApplication) {

    //Initialize dagger and inject the aApplication
    DaggerAppComponent.builder().application(aApplication).build().inject(aApplication);

    aApplication.registerActivityLifecycleCallbacks(new Application.ActivityLifecycleCallbacks() {
      @Override
      public void onActivityCreated(Activity aActivity, Bundle aBundle) {
        handleActivity(aActivity);
      }

      @Override
      public void onActivityStarted(Activity aActivity) {
      }

      @Override
      public void onActivityResumed(Activity aActivity) {
      }

      @Override
      public void onActivityPaused(Activity aActivity) {
      }

      @Override
      public void onActivityStopped(Activity aActivity) {
      }

      @Override
      public void onActivitySaveInstanceState(Activity aActivity, Bundle aBundle) {
      }

      @Override
      public void onActivityDestroyed(Activity aActivity) {
      }
    });
  }

  private static void handleActivity(Activity aActivity) {
    if (aActivity instanceof HasActivityInjector) {
      AndroidInjection.inject(aActivity);
      Timber.d("injected Activity");
    }
    if (aActivity instanceof FragmentActivity) {
      ((FragmentActivity) aActivity).getSupportFragmentManager()
        .registerFragmentLifecycleCallbacks(
          new FragmentManager.FragmentLifecycleCallbacks() {
            @Override
            public void onFragmentCreated(FragmentManager fm, Fragment f,
                                          Bundle savedInstanceState) {
              if (f instanceof Injectable) {
                Timber.d("injected Fragment");
                AndroidSupportInjection.inject(f);
              }
            }
          }, true);
    }
  }
}

Module(includes = ViewModelModule.class)
class AppModule {

  @Singleton
  @Provides
  ApiService providesApiService(OkHttpClient aClient, MyInterceptor aInterceptor) {

    //Build a Retrofit object here
  }

  @Singleton
  @Provides
  OkHttpClient providesOkHTTPClient(MyInterceptor aInterceptor) {
   //Setup OKHTTP here
  }
}

AppInjector.java

@Singleton
@Component(modules = {
  AndroidInjectionModule.class,
  AndroidSupportInjectionModule.class,
  ActivityBuilder.class,
  AppModule.class,
  DataBaseDaoModule.class
})

public interface AppComponent {
  @Component.Builder
  interface Builder {
    @BindsInstance
    Builder application(Application aApplication);

    AppComponent build();
  }

  Application application();
  void inject(MyApplication aApplication);
}

ublic class AppInjector {

  public static void init(MyApplication aApplication) {

    //Initialize dagger and inject the aApplication
    DaggerAppComponent.builder().application(aApplication).build().inject(aApplication);

    aApplication.registerActivityLifecycleCallbacks(new Application.ActivityLifecycleCallbacks() {
      @Override
      public void onActivityCreated(Activity aActivity, Bundle aBundle) {
        handleActivity(aActivity);
      }

      @Override
      public void onActivityStarted(Activity aActivity) {
      }

      @Override
      public void onActivityResumed(Activity aActivity) {
      }

      @Override
      public void onActivityPaused(Activity aActivity) {
      }

      @Override
      public void onActivityStopped(Activity aActivity) {
      }

      @Override
      public void onActivitySaveInstanceState(Activity aActivity, Bundle aBundle) {
      }

      @Override
      public void onActivityDestroyed(Activity aActivity) {
      }
    });
  }

  private static void handleActivity(Activity aActivity) {
    if (aActivity instanceof HasActivityInjector) {
      AndroidInjection.inject(aActivity);
      Timber.d("injected Activity");
    }
    if (aActivity instanceof FragmentActivity) {
      ((FragmentActivity) aActivity).getSupportFragmentManager()
        .registerFragmentLifecycleCallbacks(
          new FragmentManager.FragmentLifecycleCallbacks() {
            @Override
            public void onFragmentCreated(FragmentManager fm, Fragment f,
                                          Bundle savedInstanceState) {
              if (f instanceof Injectable) {
                Timber.d("injected Fragment");
                AndroidSupportInjection.inject(f);
              }
            }
          }, true);
    }
  }
}

Module(includes = ViewModelModule.class)
class AppModule {

  @Singleton
  @Provides
  ApiService providesApiService(OkHttpClient aClient, MyInterceptor aInterceptor) {

    //Build a Retrofit object here
  }

  @Singleton
  @Provides
  OkHttpClient providesOkHTTPClient(MyInterceptor aInterceptor) {
   //Setup OKHTTP here
  }
}

AppModule.java

@Singleton
@Component(modules = {
  AndroidInjectionModule.class,
  AndroidSupportInjectionModule.class,
  ActivityBuilder.class,
  AppModule.class,
  DataBaseDaoModule.class
})

public interface AppComponent {
  @Component.Builder
  interface Builder {
    @BindsInstance
    Builder application(Application aApplication);

    AppComponent build();
  }

  Application application();
  void inject(MyApplication aApplication);
}

ublic class AppInjector {

  public static void init(MyApplication aApplication) {

    //Initialize dagger and inject the aApplication
    DaggerAppComponent.builder().application(aApplication).build().inject(aApplication);

    aApplication.registerActivityLifecycleCallbacks(new Application.ActivityLifecycleCallbacks() {
      @Override
      public void onActivityCreated(Activity aActivity, Bundle aBundle) {
        handleActivity(aActivity);
      }

      @Override
      public void onActivityStarted(Activity aActivity) {
      }

      @Override
      public void onActivityResumed(Activity aActivity) {
      }

      @Override
      public void onActivityPaused(Activity aActivity) {
      }

      @Override
      public void onActivityStopped(Activity aActivity) {
      }

      @Override
      public void onActivitySaveInstanceState(Activity aActivity, Bundle aBundle) {
      }

      @Override
      public void onActivityDestroyed(Activity aActivity) {
      }
    });
  }

  private static void handleActivity(Activity aActivity) {
    if (aActivity instanceof HasActivityInjector) {
      AndroidInjection.inject(aActivity);
      Timber.d("injected Activity");
    }
    if (aActivity instanceof FragmentActivity) {
      ((FragmentActivity) aActivity).getSupportFragmentManager()
        .registerFragmentLifecycleCallbacks(
          new FragmentManager.FragmentLifecycleCallbacks() {
            @Override
            public void onFragmentCreated(FragmentManager fm, Fragment f,
                                          Bundle savedInstanceState) {
              if (f instanceof Injectable) {
                Timber.d("injected Fragment");
                AndroidSupportInjection.inject(f);
              }
            }
          }, true);
    }
  }
}

Module(includes = ViewModelModule.class)
class AppModule {

  @Singleton
  @Provides
  ApiService providesApiService(OkHttpClient aClient, MyInterceptor aInterceptor) {

    //Build a Retrofit object here
  }

  @Singleton
  @Provides
  OkHttpClient providesOkHTTPClient(MyInterceptor aInterceptor) {
   //Setup OKHTTP here
  }
}

最后在MyApplication.Java中的

onCreate

方法中，我只调用

AppInjector

如下：

AppInjector.init（this）

所有这些工作以及我在AppComponent的模块中放入的任何东西，我都可以注入到
活动、片段和视图模型中

但是，在某些情况下，我需要一个
实用程序
类，这取决于
应用程序
，用于
上下文
——并且我在不同的地方使用该实用程序类。或者我将有一个
管理器
类，它取决于应用程序，或者需要来自AppModule的一些东西。然而，由于我在
活动、片段和视图模型之外使用这些类，所以我不能仅仅注入。我如何提供我的
实用工具
类及其依赖项和任何其他类型的类（如管理器类）

我的第一个想法是创建一个
实用组件
和一个
管理组件
，但是我不知道如何让它们在
AppModuel
中或通过我的
AppComponent
使用任何东西
 请不要只使用
component.inject（myObject）
。始终首选构造函数注入，或者从可以执行其他设置步骤的模块中提供构造函数注入
.inject（myObject）
适用于您无权访问构造函数的框架组件

我的第一个想法是创建一个UtilityComponent和一个ManagerComponent之类的组件，但是我不知道如何让它们在AppModuel中或通过我的AppComponent处理任何东西

你不需要一个单独的组件。见下文

然而，由于我在活动、片段和视图模型之外使用这些类，所以我不能只注入它们

这与注射无关。你说的是作用域，听起来你的实用程序是一个
@Singleton
。您的
AppComponent
是一个
@Singleton
作用域组件，因此它也可以用于提供您的util

但是，在某些情况下，我需要一个实用程序类，它取决于
应用程序
，用于
上下文

如果它们是可以访问您的应用程序的
@Singleton
组件的一部分，那么它们也可以在其他任何地方提供。不需要更多的组件或任何东西。只需声明依赖项，不要想得太多


只需声明您的util，用
@Singleton
注释它，并用
@Inject
为构造函数注入标记构造函数
@Singleton
确保它将由
AppComponent
提供，并且可以访问它所依赖的
应用程序

@Singleton public class MyUtil {

  private Application application;

  @Inject public MyUtil(Application application) {
    this.application = application;
  }

}

然后你就可以把它注入到你的活动、片段，甚至其他的实用程序中

@Singleton public class MyUtilWrapper {

  private MyUtil myUtil;

  @Inject public MyUtilWrapper(MyUtil myUtil) {
    this.myUtil = myUtil;
  }

}

您可以将其中一个或两个注入到您的活动或片段中

@Inject MyUtil myUtil;
@Inject MyUtilWrapper myUtilWrapper;

void onCreate(..) {
  AndroidInjection.inject(this);
}

您不需要任何模块、方法或组件来提供简单的类。只需确保添加正确的范围
 请参阅答案。可能是重复的谢谢，但是我不打算使用AndroidImpression（），我也不需要注入视图。仅仅是实用程序类和其他类别，它们永远不会出现在活动、片段或视图模型中。但是，将尝试将答案应用于我的案例。如果这些类被约束到最顶层的组件（
@Singleton
），那么您可以从自定义
应用程序
类中获取这些依赖项，该类已在
onCreate（）
方法中初始化了依赖项图：
MyCustomApplication.getComponent（）.inject（）（MyUtilityClass.this）
。这假设在最顶层的组件中声明了
无效注入（MyUtilityClass clazz）
。根据生成类的源判断，您不能这样做。您已经声明了
无效注入（…）
方法满足您的需要。我不确定我怎么会错过这个！Mind==Blow！我更喜欢这种方式。经过测试，似乎对于足够简单的类，我可以使用这种模式，对于我需要第三方类设置的地方，例如改装或需要更多依赖性才能开始的事情，我会使用提供的方法，对吗？一个简单的问题-如果我不想让我的“简单”类成为一个单独的类，我会为它们创建一个新的作用域和组件等？或者将它们添加到AppModule？提供了附加设置的方法，是的。是的，只要在需要的时候和需要的地方创建自己的作用域。谢谢，这对我帮助很大！