Dagger2之 @Singleton

单例@Singleton

在开始写文章之前，先来了解一些与后边的内容相关的注意事项（看文章前要有这些概念，刚开始不明白没事，等看完后续的内容再回来看就知道什么意思了）：

• 1、Component的inject方法接收父类型参数，而调用时传入的是子类型对象则无法注入，也就是说无法使用多态方式进行注入。
• 2、component关联的modules中不能有重复的provide
• 3、module的provide方法使用了scope，那么component就必须使用同一个注解
• 4、module的provide方法没有使用scope，那么component和module是否加注解都无关紧要，可以通过编译
• 5、component的dependencies与component自身的scope不能相同，即组件之间的scope不同
• 6、Singleton的组件不能依赖其他的scope的组件，只能其他scope的组件依赖Singleton的组件。
• 7、没有scope的component不能依赖有scope的component
• 8、一个component不能同时有多个scope（Subcomponent除外）
• 9、@Singleton的生命周期依附于component，同一个module有provideXX()提供一个实例,且被@Singleton标注，针对不同的component，创建的实例不同。

了解Singleton

先通过一个简单的例子了解Singleton：
对于MainActivity中代码：

public class MainActivity extends AppCompatActivity {

    @Inject
    OkHttpClient mOkHttpClient1;

    @Inject
    OkHttpClient mOkHttpClient2;

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

        DaggerUserComponet.create().inject(this);
        Log.e("itydl","MainActivity--->"+mOkHttpClient1);
        Log.e("itydl","MainActivity--->"+mOkHttpClient2);
    }
}

应该有个Module类提供OkHttpClient 实例：
创建UserModel：

@Module
public class UserModule {

    @Singleton
    @Provides
    public OkHttpClient provideSingletonOkhttpClient(){
        return new OkHttpClient().newBuilder().build();
    }
}

这里对provideXXX()方法加入了@Singleton注解，然后点进去这个类：

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

它是定义的Scope（待会讲）。对应的Componet也必须定义为Scope：

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

这样客户端需要依赖，Module通过UserComponet 像其提供了依赖。运行程序：

okhttp3.OkHttpClient@3f9d7b7
okhttp3.OkHttpClient@3f9d7b7

发现两个实例是一样的。这样就对单例Singleton有了一个了解。但是它里面还存在很多很多的坑，继续往下一点点找出来吧。

挖掘Singleton存在的坑

修改所有的代码如下：

MainActivity：
public class MainActivity extends AppCompatActivity {

    @Inject
    UserManager mManager;

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

        DaggerUserComponet.create().inject(this);

        mManager.register();

    }
}

它里面需要一个UserManager 依赖，然后调用注册方法。
对于UserManager类：

public class UserManager {

    private ApiServer mApiServer;
    
    @Inject
    public UserManager(ApiServer mApiServer){
        this.mApiServer = mApiServer;
    }

    public void register(){
        mApiServer.register();
    }
}

在这个类里面提供了注册方法，真正的注册是通过调用ApiServer 的register();他需要ApiServer 的实例，通过构造方法注入这个实例。
看一下ApiServer 类：

public class ApiServer {

    OkHttpClient mOkHttpClient;

    @Inject
    public ApiServer(OkHttpClient okHttpClient){
        this.mOkHttpClient = okHttpClient;
    }

    /**
     * 往服务端保存用户信息
     */
    public void register() {
        Log.e("Howard","ApiServer--->register()"+mOkHttpClient);
    }

}

在ApiServer 的egister()方法中，肯定需要OkHttpClient 实例进行访问网络的功能，这个实例又通过ApiServer的构造方法进行了注入。
然后Module提供依赖：

@Module
public class UserModule {

    @Singleton
    @Provides
    public OkHttpClient provideSingletonOkhttpClient(){
        return new OkHttpClient().newBuilder().build();
    }

    @Provides
    public ApiServer provideApiServer(OkHttpClient okHttpClient){
        ApiServer apiServer = new ApiServer(okHttpClient);
        return apiServer;
    }

     @Provides
     public UserManager provideUserManager(ApiServer mApiServer){
         return new UserManager(mApiServer);
     }

}

这个类专门提供依赖的，provideUserManager方法提供MainActivity类需要的UserManager实例，然后这个构造方法中需要注入ApiServer 实例，直接在这个类里面提供了provideApiServer方法，然后返回出去。而这个方法创建ApiServer实例的时候又需要一个OkHttpClient 实例，同样在这里提供了provideSingletonOkhttpClient方法用于创建OkHttpClient 的。然后看一下Component里面的代码：

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

然后运行程序：

ApiServer--->register()okhttp3.OkHttpClient@3f9d7b7

打印了okhttp3的实例。

然后，假设现在有这样的需求：在MainActivity中有注册的功能，如果还有登录的功能，且希望使用的OkhttpClient是同一个实例，该怎么去处理？
还有登录的功能：创建LoginActivity，在它这里也要用到用户管理类，调用用户管理的登录方法：

public class LoginActivity extends AppCompatActivity {
    
    @Inject
    UserManager mManager;

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

        
        DaggerUserComponet.create().inject(this);
        
        mManager.login();
        
    }
}

这个时候编译阶段就报错。DaggerUserComponet.create().inject(this);存在问题。

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

因为void inject(MainActivity mainActivity);它里面接收的是MainActivity类型，显然注入LoginActivity 类型是不允许的。
我们可能天真的认为，使用多态接收就可以了：

@Singleton
@Component(modules = {UserModule.class})
public interface UserComponet {
    void inject(Activity mainActivity);
}

运行发现报空指针，是因为没有完成注入。这里应征了开头的第一条Component的inject方法接收父类型参数，而调用时传入的是子类型对象则无法注入，也就是说无法使用多态方式进行注入。
那么需要再写一个与Login相关的连接器：

@Singleton
@Component(modules = UserModule.class)
public interface LoginCompoent {
    void inject(LoginActivity loginActivity);
}

LoginCompoent 也需要加入@Singleton进行注解，因为他关联的UserModule里面provideSingletonOkhttpClient是通过单例@Singleton注解的。这里关联UserModule的原因是，它里面已经提供了创建UserManager和创建OkHttpClient的方法。
然后看一下UserManager类，里面多了一个login();方法：

    public void login() {
        mApiServer.login();
    }

调用ApiServer类的login();方法：

    public void login(){
        Log.e("Howard","ApiServer--->login()"+mOkHttpClient);
    }

也是打印了OkHttpClient实例。
然后在LoginActivity中进行注入：
DaggerLoginCompoent.create().inject(this);
打印结果：

ApiServer--->register()okhttp3.OkHttpClient@2c4dbeb6
ApiServer--->login()okhttp3.OkHttpClient@5634554

跟我们想象的差别很大啊，我们明明对UserModel的provideSingletonOkhttpClient()方法加入了@Singleton注解为单例，为何这里是两个实例呀？
解释：Dagger2里面的单例不同意java中的单例，这是两个不同的概念。在Dagger2里面的单例依附于Compoent，不同的Compoent就算关联了相同的Module且里面提供了共同所需要的实例，也是创建了不同的实例对象（地址不同）。

在一个项目中，我们希望提供的OkHttp是一个实例，而不是像上面那样，有多个Compoent就创建多个OkHttp实例，该怎么办呢？那就是下一篇文章的事了，自定义Scope。