背景
举个例子：我们在写面向对象程序时，往往会用到组合，即在一个类中引用另一个类，从而可以调用引用的类的方法完成某些功能,就像下面这样.
public class ClassA {
...
ClassB b;
...
public ClassA() {
b = new ClassB();
}
public void do() {
...
b.doSomething();
...
}
}
这个时候就产生依赖问题，ClassA依赖于ClassB，为了生成ClassA对象必须要先生成一个ClassB对象。这还是一层，如果ClassB又需要C对象才能创建，那么我们就会发现生成一个ClassA对象既要创建ClassB也要创建C，显的很乱。
一个：在ClassA里直接创建ClassB实例，违背了单一职责原则，ClassB实例的创建不应由ClassA来完成
再一个：其次耦合度增加，扩展性差，我们在实例化ClassB的时候又要传入参数ClassC，那么不得不改动ClassA的构造方法，不符合开闭原则。
现在使用依赖注入，实现代码层面：ClassB直接注入ClassA，而不需要ClassC的体现。具体生成通过Dagger第三方代码为我们生成，降低了耦合
好处（大书特书）
- 减少运行时组件之间的耦合（可是我写代码好麻烦啊）
- 等我再去抄
gradle依赖
compile 'com.google.dagger:dagger:2.15'
annotationProcessor 'com.google.dagger:dagger-compiler:2.15'
以mvp框架为例
先列出契约类
public interface MainContract {
interface IMainPresenter{
void showAlert();
}
interface IMainView{
void showToast();
}
}
（1）因为 MainPresenter需要注入MainActivity
所以在MainActivity中的mainpresenter的成员变量上面注解一个@inject，对应的在mainpresenter的构造函数注解一个，表示我是从这里开始创建的。
（因为mainpresenter的构造函数需要activity来作为参数，所以需要在mainactivity的构造函数也添加@inject,但是因为其是Androidsdk代码，无法修改，所以创建mainpresenter时需要的mainactivity需要用module类来提供）
这句话一定要参照Dagger前传看，否则极其容易看不懂
此时还不是真正的完成依赖注入。
public class MainActivity extends AppCompatActivity implements MainContract.IMainView{
@Inject
MainPresenter mPresenter;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
DaggerMainComponent.builder()
.mainModule(new MainModule(this))
.build()
.inject(this);
}
public void show(View view) {
mPresenter.showAlert();
}
@Override
public void showToast() {
Toast.makeText(this,"hi",Toast.LENGTH_SHORT).show();
}
}
public class MainPresenter implements MainContract.IMainPresenter{
private MainContract.IMainView view;
@Inject
public MainPresenter(MainContract.IMainView view) {
this.view = view;
}
@Override
public void showAlert() {
view.showToast();
}
}
（2） 我们通过第三者（module类）来生成mainpresenter，在这里提供所需要注入的东西。或许这就是解耦吧
注意module类需要要用@module注解
@Module
public class MainModule {
private MainActivity view;
public MainModule(MainActivity view) {
this.view = view;
}
//这个方法提供的是mainpresent，如果你用了inject标记了有参构造函数，你的形参必须对应
//@Inject
// public MainPresenter(MainContract.IMainView view) {
// this.view = view;
// }
@Provides
MainPresenter provideMainPresenter(MainActivity view){
return new MainPresenter(view);
}
//这种写法错误
//@Provides
// MainPresenter provideMainPresenter(){
// return new MainPresenter(view);
// }
//此时在这里提供
@Provides
MainActivity provideIMainView(){
return view;
}
}
这里有一些注意点
- @Provides表示“提供”的注解。因为我们本来就需要把mainpresent注入进界面，需要在这里面我们需要提供provideMainPresenter()这个方法。而且行参数不能为IMainView，必须是具体的类MainActivity，否则会出错。
- 方法名前缀需要为provideXXX，后面xxx随意，就像eventbus一样，是靠返回值来识别是否调用该方法而不是名字
有个问题
为什么我们有了providepresenter()，还需要provideImainview()，这个好像不需要。其实这个方法返回值是给providepresenter()做参数的用。（ 我试过providerpresenter()不用参数，new的时候传入成员变量view，发现报错。）所以这也可以看出 Dagger在Module中的执行也具备递归性。（如果是基础类型的话，就好像不需要提供了）
（3）到这里，presenter只是生成了,需要通过Component类，来实现连接。
需要用注解@component，因为我们是需要注入界面，所以添加一个方法 void inject（mainactivity activity），名字随意，以形参识别。而mainactivity需要从mainmodule提供，所以加上(modules=MainModule.class)
返回到上面，只要inject需要的参数，都需要在module类中提供一个providexxx来提供参数。
@Component(modules=MainModule.class)
public interface MainComponent {
void inject(MainActivity activity);
}
（3）make project 生成代码，并且调用
DaggerMainComponent.builder()
.mainModule(new MainModule(this))
.build()
.inject(this);
