android mvvm实例解析
MVVM架构，将整个应用分为三层，View层，VM层，Model层。其中View层单向引用VM层，VM层单向引用Model层。如上图。
单向引用，而非双向引用，这是MVVM与MVP最大的区别。View层，只是单向引用VM层，VM层不需要引用View层，但是却可以
更新View层。这是通过VM层的观察者模式实现的，在这里使用架构组件LiveData，观察者注册LiveData，当LiveData数据发生变更
的时候，就会通知注册的观察者。
VM层，执行业务逻辑，获取Model层的数据，Model层的数据由repository来提供。
举例子：
ChooseAreaFragment是View层，它持有ViewModel，它可以监听相关数据，相关数据发生变化的时候，对应的UI就会被更新。
比如：dataChanged数据发生变化，就会执行定义的观察者操作。
viewModel.dataChanged.observe(this, Observer {
adapter.notifyDataSetChanged()
listView.setSelection(0)
closeProgressDialog()
})
class ChooseAreaFragment : Fragment() {
private val viewModel by lazy { ViewModelProviders.of(this, InjectorUtil.getChooseAreaModelFactory()).get(ChooseAreaViewModel::class.java) }
private var progressDialog: ProgressDialog? = null
private lateinit var adapter: ArrayAdapter<String>
override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
val view = inflater.inflate(R.layout.choose_area, container, false)
val binding = DataBindingUtil.bind<ChooseAreaBindingImpl>(view)
binding?.viewModel = viewModel
return view
}
override fun onActivityCreated(savedInstanceState: Bundle?) {
super.onActivityCreated(savedInstanceState)
adapter = ChooseAreaAdapter(context!!, R.layout.simple_item, viewModel.dataList)
listView.adapter = adapter
observe()
}
private fun observe() {
viewModel.currentLevel.observe(this, Observer { level ->
when (level) {
LEVEL_PROVINCE -> {
titleText.text = "中国"
backButton.visibility = View.GONE
}
LEVEL_CITY -> {
titleText.text = viewModel.selectedProvince?.provinceName
backButton.visibility = View.VISIBLE
}
LEVEL_COUNTY -> {
titleText.text = viewModel.selectedCity?.cityName
backButton.visibility = View.VISIBLE
}
}
})
viewModel.dataChanged.observe(this, Observer {
adapter.notifyDataSetChanged()
listView.setSelection(0)
closeProgressDialog()
})
viewModel.isLoading.observe(this, Observer { isLoading ->
if (isLoading) showProgressDialog()
else closeProgressDialog()
})
viewModel.areaSelected.observe(this, Observer { selected ->
if (selected && viewModel.selectedCounty != null) {
if (activity is MainActivity) {
val intent = Intent(activity, WeatherActivity::class.java)
intent.putExtra("weather_id", viewModel.selectedCounty!!.weatherId)
startActivity(intent)
activity?.finish()
} else if (activity is WeatherActivity) {
val weatherActivity = activity as WeatherActivity
weatherActivity.drawerLayout.closeDrawers()
weatherActivity.viewModel.weatherId = viewModel.selectedCounty!!.weatherId
weatherActivity.viewModel.refreshWeather()
}
viewModel.areaSelected.value = false
}
})
if (viewModel.dataList.isEmpty()) {
viewModel.getProvinces()
}
}
/**
* 显示进度对话框
*/
private fun showProgressDialog() {
if (progressDialog == null) {
progressDialog = ProgressDialog(activity)
progressDialog?.setMessage("正在加载...")
progressDialog?.setCanceledOnTouchOutside(false)
}
progressDialog?.show()
}
/**
* 关闭进度对话框
*/
private fun closeProgressDialog() {
progressDialog?.dismiss()
}
companion object {
const val LEVEL_PROVINCE = 0
const val LEVEL_CITY = 1
const val LEVEL_COUNTY = 2
}
}
VM层，ViewModel：
使用LiveData包装被View层监听的数据，在VM层数据发生的变化，会通知到View层，但却无需要View层的引用。
因为LiveData应用了观察者模式，注册的观察者，在数据发生变化的时候，会自动通知观察者。
如下，currentLevel，dataChanged，isLoading等都是使用LiveData包装的，意味着，它们发生变化的时候View层会监听得到，从而进行相应的更新操作。
在VM层，持有Model层的引用，Model层的数据获取，网络请求，都依赖repository实现。
class ChooseAreaViewModel(private val repository: PlaceRepository) : ViewModel() {
var currentLevel = MutableLiveData<Int>()
var dataChanged = MutableLiveData<Int>()
var isLoading = MutableLiveData<Boolean>()
var areaSelected = MutableLiveData<Boolean>()
var selectedProvince: Province? = null
var selectedCity: City? = null
var selectedCounty: County? = null
lateinit var provinces: MutableList<Province>
lateinit var cities: MutableList<City>
lateinit var counties: MutableList<County>
val dataList = ArrayList<String>()
fun getProvinces() {
currentLevel.value = LEVEL_PROVINCE
launch {
provinces = repository.getProvinceList()
dataList.addAll(provinces.map { it.provinceName })
}
}
private fun getCities() = selectedProvince?.let {
currentLevel.value = LEVEL_CITY
launch {
cities = repository.getCityList(it.provinceCode)
dataList.addAll(cities.map { it.cityName })
}
}
private fun getCounties() = selectedCity?.let {
currentLevel.value = LEVEL_COUNTY
launch {
counties = repository.getCountyList(it.provinceId, it.cityCode)
dataList.addAll(counties.map { it.countyName })
}
}
fun onListViewItemClick(parent: AdapterView<*>, view: View, position: Int, id: Long) {
when {
currentLevel.value == LEVEL_PROVINCE -> {
selectedProvince = provinces[position]
getCities()
}
currentLevel.value == LEVEL_CITY -> {
selectedCity = cities[position]
getCounties()
}
currentLevel.value == LEVEL_COUNTY -> {
selectedCounty = counties[position]
areaSelected.value = true
}
}
}
fun onBack() {
if (currentLevel.value == LEVEL_COUNTY) {
getCities()
} else if (currentLevel.value == LEVEL_CITY) {
getProvinces()
}
}
private fun launch(block: suspend () -> Unit) = viewModelScope.launch {
try {
isLoading.value = true
dataList.clear()
block()
dataChanged.value = dataChanged.value?.plus(1)
isLoading.value = false
} catch (t: Throwable) {
t.printStackTrace()
Toast.makeText(CoolWeatherApplication.context, t.message, Toast.LENGTH_SHORT).show()
dataChanged.value = dataChanged.value?.plus(1)
isLoading.value = false
}
}
}
Model层：
在这个例子中，Model层对外提供的方法是
getProvinceList，getCityList，getCountyList。
它的数据来源，可能是数据库Dao，或者是网络，各自的实现，再委托到具体的方法去实现。
class PlaceRepository private constructor(private val placeDao: PlaceDao, private val network: CoolWeatherNetwork) {
suspend fun getProvinceList() = withContext(Dispatchers.IO) {
var list = placeDao.getProvinceList()
if (list.isEmpty()) {
list = network.fetchProvinceList()
placeDao.saveProvinceList(list)
}
list
}
suspend fun getCityList(provinceId: Int) = withContext(Dispatchers.IO) {
var list = placeDao.getCityList(provinceId)
if (list.isEmpty()) {
list = network.fetchCityList(provinceId)
list.forEach { it.provinceId = provinceId }
placeDao.saveCityList(list)
}
list
}
suspend fun getCountyList(provinceId: Int, cityId: Int) = withContext(Dispatchers.IO) {
var list = placeDao.getCountyList(cityId)
if (list.isEmpty()) {
list = network.fetchCountyList(provinceId, cityId)
list.forEach { it.cityId = cityId }
placeDao.saveCountyList(list)
}
list
}
companion object {
private var instance: PlaceRepository? = null
fun getInstance(placeDao: PlaceDao, network: CoolWeatherNetwork): PlaceRepository {
if (instance == null) {
synchronized(PlaceRepository::class.java) {
if (instance == null) {
instance = PlaceRepository(placeDao, network)
}
}
}
return instance!!
}
}
}
以上就是MVVM的实例解析。应用MVVM的时候，关键是划分功能属于哪一个层次，然后，再确定引用关系。划分功能属于哪个层次，可以依据单一职责原则，让功能代码原子化，再在这一基础上去区分层次。