Dagger2 2.38 简单使用

1.概念

dagger2 主要用于解决复杂项目的对象依赖关系。也叫依赖注入，如：butterKnife 也属于依赖注入。

1.编译时生产 各个对象的类，通过工厂式封装的形式关联对象之间的依赖关系
2.使用注解形式，简单

1.1 注解

1.@Inject

两个作用，一是用来标记需要依赖的变量，二是用来标记构造函数。

2.@Module

用于标注提供依赖的类。该类主要提供多个对象的创建方式。因为有时候我们需要第三方里的对象，但是我们无法直接拿到。

3.@Provides

提供某个对象的创建方式。 用于标注Module所标注的类中的方法

  	@Provides
    public User getUser(){
        return new User("li----dan");
    }

4.@Component

标注接口，是依赖需求方和依赖提供方之间的桥梁。
注入对象和被依赖对象之间，需要中间过程。有component来通信。
Component标注的接口在编译时会生成该接口的实现类

5.@Qulifier

用于自定义注解。

我们在使用@Module来标注提供依赖的方法时，方法名我们是可以随便定义的（虽然我们定义方法名一般以provide开头，但这并不是强制的，只是为了增加可读性而已）。那么Dagger2怎么知道这个方法是为谁提供依赖呢？

答案就是返回值的类型

@Qualifier
@Retention(RetentionPolicy.RUNTIME)
public @interface QualifierA { }
@Qualifier
@Retention(RetentionPolicy.RUNTIME)
public @interface QualifierB { }



@Module
public class MarkCarModule {

    public MarkCarModule(){ }

    @QualifierA
    @Provides
    Engine provideEngineA(){
        return new Engine("gearA");
    }

    @QualifierB
    @Provides
    Engine provideEngineB(){
        return new Engine("gearB");
    }
}

//调用方
public class Car {

    @QualifierA @Inject Engine engineA;
    @QualifierB @Inject Engine engineB;

6.@Scope

我能可以通过@Scope自定义的注解来限定注解作用域，实现局部的单例；

7 @Singleton

修饰类。被singleTon修饰的类属于单例模式。

2.使用

implementation 'com.google.dagger:dagger:2.38'
annotationProcessor 'com.google.dagger:dagger-compiler:2.38'

public class User {
    String name;

    public User(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

public class DaggerPresenter {

    MainActivity activity;

    User user;
    
    public DaggerPresenter(MainActivity activity, User user) {
        this.activity = activity;
        this.user = user;
    }

    public void showName(){

        activity.showName(user.getName());
    }
}

AppModule.class

/**
 * 模块为了维护各个对象  activity user  Presenter对象
 *  1、如何创建？
 *  2、对象之间的关系？
 *
 *  3、注意Provides注解，是提供对象实例的创建方法
 */
@Module
public class AppModule {


    MainActivity activity;
    User user;


    public AppModule(MainActivity activity) {
        this.activity = activity;
    }

    @Provides
    public MainActivity getActivity(){

        return activity;
    }

    @Provides
    public User getUser(){

        return new User("li----dan");
    }

    @Provides
    public DaggerPresenter daggerPresenter(MainActivity activity,User user){

        return new DaggerPresenter(activity,user);
    }
}

/**
 * 桥梁作用，是界面组件和映射关系的桥梁
 * modules  配置AppModule.class 说明需要哪些对象的创建。
 */
@Component(modules = AppModule.class)
public  interface AppComponent {

    void inject(MainActivity activity);
}

MainActivity.class

public class MainActivity extends AppCompatActivity {

    //创建当前对象的时候，也会创建该实例对象，不能私有

    @Inject
    DaggerPresenter daggerPresenter;
    private TextView mText;

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

        //模块对象
        AppModule appModule = new AppModule(this);
        //注入dagger的依赖关系
        //DaggerAppComponent 是按照规则生成的名字
        DaggerAppComponent.builder().appModule(appModule)
                .build()
                .inject(this);


        initViews();

        //调用presenter的方法
        daggerPresenter.showName();

    }

    public void showName(String name) {

        mText.setText(name);
    }

    private void initViews() {
        mText = findViewById(R.id.text);
    }
}

参考：https://zhuanlan.zhihu.com/p/24454466
https://blog.csdn.net/Jet_Green/article/details/80996657