【Android】Dagger2从入门到再入门（进阶）

上一篇【Android】Dagger2从入门到再入门讲解了dagger2的基本使用方式，本篇介绍一下@Named，@Singleton，@Scope等其它注解的使用方式；

一.@Singleton

先看个例子：

1.我们在MainActivity里注入两个Student对象（接着上篇讲的，不明白的可以简单浏览下上一篇文章）：

@Inject
Student student;

@Inject
Student studentTwo;

2.打印一下这两个对象：

tvOne = (TextView) findViewById(R.id.tv_one);
tvTwo = (TextView) findViewById(R.id.tv_two);
tvOne.setText(""+student);
tvTwo.setText(""+studentTwo);

3.结果：



嗯，记过很棒，确实是两个对象，但是我们如果想实现单例模式该怎么办呢，我们有时需要在不同的页面使用同一个实例，这时候@Singleton就能帮上忙了，@Singleton这个注解的作用就是声明单例模式，下面我们来验证一下：

4.StudentMoudle中提供Student实例的地方添加@Singleton注解：

@Module
public class StudentMoudle {

@Singleton
@Provides
public Student provideIStudent()
{
Student student = new Student();
student.setName("张三");
student.setSayStr("一天不装逼,浑身难受");
return student;
}
}

5.在StudentComponent注入器类的上方添加@Singleton注解，然后编译运行：

@Singleton
@Component(modules = StudentMoudle.class)
public interface StudentComponent {
void inject(MainActivity activity);
}

结果：



我们发现，确实实现了单例模式，是不是很简单；

二.@Named

再来看个例子：

1.我们在StudentMoudle中再添加一个提供Student实例的provideOtherStudent方法，如下：

@Module
public class StudentMoudle {

@Singleton
@Provides
public Student provideIStudent()
{
Student student = new Student();
student.setName("张三");
student.setSayStr("一天不装逼,浑身难受");
return student;
}

@Singleton
@Provides
public Student provideOtherStudent()
{
Student student = new Student();
student.setName("李四");
student.setSayStr("我是帅哥我怕谁");
return student;
}
}

此时编译的话，会报如下错误：



意思是说我们不能提供多个返回参数是一样实例的方法，因为dagger是根据返回类型来提供实例的，那么我们该怎么办呢？

2.这个时候就需要使用一个标记来指定需要使用哪个方法来提供实例，@Named就是干这个的了，我们加上@Named注解：

@Singleton
@Named("zhang")
@Provides
public Student provideIStudent()
{
Student student = new Student();
student.setName("张三");
student.setSayStr("一天不装逼,浑身难受");
return student;
}

@Singleton
@Named("li")
@Provides
public Student provideOtherStudent()
{
Student student = new Student();
student.setName("李四");
student.setSayStr("我是帅哥我怕谁");
return student;
}

3.在注入的地方指定需要哪个对象，然后打印Student的名字：

@Inject
@Named("zhang")
Student student;

@Inject
@Named("li")
Student studentTwo;

tvOne = (TextView) findViewById(R.id.tv_one);
tvTwo = (TextView) findViewById(R.id.tv_two);
tvOne.setText(""+student+"--student name = "+student.getName());
tvTwo.setText(""+studentTwo+"--student name = "+studentTwo.getName());

结果如下，运行成功，分别创建了自己需要的对象：



这里说一下@Qulifier注解，@Qulifier功能和@Named一样,并且@Named就是使用@Qulifier来定义的,@Named的源码如下：

@Qualifier
@Documented
@Retention(RUNTIME)
public @interface Named {

/** The name. */
String value() default "";
}

这下大家明白了吧，这个@Named可以随意定义，功能都是一样的，只是名字不同罢了，大家可以尝试下自己定义，然后使用方式和@Named一样，这里就不多说了；

三.@Scope

font size=”4” color=”#535346”>我们先来看下@Scope的源码：

/**
* Identifies scope annotations. A scope annotation applies to a class
* containing an injectable constructor and governs how the injector reuses
* instances of the type. By default, if no scope annotation is present, the
* injector creates an instance (by injecting the type's constructor), uses
* the instance for one injection, and then forgets it. If a scope annotation
* is present, the injector may retain the instance for possible reuse in a
* later injection. If multiple threads can access a scoped instance, its
* implementation should be thread safe. The implementation of the scope
* itself is left up to the injector.
*/
@Target(ANNOTATION_TYPE)
@Retention(RUNTIME)
@Documented
public @interface Scope {}

→→ 源码里对Scope的解释比较多，这里我们留下了第一段话，就是上面的一大串英文，大概意思就是说，@Scope注解是标识作用域的，意思就是说你在@Provides处使用了@Scope相关联的注解，就必须在注入类使用同样的注解标识作用范围，另外如果使用了@Scope注解，实例的创建就是单例模式，如果不使用，每次都会创建一个新的对象，单例？说到这你应该想到了上面@Singleton注解，来看下@Singleton的源码:

/**
* Identifies a type that the injector only instantiates once. Not inherited.
*
* @see javax.inject.Scope @Scope
*/
@Scope
@Documented
@Retention(RUNTIME)
public @interface Singleton {}

我们发现了@Scope的身影，这下明白了吧，@Singleton的单例其实是@Scope的作用，我们来看个简单的例子：

1.新建School类

public class School {

private String schoolName;

public School() {
}

public School(String schoolName) {
this.schoolName = schoolName;
}

public String getSchoolName() {
return schoolName;
}

public void setSchoolName(String schoolName) {
this.schoolName = schoolName;
}
}

2.自定义Scope注解

@Scope
@Retention(RUNTIME)
public @interface MainScope {
}

3.创建module和component,使用@MainScope注解

@Module
public class SchoolMoudle {

@MainScope
@Provides
public School provideISchool()
{
School school = new School();
school.setSchoolName("清华大学");
return school;
}

}

@Component(modules = SchoolMoudle.class)
@MainScope
public interface SchoolComponent {
void inject(SecondActivity activity);
}

4.新建了SecondActivity，注入School对象，编译，运行

public class SecondActivity extends AppCompatActivity {

private Button button;

@Inject
School school;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_second);

initInject();
initView();
}

private void initView() {
button = (Button) findViewById(R.id.button);
button.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
Toast.makeText(SecondActivity.this, "school name = "+school.getSchoolName(), Toast.LENGTH_SHORT).show();
}
});
}

private void initInject() {
DaggerSchoolComponent.builder().schoolMoudle(new SchoolMoudle()).build().inject(this);
}

}

结果：



注意：在同一个作用范围内,Provide方法提供的依赖对象就会变成单例,也就是说依赖需求方不管依赖几次Provide方法提供的依赖对象,Dagger2都只会调用一次这个方法;



参考连接：

1.Dagger2 入门

2.http://stackoverflow.com/questions/30260073/dagger-2-error-dependency-cannot-be-provided-without-an-inject-constructor-w