dagger2系列之Scope

　　Dagger的Scope注解代表的是作用域，通过实现自定义@Scope注解，标记当前生成对象的使用范围，标识一个类型的注射器只实例化一次，在同一个作用域内，只会生成一个实例，

然后在此作用域内共用一个实例。这样看起来很像单例模式，我们可以查看@Singleton其实就是@Scope的一个默认实现而已。当然，你得是同一个Component对象来生成

Dagger为我们提供了Scope的一种实现Singleton。单例？？？no!!!no!!!no!!!不是这么简单的。先看一下它的代码：

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

　　在Dagger中我们可以自定义注解，譬如我们可以照着上面的模版自定义一个PreScope。

@Scope
@Retention(RetentionPolicy.RUNTIME)
public @interface PreScope {
}

　　我们自定义的这个PreScope注解也有和Singleton同样的作用(单例)。下面看一下它的使用！！！

@Module
public class AppModule7 {

    private App7 app;

    public AppModule7(App7 app) {
        this.app = app;
    }

    @Provides
    @Singleton
    public App7 provideApp() {
        return app;
    }

    @Provides
    @Singleton
    Context provideApplicationContext() {
        return app.getApplicationContext();
    }

}

@Singleton
@Component(modules = {AppModule7.class})
public interface AppComponent7 {
    void inject(App7 app);

    //因为AppComponent会被dependencies，所以此处Module中提供的内容，我们需要在此处声明一下
    App7 getApp();
    Context getApplicationContext();
}

@Module
public class ActivityModule7 {

    @Provides
    @PreScope
    public DependencyPresenter7 getDependencyPresenter(App7 app){
        return new DependencyPresenter7(app);
    }
}

@PreScope
@Component(modules = ActivityModule7.class,dependencies = AppComponent7.class)
public interface ActivityComponent7 {
    void inject(TargetActivity71 activity71);
    void inject(TargetActivity72 activity72);
}

public class App7 extends Application {

    private AppComponent7 mAppComponent7;
    private ActivityComponent7 mActivityComponent7;

    @Override
    public void onCreate() {
        super.onCreate();
        mAppComponent7 = DaggerAppComponent7.builder().appModule7(new AppModule7(this)).build();
        mAppComponent7.inject(this);
        mActivityComponent7 = DaggerActivityComponent7.builder().appComponent7(mAppComponent7).build();
    }

    public AppComponent7 getAppComponent7(){
        return mAppComponent7;
    }
    public ActivityComponent7 getActivityComponent7(){
        return mActivityComponent7;
    }

}

public class DependencyPresenter7 {
    public DependencyPresenter7(App7 app){
        Log.d("Dagger.class","DependencyPresenter7-----构造器被调用--------");
    }

    public void printMethod(){
        Log.d("Dagger.class","DependencyPresenter7-----printMethod()-----");
    }

}

public abstract class BaseActivity712 extends Activity {

    private ActivityComponent7 mActivityComponent7;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        App7 app712 = (App7) getApplication();
        mActivityComponent7 = app712.getActivityComponent7();
        inject(mActivityComponent7);
    }

    public abstract void inject(ActivityComponent7 activityComponent7);
}

public class TargetActivity71 extends BaseActivity712 {

    @Inject
    DependencyPresenter7 mDependencyPresenter;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        Log.d("Dagger.class","TargetActivity71---mDependencyPresenter地址值-------"+mDependencyPresenter.toString());
    }

    @Override
    public void inject(ActivityComponent7 activityComponent7) {
        activityComponent7.inject(this);
    }

    public void jump(View v){
        startActivity(new Intent(this,TargetActivity72.class));
    }
}

public class TargetActivity72 extends BaseActivity712 {

    @Inject
    DependencyPresenter7 mDependencyPresenter;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        Log.d("Dagger.class","TargetActivity72---mDependencyPresenter地址值-------"+mDependencyPresenter.toString());
    }

    @Override
    public void inject(ActivityComponent7 activityComponent7) {
        activityComponent7.inject(this);
    }
}

　　上面的代码我们使用了Dagger默认实现的@Singleton和自定义的@PreScope注解一起实现单例。我们之所以不只用dagger提供的Singleton而且还用自定义的，是因为我们使用的域不一样，当不同的Component有依赖依赖或包含关系的时候就不能用同样的Scope，就需要我们自定义。

下面是我在学习过程中总结的结论：

　　　　1　　必须使用同一个Component对象来生成，也就是DaggerActivityComponent7.builder().build()只能执行一次。

　　　　2　　Component和它的Module要使用相同的Scope。同一个Module中需要使用同样的Scope，否则相应的Component不知道使用什么Scope

　　　　3　　有依赖关系或者包含关系的Component不能使用同样的Scope。

　　上面的三条结论就是在学习使用Singleton的时候总结出的，大家在学习的时候，最好自己也验证一下。