不停的维护公司的业务，会发现技术演进的步伐越来越跟不上，随着年纪的增长，对新技术的热情也逐渐消退，零星的空余时间逐渐从看书学习被拿来死宅，陪女友，带娃，休息，人际往来，也逐渐发现抱好一条大腿比提高什么狗屁技术重要多了。。。

### 一、简介

Jetpack由2018年正式发布，是一个仓库集合，包含四大部分：Architecture、Foundation、Behavior以及UI组件。

#### Architecture【基础组件】

基础组件可提供横向功能，例如向后兼容性、测试和 Kotlin 语言支持。包含ktx扩展库， AppCompat 降级测录等

#### Foundation【架构组件】

就是我们最常使用的部分，包含LifeCycles，LiveData，Room，ViewModel等组件

#### Behavior【行为组件】

包含和三方room合作，兼容性更好CameraX，以及通知，权限等

#### UI【界面】

界面组件可提供微件和辅助程序，让您的应用不仅简单易用，还能带来愉悦体验。了解有助于简化界面开发的 Jetpack Compose，包含动画和过渡，表情符号，Fragment，布局等。

其中Jetpack Compose的声明式构建布局的写法和Flutter基本一致。又为我们技术的无缝切换提供了便利。

除了新发布的一些组件库，我们大部分都很熟悉，作为核心功能的dataBinding你应该很早就在使用了，谷歌这次打包只是更加强了开发的规范和统一

更详细的介绍直接看[官网]()

### 二、架构组件部分

大量的概念和介绍网上的帖子多如牛毛，自行搜索吧，还是建议看官网，防止遗漏一些注意事项，另外一些坑也只能是你遇到时才能记住，我也没有研究的多透彻，只是借助一个完整的例子，将几个常用的组件封装一下，更便于使用。

不过无论是ktx还是Jetpack，目前旨在于简化，规范开发，让你写更少的代码，犯更少的错，但经过编译生成的代码量一点都不会少，因为原理不会变。

[我的项目地址]()

也可以跳过下边的介绍直接看代码，有建议或更好的代码设计方式欢迎提issue或留言，共同进步

同时可以参考官方的kt+Jetpack的[官方demo]() ,这是一个日程安排项目，算是demo级别的，所以源码没有那么严谨和规范，但很好演示了kt的使用方式，里边也运用了很多Jetpack技巧。

项目是一个美女图片浏览的小app，数据来源于gank.io的API，和我自己爬取的数据，例如你百度搜索美女，列出的美女网站你觉得不错的都可以解析html然后转成json列表渲染，使用的jsoup，如下项目截图：

#### viewModel

The ViewModel class is designed to store and manage UI-related data in a lifecycle conscious way. The ViewModel class allows data to survive configuration changes such as screen rotations.

ViewModel 是以生命周期的方式存储与管理UI相关数据。

作用：

1.在MVVM模式中，使Model与View分离。

2.存储数据。

3.负责为UI准备数据。

注意点：

1.ViewModel的生命周期比Activity或者Fragment长，因此 ViewModel不能持有Context的对象，不然会出现内存泄漏。

2.Activity在生命周期中可能会触发多次onCreate()，而ViewModel则只会在第一次onCreate()时创建，然后直到最后Activity销毁

示例

open class BaseViewModel<Any> : ViewModel(), ItemClick<Any> {    override fun onClick(body: Any) {        itemData.postValue(body)    }    val itemData: MutableLiveData<Any> by lazy {        MutableLiveData<Any>()    }    val list = ArrayList<Any>()    val data: MutableLiveData<List<Any>> by lazy {        MutableLiveData<List<Any>>()    }    val errorData: MutableLiveData<Int> by lazy {        MutableLiveData<Int>()    }    fun launch(block: suspend () -> Unit, error: suspend (Throwable) -> Unit) = viewModelScope.launch {        try {            block()        } catch (e: Throwable) {            error(e)            errorData.postValue(0)        }    }}class GankViewModel(private val repository: GankRepository) : BaseViewModel<GankMeiziBody>() {    fun getGankList(pageNum: Int, page: Int) {        launch({                val result = repository.getGankList(pageNum, page).results                    if (page == 1) {                        list.clear()                    }                    list.addAll(result)                    data.postValue(result)                    return@launch                },{})    }}

在项目中将图片的请求(业务)放于viewModel中集中处理，在UI（Act或Fragment）中只需要调用viewModel和监听数据变化

class GankFragment : BaseRequestListFragment<GankMeiziBody>() {    private val viewModel by lazy { ViewModelProviders.of(this, InjectorUtil.getGankModelFactory()).get(GankViewModel::class.java) }    override fun getViewModel(): BaseViewModel<GankMeiziBody> = viewModel    override fun onActivityCreated(savedInstanceState: Bundle?) {        super.onActivityCreated(savedInstanceState)        mAdapter?.ontItemClick = viewModel        viewModel.itemData.observe(this, Observer {                        //监听数据变化                    })    }}

###### viewModel的初始化

只需 val viewModel = ViewModelProviders.of(this).get(BaseViewModel::class.java)

项目中则是采用了进一步封装，将业务抽进repository

#### LiveData

LiveData is an observable data holder class. Unlike a regular observable, LiveData is lifecycle-aware, meaning it respects the lifecycle of other app components, such as activities, fragments, or services. This awareness ensures LiveData only updates app component observers that are in an active lifecycle state.

LiveData是一个有生命周期感知和可观察的数据持有者类。

作用：持久化的观察数据的更改与变化和及时通知UI更新。

特点：

1.感知对应Activity的生命周期，只有生命周期处于onStart与onResume时，LiveData处于活动状态，才会把更新的数据通知至对应的Activity。

2.当生命周期处于onStop或者onPause时，不回调数据更新，直至到生命周期为onResume时，立即回调。

3.当生命周期处于onDestory时，观察者会自动删除，防止内存溢出。

4.共享资源。您可以使用单例模式扩展LiveData对象以包装系统服务，以便可以在应用程序中共享它们。 LiveData对象连接到系统服务一次，然后任何需要该资源的观察者都可以只观看LiveData对象。

在上边的封装中，在viewModel里声明你的数据内容

val list = ArrayList<Any>()val data: MutableLiveData<List<Any>> by lazy {    MutableLiveData<List<Any>>()}

因为美女图片列表是分页的，所以总数据维护在list中，每次分页拉取的数据定义为data，数据变化后liveData.postValue用通知

data.postValue(result)

这样监听着就能收到通知，进行UI渲染

getViewModel().data.observe(viewLifecycleOwner, this)override fun onChanged(list: List<T>?) {        list?.takeIf {            !it.isEmpty()        }?.apply {            binding.commonRecyclerView.visibility = View.VISIBLE            binding.commonPageErrorLayout.visibility = View.GONE            if (page == 1) {                mAdapter?.notifyItemChanged(0, getViewModel().list.size)            } else {                mAdapter?.notifyItemRangeInserted(getViewModel().list.size - list.size, getViewModel().list.size)            }            loadFinish = true            if (binding.commonSwipeRefresh.isRefreshing) {                binding.commonSwipeRefresh.isRefreshing = false            }            mIsRefreshing = false        } ?: let {            hasMoreData = false        }    }

#### dataBinding

The Data Binding Library is a support library that allows you to bind UI components in your layouts to data sources in your app using a declarative format rather than programmatically.

这个东西出来很久了，之前都是独立使用，可以减少大量ui赋值的代码，尤其你的列表及其复杂，需要你编写大量holder的时候。

现在我直接给你一个封装好的bindingAdapter，不需要继承

open class CommonBindAdapter<DB : ViewDataBinding, T>(layoutId: Int, dataList: MutableList<T>) : RecyclerView.Adapter<CommonBindAdapter.CommonViewHolder<DB>>() {    public var ontItemClick: ItemClick<T>? = null        get() = field        set(value) {            field = value        }    private var dataList: MutableList<T> = ArrayList()    private var layoutId: Int = 0    init {        this.dataList = dataList        this.layoutId = layoutId    }    fun getDataList(): MutableList<T> {        return Collections.unmodifiableList(this.dataList)    }    open fun bindView(viewHolder: CommonViewHolder<DB>, position: Int) {        viewHolder.bindView.setVariable(BR.body, getDataList()[position])        ontItemClick?.let {            viewHolder.bindView.setVariable(BR.itemClick, it)        }        viewHolder.bindView.executePendingBindings()    }    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): CommonViewHolder<DB> {        return CommonViewHolder(DataBindingUtil.inflate(LayoutInflater.from(parent.context), layoutId, parent, false))    }    override fun onBindViewHolder(holder: CommonViewHolder<DB>, position: Int) {        bindView(holder, position)    }    override fun getItemCount(): Int = dataList.size    class CommonViewHolder<DB : ViewDataBinding>(var bindView: DB) : RecyclerView.ViewHolder(bindView.root)}

调用:

var mAdapter: CommonBindAdapter<ViewDataBinding, T>? = nullmAdapter = CommonBindAdapter(R.layout.xxx, getViewModel().list)

你只需要传入一个xml，这样你的xml文件就自动生成了对应的ViewDataBinding，注意xml添加

<data>    <variable        name="body"        type="com.moon.beautygirlkotlin.doubanmeizi.model.DoubanMeiziBody" />    <variable        name="itemClick"        type="com.moon.beautygirlkotlin.listener.ItemClick" /></data>

假如你的列表是multiType类型的，可以进一步封装，不过需要覆写viewType方法的来告诉adapter你到底需要什么样的布局

abstract class BaseBindAdapter(dataList: MutableList<Any>) : RecyclerView.Adapter<BaseBindAdapter.BaseHolder<Any>>() {    interface ViewTypeCallBack {        fun createViewType(position: Int): Int    }    var ontItemClick: ItemClick<Any>? = null        get() = field        set(value) {            field = value        }    private var dataList: MutableList<Any> = ArrayList()    init {        this.dataList = dataList    }    fun removeAtIndex(index: Int) {        dataList.removeAt(index)    }    fun getDataList(): MutableList<Any> {        return Collections.unmodifiableList(this.dataList)    }    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): BaseHolder<Any> {        return BaseHolder<Any>(DataBindingUtil.inflate<ViewDataBinding>(LayoutInflater.from(parent.context), viewType, parent, false)).create()    }    override fun onBindViewHolder(holder: BaseHolder<Any>, position: Int) {        holder.bindTo(dataList[position])    }    abstract fun createViewType(position: Int): Int    override fun getItemViewType(position: Int): Int {        return createViewType(position)    }    override fun getItemCount(): Int = dataList.size    class BaseHolder<T>(private val binding: ViewDataBinding) : RecyclerView.ViewHolder(binding.root) {        fun bindTo(data: T) {            binding.setVariable(BR.body, data)            binding.executePendingBindings()        }        fun create(): BaseHolder<T> {            return BaseHolder(binding)        }    }}

继承使用

class MyFavoriteAdapter( dataList: MutableList<Any>) : BaseBindAdapter(dataList ,viewType)        , ItemMoveListener {    override fun createViewType(position: Int): Int {        val t = getDataList()[position]        if (t is FavoriteBean) return R.layout.item_favourite        if (t is FavoriteBeanOther) return R.layout.item_favourite_other        return 0    }}

假如多类型adapter你也不想继承来使用，我们再改造一下,构造方法里添加一个callBack

class BaseBindAdapter(dataList: MutableList<Any> , viewType: ViewTypeCallBack) : RecyclerView.Adapter<BaseBindAdapter.BaseHolder<Any>>() {    interface ViewTypeCallBack {        fun createViewType(position: Int): Int    }    var ontItemClick: ItemClick<Any>? = null        get() = field        set(value) {            field = value        }    private var viewTypeCallBack : ViewTypeCallBack? = null    private var dataList: MutableList<Any> = ArrayList()    init {        this.dataList = dataList        this.viewTypeCallBack = viewType    }    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): BaseHolder<Any> {        return BaseHolder<Any>(DataBindingUtil.inflate<ViewDataBinding>(LayoutInflater.from(parent.context), viewType, parent, false)).create()    }    override fun onBindViewHolder(holder: BaseHolder<Any>, position: Int) {        holder.bindTo(dataList[position])    }    override fun getItemViewType(position: Int): Int {        return this.viewTypeCallBack?.createViewType(position) ?: 0    }    override fun getItemCount(): Int = dataList.size    class BaseHolder<T>(private val binding: ViewDataBinding) : RecyclerView.ViewHolder(binding.root) {        fun bindTo(data: T) {            binding.setVariable(BR.body, data)            binding.executePendingBindings()        }        fun create(): BaseHolder<T> {            return BaseHolder(binding)        }    }}

直接实例化使用

val adapter = BaseBindAdapter(viewModel.list , viewType = object : BaseBindAdapter.ViewTypeCallBack {        override fun createViewType(position: Int): Int {            val t = viewModel.list[position]            if (t is FavoriteBean) return R.layout.item_favourite            if (t is FavoriteBeanOther) return R.layout.item_favourite_other            return 0        }    }

以上就是LiveData，ViewModel，DataBinding的简易封装，项目里也用了room，使用方式可以直接查看代码，另外其他的组件看需求来引入。

如果应用到商业项目里需要进一步的封装来契合业务的随时变化，不再赘述。