Dagger2 的使用
一、Dagger2 是什么
Dagger2是第一个实现用生成的代码实现完整堆栈的库。指导原则是生成代码，该代码模仿用户可能手写的代码，以确保注入尽可能的简单，可追踪和高效。
一、Dagger2 的使用
Dagger 是通过 @Inject使用具体的某个对象，这个对象是有@Provides注解提供，但是，这个@Provides只能在固定的模块中，也就是@Module注解，我们查找的时候，不是直接去找模块，而是去找@Component
正常我们在类中使用其他类，都是 new 示例对象，如下：
//先定义一个User
public class User {
private String userName;
private int age;
}
//我们在 Activity 中使用的时候
public class MainActivity extends AppCompatActivity {
User user;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
user = new User();
}
}
加入后期对象构造方法改变，就会导致需要同步改相应的 new 代码，这样就会增加维护成本，还会一不小心产生 bug，Dagger 就是为了解决此类问题而生
开始使用Dagger2
- 引入依赖库
compile 'com.google.dagger:dagger:2.x'
annotationProcessor 'com.google.dagger:dagger-compiler:2.x'
- 创建 Module
//添加module 注解
@Module
public class MainModule {
}
- 使用Provides实例化对象
//添加module 注解
@Module
public class MainModule {
//使用provides实例化对象
@Provides
User provideUser(){
return new User();
}
}
- 创建 Component
@Component(modules = {MainModule.class})
public interface MainComponent {
void inject(MainActivity mainActivity);
}
- Rebuild Project
然后AS会自动生成两个文件
1537778156672.jpg
6）在 Activity 中使用 User
public class MainActivity extends AppCompatActivity {
@Inject User user;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//第一种关联方式
DaggerMainComponent.builder().build().inject(this);
//第二种关联方式
DaggerMainComponent.create().inject(this);
}
}
三、高级用法
模块之间的依赖关系
1）include
@Module (includes = {BModule.class})// 表示Modele包含BModule
2）一个Component 应用多个 module
@Component(modules = {AModule.class,BModule.class})
- dependencies 依赖其他Component
@Component(modules = {MainModule.class}, dependencies = AppConponent.class)
@Named 使用
相当于都是同一个类，不同Named标记的产生的实例类不同
在Module中定义
@Module
public class MainModule {
//使用provides实例化对象
@Named("A")
@Provides
User provideUserA(){
return new User();
}
@Named("B")
@Provides
User provideUserB(){
return new User();
}
}
在Activity中定义
public class MainActivity extends AppCompatActivity {
@Named("A")
@Inject User userA;
@Named("B")
@Inject User userB;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
DaggerMainComponent.create().inject(this);
Log.i("TAG", "userA =="+ userA);
Log.i("TAG", "userB =="+ userB);
}
}
Log打印
09-24 17:09:39.612 14992-14992/? I/TAG: userA ==xl.app.User@f335b59
userB ==xl.app.User@e89331e
@Singleton 单例
简单示例
//第一，在module中需要单例的对象上添加 @Singleton
@Module
public class MainModule {
@Singleton
@Provides
User provideUser(){
return new User();
}
}
//在Component添加 @Singleton
@Singleton
@Component(modules = {MainModule.class})
public interface MainComponent {
void inject(MainActivity mainActivity);
}
//使用
@Inject User userA;
@Inject User userB;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
DaggerMainComponent.create().inject(this);
Log.i("TAG", "userA =="+ userA);
Log.i("TAG", "userB =="+ userB);
}
//Log打印
TAG: userA ==xl.app.User@f335b59
userB ==xl.app.User@f335b59
这是我们再建一个Activity，使用这个单例
@Singleton
@Component(modules = {MainModule.class})
public interface MainComponent {
void inject(MainActivity mainActivity);
void inject(SubActivity subActivity);
}
public class MainActivity extends AppCompatActivity {
@Inject User user;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
DaggerMainComponent.create().inject(this);
Log.i("TAG", "MainActivity user =="+ user);
}
}
public class SubActivity extends AppCompatActivity {
@Inject
User user;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_sub);
DaggerMainComponent.create().inject(this);
Log.i("TAG", "SubActivity user =="+ user);
}
}
//Log 打印
TAG: MainActivity user ==xl.app.User@fcc3200
TAG: SubActivity user ==xl.app.User@43f5bbf
结果发现不是同一个对象了，这时候如果想要一个全局的单例，就需要自定义Scoped
自定义Scoped
/**
* @作者 ： allens
* @创建日期 ：2017/7/14 下午3:04
* @方法作用：
* 参考Singleton 的写法
* Scope 标注是Scope
* Documented 标记在文档
* @Retention(RUNTIME) 运行时级别
*/
@Scope
@Documented
@Retention(RUNTIME)
public @interface ActivityScoped {
}
Subcomponent
这个是系统提供的一个Component，当使用Subcomponent,那么默认会依赖Component
@Subcomponent(modules = TestSubModule.class)
public interface TestSubComponent {
void inject(MainActivity activity);
}
=========
@Component(modules = {MainModule.class})
public interface MainConponent {
TestSubComponent add(TestSubModule module);
}
lazy 和 Provider
其中Lazy(懒加载)的作用好比component初始化了一个present对象,然后放到一个池子里,需要的时候就get它,所以你每次get的时候拿到的对象都是同一个;并且当你第一次去get时,它才会去初始化这个实例.
procider(强制加载)的作用:
- 同上当你第一次去get时,它才会去初始化这个实例
- 后面当你去get这个实例时,是否为同一个,取决于他Module里实现的方式
参考:https://www.jianshu.com/p/2cd491f0da01