空构造函数模块和在Dagger 2中提供参数依赖关系的模块有什么区别？

Question

I am trying to learn DI with Dagger 2 by implementing it in a small example. I got the concept of @Module and @Component. @Component binds @Module with the class where dependencies need to be injected.

Dagger generates Dagger and it has a Builder class which provides and initializes dependencies.

So I was trying out some scenarios for better understanding of Dagger 2. I have some questions but I will go with one right now.

I need to inject DatabaseHelper class. I created DatabaseModule class for that. I also found out that I could skip that class and add a method in my main ApplicationModule to provide DatabaseHelper. To do that I must not add DatabaseModule to ApplicationComponent modules list. Anyway, I have kept DatabaseModule in ApplicationComponent modules list and remove the method from ApplicationModule. Coming back to my question.

I have two options when it comes to creating DatabaseModule class. Here's the first one.

@Module
public class DatabaseModule {

    private Application app;

    public DatabaseModule(Application app) {
        this.app = app;
    }

    @Singleton
    @Provides
    public DatabaseHelper provideDBHelper() {
        return new DatabaseHelper(app.getApplicationContext());
    }
}

And the second option is,

@Module
public class DatabaseModule {

    @Singleton
    @Provides
    public DatabaseHelper provideDBHelper(Application app) {
        return new DatabaseHelper(app.getApplicationContext());
    }
}

If I use the second method, I need not call Component Builder's method .databaseModule() as Dagger takes care of it. And this is quite insignificant, I guess.

My question is - What is the difference between these two? Which one should I use? what are the pros and cons of each method. Also, if I want to inject DatabaseHelper in a class where Application is not accessible, can I do it with the first choice? (As it is providing a singleton).

Please point out if I am doing something wrong and need to change to something else. Here's my ApplicationModule and ApplicationComponent classes.

@Module
public class ApplicationModule {
    private Application mApplication;

    public ApplicationModule(Application app) {
        mApplication = app;
    }

    @Singleton
    @Provides
    Application provideApplication() {
        return mApplication;
    }
}

ApplicationComponent class

@Singleton
@Component(
        modules = {
            ApplicationModule.class,
            DatabaseModule.class
        }
)
public interface ApplicationComponent {
    Application getApplication();
    void inject(MyApplication app);
    DatabaseHelper getDBHelper();
}

Answer 1

This will sound pretty odd, but the difference between a @Module that receives a parameter in its constructor and a @Module that doesn't receive a parameter in its constructor is that one of them receives a parameter and the other one doesn't.

Yes, it's quite tautological, I know. You should provide the constructor parameter if it's necessary for the module to function with it (for example, if you need a context, you'll probably want to provide the application/activity to the module for its given scope). If it doesn't need an external parameter, then there's no point in giving it one.

The key difference is that modules with external parameters must be explicitly given to the Dagger___Component.builder() method on construction. If all of your modules are unparametrized, then you can use the Dagger___Component.create() method instead, which creates every non-parametrized modules for you.

If you want to make an ApplicationModule without parameter, then you'd probably have to do something like this

public enum ApplicationHolder {
    INSTANCE;

    private CustomApplication customApplication;

    void setApplication(CustomApplication customApplication) {
        this.customApplication = customApplication;
    }

    public CustomApplication getApplication() {
        return application;
    }
}

public class CustomApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        ApplicationHolder.INSTANCE.setApplication(this);
    }
}

@Module
public class ApplicationModule {
    @Provides
    public CustomApplication customApplication() {
        return ApplicationHolder.INSTANCE.getApplication();
    } 
}