和很多自主学习的人不一样,我接触Dagger 2 框架的原因是刚进公司的时候导师给安排的学习任务,学习方式是组内培训。

听到这个消息的我,以为是部门的人轮流给我讲课。

后来导师跟我说,组内培训的意思是,我先自己好好学这个框架,然后给组内的所有人搞个培训。

没办法,在网上看了很多相关博客,浪费了不少时间,终于还是学有所得,也记录一下我最近的学习进展。

就不多讲什么历史了,你能看到我这篇博客,想来历史什么的科普你都已经被塞到吐了,还是撸代码学得快。

一 环境配置

在module的build.gradle中添加代码:

dependencies {
......
//dagger2
implementation 'com.google.dagger:dagger:2.7'
annotationProcessor 'com.google.dagger:dagger-compiler:2.7'
//butterknife
implementation 'com.jakewharton:butterknife:10.0.0'
annotationProcessor 'com.jakewharton:butterknife-compiler:10.0.0'
}

为了后面书写代码简便,将ButterKnife一起配置了。

在Project build.gradle中添加如下代码(这段代码是配置ButterKnife使用的,不配置可能就会报TimeOut的错误):

allprojects {
repositories {
google()
maven { url "https://oss.sonatype.org/content/repositories/snapshots" }
jcenter()
}
}

到这里配置就完成了,ButterKnife可以为我们省下很多代码,因为ButterKnife和Dagger的厂家是一样的,很多地方也是共通的,就不多解释原理,拿来就用。

二 源码分析

     我们先创建一个简单的Tools类:

public class Tools {
@Inject
public Tools(){}
}

不需要任何属性,只用@Inject标记一个空的构造方法,然后我们使用Ctrl+F9进行编译。

Dagger2 是通过标记来公式化编写代码,减轻我们重复编写代码的劳动。

这里提到个词“公式化”,其实很好理解。

比如,你要给你给你喜欢的女孩子表白,先跟你寝室兄弟们排练一百遍表白流程。到了女寝楼下,你清一清嗓子,就有人给你打好了灯光,你叫完女孩的名字,身后就有人放飞了粉红的爱心气球,你刚说完那羞羞的三个字,周围就全是大声呼喊“答应他、答应他......”

女孩十分感动,然后拒绝了你......

咳咳,讲偏了!

总之,公式化的东西就是这样,固定好的流程,你只需要打个特殊的手势,别人就知道该怎么做。为什么?因为流程都是公式化的,固定的,已经跑过千百次了,大家闭着眼睛都能敲出来。在程序里也是这样,不要重复造轮子。你只需要打个标记,就像上面提到的@Inject,剩下的繁琐的任务交给喜欢重复劳动的计算机。

那么,看到@Inject这个标记,计算机又做了什么呢?

编译过后会发现build中多了一个文件(你要问我路径在哪?后面我带你找,听我的,慢慢来!),叫做Tools_Factory类,内容如下:

public enum Tools_Factory implements Factory<Tools> {
INSTANCE; @Override
public Tools get() {
return new Tools();
} public static Factory<Tools> create() {
return INSTANCE;
}
}

这就是AS自动生成的代码。一个工厂类,类如其名,就是个工厂。通过create()方法进行创建,通过get()方法获得new Tools对象。

下面我就贴四大基本组件的代码了,先把框架搭起来:

首先是MainActicity:

public class MainActivity extends AppCompatActivity {

    @Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
ButterKnife.bind(this);//ButterKnife绑定Activity } @OnClick({R.id.turn_firstactivity})
public void onViewClicked(View view) {
switch (view.getId()){
case R.id.turn_firstactivity:
startActivity(new Intent(this, FirstActivity.class));
break;
}
}
}

就简简单单一个跳转,跳转到我们接下来要使用的FirstActivity中。

贴一下activity_main这个layout,平时我看博客最讨厌别人不把代码贴完,我当然不会犯这个错。

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical">
<Button
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:id="@+id/turn_firstactivity"
android:text="四大基本组件"/>
</LinearLayout>

接下来是FirstActivity,也就是我们第一个例子的主要Activitypublic class FirstActivity extends AppCompatActivity

    @BindView(R.id.fist_text_1)    TextView text1;
@BindView(R.id.fist_text_2) TextView text2; @Inject Tools tool1;
@Inject Tools tool2; @Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.first);
ButterKnife.bind(this);//绑定View和Activity
}
}

代码很好理解,用ButterKnife来直接绑定View和Activity,节省了很多代码,而节省的代码也是前面提到“公式化”的体现。

以及对应的layout的代码。

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"> <TextView
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:id="@+id/fist_text_1"
/> <TextView
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:id="@+id/fist_text_2"
/> </LinearLayout>

我们再新建接口FirstComponent:

@Component
public interface FirstComponent { void inject(FirstActivity activity); }

这个方法名inject可以随意改写,但是为了方便后来人阅读,建议你还是按照约定俗成的规矩来写,让后来接手你代码的人少骂你两句。

到这一步,我们需要先Ctrl+F9编译一下了。因为有个文件需要Dagger2自动生成后,我们才能使用。

接下来在FirstActivity中添上代码:

    protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.first);
ButterKnife.bind(this); DaggerFirstComponent.builder()
.build()
.inject(this);
text1.setText(tool1.toString());
text2.setText(tool2.toString());
}

这个多的文件就是DaggerFirstComponent.java,可以Ctrl+鼠标左键点击DaggerFirstComponent跳转到这个文件查看。

前面找不到自动生成文件在哪的,可以再点击一下这个像准星一样的图标,自动定位到对应的文件夹。

这个文件就是Dagger+Component的名字组合出来的,实际上也是继承了Component接口对其中的方法进行重写。

DaggerFirstComponent代码如下:

public final class DaggerFirstComponent implements FirstComponent {
private MembersInjector<FirstActivity> firstActivityMembersInjector; private DaggerFirstComponent(Builder builder) {
assert builder != null;
initialize(builder);
} public static Builder builder() {
return new Builder();
} public static FirstComponent create() {
return builder().build();
} @SuppressWarnings("unchecked")
private void initialize(final Builder builder) { this.firstActivityMembersInjector =
FirstActivity_MembersInjector.create(Tools_Factory.create());
} @Override
public void inject(FirstActivity activity) {
firstActivityMembersInjector.injectMembers(activity);
} public static final class Builder {
private Builder() {} public FirstComponent build() {
return new DaggerFirstComponent(this);
}
}
}

很明显的Builder建造者模式。

再反观一下Activity中对DaggerFirstComponent的调用

        DaggerFirstComponent.builder()
.build()
.inject(this);

首先在里面先初始化一个Builder类,然后调用Builder类中的build()方法对DaggerFirstComponent进行构造。

DaggerFirstComponent构造函数中,有个initialize的初始化函数,给DaggerFirstComponent持有的一个内部成员firstActivityMembersInjector赋值。

注意这行代码:

    this.firstActivityMembersInjector = FirstActivity_MembersInjector.create(Tools_Factory.create());

这又涉及到一个关键的文件,记住后缀MembersInjector就行了。

可能有的小伙伴就要问,为啥我不一次性把所有的自动生成文件都列出来?

按照逻辑一步步来,这样比较好理解。

这也是最后一个了:一个工厂类Factory、一个接口实现类DaggerComponent、加上组装类MemberInjector(如果你看见第四个,可能是ButterKnife生成的,有兴趣可以看看)

为啥要把MemberInject叫做组装类,听我慢慢讲来。

MemberInject.java源代码太长了,先只看create()

  private final Provider<Tools> tool1AndTool2Provider;

  public FirstActivity_MembersInjector(Provider<Tools> tool1AndTool2Provider) {
assert tool1AndTool2Provider != null;
this.tool1AndTool2Provider = tool1AndTool2Provider;
} public static MembersInjector<FirstActivity> create(Provider<Tools> tool1AndTool2Provider) {
return new FirstActivity_MembersInjector(tool1AndTool2Provider);
}

大概意思就是先传进来一个工厂类Factory.create(),前面讲过,工厂类就俩方法:create()和get()。然后把create好的工厂类赋给MemberInject类里的成员变量,大概就是把工厂类构建好,保存起来备用。

到这里我们就已经build()跑完了。捋一捋现在都干了啥,DaggerFirstComponent这个类调用了Factory.create(),然后把它给了MemberInject,自己保存了一个MemberInject的实例。到了这步,其实返回的还是个Component,然后继续执行Component里已有的方法而已。

注意这点,到这里返回的是个Component!划重点,后面要考的。

如果你看代码足够认真可能会注意到,DaggerFirstComponent中有个create()方法,对应的就是builder().build()。意味着依赖注入的代码可以简写成下面这种形式:

        DaggerFirstComponent.create().inject(this);

没错,确实可以这样,但强烈不建议这样写。划重点,强烈不建议!

因为不符合开闭原则,原因后面会讲到。

DaggerFirstComponent类继承了FirstComponent接口,重写了inject方法:

  @Override
public void inject(FirstActivity activity) {
firstActivityMembersInjector.injectMembers(activity);
}

可以看到Inject方法只是给MemberInject的实例传了个Activity。

MemberInject都被喂了哪些东西?

工厂类create好了送进去,Activity也给它了。

为啥叫它组装类!看代码:

    instance.tool1 = tool1Provider.get();

instance是Activity的实例,通过Activity找到之前声明的依赖注入实例tools,然后在工厂类实例tool1Provider中get()一个新的对象赋值给它。

东西都是DaggerFirstComponent给它准备好的,他只负责组装。

到这里,整个依赖注入全部完成。

运行结果如下:

注入两个不同的Tools。

回顾一下,其实逻辑很简单。

1、在需要注入依赖的Activity中,用@Inject标记所注入的依赖类的实例tools

2、在所需呀注入的类Tools的构造函数Tools()上标记@Inject,编译会根据此生成Factory工厂类

3、在接口FirstComponent上标记@Component,并写入Inject方法

4、编译生成DaggerFirstComponent.java

5、调用DaggerFirstComponent方法将工厂类的实例和Activity的实例都交给MemberInjecter

6、MemberInjecter组装完成,依赖成功注入。

等等,四大基本组件怎么只讲了两个?

因为两个就已经能基本完成一个简单的依赖注入了,下一章接着讲工厂类的另一种构成方法。

Dagger2 探索记1——四大基本组件(一)的更多相关文章

  1. Dagger2 探索记2——四大基本组件(二)

    书接上文,先回顾以下前一章写的内容. 内容大概就是在Activity中用@Inject标记一个注入的类,然后在这个类的构造函数上也打个@Inject标记,然后使用@Component来连接两边,完成对 ...

  2. Dagger2 探索记3——两大进阶组件(一)

    今天要讲的时@Scope这个组件.为什么说它是进阶组件,就是因为它基本上没作用,但在理解了基本组件之后又必须用到. Scope的意思是作用域,一般用来标记@Provide方法,将生成的对象单例化.但@ ...

  3. Android四大基本组件介绍与生命周期

    Android四大基本组件介绍与生命周期 Android四大基本组件分别是Activity,Service服务,Content Provider内容提供者,BroadcastReceiver广播接收器 ...

  4. 17.(转) Android之四大基本组件介绍与生命周期

    Android四大基本组件分别是Activity,Service服务,Content Provider内容提供者,BroadcastReceiver广播接收器. 一:了解四大基本组件 Activity ...

  5. Android基础_1 四大基本组件介绍与生命周期

    Android四大基本组件分别是Activity,Service(服务),Content Provider(内容提供者),BroadcastReceiver(广播接收器). 一.四大基本组件 Acti ...

  6. Android四大基本组件

    Android四大基本组件分别是 Activity:整个应用程序的门面,负责与用户进行交互. Service:承担大部分工作. Content Provider内容提供者:负责对外提供数据,并允许需要 ...

  7. android开发3:四大基本组件的介绍与生命周期

    android开发3:四大基本组件的介绍与生命周期 Android四大基本组件分别是Activity,Service服务,Content Provider内容提供者,BroadcastReceiver ...

  8. 【转】Android四大基本组件介绍与生命周期

    转自:http://www.cnblogs.com/bravestarrhu/archive/2012/05/02/2479461.html Android四大基本组件分别是Activity,Serv ...

  9. android拾遗——四大基本组件介绍与生命周期

    Android四大基本组件分别是Activity,Service服务,Content Provider内容提供者,BroadcastReceiver广播接收器. 一:了解四大基本组件 Activity ...

随机推荐

  1. vs2013 在按F5调试时,总是提示 “项目已经过期”的解决方案

    这个是由于缺少某些文件(如.h,xxx.icon),或者文件时间不对 引起的. 如图在工具选项设置 最小为 “诊断”. 然后编译一下,会提示 xxx过期,确认下即可.

  2. js及jquery常用代码

    1.获取屏幕尺寸 document.documentElement.scrollWidth; document.documentElement.scrollHeight; $(window).widt ...

  3. zabbix自发现item监控

    在zabbix监控中,我们可以通过自带item的可以和自定义key进行监控,但是当所需要的监控项不确定,比如key会根据时间进行变化时,这时候我们就不能把item的key定义死,要通过自发现这个高级功 ...

  4. Cause: java.lang.NumberFormatException: For input string: "D"

    异常:Cause: java.lang.NumberFormatException: For input string: "D" 问题回显: 原因分析:'D'只有1位,被认为是ch ...

  5. Python模块之ncclient

    一.简介 此模块是是netconf协议的客户端,可与netconf服务端进行交互 二.实验环境 1.操作系统:win10 2.python版本:python3.6.6 3.ncclient模块版本:0 ...

  6. Jetbrains好用的插件(经验总结)

    # Jetbrain好用的插件(经验总结) 笔者使用过idea,phpstorm,webstorm,pycharm和goland开发过项目,不得不说,Jetbrains的编辑器每一款都挺好用的,而且快 ...

  7. 记录一则LOCAL_LISTENER的问题

    有网友反映,他在一套Oracle的测试环境中配置有两个监听,分别监听不同端口. 目前想把环境上的一套数据库同时注册到这两个监听,他将数据库参数local_listener和tnsname.ora文件配 ...

  8. TensorFlow Slim 的常用操作

    https://blog.csdn.net/mzpmzk/article/details/81706379

  9. [WPF自定义控件库] 关于ScrollViewr和滚动轮劫持(scroll-wheel-hijack)

    1. 什么是滚动轮劫持 这篇文章介绍一个很简单的继承自ScrollViewer的控件: public class ExtendedScrollViewer : ScrollViewer { prote ...

  10. 基于随机游走的三维网格分割算法(Random Walks)

    首先以一维随机游走(1D Random Walks)为例来介绍下随机游走(Random Walks)算法,如下图所示,从某点出发,随机向左右移动,向左和向右的概率相同,都为1/2,并且到达0点或N点则 ...