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的时候总结出的，你们在学习的时候，最好本身也验证一下。