【Kotlin】八、Kotlin Android Extensions

2019-10-18 15:01 来源:未知

由于官网的例子很全面,因此这里直接套用Kotlin官网的例子:

前言

(PS:因为Android Stuidio 3.0后,会自动导入插件,所以文章只针对之前版本或其他idea)

另一个Kotlin团队研发的可以让开发更简单的插件是 Kotlin Android
Extensions 。当前仅仅包括了view的绑定。这个插件自动创建了很多的属性来让
我们直接访问XML中的view。这种方式不需要你在开始使用之前明确地从布局中去
找到这些views。

这些属性的名字就是来自对应view的id,所以我们取id的时候要十分小心,因为它
们将会是我们类中非常重要的一部分。这些属性的类型也是来自XML中的,所以我
们不需要去进行额外的类型转换。

Kotlin Android Extensions 的一个优点是它不需要在我们的代码中依赖其它
额外的库。它仅仅由插件组层,需要时用于生成工作所需的代码,只需要依赖于
Kotlin的标准库。

那它背后是怎么工作的?该插件会代替任何属性调用函数,比如获取到view并具有
缓存功能,以免每次属性被调用都会去重新获取这个view。需要注意的是这个缓存
装置只会在 Activity 或者 Fragment 中才有效。如果它是在一个扩展函数中增
32450新蒲京网站,加的,这个缓存就会被跳过,因为它可以被用在 Activity 中但是插件不能被修
改,所以不需要再去增加一个缓存功能。

open class D {
}

class D1 : D() {
}

open class C {
    open fun D.foo() {
        println("D.foo in C")
    }

    open fun D1.foo() {
        println("D1.foo in C")
    }

    fun caller(d: D) {
        d.foo()   // call the extension function
    }
}

class C1 : C() {
    override fun D.foo() {
        println("D.foo in C1")
    }

    override fun D1.foo() {
        println("D1.foo in C1")
    }
}

C().caller(D())   // prints "D.foo in C"
C1().caller(D())  // prints "D.foo in C1" - dispatch receiver is resolved virtually
C().caller(D1())  // prints "D.foo in C" - extension receiver is resolved statically

怎么去使用Kotlin Android Extensions

如果你还记得,现在项目已经准备好去使用Kotlin Android Extensions。当我们创建
这个项目,我们就已经在 build.gradle 中增加了这个依赖:

buldscript{
    repositories {
        jcenter()
    }
    dependencies {
        classpath "org.jetbrains.kotlin:kotlin-android-extensions:$kotlin_version"
    }
}

唯一一件需要这个插件做的事情是在类中增加一个特定的"手工" import 来使用这
个功能。我们有两个方法来使用它:

例子很简单,无非就是Extension的声明和如何调用Extension方法(注意:这里调用Members' Extension 通过了实例方法的转接,可以跟Kotlin Extension - Method中提到的无法在.kt文件中从实例或者外界直接拿到Extension方法引用联系起来)
这里Kotlin定义了两个重要的概念:

Activities 或者 Fragments 的 Android Extensions

这是最典型的使用方式。它们可以作为 activity 或 fragment 的属性是可以被
访问的。属性的名字就是XML中对应view的id。

我们需要使用的 import 语句以 kotlin.android.synthetic 开头,然后加上我
们要绑定到Activity的布局XML的名字:

import kotlinx.android.synthetic.activity_main.*

此后,我们就可以在 setContentView 被调用后访问这些view。新的Android
Studio版本中可以通过使用 include 标签在Activity默认布局中增加内嵌的布局。
很重要的一点是,针对这些布局,我们也需要增加手工的import:

import kotlinx.android.synthetic.activity_main.*
import kotlinx.android.synthetic.content_main.*
dispatch receiver: 指的便是例子中执行caller() 方法的C或者C1实例对象

Views 的 Android Extensions

前面说的使用还是有局限性的,因为可能有很多代码需要访问XML中的view。比
如,一个自定义view或者一个adapter。举个例子,绑定一个xml中的view到另一个
view。唯一不同的就是需要 import :

import kotlinx.android.synthetic.view_item.view.*

如果我们需要一个adapter,比如,我们现在要从inflater的View中访问属性:

view.textView.text = "Hello"
extension receiver: 指的便是例子中caller() 方法定义中执行Extension方法foo() 的对象

接下来看看三个例子给我们揭示的一些重要现象

重构我们的代码

现在是时候使用 Kotlin Android Extensions 来修改我们的代码了。修改相当
简单。

我们从 MainActivity 开始。我们当前只是使用了 forecastList 的
RecyclerView。但是我们可以简化一点代码。首先,为 activity_main XML增加
手工import:

import kotlinx.android.synthetic.activity_main.*

之前说过,我们使用id来访问views。所以我要修改 RecyclerView 的id,不使用
下划线,让它更加适合Kotlin变量的名字。XML最后如下:

<FrameLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">
    <android.support.v7.widget.RecyclerView
        android:id="@+id/forecastList"
        android:layout_width="match_parent"
        android:layout_height="match_parent"/>
</FrameLayout>

然后现在,我们可以不需要 find 这一行了:

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    forecastList.layoutManager = LinearLayoutManager(this)
    ...
}

这已经是最小的简化了,因为这个布局非常简单。但是 ForecastListAdapter 也
可以从这个插件中受益。这里你可以使用一个装置来绑定这些属性到view中,它可
以帮助我们移除所有 ViewHolder 的 find 代码。

首先,为 item_forecast 增加手工导入:

import kotlinx.android.synthetic.item_forecast.view.*

然后现在我们可以在 ViewHolder 中使用包含在 itemView 中的属性。实际上你
可以在任何view中使用这些属性,但是很显然如果view不包含要获取的子view就会
奔溃。

现在我们可以直接访问view的属性了:

class ViewHolder(view: View, val itemClick: (Forecast) ->Unit):RecyclerView.ViewHolder(view) {
    fun bindForecast(forecast: Forecast) {
        with(forecast){
            Picasso.with(itemView.ctx).load(iconUrl).into(itemView.icon)
            itemView.date.text = date
            itemView.description.text = description
            itemView.maxTemperature.text = "${high.toString()}"
            itemView.minTemperature.text = "${low.toString()}"
            itemView.onClick { itemClick(forecast) }
        }
    }
}

Kotlin Android Extensions插件帮助我们减少了很多模版代码,并且简化了我们访问
view的方式。

1. C().caller(D1())

很明显,我们这里往caller()方法里面传的是extension receiver类型是D1,但是为何最后调用的是父类D的Extension方法呢?
通过反编译生成的.class文件我们找到的原因所在

//C.class
...
public final void caller(com.maxtropy.viewtest.D);
    Code:
       0: aload_1
       1: ldc           #39                 // String d
       3: invokestatic  #15                 // Method kotlin/jvm/internal/Intrinsics.checkParameterIsNotNull:(Ljava/lang/Object;Ljava/lang/String;)V
       6: aload_0
       7: aload_1
       8: invokevirtual #41                 // Method foo:(Lcom/maxtropy/viewtest/D;)V
      11: return
...

//.class where C().caller(D1()) was executed
...
      32: invokespecial #20                 // Method com/maxtropy/viewtest/C."<init>":()V
      35: new           #29                 // class com/maxtropy/viewtest/D1
      38: dup
      39: invokespecial #30                 // Method com/maxtropy/viewtest/D1."<init>":()V
      42: checkcast     #22                 // class com/maxtropy/viewtest/D
      45: invokevirtual #27                 // Method com/maxtropy/viewtest/C.caller:(Lcom/maxtropy/viewtest/D;)V
...

在caller()的入参中,d的参数类型是D,因此在调用caller()时,入参实例的类型就已经被上转型成D了。

2. C1().caller(D())

程序执行的结果很明显的告诉我们这是动态选择的结果,执行的是C1中的Extension方法,而不是父类C中的Extension方法。
哇!在 top-level Extension反编译的例子中很明显的看到Extension方法被编译成了静态方法,这里怎么又跟动态选择有关了呢???
同样施以反编译的魔法:

//C.class
Compiled from "C.kt"
public class com.maxtropy.viewtest.C {
  public void foo(com.maxtropy.viewtest.D);
    Code:
       0: aload_1
       1: ldc           #9                  // String $receiver
       3: invokestatic  #15                 // Method kotlin/jvm/internal/Intrinsics.checkParameterIsNotNull:(Ljava/lang/Object;Ljava/lang/String;)V
       6: ldc           #17                 // String D.foo in C
       8: astore_2
       9: getstatic     #23                 // Field java/lang/System.out:Ljava/io/PrintStream;
      12: aload_2
      13: invokevirtual #29                 // Method java/io/PrintStream.println:(Ljava/lang/Object;)V
      16: return

  public void foo(com.maxtropy.viewtest.D1);
    Code:
       0: aload_1
       1: ldc           #9                  // String $receiver
       3: invokestatic  #15                 // Method kotlin/jvm/internal/Intrinsics.checkParameterIsNotNull:(Ljava/lang/Object;Ljava/lang/String;)V
       6: ldc           #35                 // String D1.foo in C
       8: astore_2
       9: getstatic     #23                 // Field java/lang/System.out:Ljava/io/PrintStream;
      12: aload_2
      13: invokevirtual #29                 // Method java/io/PrintStream.println:(Ljava/lang/Object;)V
      16: return

  public final void caller(com.maxtropy.viewtest.D);
    Code:
       0: aload_1
       1: ldc           #39                 // String d
       3: invokestatic  #15                 // Method kotlin/jvm/internal/Intrinsics.checkParameterIsNotNull:(Ljava/lang/Object;Ljava/lang/String;)V
       6: aload_0
       7: aload_1
       8: invokevirtual #41                 // Method foo:(Lcom/maxtropy/viewtest/D;)V
      11: return

  public com.maxtropy.viewtest.C();
    Code:
       0: aload_0
       1: invokespecial #45                 // Method java/lang/Object."<init>":()V
       4: return
}

//C1.class
Compiled from "C.kt"
public final class com.maxtropy.viewtest.C1 extends com.maxtropy.viewtest.C {
  public void foo(com.maxtropy.viewtest.D);
    Code:
       0: aload_1
       1: ldc           #9                  // String $receiver
       3: invokestatic  #15                 // Method kotlin/jvm/internal/Intrinsics.checkParameterIsNotNull:(Ljava/lang/Object;Ljava/lang/String;)V
       6: ldc           #17                 // String D.foo in C1
       8: astore_2
       9: getstatic     #23                 // Field java/lang/System.out:Ljava/io/PrintStream;
      12: aload_2
      13: invokevirtual #29                 // Method java/io/PrintStream.println:(Ljava/lang/Object;)V
      16: return

  public void foo(com.maxtropy.viewtest.D1);
    Code:
       0: aload_1
       1: ldc           #9                  // String $receiver
       3: invokestatic  #15                 // Method kotlin/jvm/internal/Intrinsics.checkParameterIsNotNull:(Ljava/lang/Object;Ljava/lang/String;)V
       6: ldc           #35                 // String D1.foo in C1
       8: astore_2
       9: getstatic     #23                 // Field java/lang/System.out:Ljava/io/PrintStream;
      12: aload_2
      13: invokevirtual #29                 // Method java/io/PrintStream.println:(Ljava/lang/Object;)V
      16: return

  public com.maxtropy.viewtest.C1();
    Code:
       0: aload_0
       1: invokespecial #40                 // Method com/maxtropy/viewtest/C."<init>":()V
       4: return
}

原来声明在Member中的Extension方法全部被编译成了Member所在类型的实例方法!
这实例方法有什么用呢?(再次重复这些实例方法在写.kt时无法通过实例直接拿到引用,也就c.foo()是不能通过编译的)
玄妙便在call()方法的第6、行, 第6行的aload_0指的便是this, 也即是caller()被执行时真正的实例对象dispatch receiver。正是this,让Extension方法具备了动态选择的能力。

TAG标签:
版权声明:本文由32450新蒲京网站发布于葡萄游戏厅_棋牌游戏,转载请注明出处:【Kotlin】八、Kotlin Android Extensions