I've come across a scenario where even though I hadn't explicitly included a module (via either @Module(includes = { .. } ) or @Component(modules = { .. })), dagger is able to construct all the classes just fine.
To make things more clear, here's the example Maven project I created:
src/
├── main
│ ├── java
│ │ └── org
│ │ └── daggertest
│ │ ├── Main.java
│ │ ├── persistence
│ │ │ ├── di
│ │ │ │ └── PersistenceModule.java
│ │ │ └── PersistenceManager.java
│ │ ├── ui
│ │ │ ├── AppUI.java
│ │ │ └── di
│ │ │ └── UIComponent.java
│ │ └── util
│ │ ├── di
│ │ │ └── UtilModule.java
│ │ └── SystemUtil.java
│ └── resources
└── test
└── java
There is a Main class and three packages (persistence, ui, util). There is a corresponding module for persistence and util. And a component for ui.
Let's start from the bottom. The UtilModule simply provides SystemUtil:
@Module
public class UtilModule {
@Provides
public SystemUtil providesSystemUtil() {
return new SystemUtil();
}
}
Pretty straightforward. Nothing going on here. As requested in the comments, here is how SystemUtil looks:
public class SystemUtil {
public Path getSomeFile(String fileName) {
return Path.of(fileName);
}
}
Then, in the persistence package, PersistanceManager injects SystemUtil. So PersistenceModule provides PersistenceManager like so:
@Module
public class PersistenceModule {
@Provides
public PersistenceManager providesPersistenceManager(SystemUtil systemUtil) {
return new PersistenceManager(systemUtil);
}
}
- Even though PersistenceModule doesn't explicitly include the module (by doing
@Module(includes = { UtilModule.class })), this works fine. Why?
Then, in the ui package, AppUI injects both PersistenceManager and SystemUtil. And I wrote UIComponent like so:
@Component(modules = { UtilModule.class })
public interface UIComponent {
AppUI buildAppUI();
}
- I only explicitly included the UtilModule. But it was still able to inject PersistenceManager even though I didn't specify the PersistenceModule. How is this able to work? Interestingly, if I don't include the UtilModule here, it fails.
My guess is that I have a misunderstanding of how the modules/components are able to isolate from each other.
- My expectation was that if it wasn't explicitly included in the Component or Module annotation, it would fail compilation. Is this not true? Is it possible to enforce this?
