关于Dagger2的一些个人理解

作者：幽灵-玲 | 来源：互联网 | 2023-06-29 20:46

写作目的现在基本上有一些规模的项目，都使用了Dagger2，也不是装13，个人感觉也的确是大势所趋，Dagger2的确

写作目的

现在基本上有一些规模的项目&＃xff0c;都使用了Dagger2&＃xff0c;也不是装13&＃xff0c;个人感觉也的确是大势所趋&＃xff0c;Dagger2的确有它的优势。借着手上的项目&＃xff0c;学习了一下Dagger2&＃xff0c;打算用在公司的项目中。今天就来以自己初学者的角度来谈谈dagger2的认识。

问题由来

我是目前是移动端开发者&＃xff0c;主要从事的是Android端开发。在andorid开发过程中&＃xff0c;按照套路我们会有SharePreferenceManager、DatabaseManager、NetWorkManager、CacheManager等各种Manager&＃xff0c;当然你的叫法也可以不同&＃xff0c;他们都会存在初始化&＃xff0c;考虑到有种可能的初始化顺序&＃xff0c;如下图&＃xff1a;

我们可能需要先使用Application初始化SpManager(SharePreferenceManager)拿到一些关键数据&＃xff0c;从而通过这些数据来初始化DbManager&＃xff0c;NWManager或者CacheManager。可以看到我们的各个对象就存在初始化先后的问题&＃xff0c;试想如果系统过于复杂&＃xff0c;像这种对象初始化有相互依赖的各种关系&＃xff0c;想必是非常复杂的&＃xff1b;如果是我们用代码去写&＃xff0c;也是很繁杂的而且没多大效率的&＃xff1b;还有一个问题,看下图&＃xff1a;

如果有一天&＃xff0c;我们的E对象突然改变了初始化方法&＃xff0c;而且很多地方都需要E对象的初始化&＃xff0c;那我们是不是很懵&＃xff0c;因为有很多地方需要修改&＃xff0c;那苦逼的程序员是不是很难受&＃xff0c;这也就是我们常说的程序的耦合性&＃xff0c;改一处&＃xff0c;就要变100处地方。很显然dagger的出现就是为了解决这个问题的。具体怎么解决&＃xff0c;我还有想用一张图来说明我的想法&＃xff1a;

假设dagger在初始化某对象时&＃xff0c;同时需要a b c g四个对象&＃xff0c;它就会在容器中寻找(这里的寻找有可能是上一次创建的)&＃xff0c;找到了就拿来使用&＃xff0c;没有找到就需要靠自身去创建了。你可以看到a d g对象都会存在&＃xff0c;此时c对象不存在&＃xff0c;那么此时的c对象的创建又变成了XObject对象的创建&＃xff0c;此时需要找到c对象创建时&＃xff0c;需要m对象和p对象&＃xff0c;一环一环套下去&＃xff0c;然后直到所有的需要的对象都创建完成&＃xff0c;然后再递归到需要它需要创建的对象&＃xff0c;直到所有的对象初始化完成。明白了这个道理&＃xff0c;感觉学习dagger2就不难了。

开始Dagger2

配置

AS , gradle配置&＃xff1a;

//dagger2 compile &＃39;com.google.dagger:dagger:2.14.1&＃39; annotationProcessor &＃39;com.google.dagger:dagger-compiler:2.14.1&＃39;

新建Student类&＃xff1a;

public class Student { private String name ; private int score ; &＃64;Inject public Student(){ this.name &＃61; "zhangsan" ; this.score &＃61; 30 ; } public Student(String name, int score) { this.name &＃61; name; this.score &＃61; score; } &＃64;Override public String toString() { return "Student{" &＃43; "name&＃61;&＃39;" &＃43; name &＃43; &＃39;\&＃39;&＃39; &＃43; ", score&＃61;" &＃43; score &＃43; &＃39;}&＃39;; } }

和普通java类一致&＃xff0c;只是在构造方法上使用了注解&＃64;javax.inject.Inject注解&＃xff0c;第一步完成&＃xff1b;

创建接口StudentComponent,当然这个接口名字你可以乱写&＃xff0c;但是为了规范我还是建议你初始化啥对象&＃xff0c;就写这个名字&＃xff0c;接口很简单&＃xff1a;

&＃64;Component public interface StudentComponent { void inject(SecondActivity activity); }

我们需要一个&＃64;dagger.Component的注解&＃xff0c;和一个SecondActivity&＃xff0c;这个SecondActivity是我们需要用到的Activity&＃xff0c;在这个Activity中我们需要对Student对象进行初始化&＃xff1a;
SecondActivity源码&＃xff1a;

public class SecondActivity extends AppCompatActivity { &＃64;Inject Student su; TextView tv; &＃64;Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_second); tv &＃61; findViewById(R.id.id_tv_content); } public void getStudentInfo(View view) { tv.setText(su.toString()); } }

在我们需要的初始化的对象上Student也加上&＃64;Inject注解&＃xff0c;其他的好像真的完事了&＃xff0c;就这么简单&＃xff1f;当然&＃xff0c;你需要将make一下你的project(这里吐槽一下当年使用window系统最终放弃了dagger2无数次&＃xff0c;make项目绝对是我不想坚持下去的最大原因&＃xff0c;太尼玛花时间了)&＃xff0c;然后加上一句话&＃xff1a;

编译运行&＃xff0c;我们可以看到&＃xff1a;

的确&＃xff0c;程序没有我们想象中报了异常&＃xff0c;而是真的被初始化&＃xff0c;而且被赋值了。第一次用Dagger2的感觉就是这么神奇。当然这算得上Dagger2最简单的应用场景吧。

不过&＃xff0c;距离真正去使用Dagger2还有有一定的差距&＃xff0c;因为我们还缺少一样叫module的类。真正的Dagger2是存在三部分的。
1. 对象的实例化部分&＃xff0c;相当于我们的new Object(); Dagger提供类似容器功能&＃xff0c;提供实例化的功能&＃xff1b;这一个叫module&＃xff1b;
2. 需要实例化的部分&＃xff0c;你实例化的对象需要被用得到&＃xff0c;这是个非常抽象的部分&＃xff0c;可以使是Activity&＃xff0c;也可以是Fragment&＃xff0c;或者是任意的Java对象&＃xff1b;
3. 连接部分&＃xff0c;将实例化的对象和需要用到这些对象的部分连接起来。这一个在dagger中叫Component。

好了&＃xff0c;有了上面的简单说明&＃xff0c;我们来个真正的dagger用法。来个Student2对象&＃xff0c;相当于我们的数据&＃xff1a;

public class Student2 { private String name ; private int score ; public Student2(String name, int score) { this.name &＃61; name; this.score &＃61; score; } &＃64;Override public String toString() { return "Student2{" &＃43; "name&＃61;&＃39;" &＃43; name &＃43; &＃39;\&＃39;&＃39; &＃43; ", score&＃61;" &＃43; score &＃43; &＃39;}&＃39;; } }

现在我们需要module组件&＃xff0c;给我们提供对象实例化的&＃xff0c;这个可能稍微有点拐弯&＃xff1a;

&＃64;Module public class Student2Module { &＃64;Provides public String provideName() { return "lisi" ; } &＃64;Provides public int provideScore(){ return 98 ; } &＃64;Provides public Student2 provideStudent2(String name , int score){ return new Student2(name,score); } }

我们看到了&＃64;provides&＃xff0c;这是来自Dagger的注解&＃xff0c;正如翻译过来&＃xff0c;就是给你提供数据量&＃xff0c;它提供了一个Student2对象&＃xff0c;那么问题来了&＃xff0c;那name和score是哪里来的呢&＃xff1f;同样我们看到了它提供另外两个方法provideScore()和provideName(),同样也被&＃64;Provides注解修饰&＃xff0c;意思就是我给你提供数据量。

已经有数据可以提供了&＃xff0c;那哪里需要这个数据呢&＃xff1f;来&＃xff0c;看一下我们的Activity&＃xff0c;在Activity中有地方需要它:

public class ThirdActivity extends AppCompatActivity { &＃64;Inject //这里使用&＃64;Inject 说明我需要被初始化 Student2 stu ; TextView tv ; &＃64;Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_second); tv &＃61; findViewById(R.id.id_tv_content); } //这里是按钮的点击作用&＃xff0c;我们需要看一下这个Student2对象是否被初始化 public void getStudentInfo(View v) { tv.setText(stu.toString()); } }

数据源和数据去向都有了&＃xff0c;那我们就需要一个中间的连接着Component了&＃xff0c;好了&＃xff0c;我们来造一个Component&＃xff0c;如下&＃xff1a;

&＃64;Component(modules &＃61; Student2Module.class) //这就是中间的链接部分&＃xff0c;数据源就是这个modules所对应的数据类 public interface Student2Component { //Component是接口&＃xff0c;相当于中间件 void inject(ThirdActivity activity); //这个是数据去向&＃xff0c;注意不要使用什么BaseActivity&＃xff0c;一定要写具体的activity }

好了&＃xff0c;然后我们make(build,reBuild)一下我们的项目&＃xff0c;然后在ThirdActivity中添加一句代码&＃xff1a;

这个DaggerStudentComponent是Dagger框架自动生成的&＃xff0c;它是由你的Component接口然后加上Dagger前缀生成的&＃xff0c;作用是连接我们的数据源和数据接收者。点击按钮&＃xff0c;可以看到结果&＃xff1a;

结果就是我们想要的&＃xff0c;也可以看到Student2Module中提供的name和score的确在Activity的Student2对象中了。是不是很简单呢&＃xff1f;是啊&＃xff0c;我们的dagger注入框架就好了&＃xff0c;这就是注入的效果。

但是你有没有一种感觉&＃xff0c;为啥Student类和Student2对象中&＃xff0c;Student构造器中使用了&＃64;Inject注解&＃xff0c;但是Student2构造器中没有使用&＃64;Inject呢&＃xff1b;为啥Student对应的StudentComponent没有提供获取Student方法&＃xff0c;而Student2Component中提供了获取Student2的方法呢&＃xff1f;

这就需要我们理解Module作为数据提供者&＃xff0c;提供数据也是有先后顺序的&＃xff0c;一般顺序如下&＃xff1a;
1. 我现在module数据提供者中找有没有提供初始化对象的方法&＃xff1b;
2. 我找到了&＃xff0c;我就返回该对象&＃xff1b;
3. 我没有找到&＃xff0c;我就去查看这个对象的构造器是否被&＃64;Inject找到
4. 找到了&＃xff0c;那么自己执行new Object过程&＃xff1b;没有找到&＃xff0c;对不起&＃xff0c;编译出错&＃xff0c;说明你dagger方法使用错误。

所以&＃xff0c;综上所述&＃xff0c;一个对象的构造器Constructor没有被&＃64;Inject修饰&＃xff0c;那么在Module中必须有方法提供初始化对象。

好了&＃xff0c;我们接下来就说一说工作和生活中用得比较多的对象&＃xff0c;也就是关于dagger的标识符问题了。

&＃64;Singleton

和Java思想中一致&＃xff0c;就是单例的意思。这里的单例依据个人的理解&＃xff0c;一个数据接收容器中存在多个数据接收者&＃xff0c;那么多个数据接收者指向的对象是同一个。说的自己都有点不信了&＃xff0c;举个例子&＃xff1a;
定义StudentSingleton数据结构&＃xff1a;

&＃64;Singleton public class StudentSingleton { private String name ; private int score ; &＃64;Inject //看这里被&＃64;Inject修饰了 public StudentSingleton(String name, int score) { this.name &＃61; name; this.score &＃61; score; } }

数据提供者StudentSingletonModule&＃xff1a;

&＃64;Module public class StudentSingletonModule { &＃64;Provides public String getName(){ return "tom"; } &＃64;Provides public int score() { return 20; } }

数据需求者SingletonActivity&＃xff0c;可以看得到里面有两个StudentSingleton对象等待被初始化&＃xff1a;

public class SingletonActivity extends AppCompatActivity { &＃64;Inject StudentSingleton singleton1 ; &＃64;Inject StudentSingleton singleton2 ; TextView tv; &＃64;Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_second); tv &＃61; findViewById(R.id.id_tv_content); //build之后进行对象注入 DaggerStudentSingleComponent.builder().build().inject(this); } public void getStudentInfo(View v) { tv.setText(singleton1 &＃43; "\n" &＃43; singleton2); } }

我们看一下结果&＃xff1a;

我们可以看到两个StudentSingleton对象指向的相同的地址&＃xff0c;那么说明它们是同一个对象。
同样&＃xff0c;我们在另外一个Activity中也需要一个StudentSingleton&＃xff0c;如下代码&＃xff1a;

public class AnotherStudentSingletonActivity extends AppCompatActivity { &＃64;Inject StudentSingleton stu ; TextView tv; &＃64;Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_another_student_singleton); tv &＃61; findViewById(R.id.id_tv_content); DaggerStudentSingleComponent.builder().build().inject(this); tv.setText(stu.toString()); } }

获取的结果为&＃xff1a;

由此可见&＃xff0c;&＃64;Singleton注解并不是我们平常意义上的单例&＃xff0c;只是在同一个容器的中&＃xff0c;指向同一个对象才可能被称为单例。

当然了&＃xff0c;你去掉&＃64;Singleton注解&＃xff0c;去看看在一个Activity同时获取两个StudentSingleton对象&＃xff0c;地址是不是一样呢&＃xff1f;答案肯定是不一样的。

初始化对象时&＃xff0c;需要获取外部参数

这个在Andorid中需求的比较多&＃xff0c;很多时候我们需要一个Context对象&＃xff0c;到处都是Context对象&＃xff0c;举个例子&＃xff1a;
先来个StudentContext对象&＃xff1a;

public class StudentContext { private String name ; private int score ; private Context context; public StudentContext(){} &＃64;Inject //注意&＃64;Inject注解修饰的这个构造器 public StudentContext(String name, int score, Context context) { this.name &＃61; name; this.score &＃61; score; this.context &＃61; context; } &＃64;Override public String toString() { return "StudentContext{" &＃43; "name&＃61;&＃39;" &＃43; name &＃43; &＃39;\&＃39;&＃39; &＃43; ", score&＃61;" &＃43; score &＃43; ", context&＃61;" &＃43; context &＃43; &＃39;}&＃39;; } }

在我们的Module中&＃xff0c;我们这时需要传入一下个Context对象&＃xff1a;

&＃64;Module public class StudentContextModule { private Context context; //此时需要你传入一个Context对象进入 public StudentContextModule(Context context) { this.context &＃61; context; } &＃64;Provides public String provideName() { return "jerry" ; } &＃64;Provides public int provideScore() { return 20 ; } //这里提供一个Context对象方法 &＃64;Provides public Context provideContext() { return context; } }

我们桥接对象为&＃xff1a;

&＃64;Component(modules &＃61; StudentContextModule.class) public interface StudentContextComponent { void inject(StudentContextActivity activity); }

make一下我们的项目&＃xff0c;在数据接收容器StudentContextActivity中&＃xff0c;这么写&＃xff1a;

public class StudentContextActivity extends AppCompatActivity { &＃64;Inject StudentContext sContext; TextView tv ; &＃64;Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_second); tv &＃61; findViewById(R.id.id_tv_content); //这里我们就需要提供一个StudentContextModule对象 //是的&＃xff0c;这个对象是我们New的 DaggerStudentContextComponent.builder().studentContextModule(new StudentContextModule(this)).build().inject(this); } public void getStudentInfo(View v) { tv.setText(sContext.toString()); } }

结果为&＃xff1a;

你可以看到&＃xff0c;我们的Context对象也被传入进去了&＃xff0c;其实就是我们的StudentContextModule被new时传入的this写入的。

依赖Module

这个意义&＃xff0c;就相当我们每个应用中只有一个Application&＃xff0c;我们的Activity可以依赖于这个Application&＃xff0c;然后可以Toast&＃xff0c;SharePreference我们想要的东西。那么就来一个AppModule&＃xff0c;全局来一个Context&＃xff1a;

&＃64;Module public class AppModule { private Context context ; public AppModule(Context context) { this.context &＃61; context; } &＃64;Provides public Context provideContext() { return context; } &＃64;Provides public String provideGlobalName() { return "globalName" ; } }

那么它对应的Component为&＃xff1a;

&＃64;Component(modules &＃61; AppModule.class) public interface AppComponent { /** * 向下提供Context * &＃64;return */ Context getContext(); /** * 向下提供Name * &＃64;return */ String getStringName(); }

这里有一点需要声明一下&＃xff0c;APPComponent将要被依赖&＃xff0c;那么它需要暴露出提供初始化对象的方法&＃xff0c;然后依赖它的Component将找不到。
好了&＃xff0c;基类被依赖的APPComponent已经有了&＃xff0c;现在来一个ActivityComponent&＃xff0c;它提供了StudentContext对象方法和score对象方法。

&＃64;Module public class ActivityModule { &＃64;Provides public StudentContext provideStudentContext(Context context,String name , int score) { return new StudentContext(name,score,context); } &＃64;Provides public int provideActivityScore() { return 78 ; } }

那么重点来了&＃xff0c;ActivityComponent将会依赖AppComponent&＃xff0c;AppComponent将会提供Context对象方法和name对象方法&＃xff0c;注意dependencies关键字&＃xff0c;它指向了依赖的对象&＃xff0c;同时依赖的对象也是一个Component。

&＃64;Component(modules &＃61; ActivityModule.class, dependencies &＃61; AppComponent.class) public interface ActivityComponent { void inject(DependencyActivity activity); }

在DependencyActivity中&＃xff1a;

public class DependencyActivity extends AppCompatActivity { &＃64;Inject StudentContext sContext; TextView tv ; &＃64;Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_second); tv &＃61; findViewById(R.id.id_tv_content); //先获取AppComponent对象 AppComponent appComponent &＃61; DaggerAppComponent.builder().appModule(new AppModule(this)).build(); //ActivityComponent对象将会依赖于AppComponent DaggerActivityComponent. builder(). appComponent(appComponent). build().inject(this); } public void getStudentInfo(View v) { tv.setText(sContext.toString()); } }

同样我们打印结果为&＃xff1a;

&＃64;Name注解

主要解决同一个容器中&＃xff0c;同时又多个相同对象需要被注入&＃xff0c;如果你不做任何指导&＃xff0c;那么dagger就不确定数据注入的唯一性(数据提供者 -> 数据接收者)&＃xff0c;此时有一种方法就是使用&＃64;Name注解&＃xff1a;
还是定义一个StudentForNameAt对象&＃xff0c;可以看到它有一个name和context属性

public class StudentForNameAt { private String name ; private Context context; public StudentForNameAt(String name) { this.name &＃61; name; } public StudentForNameAt(Context context) { this.context &＃61; context; } &＃64;Override public String toString() { return "StudentForNameAt{" &＃43; "name&＃61;&＃39;" &＃43; name &＃43; &＃39;\&＃39;&＃39; &＃43; ", context&＃61;" &＃43; context &＃43; &＃39;}&＃39;; } }

那么NameAtModule需要这么写&＃xff1a;

&＃64;Module public class NameAtModule { private Context context ; private String name ; public NameAtModule(Context context,String name) { this.context &＃61; context; this.name &＃61; name; } &＃64;Provides public Context provideContext() { return context; } &＃64;Named("context") //这里使用"contex"标识 &＃64;Provides public StudentForNameAt provideStudentForNameAtContext() { return new StudentForNameAt(context); } &＃64;Named("name")//这里使用"name"标识 &＃64;Provides public StudentForNameAt provideStudentForNameAtName(){ return new StudentForNameAt(name); } }

最后&＃xff0c;在我们的NameAtActivity中&＃xff0c;同时也需要&＃64;Name("name")和&＃64;Name("context")标识对象的注入&＃xff1a;

public class NameAtActivity extends AppCompatActivity { &＃64;Named("name")//这里标识 &＃64;Inject StudentForNameAt at1 ; &＃64;Named("context") //这里标识 &＃64;Inject StudentForNameAt at2 ; TextView tv; &＃64;Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_second); tv &＃61; findViewById(R.id.id_tv_content); DaggerNameAtComponent.builder().nameAtModule(new NameAtModule(this,"hello world")).build().inject(this); } public void getStudentInfo(View v) { tv.setText(at1.toString() &＃43; "\n" &＃43; at2.toString()); } }

获取结果为&＃xff1a;

可以看到&＃xff0c;我们的两个StudentForNameAt对象分别被注入了Name和Context。

当然这只是其中一种方法&＃xff0c;还有一种方法就是自定义的Qualifier标识符。

&＃64;Qualifier 自定义标识符

&＃64;Qualifier标识符也是为了解决上面的问题&＃xff0c;我们来同时定义一下两个注解标识符&＃64;StudentForName和StudentForScore&＃xff1a;

&＃64;Qualifier //dagger Qualifier标识符 &＃64;Retention(RetentionPolicy.RUNTIME) //标识为运行时状态 public &＃64;interface StudentForName { }

&＃64;Qualifier &＃64;Retention(RetentionPolicy.RUNTIME) public &＃64;interface StudentForScore { }

定义一个StudentQualifier对象&＃xff0c;如下&＃xff1a;

public class StudentQualifier { private String name ; private int score ; public StudentQualifier(){ //空的构造器 name是Tom score是77 this.name &＃61; "Tom"; this.score &＃61; 77 ; } public StudentQualifier(String name , int score) { this.name &＃61; name; this.score &＃61; score; } &＃64;Override public String toString() { return "StudentQualifier{" &＃43; "name&＃61;&＃39;" &＃43; name &＃43; &＃39;\&＃39;&＃39; &＃43; ", score&＃61;" &＃43; score &＃43; &＃39;}&＃39;; } }

数据提供者Module为&＃xff1a;

&＃64;Module public class StudentQualifierModule { &＃64;Provides public String provideName(){ return "zhangsan" ; } &＃64;Provides public int provideScore(){ return 22 ; } &＃64;StudentForScore //默认构造器被&＃64;StudentForScore修饰 &＃64;Provides public StudentQualifier provideStudent(){ return new StudentQualifier(); } &＃64;StudentForName //有参构造器被&＃64;StudentForName修饰 &＃64;Provides public StudentQualifier provideStudentWithParams(String name , int score){ return new StudentQualifier(name,score); } }

然后在数据QualifierActivity接收器中&＃xff1a;

public class QualifierActivity extends AppCompatActivity { TextView tv; &＃64;StudentForName //被&＃64;StudentForName修饰&＃xff0c;按道理应该是调用了有参构造器 &＃64;Inject StudentQualifier qualifier1 ; &＃64;StudentForScore//这个就是无参数的 &＃64;Inject StudentQualifier qualifier2 ; &＃64;Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_second); tv &＃61; findViewById(R.id.id_tv_content); DaggerStudentQualifierComponent.builder().build().inject(this); } public void getStudentInfo(View v) { tv.setText(qualifier1.toString() &＃43; "\n" &＃43; qualifier2.toString()); } }

我们猜测一下结果&＃xff0c;qualifier1应该为zhangsan和22&＃xff1b;qualifier2应该为这Tom和77&＃xff0c;结果为&＃xff1a;

结果一致。

&＃64;PerApp and &＃64;PerActivity

我也不知道为什么&＃xff0c;上github上看dagger写的代码&＃xff0c;都少不了这个两个注解。如果理解了&＃64;Singleton注解的意义&＃xff0c;那么&＃64;PerApp和&＃64;PerActivity意义就差不多。上面已经说过&＃xff0c;一个App中只有一个Applicataion,那么我们可以定义一个注解&＃64;PerApp
生命周期可以与Application一致&＃xff0c;那么就可以理解为&＃64;PerApp修饰的方法&＃xff0c;提供的对象在全局范围是单例的&＃xff1b;如果定义一个&＃64;PerActivity,那么&＃64;PerActivity修饰的方法返回的对象&＃xff0c;生命周期是与Activity是一致的。举个例子吧&＃xff1a;
定义一个&＃64;AndroidPerApp

&＃64;Scope //这里是&＃64;Scope 注意不是&＃64;Qualifier &＃64;Documented //文档标记 &＃64;Retention(RetentionPolicy.RUNTIME) public &＃64;interface AndroidPerApp { }

再定义一个Module,此时有个方法被&＃64;AndroidPerApp修饰&＃xff1a;

&＃64;Module public class AndroidPerAppModule { private Context context; public AndroidPerAppModule(Context context) { this.context &＃61; context ; } &＃64;Provides &＃64;AndroidPerApp //标记该方法只产生一个实例该实例的生命周期与绑定的Context生命周期一致 public Context provideContext(){ return context; } }

此时我们的AndroidPerAppComponent

&＃64;AndroidPerApp//AndroidPerAppModule有方法被&＃64;AndroidPerApp修饰那么此时AndroidPerAppComponent也要被&＃64;AndroidPerApp修饰 &＃64;Component(modules &＃61; AndroidPerAppModule.class) public interface AndroidPerAppComponent { /** * 向下提供Context * &＃64;return */ Context getContext(); }

此时&＃xff0c;既然是AppComponent&＃xff0c;那么需要与App绑定了&＃xff1a;

public class MyApp extends Application{ //这里使用静态的因为MyApp全局就一个 static AndroidPerAppComponent component ; &＃64;Override public void onCreate() { super.onCreate(); component &＃61; DaggerAndroidPerAppComponent.builder().androidPerAppModule(new AndroidPerAppModule(this)).build(); } public static AndroidPerAppComponent getAppComponent(){ return component; } }

那么我们可以全局调用MyApp.getAppComponent()了&＃xff0c;这个等会再用&＃xff0c;现在再来顶一个&＃64;PerActivity&＃xff1a;

&＃64;Scope &＃64;Documented &＃64;Retention(RetentionPolicy.RUNTIME) public &＃64;interface AndroidPerActivity { }

在AndroidPerActivityModule中&＃xff0c;Activity生命周期范围内&＃xff0c;返回的数据是单例的&＃xff0c;其实是和&＃64;Singleton作用是一致的&＃xff0c;它并没有像市面上说的&＃xff0c;具有和Activity相同生命周期的说法。

&＃64;Module public class AndroidPerActivityModule { &＃64;AndroidPerActivity &＃64;Provides public Student provideStudent(){ return new Student(); } }

然后最重要的是PerActivityComponent了&＃xff1a;

&＃64;AndroidPerActivity &＃64;Component(modules &＃61; AndroidPerActivityModule.class, dependencies &＃61; AndroidPerAppComponent.class) public interface AndroidPerActivityComponent { void inject(AndroidAnnotationActivity activity); }

在AndroidAnnotationActivity中&＃xff1a;

public class AndroidAnnotationActivity extends AppCompatActivity { &＃64;Inject Student st1 ; &＃64;Inject Student st2; TextView tv ; &＃64;Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_second); tv &＃61; findViewById(R.id.id_tv_content); //直接使用App.getAppComponent()获取全局的AppComponent对象 DaggerAndroidPerActivityComponent.builder().androidPerAppComponent(MyApp.getAppComponent()).build().inject(this); } public void getStudentInfo(View v) { //Toast.makeText(this, "---->>" &＃43; MyApp.getAppComponent(), Toast.LENGTH_SHORT).show(); tv.setText(st1.toString() &＃43; "--\n--" &＃43; st2.toString()); } }

我们此时开看一下st1和st2的结果&＃xff1a;

可以看出&＃xff0c;它们在AndroidAnnotationActivity范围内是单例的&＃xff0c;这个和&＃64;Singleton注解是一致的。工作中我们会用到&＃64;PerApp&＃xff0c;它解决了我们全局需要Context的问题。

Lazy 和 Provider

根据词义&＃xff0c;Lazy相当于我们懒加载机制&＃xff0c;调用了本方法才会去加载&＃xff0c;没有调用就不加载&＃xff1b;Provider很类似&＃64;Provides注解&＃xff0c;但是它在的含义是每次调用都会去重复调用Module被&＃64;Provides修饰的方法。举个例子&＃xff1a;
定义一个对象类型StudentOther&＃xff1a;

public class StudentOther { private String name ; private int score ; private String address ; //初始化过程中会使用random对象以此来模拟是否为重复创建 public StudentOther(Random random) { this.name &＃61; "zhansgan" &＃43; random.nextDouble() ; this.score &＃61; random.nextInt(200); this.address &＃61; "shanghai" &＃43; random.nextGaussian(); } &＃64;Override public String toString() { return "StudentOther{" &＃43; "name&＃61;&＃39;" &＃43; name &＃43; &＃39;\&＃39;&＃39; &＃43; ", score&＃61;" &＃43; score &＃43; ", address&＃61;&＃39;" &＃43; address &＃43; &＃39;\&＃39;&＃39; &＃43; &＃39;}&＃39;; } }

定义一个OtherActivityModule对象&＃xff0c;提供了Random方法&＃xff0c;还有两个&＃64;StudentForName和&＃64;StudentForScore注解修饰的方法&＃xff1a;

&＃64;Module public class OtherActivityModule { public Random random ; public OtherActivityModule(){ random &＃61; new Random(); } &＃64;Provides public Random provideRandom(){ return random; } &＃64;StudentForName &＃64;Provides public StudentOther provideStudentOther(Random random){ return new StudentOther(random); } &＃64;StudentForScore &＃64;Provides public StudentOther provideStudentOtherWidth(Random random){ return new StudentOther(random); } }

在数据接收器OtherActivity中&＃xff0c;如下&＃xff1a;

public class OtherActivity extends AppCompatActivity { &＃64;StudentForScore &＃64;Inject Lazy other; &＃64;StudentForName &＃64;Inject Provider other2 ; TextView tv; &＃64;Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_second); tv &＃61; findViewById(R.id.id_tv_content); DaggerOtherActivityComponent.builder().build().inject(this); } public void getStudentInfo(View v){ StudentOther innerOther &＃61; other.get(); //调用该方法时才会去创建 StudentOther innerOther2 &＃61; other2.get(); //调用该方法时才会去创建&＃xff0c;但是每次都会重新加载Module中的方法返回值有可能相同也有可能不同 tv.setText(innerOther.toString() &＃43; "---\n---" &＃43; innerOther2.toString()); } }