主要讲解以下几点:
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());
}
}
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));
}
}
看吧,三个猴子的地址是一样的,这是局部单例哦,如果你把猴子在一个新的activity里面,在打印地址,你会发现,两个activity的猴子地址是不一样的。
注意:单利对象只能在同一个Activity中有效。不同的Activity 持有的对象不同,所以就要来说说下面的全局单例了, 使用@Singeton注解或者定制的@Scope的, 只在同一个activity(或者fragment)的一个生命周期中保持单例
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));
}
}
再看一个新的activity的结果
两个actiivty的地址是一样的,这样就实现全局单利啦~