“一盘沙拉”带你入门Dagger2（五）之 @Scope

系列文章

“一盘沙拉”带你入门Dagger2（一）之HelloWorld

“一盘沙拉”带你入门Dagger2（二）之带参数怎么办

“一盘沙拉”带你入门Dagger2（三）之@Qualifier

“一盘沙拉”带你入门Dagger2（四）之 @Singleton

“一盘沙拉”带你入门Dagger2（五）之 @Scope

像上文所说我们要让苹果、梨使用同一把刀，让香蕉使用另外一把刀，开始吧

1. 在Dagger2中，我们可以通过自定义Scope来实现局部单例。
   首先让我们先来定义一个局部作用域：

   /**
    * 自定义一个作用域
    */
   @Scope
   @Retention(RetentionPolicy.RUNTIME)
   public @interface KnifeScope {
   }

2. 在Module里使用 @KnifeScope，

   /**
    * 在Module里使用 @KnifeScope，
    * 指定目前这个Module的使用范围
    */
   @Module
   public class KnifeMofule {
   
       @KnifeScope
       @Provides
       public Knife provideKnife(){
           Knife knife = new Knife();
           return knife;
       }
   }
   

3. 在Component里使用@KnifeScope

   /**
    * 在Component里使用@KnifeScope，
    * 与之前的KnifeModule相呼应，
    * 指明目前这个Component的使用范围
    */
   @KnifeScope
   @Component(modules = KnifeMofule.class)
   public interface KnifeComponent {
   //    注意：这里我们只inject了苹果和梨，说明我们要把KnifeModule
   //    所建立的实例，注入到苹果、梨里（而不注入到香蕉里）
       void  inject(Apple apple);
       void  inject(Pear pear);
   }

4. 创建MyApp，别忘了清单文件注册，使用MyApp来获取，唯一的KnifeComponent

   public class MyApp extends Application{
   //这里不一定非得使用static，由于我注入的不是Activity，无法用getApplication来得到MyApp的对象（否则还得传入一个Activity），所以为了方便，使用了静态。
       private static KnifeComponent knifeComponent;
   
       @Override
       public void onCreate() {
           super.onCreate();
   //        为了实现局部共享一个实例，
   //        我们需要在Application里，首先得到knifeComponent的实例
   //        由于Application的onCreate方法，在应用程序里面，只运行一次
   //        所以只得到了一个knifeComponent
   //       （后面我们通过getKnifeComponent来得到这唯一的一个getKnifeComponent）
   //        ok，我们之后会通过这个唯一的KnifeComponent来得到他所连接的KnifeModule
   //        所提供的Knife的实例，再把这个实例注入到苹果、梨里面去，从而实现了苹果、梨
   //        会共享这个实例。
   //        而香蕉里的Knife，我们要重新建立一个Module和Component来获取Knife的新实例
   //        这样就实现了Knife的实例，在苹果、梨之间局部共享，而香蕉使用的是另外一个实例
           knifeComponent = DaggerKnifeComponent
                   .builder()
                   .knifeMofule(new KnifeMofule())
                   .build();
       }
   
       public  static  KnifeComponent getKnifeComponent() {
           return knifeComponent;
       }
   }
   

5. 把Knife注入到苹果、梨里面

   public class Apple {
       @Inject
       Knife knife;
   
       public Apple() {
           MyApp.getKnifeComponent().inject(this);
           Log.e("knife", "苹果里的knife内存地址：" + knife.toString());
       }
   

   public class Pear {
       @Inject
       Knife knife;
       public Pear(){
           Log.e("TAG", "我是一个梨");
           MyApp.getKnifeComponent().inject(this);
   
           Log.e("knife", "梨里的knife内存地址："+knife.toString());
       }
   }

6. 测试：内存地址是一样的，证明使用的是同一个实例。

   E/knife: 苹果里的knife内存地址：com.demo.dagger2demo2.Knife@16e3e55f
   E/knife: 梨里的knife内存地址：com.demo.dagger2demo2.Knife@16e3e55f

如何让香蕉用另一把刀呢，很简单煎饼果子来一套即可（在写一套Module和Component）

1. Module

   @Module
   public class KnifeForBananaModule {
       @Provides
       public Knife provideKnife(){
           Knife knife = new Knife();
           return knife;
       }
   }
   

2. Component

   @Component(modules = KnifeForBananaModule.class)
   public interface KnifeForBananaComponent {
       void inject(Banana banana);
   
   }

3. 注入到香蕉里

   public class Banana {
       @Inject
       Knife knife;
   
       public Banana() {
           KnifeForBananaComponent knifeForBananaComponent = DaggerKnifeForBananaComponent.builder().knifeForBananaModule(new KnifeForBananaModule()).build();
           knifeForBananaComponent.inject(this);
           Log.e("knife", "kinfe在香蕉中的内存地址：" + knife.toString());
       }
   }

4. 测试：苹果和梨使用了同一个Knife的实例，而香蕉使用了另一把Knife的实例，实现了局部共享实例啦

   E/knife: 苹果里的knife内存地址：com.demo.dagger2demo2.Knife@336e5075
   E/knife: 梨里的knife内存地址：com.demo.dagger2demo2.Knife@336e5075
   E/knife: kinfe在香蕉中的内存地址：com.demo.dagger2demo2.Knife@10ac0fa3

   下一篇文章，说说Component之间的依赖关系