@Singleton能保证单例吗

时间 2019-12-05

标签 singleton 保证繁體版

原文原文链接

scope里有个@Singleton,它能保证单例吗？

答案是不彻底能（或者是说是有条件的能）java

当你不使用@Singleton时，在同一个宿主类里，注入两次同一个类的对象你会发现，两个对象的地址不同bash

当你使用了@Singleton，在同一个宿主类里，注入两次同一个类的对象你会发现，两个对象的地址变得同样了ide

可是使用了@Singleton后，此时你在另外一个宿主内，再次注入两次同一个类的对象你会发现，两个对象的地址在本宿主内是同样的，可是与以前的那个宿主里的对象地址是不一样的ui

为何会这样的呢，答案是当你使用了@Singleton后，你所注入的对象是经过Component管理的，只要是同一个Component管理到的，且通过@Singleto注解后的对象，不管注入几个都是同一个地址（也就是单例）this

可是上面咱们在新的宿主里，又从新new了个Component，因此新宿主里的两个对象是在新的Component所管理的，他们地址是同样的，而他们与第一个宿主以前的Component是不一样的，因此地址会不同spa

因此，结论来了,在同一个Component管理的对象，若是没了@Singleton注解了，那么他仍是单例，不一样Component所管理的对象，即便是@Singleton注解过了，依然不是单例3d

来看看源码

1、没使用Singleton注解的

这是DaggerPetComponent类code

先获得providesPetProvider实例,而后在不一样的宿主类（本例是Main2Activity，Main3Activity，BaseActivity）经过providesPetProvider，获得相应的main2ActivityMembersInjector，main3ActivityMembersInjector，baseActivityMembersInjectorcomponent

而后实现了PetComponen接口里的注入方法，这里会经过上面获得的main2ActivityMembersInjector，main3ActivityMembersInjector，baseActivityMembersInjector去实现cdn

可见，每次构建新的DaggerPetComponent，都会有新的providesPetProvider产生,致使main2ActivityMembersInjector，main3ActivityMembersInjector，baseActivityMembersInjector里所保存的注入实例是不一样的，致使在不一样的DaggerPetComponent所管理的对象之间不是单例

2、使用了Singleton后注解的，

这是DaggerPetComponent类
咱们点击DoubleCheck看看

咱们看到，经过DoubleCheck保证了providesPetProvider是单例，而后使用同一个providesPetProvider，产生的对应的main2ActivityMembersInjector，main3ActivityMembersInjector，baseActivityMembersInjector里面实际保存的是相同的对象实例，从而实现了跨DaggerPetComponent间的单例

问题来了，如何保证全局单例呢

答案：全局保证明例化一个Component，而后全部的注入对象都是经过这个Component来管理,方法有二：

1、在Application里实例化一个Component

由于Application执行一次，从而保证里全局只有一个Component

class MyApplication :Application(){
    companion object{
        val petComponent = DaggerPetComponent.create()//初始化petComponent
    }

    override fun onCreate() {
        super.onCreate()
    }
}

复制代码

class Main2Activity : BaseActivity() {
    @Inject
    lateinit var pet: Pet
    @Inject
    lateinit var pet1: Pet

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main2)
//        DaggerPetComponent.builder().petModule(PetModule()).build().inject(this)//不要这样注入，这样是new了新的petComponent，就不是全局单例了
        MyApplication.petComponent.inject(this)//要使用MyApplication里的petComponent
        bt.setOnClickListener {

            Log.e("ccc", pet.toString())
            Log.e("ccc", pet1.toString())

        }
        bt1.setOnClickListener {

            startActivity(Intent(this, Main3Activity::class.java))
        }
    }
}
复制代码

class Main3Activity : BaseActivity() {
    @Inject
    lateinit var pet: Pet
    @Inject
    lateinit var pet1: Pet

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main3)

//       DaggerPetComponent.builder().petModule(PetModule()).build().inject(this)//不要这样注入，这样是new了新的petComponent，就不是全局单例了
        MyApplication.petComponent.inject(this)//要使用MyApplication里的petComponent
        Log.e("ccc", "pet${pet.toString()}")
        Log.e("ccc", "pet${pet1.toString()}")
    }
}

复制代码

结果是全局单例

2、Component再也不是一个接口了，把它改形成一个抽象类，在抽象类里实现本类的单例

@Component(modules = [PetModule::class])
@Singleton

abstract class PetComponent {
    companion object {
        private  var mComponent: PetComponent? =null
        fun getInstance(): PetComponent? {
            if (mComponent == null) {
                synchronized(PetComponent::class.java) {
                    if (mComponent == null) {
                        mComponent = DaggerPetComponent.create()
                    }
                }
            }
            return mComponent
        }
    }
    abstract fun inject(activity: Main2Activity)
    abstract fun inject(activity: Main3Activity)
}
复制代码

class Main2Activity : BaseActivity() {
    @Inject
    lateinit var pet: Pet
    @Inject
    lateinit var pet1: Pet

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main2)

        PetComponent.getInstance()!!.inject(this)//单例注入

        bt.setOnClickListener {

            Log.e("ccc", pet.toString())
            Log.e("ccc", pet1.toString())

        }
        bt1.setOnClickListener {

            startActivity(Intent(this, Main3Activity::class.java))
        }
    }
}
复制代码

class Main3Activity : BaseActivity() {
    @Inject
    lateinit var pet: Pet
    @Inject
    lateinit var pet1: Pet

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main3)

//       DaggerPetComponent.builder().petModule(PetModule()).build().inject(this)
//        MyApplication.petComponent.inject(this)
        PetComponent.getInstance()!!.inject(this)//单例注入


        Log.e("ccc", "pet${pet.toString()}")
        Log.e("ccc", "pet${pet1.toString()}")
    }
}

复制代码

说说kotlin的单例模式

其实在kotlin里单例模式只需一个object便可

即把class改成object，kotlin内部就会把这个类改成单例可是惋惜，我们的PetComponent必须包含抽象方法，那么这个类必须是abstract的，可是 abstract object不能同时使用因此使用了上面的两次判空的经典单例写法

参考

详解 Dagger2 的 @Scope 和 @Subcomponent