Dagger2是一个依赖注入框架，目前由google维护。
关于依赖注入是什么可以看依赖注入简介
引入Dagger
// Add Dagger dependencies
dependencies {
compile 'com.google.dagger:dagger:2.x'
annotationProcessor 'com.google.dagger:dagger-compiler:2.x'
}
Dagger初体验
@Inject 通常使用在构造函数和成员变量上，当使用在构造函数上时表示为其他需要依赖的成员变量提供依赖，而使用在成员变量上的时候表示需要由Dagger2为该变量提供依赖，此处需要注意Dagger2不能使用在私有的（private）成员变量上。
@Component 通常注解在一个接口上，表示编译时会产生相应的类（这个类的命名为DaggerXxxx,Xxxx为你使用@Component标记的接口的名字），这个类为依赖提供方和依赖需求方之间的桥梁，从提供方获取依赖并注入需求方。
public class Student {
private String name;
private int age;
@Inject
public Student() {
this.name = "mike";
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
public class ClassRoom {
@Inject
Student student;
@Override
public String toString() {
return "ClassRoom{" +
"student=" + student +
'}';
}
}
//Rebuild后生成类名为DaggerClassRoomComponent
@Component
public interface ClassRoomComponent {
//必须是具体的类，不能是其父类,此处是ClassRoom
void injectStudent(ClassRoom classRoom);
}
编写好以上两个类和一个接口之后Rebuild Project即可生成DaggerClassRoomComponent类
//使用Junit4进行测试
@Test
public void testDagger2() {
ClassRoom classRoom = new ClassRoom();
//将Student注入classRoom中
DaggerClassRoomComponent.create()
.injectStudent(classRoom);
System.out.println(classRoom);
}
@Module和@Provide
@Module 注解用于一个类上，表示该类是专门用来提供依赖的，有一些类我们无法修改源码，比如一些引用进来jar包，这时候就可以在@Module注解的类里面创建对象，对目标类提供依赖
@Provides 注解用于Module注解的类中的方法上，该方法将在目标对象需要的时候为其提供依赖
//Student类
public class Student {
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
//Module类
@Module
public class StudentModule {
@Provides
public Student provideStudent() {
return new Student("mike", 66);
}
}
//Component接口
@Component(modules = StudentModule.class)
public interface ClassRoomComponent {
void injectStudent(ClassRoom classRoom);
}
//ClassRoom类
public class ClassRoom {
@Inject
Student student;
@Override
public String toString() {
return "ClassRoom{" +
"student=" + student +
'}';
}
}
Dagger2提供依赖的规则
步骤1：查找Module中是否存在创建该类的方法。
步骤2：若存在创建类方法，查看该方法是否存在参数
步骤2.1：若存在参数，则按从步骤1开始依次初始化每个参数
步骤2.2：若不存在参数，则直接初始化该类实例，一次依赖注入到此结束
步骤3：若不存在创建类方法，则查找Inject注解的构造函数，看构造函数是否存在参数
步骤3.1：若存在参数，则从步骤1开始依次初始化每个参数
步骤3.2：若不存在参数，则直接初始化该类实例，一次依赖注入到此结束
使用@Qualifier解决依赖迷失
Dagger是根据@Provides注解的方法的返回值类型确定由哪个方法提供依赖的，如果两个方法的返回值类型一样就会造成依赖迷失，也就是无法确定使用哪个方法这时候编译过程就会报错，@Qualifier注解就是用来解决这个问题的.
//自定义注解Lee
@Qualifier
@Retention(RUNTIME)
public @interface Lee {
}
//Mike
@Qualifier
@Retention(RUNTIME)
public @interface Mike {
}
//ClassRoom类
public class ClassRoom {
@Inject
@Mike
//@Named("Mike")
Student student;
@Override
public String toString() {
return "ClassRoom{" +
"student=" + student +
'}';
}
}
//StudentModule类
@Module
public class StudentModule {
@Provides
@Mike
//使用java提供的Named注解也可以由一样的效果
//@Named("Mike")
public Student provideMike() {
return new Student("Mike", 66);
}
@Provides
@Lee
//@Named("Lee")
public Student provideLee() {
return new Student("Lee", 18);
}
}
//Test
@Test
public void testDagger2() {
ClassRoom classRoom = new ClassRoom();
DaggerClassRoomComponent
.builder()
.studentModule(new StudentModule())
.build()
.injectStudent(classRoom);
System.out.println(classRoom);
}
@Scope
我们可以通过@Scope注解自定义注解来达到局部单例的目的
，@Singleton是@Scope的一个实现，只要再Component和Provides
上注解就可以实现局部单例
@Singleton
@Component(modules = StudentModule.class)
public interface StudentComponent {
void injectStudent(ClassRoom classRoom);
}
@Module
public class StudentModule {
@Provides
@Singleton
@Mike
public Student provideMike() {
return new Student("Mike", 66);
}
@Provides
@Lee
public Student provideLee() {
return new Student("Lee", 18);
}
}
为什么说是局部单例呢
@Test
public void testDagger2() {
ClassRoom classRoom1 = new ClassRoom();
ClassRoom classRoom2 = new ClassRoom();
DaggerStudentComponent.create().injectStudent(classRoom1);
System.out.println(classRoom1.getStudent1() == classRoom1.getStudent2());
}
以上代码测试输出结果为true，说明ClassRoom中的两个Student对象确实是同一个对象
@Test
public void testDagger2() {
ClassRoom classRoom1 = new ClassRoom();
ClassRoom classRoom2 = new ClassRoom();
DaggerStudentComponent.create().injectStudent(classRoom1);
DaggerStudentComponent.create().injectStudent(classRoom2);
System.out.println(classRoom1.getStudent1() == classRoom2.getStudent1());
System.out.println(classRoom2.getStudent1() == classRoom2.getStudent2());
}
上面的代码输出为false，true，说明classRoom1中的Student和classRoom2中的不是同一个对象，而classRoom2中的两个Student对象是同一个对象。
上面两个结果对比可知单例的生命周期与Component的生命周期相同
如果要在安卓中实现真正的单例可以创建一个与app一起创建，当app退出才销毁的Component对象，代码如下
public class App extends Application {
private StudentComponent studentComponent;
@Override
public void onCreate() {
super.onCreate();
studentComponent = DaggerStudentComponent.create();
}
public StudentComponent getStudentComponent() {
return studentComponent;
}
}
然后在AndroidManifest.xml中添加即可全局获取StudentComponent
实现单例模式
总结
Dagger2设计精巧，使用方便，通过编译后生成的类为目标类提供依赖，不过需要使用DaggerXXX.builder...进行注入，对代码有一定的侵入性。
每次修改完Component或者Module都要Rebuild Project
