关于Dagger2使用的基础如果你还不了解，可以参考我的上一篇文章，这有助于你理解本篇文章。

OK，我们在上篇文章介绍另外Dagger2使用过程中四个基本的注解，分别是@Module、@Provides、@Inject以及@Component。今天我想来说说Dagger2中另外一个注解，那就是@Scope注解。看网上的资料，大家基本上都知道@Scope是用来给依赖划定作用域的，那我今天就来来说说这个作用域的问题。

首先Dagger2中有一个现成的作用域注解，那就是@Singleton，其实这个@Singleton还是由Java提供的。那么这个注解的作用域就是让我们的依赖成为单例模式。比如下面一个例子：假设我有一个用户对象，如下：

public class User {	....	....	    @Inject    public User() {    }	....	....	}

我这里暂时先用@Inject来注解这个用户对象，避免使用Module，然后我需要一个Component来注入这个User对象到我的Activity中，我的Component如下：

@Componentpublic interface ActivityComponent {    void inject(MainActivity activity);}

OK，然后我在我的MainActivity中初始化User对象，并将其地址显示出来：

public class MainActivity extends AppCompatActivity {    @Inject    User user;    @Inject    User user2;    private TextView tv;    private TextView tv2;    @Override    protected void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_main);        DaggerActivityComponent.builder().build().inject(this);        tv = ((TextView) findViewById(R.id.tv));        tv2 = ((TextView) findViewById(R.id.tv2));        tv.setText(user.toString());        tv2.setText(user2.toString());    }}

显示结果如下：

OK ，大家看到这完全是两个不同的对象，两个对象的引用地址完全不一样。那如果我想让User变为一个单例模式该怎么办呢？其实很简单，添加上@Singleton注解就可以了，在哪里添加呢？两个地方：

1.给User类添加上@Singleton注解：

@Singletonpublic class User {	....	....	    @Inject    public User() {    }	....	....	}

2.给ActivityComponent添加上@Singleton注解

@Singleton@Componentpublic interface ActivityComponent {    void inject(MainActivity activity);}

如此之后我再运行，结果如下：

OK，这个时候User对象就会以单例形式存在于我的App中了。OK，那如果我的项目中有Module，又该如何使我的User对象单例呢？

很简单，在Module中提供User对象，提供User对象的方法需要有单例注解：

@Modulepublic class UserModule {    @Provides    @Singleton    User providesUser() {        return new User();    }}

这个时候User对象上的注解就都可以去掉了，然后稍微修改一下ActivityComponent，如下：

@Singleton@Component(modules = UserModule.class)public interface ActivityComponent {    void inject(MainActivity activity);}

然后MainActivity中初始化的代码也要稍微修改一下下：

DaggerActivityComponent.builder().userModule(new UserModule()).build().inject(this);

然后再运行，依然是单例模式。

OK，那我们知道@Singleton注解实际上实现的是一个全局单例模式，在实际开发中我们可能还需要一种局部单例的控件（这个应该是更常用），比如说我们有三个Activity，MainActivity，BActivity和CActivity，我们想让MainActivity和BActivity共享同一个实例，而让CActivity获取另外一个实例，这又该怎么实现呢？在Dagger2中，我们可以通过自定义Scope来实现局部单例。爽歪歪吧！OK，那就动手吧：

首先让我们先来定义一个局部作用域：

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

然后在我们的UserModule和ActivityComponent中应用该局部作用域：

@Modulepublic class UserModule {    @Provides    @UserScope    User providesUser() {        return new User();    }}

@UserScope@Component(modules = UserModule.class)public interface ActivityComponent {    void inject(MainActivity activity);    void inject(BActivity activity);}

请大家注意，我的ActivityComponent作为一个注入器只可以向MainActivity和BActivity两个Activity中注入依赖，不可以向CActivity中注入依赖。最后，要让该局部作用域产生单例效果，需要我们在自定义的Appliation类中来初始化这个Component，如下：

public class MyApp extends Application {    ActivityComponent activityComponent;    @Override    public void onCreate() {        super.onCreate();        activityComponent = DaggerActivityComponent.builder().userModule(new UserModule()).build();    }    ActivityComponent getActivityComponent(){        return activityComponent;    }}

接下来我们在MainActivity和BActivity中注入依赖，MainActivity如下：

@Inject    User user;    @Inject    User user2;    private TextView tv;    private TextView tv2;    @Override    protected void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_main);//        DaggerActivityComponent.builder().userModule(new UserModule()).build().inject(this);        ((MyApp) getApplication()).getActivityComponent().inject(this);        tv = ((TextView) findViewById(R.id.tv));        tv2 = ((TextView) findViewById(R.id.tv2));        tv.setText(user.toString());        tv2.setText(user2.toString());    }

BActivity如下：

@Inject    User user;    @Override    protected void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_b);        ((MyApp) getApplication()).getActivityComponent().inject(this);        TextView tv = (TextView) findViewById(R.id.tv);        tv.setText(user.toString());    }

那么如果我还想在CActivity中使用User对象该怎么办呢？再来一个CUserModule和CActivityComponent呗！

CUserModule如下：

@Modulepublic class CUserModule {    @Provides    User providesUser() {        return new User();    }}

这里我没有再注明单例了哦！

CActivityComponent如下：

@Component(modules = CUserModule.class)public interface CActivityComponent {    void inject(CActivity activity);}

在CActivity中注入依赖：

@Inject    User user;    @Override    protected void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_c);        DaggerCActivityComponent.builder().cUserModule(new CUserModule()).build().inject(this);        TextView tv = (TextView) findViewById(R.id.tv);        tv.setText(user.toString());    }

运行结果如下：

大家看到，MainActivity和BActivity是同一个实例，而CActivity则是另外一个实例。

那么可能会有小伙伴问@UserScope在这里到底起了什么作用？我引用网上一段话：

以下文字来源：

Scope的使用，如何实现单例？这个迷之Scope也是有点难以理解，我们在哪里使用到了Scope呢。在我们的AppComponent中添加了一个注解为@Singleton，@Singleton就是一个Scope，据说可以实现单例哟。。。难道这样就实现了单例模式？我刚刚开始是这样理解的。直到仔细的看了几遍这篇文章我才知道并不是这样的。事实上@Sinleton中并没有创建单例的能力，那么AppComponent中提供的依赖注入是如何实现单例的呢。其实这个原理很贱单。首先Module提供了创建实例的方法，接着AppComponent中对Module进行管理，最后AppComponent在自定义Applicaiton中被实例化了一次。这个实例化了一次是最重要的呀。仅仅被实例化了一次，那不就是单例么。就是这么简单呀。可能有些童靴当时就不乐意了，那既然这样都已经实现了单例，那么这个@Singltop还要来何用？不是多此一举吗。其实@Singletop还有有一些作用的，首先一方面能让你直面的了解到这是一个单例，其次这个@Singletop能够更好的管理Modlue和Component之间的关系。Dagger2需要保证Component和Module是匹配的，就需要用到这个注解。

OK，这就是Dagger2中@Scope注解的使用。后面我再来介绍Component之间的依赖关系。

以上。