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~