主要讲解以下几点：

1、简单介绍 Dagger 2
2、简单的基本使用方法
3、创建局部单例
4、创建全局单例
5、Dagger 2 ＋ MVP （下一篇文章写，不然篇幅有点长）
Dagger 2 与MVP的简单使用

此项目github地址: https://github.com/Mchunyan/DaggerTest

1、简单介绍Dagger 2 ？

1、 dagger2 是什么？
　答：是一个依赖注入框架，由google 维护。
2、什么事依赖注入？
　答：依赖注入是一种面向对象的编程模式，它的出现是为了降低耦合性，所谓耦合就是类之间依赖关系，所谓降低耦合就是降低类和类之间依赖关系。
3、为什么使用 dagger 2 ？
　答：降低类与类之间的耦合度。
.....
dagger 2官网：https://github.com/google/dagger

2、简单的基本使用方法

2.1、先介绍几个注解的关键字：
　@Inject
　　1、给属性做标记时，说明了它是一个依赖需求方，需要一些依赖，被标注的属性不能使用private修饰，否则无法注入。
　　2、给构造方法进行注解时，表明了它能提供依赖的能力。
　　3、给方法进行注解。
　　ps：方法注入和属性注入基本上没有区别，那么什么时候应该使用方法注入呢？
　　　比如该依赖需要this对象的时候，使用方法注入可以提供安全的this对象，因为方法注入是在构造　器之后执行的。
　@Component
　　1、相当于联系纽带，将 @inject 标记的需求方和依赖绑定起来，并建立了联系，而 Dagger2 在编译代码时会依靠这种关系来进行对应的依赖注入。
　@Provides
　　1、本身的字面意思就是提供，显然在 Dagger2 中它的作用就是提供依赖。
　@Module
　　1、模块的意思，Dagger2 中规定，用 @Provides 注解的依赖必须存在一个用 @Module 注解的类中。
　@Singleton
　　1、注解一个类表明该类的创建采用的是单例模式，其会被多个线程共同使用
　@Scope
　　1、作用域，也就是表达一种能力的范围。
2.2 工作流程：
　　Dagger 是通过@Inject使用具体的某个对象，这个对象呢，是由@Provides注解提供，但是呢，这个@Provides只能在固定的模块中，也就是@Module注解，我们查找的时候，不是直接去找模块，而是去找@Component

举个例子

2.3 基本使用：
2.3.1 依赖：

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

2.3.2 创建一个AppleBean的实体类：

public class AppleBean {
    private String color="红色";

    private String testApple() {
        return "苹果的默认颜色是："+color;
    }
}

2.3.3 创建Module：

@Module//提供依赖对象的实例
public class AppleModule {

    @Provides // 关键字，标明该方法提供依赖对象AppleBean
    AppleBean providesApple() {
        return new AppleBean();
    }
}

2.3.4 创建一个Component

@Component(modules = AppleModule.class)// 作为桥梁，沟通调用者和依赖对象库
public interface AppleComponent {
    void join(MainActivity mainActivity);//写一个方法 绑定Activity /Fragment(调用者)
}

2.3.5 MainActivity

public class MainActivity extends AppCompatActivity {
    private TextView textView;
    @Inject
    AppleBean appleBean;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        textView = findViewById(R.id.textView);
        DaggerAppleComponent.builder().build().join(this);//方式一
//        DaggerAppleComponent.create().join(this);//方式二
        appleBean.testApple();

    }
    
    public void 基本使用(View view) {
        textView.setText(appleBean.testApple());

    }
}

以上就可以使用啦，当然了，那是 AppleBean无构造方法 的情况，我们再来看看 有构造方法的情况 的情况：
2.3.2有参 AppleBean的实体类：
为了兼容上面无参的调用方法，显示的写了无参的构造方法，不然编译器就报错的啦~~

public class AppleBean {
    private String color = "红色";

    public AppleBean() {
    }

    public AppleBean(String color) {
        this.color = color;
    }

    public String testApple() {
        return "苹果的默认颜色是：" + color;
    }
}

2.3.3有参创建Module：
这里有引入了一个新的注解@Named() 相当于有个表示，虽然大家都是同一个对象，但是实例化对象不同

@Module//提供依赖对象的实例
public class AppleModule {
    private String color;

    public AppleModule() {
        //这个是为了兼容方式一和方式二
    }

    public AppleModule(String color) {
        //这个有参数的方式
        this.color = color;
    }

    @Named("appleA")
    @Provides
    AppleBean providesAppleA() {
        return new AppleBean();
    }

    @Named("appleB")
    @Provides
    AppleBean providesAppleB() {
        return new AppleBean(color);
    }
}
}

2.3.4有参创建一个Component
这个和上面一样的没变化

@Component(modules = AppleModule.class)// 作为桥梁，沟通调用者和依赖对象库
public interface AppleComponent {
 void join(MainActivity mainActivity);//写一个方法 绑定Activity /Fragment(调用者)
}

2.3.5有参 MainActivity
方式一和方式二：是无参的使用方法，虽然也可以调用有参的方法，但是颜色那里是null。
有参数方式：是调用有参的构造方法，可兼容方式一和方式二的无参方法。

public class MainActivity extends AppCompatActivity {
    private TextView textView;
    @Named("appleA")
    @Inject
    AppleBean appleBeanA;
    @Named("appleB")
    @Inject
    AppleBean appleBeanB;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        textView = findViewById(R.id.textView);
//        DaggerAppleComponent.builder().build().join(this);//方式一
//        DaggerAppleComponent.create().join(this);//方式二
        DaggerAppleComponent.builder().appleModule(new AppleModule("青色")).build().join(this);//有参数方式


    }

    public void 基本使用(View view) {
        textView.setText(appleBeanA.testApple() + "\n" +appleBeanB.testApple());

    }
}

2019-04-29 22：30.png

1.jpg

3、创建局部单例

为了不混淆用法，上面用AppleBean，单例用MonkeyBean
3.1 创建MonekyBean类

public class MonkeyBean {
    private String name;

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

3.2 创建Module
单例哈，用@Singleton来表示，提供一个单例对象

@Module
public class MonkeyModule {
    @Singleton
    @Provides
    MonkeyBean providesMonkeyA() {
        return new MonkeyBean("花花猴子");
    }
}

3.3 创建Component
注意：如果 moudule所依赖的Comonent 中有被@Singleton单利的对象，那么Conponnent也必须是单利的@Singleton

@Singleton
@Component(modules = MonkeyModule.class)
public interface MonkeyComponent {
    void join(MonkeyActivity monkeyActivity);
}

3.4 MonkeyActivity

public class MonkeyActivity extends AppCompatActivity {
    private TextView textView;
    @Inject
    MonkeyBean monkeyBeanA;
    @Inject
    MonkeyBean monkeyBeanB;
    @Inject
    MonkeyBean monkeyBeanC;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_monkey);
        textView = findViewById(R.id.textView);
        DaggerMonkeyComponent.create().join(this);
    }

    public void 点击查看单例(View view) {
        textView.setText("猴子一号:" + monkeyBeanA.hashCode() + "\n"
                + "猴子二号:" + monkeyBeanB.hashCode() + "\n"
                + "猴子三号:" + monkeyBeanC.hashCode() + "\n");
    }

    public void 点击下一页(View view) {
        startActivity(new Intent(this, StudentActivity.class));

    }
}

pic1.png

看吧，三个猴子的地址是一样的，这是局部单例哦，如果你把猴子在一个新的activity里面，在打印地址，你会发现，两个activity的猴子地址是不一样的。

pic2.png

注意：单利对象只能在同一个Activity中有效。不同的Activity 持有的对象不同，所以就要来说说下面的全局单例了, 使用@Singeton注解或者定制的@Scope的, 只在同一个activity(或者fragment)的一个生命周期中保持单例

2.jpg

4、创建全局单例

DaggerMonkeyComponent在两个activity中被各自被实例化一次, 导致产生了两个不同的对象, 所以我们需要做到让Component能够实现单例, Android中, 我们知道在整个App生命周期中都只有一个Appclication实例,所以在Application中获得一个唯一的component实例, 用它来提供我们需要的单例:
4.1 创建StudentBean类
只是创建一个空的类,目的是答应这个类的地址,没做别的业务.

public class StudentBean {
}

4.2 创建BaseModule
这是个单利的写法,和上面的money那个是一样的哈

@Module
public class BaseModule {
    @Singleton
    @Provides
    StudentBean providesStudent() {
        return new StudentBean();
    }
}

4.3 创建BaseComponent
这个和普通的Componet就一样好哈, BaseComponent中不再需要写inject方法,因为这个component是用来让别的component来依赖的, 只需要告诉别的component他可以提供哪些类型的依赖即可.

@Singleton
@Component(modules = BaseModule.class)
public interface BaseComponent {
    StudentBean getSingletonStudent();
}

4.4 创建自己定义application,并且提供一个唯一的baseComponent类

public class MyApplication extends Application {

    private BaseComponent baseComponent;

    @Override
    public void onCreate() {
        super.onCreate();
        baseComponent = DaggerBaseComponent.create();
    }

    public BaseComponent getBaseComponent() {
        return baseComponent;
    }
}

4.5 自定义了一个Scope

如果依赖的component(BaseComponent )中也使用了@singleton时, 被依赖(下面的StudentComponet)的地方就不能使用了,只能自定义一个.

/**
 * Scope 标注是Scope
 * @Retention(RUNTIME) 运行时级别
 */
@Scope
@Retention(RetentionPolicy.RUNTIME)
public @interface BaseScope {
}

4.6 创建StudentModule
这里是个空的,这个就是自己自定义业务了.

@Module
public class StudentModule {

}

4.7 创建StudentComponet
在我们自己的Component, 使用dependencies依赖于baseComponent, (在@Component注解参数中, 可以依赖多个module和component, 根据自己的业务需求定义即可.)

@BaseScope
@Component(modules = StudentModule.class, dependencies = BaseComponent.class)
public interface StudentComponet {
    void join(StudentActivity studentActivity);
    void join(Student2Activity student2Activity);
}

4.8 创建 StudentActivity

public class StudentActivity extends AppCompatActivity {
    private TextView textView;

    @Inject
    StudentBean studentBeanA;
    @Inject
    StudentBean studentBeanB;
    @Inject
    StudentBean studentBeanC;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_student);
        ((TextView) findViewById(R.id.text)).setText("第一个界面");
        textView = findViewById(R.id.textView);
        DaggerStudentComponet.builder().baseComponent(((MyApplication) getApplication()).getBaseComponent()).build().join(this);
    }

    public void 点击全局单例(View view) {
        textView.setText("学生A:" + studentBeanA.hashCode() + "\n"
                + "学生B:" + studentBeanB.hashCode() + "\n"
                + "学生C:" + studentBeanC.hashCode() + "\n");
    }

    public void 下一个全局单例(View view) {
        startActivity(new Intent(this, Student2Activity.class));
    }
}