I am new in Dagger 2. I created a module which has a provider method that takes one String parameter:
@Module
public class MyModule {
@Provides
Student provideStudent(String name) {
return new Student(name);
}
}
How should I pass the parameter name when injecting student? @Inject Student student? But where/How can I pass the name in?
You want to supply an object (String name) as a parameter to your component so that it can be used by other parts. You basically have 2 options to do so.
Using module arguments is the "classic" approach that you would use before they introduced the Component.Builder.
All you do is add what you need to your module constructor, and provide it from the module.
@Module
public class MyModule {
private String name;
MyModule(String name) {
this.name = name;
}
// -----------------------------------------------
// you could obviously just use the field directly
@Provides
Student provideStudent() {
return new Student(name);
}
// ---------------------------------------------------------------------
// alternatively you'd add a Qualifier and add the argument to the graph
@Provides
@Named("name")
String provideName() {
return name;
}
// then you can use it...
@Provides
Student provideStudent(@Named("name") String name) {
return new Student(name);
}
}
The first option that directly uses the name means that it's only available within that module. If you want to make use of constructor injection or use the qualified String you have to add it to the graph as shown second.
With either approach you'd have to manually add the module to the component, since the module does no longer use a default constructor. This is where you'd also supply your argument now.
DaggerMyComponent.builder()
.myModule(new MyModule("some name"))
.build();
The same concept but a different approach would be to use the component builder to achieve the same thing—bind something to the graph.
@Component(modules = MyModule.class)
interface MyComponent {
@Component.Builder
interface Builder {
@BindsInstance Builder name(@Named("name") String name);
MyComponent build();
}
}
@Module
class MyModule {
@Provides
Student provideStudent(@Named("name") String name) {
return new Student(name);
}
}
Here you also just add an object to the graph that can be used. Here, too, you'd have to add it to the component builder
DaggerMyComponent.builder()
.name("some name")
.build();
My question is how to inject a student instance with a name can be hardcoded.
name is a dependency of Student, and this dependency as to be resolved. To do so you need an annotated @Provide method that returns that String. Since the type is usually inferred by the return type, in case of String you will have to use also the annotation @Named
@Provides
@Named("Name")
public String provideName() {
return "My name";
}
and change your method like
@Provides
Student provideStudent(@Named("Name") String name) {
return new Student(name);
}
this way dagger2 knows ho to resolve that String to build Student
Instead of injecting the Student directly, you could create a Student factory and inject it instead:
public class Student {
public Student(String name, Knowledge knowledge) {}
public static class Factory {
private Knowledge knowledge;
@Inject
public Factory(Knowledge knowledge) {
this.knowledge = knownledge;
}
public Student create(String name) {
return new Student(name, knowledge);
}
}
}
Or the same code in Kotlin:
class Student(name: String, knowledge: Knowledge) {
class Factory @Inject constructor(private val knowledge: Knowledge) {
fun create(name: String) = Student(name, knowledge)
}
}
This allows passing the name parameter on Student instantiation, like this:
public class MyClass {
@Inject
public Student.Factory studentFactory;
private Student student;
public void setupStudent() {
this.student = studentFactory.create("Student's name");
}
}
