Dagger2的无参构造inject的一些思考

今天写这个demo的时候发现很奇怪的一点，在MainActivity里依赖的MainPresenter需要用inject并且其构造方法里也需要inject同时component里需要inject这个MainActivity，就像这样：
MainActivity（注意“关键1”）

public class MainActivity extends AppCompatActivity implements MainView{

    @Inject
    MainPresenter mainPresenter;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        DaggerMyComponent.builder().build().inject(this);//关键1
        mainPresenter.getData();
    }

    @Override
    public void onSuccess() {

    }
}

MainPresenter:

public class MainPresenter {

    MainRepotority mainRepotority;

    @Inject
    public MainPresenter() {

    }

    public void getData(){
        Log.d("lwp","调用成功");
       // mainRepotority.fuckSs();
    }
}

我们知道component提供依赖，所以我们看到在需要提供MainPresenter的地方我们inject了该对象。但是我现在的mvp中MainPresenter需要一个model来进行具体逻辑计算，因此定义一个MainRepotority，按照之前的想法，需要在component里提供一个inject(MainPresenter presenter)这样的方法，但是事实上，我们只需要两个inject即可：
MainPresenter

public class MainPresenter {

    @Inject
    MainRepotority mainRepotority;

    @Inject
    public MainPresenter() {

    }

    public void getData(){
        Log.d("lwp","调用成功");
       // mainRepotority.fuckSs();
    }
}

MainRepotority:

public class MainRepotority {

    @Inject
    public MainRepotority() {
    }
    public void fuckSs(){
        Log.d("MainRepotority","MainRepotority fuckss");
    }
}

我觉得很奇怪，带着问题去看了下dagger生成的类文件：
我们对比下这个生成的component类文件在加入MainRepotority之前和之后的区别:
之前：

package com.liwenpeng.dagproject;

public final class DaggerMyComponent implements MyComponent {
  private DaggerMyComponent(Builder builder) {}

  public static Builder builder() {
    return new Builder();
  }

  public static MyComponent create() {
    return new Builder().build();
  }

  @Override
  public void inject(MainActivity mainActivity) {
    injectMainActivity(mainActivity);
  }

  private MainActivity injectMainActivity(MainActivity instance) {
    MainActivity_MembersInjector.injectMainPresenter(instance, new MainPresenter());
    return instance;
  }

  public static final class Builder {
    private Builder() {}

    public MyComponent build() {
      return new DaggerMyComponent(this);
    }
  }
}

之后：

package com.liwenpeng.dagproject;

public final class DaggerMyComponent implements MyComponent {
  private DaggerMyComponent(Builder builder) {}

  public static Builder builder() {
    return new Builder();
  }

  public static MyComponent create() {
    return new Builder().build();
  }

  private MainPresenter getMainPresenter() {
    return injectMainPresenter(MainPresenter_Factory.newMainPresenter());
  }

  @Override
  public void inject(MainActivity mainActivity) {
    injectMainActivity(mainActivity);
  }

  private MainPresenter injectMainPresenter(MainPresenter instance) {
    MainPresenter_MembersInjector.injectMainRepotority(instance, new MainRepotority());
    return instance;
  }

  private MainActivity injectMainActivity(MainActivity instance) {
    MainActivity_MembersInjector.injectMainPresenter(instance, getMainPresenter());
    return instance;
  }

  public static final class Builder {
    private Builder() {}

    public MyComponent build() {
      return new DaggerMyComponent(this);
    }
  }
}

可以看到加入后多出来的两个方法:

  private MainPresenter getMainPresenter() {
    return injectMainPresenter(MainPresenter_Factory.newMainPresenter());
  }

  private MainPresenter injectMainPresenter(MainPresenter instance) {
    MainPresenter_MembersInjector.injectMainRepotority(instance, new MainRepotority());
    return instance;
  }

既然这样，我想到之后我调用无参的构造方法都不用component注入了？于是我新建了一个SecondActivity

public class SecondActivity extends AppCompatActivity {

    @Inject
    SecondPresenter secondActivity;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_second);
        secondActivity.testSecondActivity();
    }
}

SecondPresenter

public class SecondPresenter {
    @Inject
    public SecondPresenter() {
    }
    public void testSecondActivity(){
        Log.d("second","testSecondActivity");
    }
}

然后从MainActivity跳转，报了空指针，我们再看这个生成的component类文件

public final class DaggerMyComponent implements MyComponent {
  private DaggerMyComponent(Builder builder) {}

  public static Builder builder() {
    return new Builder();
  }

  public static MyComponent create() {
    return new Builder().build();
  }

  private MainPresenter getMainPresenter() {
    return injectMainPresenter(MainPresenter_Factory.newMainPresenter());
  }

  @Override
  public void inject(MainActivity mainActivity) {
    injectMainActivity(mainActivity);
  }

  private MainPresenter injectMainPresenter(MainPresenter instance) {
    MainPresenter_MembersInjector.injectMainRepotority(instance, new MainRepotority());
    return instance;
  }

  private MainActivity injectMainActivity(MainActivity instance) {
    MainActivity_MembersInjector.injectMainPresenter(instance, getMainPresenter());
    return instance;
  }

  public static final class Builder {
    private Builder() {}

    public MyComponent build() {
      return new DaggerMyComponent(this);
    }
  }
}

还是没变化，因此能得出结论：Activity/fragment类别的即使是无参的构造也要重新调用daggerYourcomponentinject，但是其他类别像时自定义的类，就不用，直接inject即可