Dagger 2 基本使用,局部单例,全局单例

主要讲解以下几点:

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

Dagger 2 基本使用,局部单例,全局单例_第1张图片
举个例子

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

    }
}
Dagger 2 基本使用,局部单例,全局单例_第2张图片
2019-04-29 22:30.png

Dagger 2 基本使用,局部单例,全局单例_第3张图片
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));

    }
}
Dagger 2 基本使用,局部单例,全局单例_第4张图片
pic1.png

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


Dagger 2 基本使用,局部单例,全局单例_第5张图片
pic2.png

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

Dagger 2 基本使用,局部单例,全局单例_第6张图片
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));
    }
}
Dagger 2 基本使用,局部单例,全局单例_第7张图片
Screenshot_2019-05-05-13-24-41.png

再看一个新的activity的结果


Dagger 2 基本使用,局部单例,全局单例_第8张图片
Screenshot_2019-05-05-13-24-41.png

两个actiivty的地址是一样的,这样就实现全局单利啦~


Dagger 2 基本使用,局部单例,全局单例_第9张图片
3.jpg

github地址: https://github.com/Mchunyan/DaggerTest

------------------------THE END---------------------

你可能感兴趣的:(Dagger 2 基本使用,局部单例,全局单例)