Dagger2学习笔记5(关于Lazy,Provide的使用)

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;

    @Inject
    Lazy 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~