module
一个类似工厂的类。
@Module
public class ApplicationModule {
}
需要被包含到component中才能起作用。通过Component的modules属性赋值。
@Component(modules = {ApplicationModule.class})
public interface ApplicationComponent {
void inject(MyApp app);
User user();
}
如上，我们需要在接口ApplicationComponent 中获取到User，或者在MyApp中注入User。
public class MyApp extends Application {
@Inject
User user;
@Override
public void onCreate() {
super.onCreate();
DaggerApplicationComponent.create().inject(this);
}
}
可以通过在User的构造函数上标注Inject实现。
public class User {
@Inject
public User(){
}
}
也可以通过在module的方法上标注Providers实现。这种方式的优先级高于inject标注构造函数的优先级。
@Module
public class ApplicationModule {
@Provides
User user() {
return new User();
}
}
成功编译后的Dagger类。
@Generated("dagger.internal.codegen.ComponentProcessor")
public final class DaggerApplicationComponent implements ApplicationComponent {
private Provider<User> userProvider;
private MembersInjector<MyApp> myAppMembersInjector;
private DaggerApplicationComponent(Builder builder) {
assert builder != null;
initialize(builder);
}
public static Builder builder() {
return new Builder();
}
public static ApplicationComponent create() {
return builder().build();
}
private void initialize(final Builder builder) {
this.userProvider = ApplicationModule_UserFactory.create(builder.applicationModule);
this.myAppMembersInjector = MyApp_MembersInjector.create((MembersInjector) MembersInjectors.noOp(), userProvider);
}
@Override
public void inject(MyApp app) {
myAppMembersInjector.injectMembers(app);
}
@Override
public User user() {
return userProvider.get();
}
public static final class Builder {
private ApplicationModule applicationModule;
private Builder() {
}
public ApplicationComponent build() {
if (applicationModule == null) {
this.applicationModule = new ApplicationModule();
}
return new DaggerApplicationComponent(this);
}
public Builder applicationModule(ApplicationModule applicationModule) {
if (applicationModule == null) {
throw new NullPointerException("applicationModule");
}
this.applicationModule = applicationModule;
return this;
}
}
}
实质是根据传入的module创建了一个工厂类。
@Generated("dagger.internal.codegen.ComponentProcessor")
public final class ApplicationModule_UserFactory implements Factory<User> {
private final ApplicationModule module;
public ApplicationModule_UserFactory(ApplicationModule module) {
assert module != null;
this.module = module;
}
@Override
public User get() {
User provided = module.user();
if (provided == null) {
throw new NullPointerException("Cannot return null from a non-@Nullable @Provides method");
}
return provided;
}
public static Factory<User> create(ApplicationModule module) {
return new ApplicationModule_UserFactory(module);
}
}
Component接口获取的实例就是工厂类的get方法返回的实例，工厂类返回的实质上是module里的方法返回的实例。注入的实例也是这样来的。
