匕首2相互依赖问题

Question

在我的应用程序中，我试图创建Dagger2组件

null

我已经创建了组件，并从应用程序类启动。

    public class MyApp extends Application{

      private ContextComponent mContextComponent;
      private AppUtilComponent mAppUtilComponent;
      private NetworkComponent mNetworkComponent;

      @Override
        public void onCreate() {
            super.onCreate();
            mNetworkComponent = createNetworkComponent();
            mContextComponent =  createContextComponent();
            mAppUtilComponent = createAppUtilComponent();
        }

        private AppUtilComponent createAppUtilComponent() {
                return DaggerAppUtilComponent.builder().appUtilModule(new AppUtilModule(this)).build();
        }

        public AppUtilComponent getAppUtilComponent() {
           return mAppUtilComponent;
        }

        private NetworkComponent createNetworkComponent() {
             return DaggerNetworkComponent.builder().networkModule(new NetworkModule()).build();
        }

        public NetworkComponent getNetworkComponent() {
            return mNetworkComponent;
        }

        private ContextComponent createContextComponent() {

            return DaggerContextComponent.builder().contextModule(new ContextModule(this)).build();
        }

        public ContextComponent getContextComponent(){
            return mContextComponent;
        }
    }

ContextModule类如下所示

@Module
public class ContextModule {

    private Context mContext;

    public ContextModule(Context context){
        mContext = context;
    }

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

上下文组件将是

@Singleton
@Component (modules = ContextModule.class)
public interface ContextComponent {

    void inject(AppUtils appUtils);

}

@Singleton
@Component (modules = AppUtilModule.class)

public interface AppUtilComponent {

   void inject(SplashActivity splashActivity);
}

@Module (includes = ContextModule.class)
public class AppUtilModule {

    private AppUtils mAppUtils;
    private Context context;

    @Inject
    public AppUtilModule(Context context) {
        this.context = context;
    }

    @Provides
    public AppUtils getAppUtil(){
        mAppUtils = new AppUtils(context);
        return mAppUtils;
    }
}

public class AppUtils {

    public Context mContext;

    @Inject
    public AppUtils(Context _context){
        mContext = _context;
    }

    public boolean isNetworkConnected(){
     //Using mContext to determine Network
    }
    ... Other Utility methods which will be used throughout my application
}

public class SplashActivity ....
 {

    @Inject
    public NetworkProcessor mNetworkProcessor;
    .....
    @Inject
    public AppUtils mAppUtils;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        MyApp.getInstance().getAppUtilComponent().inject(this);

        MyApp.getInstance().getNetworkComponent().inject(this);
    }

}

错误：

rror: [Dagger/MissingBinding] com.dev.myapp.networking.NetworkProcessor cannot be provided without an @Inject constructor or an @Provides-annotated method.
com.dev.myapp.networking.NetworkProcessor is injected at
com.dev.myapp.ui.activities.landing.SplashActivity.mNetworkProcessor
com.dev.myapp.ui.activities.landing.SplashActivity is injected at
com.dev.myapp.components.AppUtilComponent.inject(com.dev.myapp.ui.activities.landing.SplashActivity)

Answer 1

因此，一个组件可以同时创建多个依赖项，这些依赖项通常按生存期范围分组（应用程序=整个应用程序生存期，活动=活动生存期）。

因此，如果AppUtils类的作用域与ContextComponent相同，则可以使用它将AppUtils注入到应该使用它的类中，例如一个活动：

public class MainActivity extens Activity {

    @Inject AppUtils appUtils;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        ((MyApp) getApplication()).getContextComponent().inject(this);
    }
}

将ContextComponent定义扩展为

@Singleton
@Component (modules = ContextModule.class)
public interface ContextComponent {

    void inject(AppUtils appUtils);

    void inject(MainActivity activity);
}

public class AppUtils {
    private Context mContext;

    @Inject 
    public AppUtils(Context context){
        this.mContext = context;
    }
}

Dagger不知道如何创建networkprocessor-类，因此编译器出错。要使其工作，您应该更改NetworkProcessor，使其具有一个用@inject注释的构造函数，就像使用apputils一样（第二个选项是在dagger模块中创建@provides方法，但第一个解决方案更容易）。

您没有提供networkprocessor的源代码，所以我在这里假设它只需要context作为依赖项。

既然apputils和networkprocessor都有一个仅有context作为参数的可注入构造函数，Dagger可以自己创建缺少的链接。

您不需要networkcomponent和apputilcomponent，只需要一个组件，所以删除它们。还要删除networkmodule和apputilmodule。ContextComponent现在就足以将所有依赖项注入SplashActivity:

public class SplashActivity .... {

    @Inject public NetworkProcessor mNetworkProcessor;
    .....
    @Inject public AppUtils mAppUtils;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        MyApp.getInstance().getContextComponent().inject(this);
    }
    //...
}

这是因为Dagger可以自己创建布线代码，因为它知道如何实例化apputils和networkprocessor。