Dagger2学习笔记1(基础概念学习)
Dagger2学习笔记2(学习Dagger2的简单使用)
Dagger2学习笔记3(各个注解学习)
Dagger2学习笔记4(@Singleton 与@ Scope 实现全局单例与作用域单例)
之前的学习中我们了解了Dagger2的大部分使用方法, 接下来学习Lazy, Provide的使用.
Lazy和Provide可以用来包装我们需要注入的依赖, Lazy为懒加载模式, 用到的时候才会依赖, 加载过一次之后就会只使用之前的实例, 而Provide为强制加载, 每次调用都会强制重新加载.
定义一个可以提供flower, dog和car的module, 都没有使用singleton或者scope注解
@Module
public class MainModule {
@Provides
Flower provideFlower(){
Log.d("mainmodule", "new flower");
return new Flower();
}
@Provides
Dog providerDog(){
Log.d("mianmodule","new dog");
return new Dog();
}
@Provides
Car provideCar(){
Log.d("mainmodule", "new car");
return new Car();
}
}
public class MainActivity extends AppCompatActivity {
@Inject
Flower flower;
@Inject
Provider<Dog> dog;
@Inject
Lazy<Car> car;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
DaggerMainComponent.builder().mainModule(new MainModule()).build().inject(this);
}
}
先什么都不做, 只是声明注入对象, 分别使用普通注入, Provider包装, Lazy包装. 控制台输出结果:
09-19 17:39:52.598 23914-23914/com.example.Dagger D/mainmodule: new flower
可以看到普通注入只要声明就会被初始化, 而使用Provider和Lazy包装的并没有进行初始化, 接下来我们分别对这些不同对象调用两次:
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
DaggerMainComponent.builder().mainModule(new
MainModule()).build().inject(this);
flower.toString();
flower.toString();
Log.e("mainactivity", "--------------");
dog.get();
dog.get();
Log.e("mainactivity", "--------------");
car.get();
car.get();
}
控制台输出:
09-19 17:47:39.042 851-851/? D/mainmodule: new flower
09-19 17:47:39.043 851-851/? E/mainactivity: --------------
09-19 17:47:39.043 851-851/? D/mianmodule: new dog
09-19 17:47:39.044 851-851/? D/mianmodule: new dog
09-19 17:47:39.044 851-851/? E/mainactivity: --------------
09-19 17:47:39.044 851-851/? D/mainmodule: new car
可以看到使用Provider包装的dog, 每次调用都会重新获取新的实例, 而使用普通注入和使用Lazy包装都使用的是用一个实例, 从而也就能看出各自的区别.
以上为依赖没有使用Singlton或者Scope限定单例范围, 接下来我们限定单例, 看看结果如何, 修改Module文件:
@Module
public class MainModule {
@Singleton
@Provides
Flower provideFlower(){
Log.d("mainmodule", "new flower");
return new Flower();
}
@Singleton
@Provides
Dog providerDog(){
Log.d("mianmodule","new dog");
return new Dog();
}
@Singleton
@Provides
Car provideCar(){
Log.d("mainmodule", "new car");
return new Car();
}
}
在运行得到结果:
09-19 17:52:25.668 5048-5048/? D/mainmodule: new flower
09-19 17:52:25.669 5048-5048/? E/mainactivity: --------------
09-19 17:52:25.669 5048-5048/? D/mianmodule: new dog
09-19 17:52:25.670 5048-5048/? E/mainactivity: --------------
09-19 17:52:25.670 5048-5048/? D/mainmodule: new car
我们看到, 当限定局部单例之后, 无论是Provider还是Lazy, 在同一个activity中只会获取同一个依赖对象.
我们已经学习了Dagger的各种使用, 接下来会对Dagger的实现原理进行学习!
End~
