[关闭]
@ltlovezh 2016-04-29T14:38:17.000000Z 字数 6370 阅读 507

Kotlin : Type-safe Builders及性能对比

Kotlin


Extensions

在Kotlin中,我们可以在不继承类的基础上,对某个类添加函数和属性,即扩展函数和扩展属性。

扩展函数

扩展函数基本格式:

  1. fun 被扩展类.扩展函数(函数参数...) : 返回类型{
  2. //代码块内,可以访问被扩展类的成员属性和函数
  3. }

我感觉扩展函数最大的特色就是可以访问被扩展类的成员属性和函数,这点太方便了。看个官网的例子:

  1. fun <T> MutableList<T>.swap(index1: Int, index2: Int) {
  2. // 'this' corresponds to the list
  3. val tmp = this[index1]
  4. this[index1] = this[index2]
  5. this[index2] = tmp
  6. }
  7. 调用:
  8. var mList = mutableListOf(1,2,3,4)
  9. mList.swap(1,2)
  10. println(mList)
  11. 输出:
  12. [1, 3, 2, 4]

关于扩展函数有几点需要说明:
1. 扩展函数是静态解析的,不是虚函数,即不能被重写。
2. 当类的成员函数和扩展函数有相同函数签名时,成员函数会优先被调用。

扩展属性

扩展属性基本格式:

  1. var 被扩展类.扩展属性 : 扩展属性类型
  2. set(value)
  3. get()

实际上,扩展属性并没有真正的在类中新增属性,所以扩展属性没有field字段,即不能为扩展属性设置初始值。一般情况下,只能重写setget方法,为扩展属性提供操作。看个官网的例子:

  1. val <T> MutableList<T>.lastIndex: Int
  2. get() = size - 1
  3. 调用:
  4. var mList = mutableListOf(1, 2, 3, 4)
  5. println(mList.lastIndex)
  6. 输出:
  7. 3

Type-safe Builders

个人感觉Type-safe Builders是kotlin中的一大特色。它让我们以陈述式语言风格来创建对象。非常适合于创建多级嵌套的数据结构,例如:XML文件、布局文件等。其语法类似于gradle,都是基于DSL构建。

Type-safe Builders之所以能够成行,很大程度上依赖于扩展函数、扩展属性和Lambda With Receiver。关于Lambda With Receiver,可以参考上一篇文章。

下面看一个例子,假如我们要创建任意Android View,若通过java代码来写,那么每个View都是不同的,需要每个View单独来写。但是在Kotlin中,我们可以结合泛型、扩展函数和Lambda With Receiver,实现一个通用的函数。

  1. //对Context的扩展函数,创建任意View,并使用init函数对View进行初始化
  2. inline fun <reified T : View> Context.createView(init: T.() -> Unit): T {
  3. val construct = T::class.java.getConstructor(Context::class.java)
  4. val mView = construct.newInstance(this)
  5. mView.init()
  6. return mView
  7. }
  8. //需要在Activity中调用,创建一个Button
  9. var mButton = createView<Button> {
  10. //这里实际调用了Button.setText方法
  11. text = "Click Me"
  12. //这里实际调用了Button.setTextSize方法
  13. textSize = 20f
  14. }
  15. //需要在Activity中调用,创建一个TextView
  16. var mTextView = createView<TextView> {
  17. text = "Hello World"
  18. textSize = 20f
  19. }

上面针对Context创建了一个扩展函数createView,参数类型是T.() -> Unit,即一种Lambda With Receiver,这里Receiver就是泛型T。接着在函数体内根据反射创建了具体的泛型对象(必须是View的子类),然后调用参数函数对泛型对象进行初始化。最后,使用该函数,分别创建了Button和TextView。

理论上,通过createView函数,我们可以创建任意View对象,并且可以针对不同对象指定不同的初始化操作。

实现createView函数有一个很重要的条件,那就是根据泛型类型T,创建对应的对象(在java里,打死也做不到)。这要求函数必须是inline的,且T必须是reified具体化的。这样,函数在调用时就会内联到函数调用处,此时T的类型实际上是确定的,因而Kotlin通过reified关键字告诉编译器,T可以当实际类型来使用。

OK,上面实现了第一步,可以创建任意View了。但是还无法创建层级关系。下面我们再来一个扩展函数,搞定层级关系:

  1. //对ViewGroup的扩展函数,创建任意子View,并使用init函数对子View进行初始化,同时把子View添加到Receiver表示的父View当中。
  2. inline fun <reified T : View> ViewGroup.createView(init: T.() -> Unit): TV {
  3. val construct = T::class.java.getConstructor(Context::class.java)
  4. val mView = construct.newInstance(context)
  5. addView(mView)
  6. mView.init()
  7. return mView
  8. }

上面对ViewGroup定义了扩展函数createView。在createView内部可以访问ViewGroup的成员函数和属性,这里通过addView把创建出来的子View添加到了父View中,实现了层级的关联。

假如我们要用kotlin实现下面的View布局:

  1. <LinearLayout
  2. android:layout_width="wrap_content"
  3. android:layout_height="wrap_content"
  4. android:orientation="horizontal">
  5. <Button
  6. android:layout_width="wrap_content"
  7. android:layout_height="wrap_content"
  8. android:layout_weight="1"
  9. android:text="first Button"
  10. android:textSize="20px" />
  11. <TextView
  12. android:layout_width="wrap_content"
  13. android:layout_height="wrap_content"
  14. android:layout_weight="1"
  15. android:text="second TextView"
  16. android:textSize="20px" />
  17. </LinearLayout>

利用之前提供的两个createView函数,来实现上述布局,如下所示:

  1. createView<LinearLayout> {
  2. orientation = LinearLayout.HORIZONTAL
  3. //添加第一个子View
  4. createView<Button> {
  5. with(layoutParams as LinearLayout.LayoutParams) {
  6. width = ViewGroup.LayoutParams.WRAP_CONTENT
  7. height = ViewGroup.LayoutParams.WRAP_CONTENT
  8. weight = 1f
  9. }
  10. textSize = 20f
  11. text = "first Button"
  12. }
  13. //添加第二个子View
  14. createView<TextView> {
  15. with(layoutParams as LinearLayout.LayoutParams) {
  16. width = ViewGroup.LayoutParams.WRAP_CONTENT
  17. height = ViewGroup.LayoutParams.WRAP_CONTENT
  18. weight = 1f
  19. }
  20. textSize = 20f
  21. text = "second TextView"
  22. }
  23. }

最外层的createView函数是Context的扩展函数,他的函数参数是LinearLayout.() -> Unit,所以最外层大括号内的Receiver就是LinearLayout对象。
因此内层的createView函数是ViewGroup的扩展函数,这样内部创建的Button和TextView都添加到了LinearLayout中,实现了层级关联。

上面的代码已经很简洁了,但是还有提升的空间(这里一开始我也没有想到,是参考的这篇文章)。

上述构建方式主要缺点是还要指定泛型参数,下面我们就把泛型参数干掉。首先,需要根据View类型为Context和ViewGroup声明扩展函数,如下所示:

  1. //下面的三个函数调用的都是Context的扩展函数createView,因此创建出来的都是单个View。
  2. fun Context.linearLayout(init: LinearLayout.() -> Unit) = createView(init)
  3. fun Context.textView(init: TextView.() -> Unit) = createView(init)
  4. fun Context.button(init: TextView.() -> Unit) = createView(init)
  5. //下面的三个函数调用的都是ViewGroup的扩展函数createView,因此创建出来的View都会被添加到付ViewGroup中。
  6. fun ViewGroup.linearLayout(init: LinearLayout.() -> Unit) = createView(init)
  7. fun ViewGroup.textView(init: TextView.() -> Unit) = createView(init)
  8. fun ViewGroup.button(init: TextView.() -> Unit) = createView(init)

因为上述扩展函数,不再有泛型,而且都是单个函数参数,因此新的构建方式可以简化如下:

  1. //调用Context.linearLayout函数
  2. linearLayout {
  3. orientation = LinearLayout.HORIZONTAL
  4. //调用ViewGroup.button函数
  5. button {
  6. with(layoutParams as LinearLayout.LayoutParams) {
  7. weight = 1f
  8. }
  9. textSize = 20f
  10. text = "first Button"
  11. }
  12. //调用ViewGroup.textView函数
  13. textView {
  14. with(layoutParams as LinearLayout.LayoutParams) {
  15. weight = 1f
  16. }
  17. textSize = 20f
  18. text = "second TextView"
  19. }
  20. }

怎样,上述方式是不是很像Gradle配置文件,都是基于DSL的,差不太多。

这种基于Type-safe Builders构建View层级的方式相对于Java Code来说确实简洁不少。
但是在Android中,我们一般通过XML文件来进行View布局,这种方式非常直观。但使用XML布局文件也存在着性能问题,因为系统需要先解析XML文件,再去构建View对象。

下面我们简单对比下通过Type-safe Builders形式代码和XML文件实现相同布局的耗时。这里的对比方案是使用Github上的项目kotlin-view-builder,详细过程可以看下代码。

简单来说,一种是通过上面介绍的Type-safe Builders方式构建View对象,另一种是通过LayoutInflater来加载布局文件。最终要实现的布局如下所示:

  1. <LinearLayout
  2. xmlns:android="http://schemas.android.com/apk/res/android"
  3. android:layout_width="match_parent"
  4. android:layout_height="wrap_content"
  5. android:orientation="horizontal"
  6. android:paddingTop="8dp"
  7. android:paddingBottom="8dp"
  8. android:paddingLeft="16dp"
  9. android:paddingRight="16dp">
  10. <TextView
  11. android:layout_width="wrap_content"
  12. android:layout_height="wrap_content"
  13. android:layout_marginRight="16dp"
  14. android:layout_marginEnd="16dp"
  15. android:layout_gravity="center_vertical"
  16. android:textSize="24sp"
  17. android:text="@string/time"
  18. />
  19. <LinearLayout
  20. android:layout_width="0dp"
  21. android:layout_height="wrap_content"
  22. android:layout_weight="1"
  23. android:layout_gravity="center_vertical"
  24. android:orientation="vertical"
  25. >
  26. <TextView
  27. android:layout_width="wrap_content"
  28. android:layout_height="wrap_content"
  29. android:text="@string/day"
  30. />
  31. <TextView
  32. android:layout_width="wrap_content"
  33. android:layout_height="wrap_content"
  34. android:text="@string/location"
  35. />
  36. </LinearLayout>
  37. </LinearLayout>

耗时结果如下表所示(单位:ms,取5次平均值,测试手机为小米4 Android6.0系统):

创建View对象的次数 Type-safe Builders XML XML / Builders
1 2 4 2.0
10 20 35 1.75
100 189 284 1.50
500 968 1402 1.44
1000 1945 2681 1.38

由上表可知:通过代码构建View对象总体上还是要比XML快一些。但是随着View对象增多,kotlin的优势逐渐变小(这点还没有想明白)。
除了上述性能对比,其实这两种方式各有其使用场景,具体可以参考
实战kotlin@android(三):扩展变量与其它技巧

方法数和安装包

在Android开发中,方法数和安装包是永恒的话题。因此我们看下添加kotlin后的安装包和方法数增量。

项目 安装包 方法数
新建的Android项目 1.2M 16259
新增Stdlib和Runtime类库 1.5M 23177
新增Reflect类库 2.1M 34855
新增Anko类库 2.2M 36971

Stdlib和Runtime是Kotlin必不可少的基础类库,方法数大概是7000个,还可以接受。
相对来说,Reflect类库的安装包和方法数增量都比较大,但是该类库不是必须的,可以选择使用(主要是为了处理kotlin反射和java反射之间的兼容性)。最后一个Anko是为了方便构建动态View层级,可视情况决定是否采用。

添加新批注
在作者公开此批注前,只有你和作者可见。
回复批注