android dagger2 注入mvp架构

dagger2简单应用用一个mvp架构来做例子
apt编译时生成代码
apt自动生成代码 再为dagger2提供注入

本博客说的是采用dagger2来搭建一个简单的mvp架构
文章分这么几个部分。

1. 首先是说下mvp的架构
2. 然后是 dagger的使用
3. 最后是采用dagger2完成注入搭建mvp架构

由于重点是dagger2.网络部分不做封装了，一般都是采用rxjava+retrofit。这个需要结合自己实际情况，不是一套后台，封装的也是不一样的。

第一部分mvp架构

mvp估计大家都很清楚，我就不废话。这里采用简化的view 和presenter ，项目实在用不到m层。。activity 和fragment负责ui， presenter 负责加载数据，网络请求，然后加载完数据通过接口回掉给 activity 和fragment。这样就 是一个简单的mvp架构。减轻了activity压力

第二部分dagger2使用简单介绍

dagger2的原理和详细已经有很多文章写的很好了。我这就简单说下怎么用就好了。
首先有这么几个东西，Component Module 和scope。这三个东西 是一套完整的注入。application级别的Component 需要在application里面初始化，activity级别的需要在activity里面初始化，fragment同activity一样

首先引入包

    compile 'com.google.dagger:dagger:2.7'
    provided   'com.google.dagger:dagger-compiler:2.6.1'

Scope Module Component

• 先说最简单的scope

scope是用来标注作用范围，作用域，在provider方法写上，这个注解
application一般是全局单例模式的，所以Socope用dagger2自带的Singleton就好了
其他的 Socope自己定义就好，比如activity 的

@Scope
public @interface ActivityScope {
}

就是这么简单。

• 说完scope创建Module

modeule作用就是创建你的实例。依赖注入也要有地方来创建你的实例才行吧，对就是module。
Module其实是一个简单工厂模式，Module里面的方法基本都是创建类实例的方法。 但是 ，自己的类不是三方的，可以不用创建，只需要你把需要实例化的对象的构造方法 用inject标注，module里面一个方法用Provides 来标注，那么这个方法返回值就是 inject标注的构造方法的参数，dagger2会自己初始化这个被inject标注的构造方法看个例子

@Module
public class TestModule {
 

    public TestModule(Activity a) {
    
    }

    @Provides
    @ActivityScope//自定义的soupe
    public String provideBindMobActivity() {
        return new String("xx"); 
    
    }

public class Student {
    private String name;

    @Inject
    public Student(String name) {
        this.name = name;
    }
}

最后是使用

@inject
Student xiaoming；

就有有一个xiaoming的student实例了。

总结一下就是 ，新建一个module需要添加类注解module，这样dagger2就知道这是一个module了。
student的构造接受string 而module里面的provider方法正好返回一个string。这样就可以匹配上，不需要写new就能实例化一个student。

• 最后的就是Component
  是不是好奇，module怎么和inject关联的。就是通过component这个中间件来建立连接的。
  来看例子

@ActivityScope
@Component(modules = TestModule.class)
public interface Testcomponent {
    void inject(Activity a)
}

规则就是这样，先是一个scope的作用域，这个与你module上的provider方法的那个scope是对应的。然后是这类是一个接口，
采用Component 把module和inject来进行了关联。对就是这样。 接口有个inect方法，来进行activity注入

dagger2 就是这样。简单了解下。下面就是dagger2和mvp的结合，后面会给出代码

dagger2 和mvp结合

上面的mvp架构，需要new new new 采用dagger2依赖注入厚，不需要在new。
首先是dagger2的app级别的初始化。还是分三个部分
Module

@Module
public class AppModule {
    private Application application;
    public AppModule(Application application) {
        this.application = application;
    }
   
}

Component

@Singleton
@Component(modules = AppModule.class)
public interface Appcomponent {

}

以及注入初始化代码。 app级别的当然在application里面出初始化

public class MyApplication extends Application {
    private static MyApplication mInst;
    private Appcomponent mAppcomponent;
    @Override
    public void onCreate() {
        super.onCreate();
        mInst = this;
        mAppcomponent = DaggerAppcomponent.     //Dagger +自己定义的component名字
                builder()
                .appModule(new AppModule(this))  // 自己定义的App级别Module的名字
                .build();
    }
    public static MyApplication getInst() {
        return mInst;
    }

    public Appcomponent getAppComponent() {
        return mAppcomponent;
    }

}

完成app级别的初始化，就可以继续activity级别的。 还是三部分

module 的构造接受一个activity，然后provider直接返回

@Module
public class ActivityModule {
    BaseMVPActivity activity;

    public ActivityModule(BaseMVPActivity activity) {
        this.activity = activity;
    }
    @Provides
    @ActivityScope
    public BaseMVPActivity provideBindMobActivity() {
        return activity;
   

这个 的 Component dependencies了一个app的，这点像继承关系，可以用app里面的，自己的是 ActivityModule。

@ActivityScope
@Component(dependencies = Appcomponent.class,
        modules = ActivityModule.class)
public interface Activitycomponent {

    void inject(MainActivity activity);

 //    可以公用一个Component
//    void inject(SecondActivity activity);
    
//    void inject(Tread activity);
}

最后一步是初始化注入 在activity自然写在activity里面

这里写在抽象父类里面

public abstract class BaseMVPActivity<P extends BasePresenter> extends AppCompatActivity implements BaseMvpViewInterface {

    @Inject//与Presenter 构造的方法的inject注解对应。自动注入
    protected P mvpPresenter;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        initInject(DaggerActivitycomponent.builder()
                .appcomponent(MyApplication.getInst().getAppComponent())
                .activityModule(new ActivityModule(this))
                .build());
        mvpPresenter.attachView(this);
    }
    protected abstract void initInject(Activitycomponent activityComponent);

    @Override
    protected void onDestroy() {
        super.onDestroy();
        if (mvpPresenter != null) {
            mvpPresenter.detachView();
        }
    }
}

public class MainActivity extends BaseMVPActivity<MainAcPresenter> implements MainAcView {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mvpPresenter.loadData();
    }

    @Override
    protected void initInject(Activitycomponent activityComponent) {
        activityComponent.inject(this);
    }

    @Override
    public void loadSucess(String string) {
        Toast.makeText(this, string, Toast.LENGTH_SHORT).show();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        mvpPresenter.detachView();
    }
}

抽象父类个抽象方法，来注入子类，用inject标注的preseter就不需要在new了。

就是这个样子。每当新建mvp的activity也不需要过过多操作，
只要实现一下 父类抽象方法，注入一下就可以了。

demo地址 https://github.com/836154942/simpledaggermvp