Dagger之初体验

我才20出头

背景

举个例子：我们在写面向对象程序时，往往会用到组合，即在一个类中引用另一个类，从而可以调用引用的类的方法完成某些功能,就像下面这样.

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);