Question

我们一直在讨论这个问题，但是我们不知道创建视图模型工厂来创建视图模型而不是直接实例化视图模型的原因。创建仅创建视图模型的工厂有什么好处？

我只是举了一个简单的例子，说明我没有工厂时如何做到的

这是kodein模块：

val heroesRepositoryModel = Kodein {
    bind<HeroesRepository>() with singleton {
        HeroesRepository()
    }

    bind<ApiDataSource>() with singleton {
        DataModule.create()
    }

    bind<MainViewModel>() with provider {
        MainViewModel()
    }
}

我没有使用工厂实例化viewmodel的Activity部分

class MainActivity : AppCompatActivity() {
    private lateinit var heroesAdapter: HeroAdapter
    private lateinit var viewModel: MainViewModel
    private val heroesList = mutableListOf<Heroes.MapHero>()
    private var page = 0
    private var progressBarUpdated = false

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        viewModel = ViewModelProviders.of(this)
                .get(MainViewModel::class.java)
        initAdapter()
        initObserver()
        findHeroes()
    }

我直接实例化用例的ViewModel，而无需在构造函数中使用它

class MainViewModel : ViewModel(), CoroutineScope {

    private val heroesRepository: HeroesRepository = heroesRepositoryModel.instance()
    val data = MutableLiveData<List<Heroes.MapHero>>()

    private var job: Job = Job()
    override val coroutineContext: CoroutineContext
        get() = uiContext + job

    fun getHeroesFromRepository(page: Int) {
        launch {
            try {
                val response = heroesRepository.getHeroes(page).await()
                data.value = response.data.results.map { it.convertToMapHero() }
            } catch (e: HttpException) {
                data.value = null
            } catch (e: Throwable) {
                data.value = null
            }
        }
    }

    override fun onCleared() {
        super.onCleared()
        job.cancel()
    }
}

这里是使用工厂的示例

class ListFragment : Fragment(), KodeinAware, ContactsAdapter.OnContactListener {

    override val kodein by closestKodein()

    private lateinit var adapterContacts: ContactsAdapter

    private val mainViewModelFactory: MainViewModelFactory by instance()
    private val mainViewModel: MainViewModel by lazy {
        activity?.run {
            ViewModelProviders.of(this, mainViewModelFactory)
                .get(MainViewModel::class.java)
        } ?: throw Exception("Invalid Activity")
    }

    override fun onCreateView(
            inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
        return inflater.inflate(R.layout.fragment_list, container, false)
    }

viewmodelfactory：

class MainViewModelFactory (private val getContacts: GetContacts) : ViewModelProvider.Factory {

    override fun <T : ViewModel?> create(modelClass: Class<T>): T {
        if (modelClass.isAssignableFrom(MainViewModel::class.java)) {
            return MainViewModel(getContacts) as T
        }
        throw IllegalArgumentException("Unknown ViewModel class")
    }
}

和视图模型：

class MainViewModel(private val getContacts: GetContacts) : BaseViewModel() {
    lateinit var gamesList: LiveData<PagedList<Contact>>
    var contactsSelectedData: MutableLiveData<List<Contact>> = MutableLiveData()
    var contactsSelected: ArrayList<Contact> = ArrayList()
    private val pagedListConfig by lazy {
        PagedList.Config.Builder()
                .setEnablePlaceholders(false)
                .setInitialLoadSizeHint(PAGES_CONTACTS_SIZE)
                .setPageSize(PAGES_CONTACTS_SIZE)
                .setPrefetchDistance(PAGES_CONTACTS_SIZE*2)
                .build()
    }

这是完整的第一个示例：

https://github.com/ibanarriolaIT/Marvel/tree/mvvm

还有完整的第二个示例：

https://github.com/AdrianMeizoso/Payment-App

Answer 1

简而言之，

如果我们需要将一些input data传递给constructor的{{1}}，则需要为viewModel创建一个viewModel。

例如示例：-

factory class

原因

我们无法直接创建class MyViewModelFactory constructor(private val repository: DataRepository): ViewModelProvider.Factory { override fun <T : ViewModel> create(modelClass: Class<T>): T { return if (modelClass.isAssignableFrom(MyViewModel::class.java!!)) { MyViewModel(this.repository) as T } else { throw IllegalArgumentException("ViewModel Not Found") } } }的对象，因为它不会知道ViewModel。所以我们用：-

lifecyclerOwner

Answer 2

我们无法自行创建ViewModel。我们需要Android提供的ViewModelProviders实用程序来创建ViewModels。

但是ViewModelProviders只能实例化没有arg构造函数的ViewModel。

因此，如果我有一个带有多个参数的ViewModel，则需要使用一个Factory，可以将其传递给ViewModelProviders，以便在需要MyViewModel实例时使用。

例如-

public class MyViewModel extends ViewModel {
    private final MyRepo myrepo;
    public MyViewModel(MyRepo myrepo) {
         this.myrepo = myrepo;
    }
}

要实例化此ViewModel，我需要有一个工厂，ViewModelProviders可以使用该工厂来创建其实例。

ViewModelProviders实用程序无法创建带有参数构造函数的ViewModel实例，因为它不知道如何以及在构造函数中传递哪些对象。

Answer 3

我们一直在讨论这个问题，但是我们不知道创建视图模型工厂来创建视图模型而不是直接实例化视图模型的原因。创建仅创建视图模型的工厂有什么好处？

因为Android仅会为尚未为该特定给定LifecycleOwner创建的新实例给您一个新实例。

我们也不要忘记ViewModels在配置更改后仍保持活动状态，因此，如果旋转手机，则不应该创建新的ViewModel。

如果您要返回上一个活动，然后重新打开该活动，则先前的ViewModel应该收到onCleared()，而新的Activity应该有一个新的ViewModel。

除非您自己这样做，否则您可能应该只相信ViewModelProviders.Factory来完成其工作。

（而且您需要工厂，因为您通常不只是有一个no-arg构造函数，您的ViewModel有构造函数参数，而ViewModelProvider必须知道如何在您填写时重新使用非默认构造函数）。

Answer 4

我们可以通过viewmodel工厂在viewmodel中传递参数。没有工厂，就无法在viewmodel中传递参数。

class UserViewModelFactory(private val context: Context) : ViewModelProvider.NewInstanceFactory() {
 
    override fun <T : ViewModel?> create(modelClass: Class<T>): T {
        return UserViewModel(context) as T
    }
 
}

class UserViewModel(private val context: Context) : ViewModel() {
 
    private var listData = MutableLiveData<ArrayList<User>>()
 
    init{
        val userRepository : UserRepository by lazy {
            UserRepository
        }
        if(context.isInternetAvailable()) {
            listData = userRepository.getMutableLiveData(context)
        }
    }
 
    fun getData() : MutableLiveData<ArrayList<User>>{
        return listData
    }
}

您可以在以下活动中调用viewmodel

val userViewModel = ViewModelProviders.of(this,UserViewModelFactory(this)).get(UserViewModel::class.java)

更多参考：Android MVVM Kotlin Example

Answer 5

当我们只是使用 ViewModel 时，我们无法向该 ViewModel 传递参数

class GameViewModel() : ViewModel() {

    init {
        Log.d(TAG, "GameViewModel created")
    }
}

但是，在某些情况下，我们需要将自己的参数传递给 ViewModel。这可以使用 ViewModelFactory 来完成。

class ScoreViewModel(finalScore: Int) : ViewModel() {

    val score = finalScore

    init {
        Log.d(TAG, "Final score: $finalScore")
    }
}

为了实例化这个 ViewModel，我们需要一个 ViewModelProvider.Factory，因为简单的 ViewModel 无法实例化它。

class ScoreViewModelFactory(private val finalScore: Int) : ViewModelProvider.Factory {

    override fun <T : ViewModel?> create(modelClass: Class<T>): T {
        if (modelClass.isAssignableFrom(ScoreViewModel::class.java)) {
            return ScoreViewModel(finalScore) as T
        }
        throw IllegalArgumentException("Unknown ViewModel class")
    }
}

当涉及到实例化此 ViewModel 的对象时，即使用 ViewModelProvider，我们将 ViewModelFactory 作为参数传递，其中包含有关我们要传递的自定义参数的信息。它是这样的：

viewModelFactory = ScoreViewModelFactory(score)
viewModel = ViewModelProvider(this,viewModelFactory).get(ScoreViewModel::class.java)

这就是工厂方法存在的原因。

为什么Android中需要viewmodel工厂？

5 个答案: