Dagger2 探索记3——两大进阶组件(一)

       今天要讲的时@Scope这个组件。为什么说它是进阶组件，就是因为它基本上没作用，但在理解了基本组件之后又必须用到。

       Scope的意思是作用域，一般用来标记@Provide方法，将生成的对象单例化。但@Scope不能直接使用，需要先实现。默认实现有@Singleton。

一 局部单例

       话说千百句，不如码二行。

       直接上代码，就不在原来的代码上改了，另起一个Activity，命名为SecondActivity。

public class SecondActivity extends AppCompatActivity {
    @BindView(R.id.second_text_1)    TextView text1;
    @BindView(R.id.second_text_2)    TextView text2;
    @BindView(R.id.second_text_3)    TextView text3;
    @BindView(R.id.second_text_4)    TextView text4;

    @Inject    Coffee coffee1;
    @Inject    Coffee coffee2;
    @Inject    Tools tool1;
    @Inject    Tools tool2;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.second);
        ButterKnife.bind(this);

        SecondComponent component = DaggerSecondComponent.builder()
                .secondModule(new SecondModule())//添加Module
                .build();

        coffee1 = component.coffee();
        coffee2 = component.coffee();
        tool1 = component.tools();
        tool2 = component.tools();

        text1.setText(coffee1.toString());
        text2.setText(coffee2.toString());
        text3.setText(tool1.toString());
        text4.setText(tool2.toString());
    }
}

       然后是Layout命名为second。

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <TextView
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:id="@+id/second_text_1"
        />

    <TextView
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:id="@+id/second_text_2"
        />

    <TextView
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:id="@+id/second_text_3"
        />

    <TextView
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:id="@+id/second_text_4"
        />

</LinearLayout>

        工具用过了，这次我们改喝Coffee。

public class Coffee {
    public Coffee(){};
}

        其实没啥变化，主要是不和之前的代码混淆，影响理解。

        时刻记住，一个阶段结束了，就要换个起点重新开始。

        下面是Module和Component：

@Module
public class SecondModule {

    @Singleton
    @Provides
    Coffee provideCoffee(){
        return new Coffee();
    }

    @Provides
    Tools provideTools(){
        return new Tools();
    }
}

@Singleton
@Component(modules = SecondModule.class)
public interface SecondComponent {
    Coffee coffee();

    Tools tools();
}

          细心的小伙伴看完这些代码就会发现，这次的Component里面，没有写inject()方法！

          没错，记得我前面说过，在使用inject()方法之前，返回的是一个Component。

          还标了是考点，不记得的小伙伴重修一遍第一章。

          所以这次是手动调用Component中的方法来进行赋值。

          最后在MainActivity中加个跳转Button，layout我就不贴了，代码看多了容易脱发。

    @OnClick({R.id.turn_firstactivity,R.id.turn_secondactivity})
    public void onViewClicked(View view) {
        switch (view.getId()){
            case R.id.turn_firstactivity:
                startActivity(new Intent(this, FirstActivity.class));
                break;
            case R.id.turn_secondactivity:
                startActivity(new Intent(this, SecondActivity.class));
                break;
        }
    }

          是不是突然发现了ButterKnife的好处，简化了很大一部分代码，直接依靠id设置点击事件，不用管是不是Button。

          来我们好好看看DaggerComponen中变化的源码。

  private void initialize(final Builder builder) {

    this.provideCoffeeProvider =
        DoubleCheck.provider(SecondModule_ProvideCoffeeFactory.create(builder.secondModule));

    this.provideToolsProvider = SecondModule_ProvideToolsFactory.create(builder.secondModule);
  }

  @Override
  public Coffee coffee() {
    return provideCoffeeProvider.get();
  }

  @Override
  public Tools tools() {
    return provideToolsProvider.get();
  }

        重写了Component中的两个方法，并各自对应上了相应的工厂类的实例，直接return get()方法。

        运行一下，发现结果是

        两个用@Singleton标记了@Provide的Coffee实例的哈希地址一致，因为是同一个对象。(有兴趣的小朋友可以更改一个类的成员变量，看看另一个会不会变。)

        @Singleton就是这个用处，叫做局部单例。注意，不是全局单例，只在同一个Activity中是相同的，跨Activity就不同了。

        注意用@Singleton标记的@Provide的@Module绑定@Component时，@Component也要标记@Singleton，表示@Component中有@Singleton单例方法。

        这句话很绕，多看几遍就懂了。

        至于单例是怎么实现的，我们看看源码。

    this.provideCoffeeProvider =
        DoubleCheck.provider(SecondModule_ProvideCoffeeFactory.create(builder.secondModule));

    this.provideToolsProvider = SecondModule_ProvideToolsFactory.create(builder.secondModule);

       问题就出在这个DoubleCheck上面，有兴趣的朋友可以去看看DoubleCheck的实现源码，我太懒了，懒得讲。

       那么，既然@Singleton是局部单例，怎么实现全局单例呢？接下来就来讲。

二 全局单例

       前面说过，@Scope是作用区域，我们使用的是在Activity中实例化，所以是在Activity中局部单例。那么全局单例就得在Application中实例化。

       我们先写个自己的Application来注入依赖。

public class MyApplication extends Application {

    private static GlobalComponent component;

    @Override
    public void onCreate() {
        super.onCreate();

        component = DaggerGlobalComponent.builder()
                .globalModule(new GlobalModule())
                .build();
    }

    GlobalComponent get(){
        return component;
    }
}

         因为重写了Application，需要在Manifiest中把它添加进去

    <application
        android:name="MyApplication"
        ......
    </application>

        给全局的Application注入，前面写的很清楚了，后面直接贴代码。

        再来个类Global，全球化一点。

public class Global {
    public Global(){};
}

        Component：

@Component(modules = GlobalModule.class)
public interface GlobalComponent {

    Global global();

}

         Module：

@Module
public class GlobalModule {

    @Provides
    Global provideGlobal(){
        return new Global();
    }

}

       如果前面好好听讲了的同学，现在应该已经能看懂了。我们在MyApplication中注入了一个Component的实例，并写了个get()方法来获取它。

       后续需要就直接获取MyApplication中的Component实例即可。

       例如前面的SecondActivity怎么注入Global实例呢？仅仅需要在SecondComponent中依赖GlobalComponent即可，可以理解为继承。

       看代码！

@Singleton
@Component(modules = SecondModule.class,dependencies = GlobalComponent.class)
public interface SecondComponent {
    void inject(SecondActivity activity);
}

      在括号中用dependence即可，这里我要特别说一点. 我说完了。

      可能又有细心的盲僧发现了华点。没错，怎么又改回用inject了？难道dependence就必须用inject方法吗？

      先表扬一下这位同学，观察很细致。

      答案是：不是。只是我懒得在后面写代码了。

      改回来多方便，前面是为了给你们演示才特意写了一下。像我这么懒的人自然是怎么简单怎么来。

      SecondActivity也改了，记得要编译，不然会标红。

public class SecondActivity extends AppCompatActivity {
    @BindView(R.id.second_text_1)    TextView text1;
    @BindView(R.id.second_text_2)    TextView text2;
    @BindView(R.id.second_text_3)    TextView text3;
    @BindView(R.id.second_text_4)    TextView text4;

    @Inject    Coffee coffee1;
    @Inject    Coffee coffee2;
    @Inject    Global global1;
    @Inject    Global global2;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.second);
        ButterKnife.bind(this);

        DaggerSecondComponent.builder()
                .globalComponent(new MyApplication().get())
                .secondModule(new SecondModule())//添加Module
                .build()
                .inject(this);

        text1.setText(coffee1.toString());
        text2.setText(coffee2.toString());
        text3.setText(global1.toString());
        text4.setText(global2.toString());
    }
}

         把之前的参照组改成了实验组，实验组改成了参照组。(上过初中生物的理科生应该懂。)

         因为绑定了SecondMoudle所以调用secondMoudle，这次继承了GlobalComponent，自然也要调用，输入参数是Component。

         跑一下就能发现，global注入进去了。

         但是，很明显不是单例。因为我们还没有给它变形。

         好了，敲黑板，别低头看书了，都看我，我要开始变形了。

         先讲一下要点。@Scope不能直接用，我们之前用的是默认实现的一个@Singleton，先看看它的源码。

@Scope
@Documented
@Retention(RUNTIME)
public @interface Singleton {}

          我们自己也来设置一个：

@Scope
@Documented
@Retention(RUNTIME)
public @interface MyScope {
}

         很简单对不对？照着抄就好了，就改了个名字。

         要是爱情也这么简单就好了。

         现在是动手时间，把SecondModule和SecondComponent中的@Singleton替换成@MyScope，然后跑一遍，看看结果是不是一样的。

         我去上个厕所......

         跑好的同学，去给GlobalModule和GlobalComponent中加上@Singleton。再跑一遍。

         一般上课都是这样，前三十分钟老师讲课，后十五分钟学生做练习。

         我写些代码，你们也要练一下。

         让我猜猜，有些调皮的同学，趁着老师上厕所没回来的时间，偷偷看了后面的练习题，想要偷个懒。

         于是很省力的，直接把@MyScope加在了GlobalModule和GlobalComponent里面。

         然后就报错了。

错误: This @Singleton component cannot depend on scoped components:
@com.yuanxixing.dagger2.MyScope com.yuanxixing.dagger2.GlobalComponent

         必须先表扬这一批同学，选择了少有人走的路。

         哪怕是错的，也只是发现了一条不可行的方法！

         确实，这是一个隐藏的成就。

         先讲讲Component的继承，也就是Dependence。

         一个被@Scope标记的Component，在被继承时，继承它的Component也必须被@Scope标记。这里的原因应该是，继承Component时，就继承了它提供的方法，但是我们之前说过，给Component标记@Scope就是意味着里面有单例的@Provide，所以继承了单例@Provde的Component也要打上@Scope。

         并且这两个@Scope还不能相同。我前面要求做法是用@MyScope标记的SecondComponent来dependence被@Singleton标记的GlobalComponent。

         但是有的同学反过来试了，用@Singleton标记的SecondComponent来dependence被@MyScope标记的GlobalComponent于是就报错了。

         我也尝试了几种情况，用两个自定义的@Scope标记Component继承，没问题。

         但是@Singleton就是不一样，它标记的Component就是只能被dependence，它就是高人一等，它标记的Component不需要也不能依靠别人。

         所以，记住就行。

         好了，最后老师再辛苦一下，写个ThridActivity测试一下Global是不是全局单例。

public class ThridActivity extends AppCompatActivity {
    @BindView(R.id.thrid_text_1)    TextView text1;
    @BindView(R.id.thrid_text_2)    TextView text2;
    @BindView(R.id.thrid_text_3)    TextView text3;
    @BindView(R.id.thrid_text_4)    TextView text4;

    @Inject    Coffee coffee1;
    @Inject    Coffee coffee2;
    @Inject    Global global1;
    @Inject    Global global2;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.thrid);
        ButterKnife.bind(this);

        DaggerSecondComponent.builder()
                .globalComponent(new MyApplication().get())
                .secondModule(new SecondModule())//添加Module
                .build()
                .inject(this);

        text1.setText(coffee1.toString());
        text2.setText(coffee2.toString());
        text3.setText(global1.toString());
        text4.setText(global2.toString());
    }
}

           layout的代码：

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <TextView
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:id="@+id/thrid_text_1"
        />

    <TextView
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:id="@+id/thrid_text_2"
        />

    <TextView
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:id="@+id/thrid_text_3"
        />

    <TextView
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:id="@+id/thrid_text_4"
        />

</LinearLayout>

           看得出来我使用的还是DaggerSecondComponent来注入，所以我需要再SecondComponent中加上代码，适配一下ThrdActivity。

@MyScope
@Component(modules = SecondModule.class,dependencies = GlobalComponent.class)
public interface SecondComponent {
    void inject(SecondActivity activity);
    void inject(ThridActivity activity);
}

          然后在SecondActivity中加入一个点击跳转，button自己去加。

    @OnClick({R.id.turn_thridactivity})
    public void onViewClicked(View view) {
        startActivity(new Intent(this, ThridActivity.class));
    }

           然后跑完就可以看。。。。。。

           妈的！虚拟机崩了。

          算了，你们自己跑吧！

          下一章再讲源代码。