知乎 · 热度

首先很抱歉上一篇文章已经胎死腹中。。新的文章已经在酝酿中了，这几天内会发布出来，这篇就当做是给大家的一个新年祝福~顺便写写近期遇到的一些事。

Parceable generator for kotlin’s data class

这个我在上一篇（被遗弃的）板凳文里面就提到了，这是我前一段时间一直在捣鼓的一个 IntelliJ IDEA Plugin。我为什么一直在说它呢？因为，，这是非 kotlin 官方团队出的目前唯一一个 Plugin，其余几个 Plugin 都是出自 kotlin 官方团队。

为什么会出现这种情况呢？归根究底，我认为有两个原因：

1. 有 Plugin 开发经验的大牛们，还未有对该们语言提起兴趣的；
2. 基于 kotlin 语言开发 Plugin 必须依赖 kotlin-plugin 官方插件。IntelliJ IDEA 对 kotlin 语言的支持是以插件的形式提供的（这有利有弊），对 kotlin 语言内的各种 PSI Elements（IntelliJ Platform SDK DevGuide ）的处理不同于原生对 Java 的那一套。

第二点具体是什么概念？我解释一下，Jetbrains 虽然在 Github 上开源了 kotlin 所有相关的实现，但并没有任何官方 Wiki 对 kotlin-plugin 进行任何接口解释。要写出一个第三方 Plugin 完全靠阅读 JetBrains/kotlin · GitHub 的一大堆源码啊。

当然，最后我还是把它弄出来了 ：D。期间有个白俄罗斯的小伙提交了个 Issue，有人反馈的感觉真好~立马修复并更新上 Plugins Repository，目前下载量有两百多（不多，但是在缓步上升），期待能有其他人参与贡献。

Android 开发者市场水太深

近几天，无聊搜了好几个 Android 开发 QQ 群来加。人嘛，都是社群动物，总想和自己领域内的人打打交道。

然而我发现，现在的各种培训班真是无处不在，我 TM 刚进群就几个陌生妹子号开私窗和我唠起来了，先是套近乎，接着「热情」给我推荐各种 Android 在线培训全家桶，只需花个几千块就可两个月内入门 Android 应用开发，一年内月入上万有木有。。

再看看群友们平时都在聊些什么。。。。

大家都在讨论着哪个培训班更便宜、更靠谱，交流着各种培训班的训练项目，讨论的问题也基本上是一些低层次的问题。。

这些无良培训班，打着培训完后月入上万的口号，让多少非专业甚至对编程完全不感兴趣的人涌入开发者市场。本身对编程感兴趣的人就算不上多了，现在还要跟一群其他行业转过来的培训生竞争岗位，也是醉了。

前几个月公司忙着招人的时候，身为面试官，对所有培训班出来的面试者天然降 30 分（真有能力者例外）。并非歧视培训班出来的人，但是培训班出来的，多数要不就是其他专业转过来的，要不就是大学时期没好好学习，工作前还需要再培训。

要知道，并非培训几个月就能熟悉某个领域，更不是做过几个培训项目就有动手能力。问过几个培训班出来的，甚至连很多计算机基础问题都答不出来，整场面试也就只能围绕着他们做的那几个「培训项目」说说。到后来也就疲倦了，凡是看不上的都直接提前中止面试，省得浪费时间。

这年头，比较好的开发者很多都开始移民了，现在给国内这些培训班一搅和，长尾效应更严重了，花个半天时间去逛 CSDN、eoeAndroid 等社区，会发现实在是鱼塘水深。

对于上一期文章末尾讲的 companion 还遗留了一些需要解释的地方。

• 上期最后 Parcelable 类的 @JvmStatic 注解词已纠正为更适合的 @JvmField 。@JvmField 将 CREATOR 变量注解为纯 Java 的 field，去掉 kotlin 的特性（例如自动生成 getter, setter），直接暴露 CREATOR 变量给 Java 代码。
• @JvmStatic 通常用来注解函数（必须定义在 companion object 或 named object 类内），注解后的函数可以直接在 Java 中通过类名访问：

KotlinClass.doSomething()

• 前缀为 Jvm 的注解词 ，是在需要和 Java 代码进行交互的地方才用到，会失去大部分 kotlin 中的特性，非不得已的话，还是少用为妙。
• companion object 在 Java 中的等价实现，实际上是一个 static 修饰的内部 class。就算不借助 Jvm/java-interop 注解词，我们也可以在 Java 代码中，通过 class 内的 Companion 内部类，来访问 companion object 代码块中的变量：

KotlinClass.Companion.doSomething()

另外，上期文章末尾在对 companion做解释时，提到了 named object，下面粗略提一下。

named object 定义一个全局单例

例如，我们可以在 Model 类内定义一个实名 object 对象 ModelList，并在每次新建 Model 的时候，将实例加入到 ModelList 中的 list 中。

data class Model(var test1: Int, var test2: Int): Parcelable {
    constructor(source: Parcel): this(source.readInt(), source.readInt()) {
        ModelList.list.add(this)
    }
    // ...
    object ModelList {
        val list = arrayListOf<Model>()
    }
}

这样我们就维护了一个 全局的 ModelList 单例。当然，named object 还有其他用处，这里暂且就不细说了。

侃

很抱歉拖了很长一段时间的稿，最近工作较忙，空闲时间较少，故而一直未跟进该系列专栏（好吧，其实是懒）。

另，如果时间充足的话，笔者会考虑再开一个 『使用 python 开发 Web』 系列专栏，初步构想是讲解tornado 的一些初、中级知识。专栏也会涉猎到，但不限于 「爬虫、Web Front-end」 等领域。

当然一切只是空想，事实上有出入的话请别打我 ╮(╯_╰)╭ 笔者是个懒人。

回到正文

这节将对 kotlin_android_base_framework （以下简称 base_framework） 中的 activity/helper 进行讲解。

base_framework 使用的一个包结构如下：

com.nekocode.baseframework
├─ data
│  ├─ net
│  └─ local
│ 
├─ presenter
│ 
├─ ui
│  ├─ activity
│  ├─ adapter
│  ├─ fragment
│  └─ view
│ 
├─ utils
│ 
├─ App.kt
└─ Config.kt

为了方便，并没有将 kotlin 源码文件提取到新的 kotlin source 文件夹中。目前暂时混合储存在 java source 文件夹中。

BaseActivity.kt

得益于 Java 的继承机制，在 base_framework 中，我们可以实现一个抽象的 BaseActivity 类，并在其中实现一些 Activity 通用的方法（例如实现「应用内 UI 风格统一」），这样我们在添加新 Activity 时，只需要继承 BaseActivity 就能获取统一的 features 和接口。

在 BaseActivity.kt 中已经实现的通用接口：

• 维护一个全局 Handler 来解决「 Activity 中」异步通知，以及「 Activity 间」的通信问题

使用 sendMsg()，sendMsgDelayed() 以及 runDelayed() 来实现 Activity 中异步通知。而继承 BaseActivity 的子类都 必须实现抽象的 handler() 方法，来处理异步传来的消息，例如：

public class MainActivity : BaseActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        sendMsgDelayed(msg(MSG.SHOW_HELLO), 1000)
    }

    object MSG {
        const val SHOW_HELLO = 0
    }

    override fun handler(msg: Message) {
        when(msg.what) {
            MSG.SHOW_HELLO -> showToast("hello")
        }
    }
}

这样，在 Activity 创建后，会延迟一秒再发送 SHOW_HELLO 消息给自己，这个在很多异步场景下十分实用。例如进行一次异步网络请求，或者其他异步耗时操作时，在操作完成后，可以使用 sendMsg() 通知 Activity 已完成操作。注意：handler() 中的消息处理是在 UI Thread 中完成的。

另外，上面的 showToast() 的用法，可以使用 kotlin 的 Extensions 语法糖来实现：

public fun Context.showToast(any: Any) {
    when(any) {
        is Int ->
            Toast.makeText(this, any, Toast.LENGTH_SHORT).show()
        is String ->
            Toast.makeText(this, any, Toast.LENGTH_SHORT).show()
    }
}

这里，我们为 Context 类拓展了 showToast 外部函数，在 showToast() 内可以通过 this 变量来访问「 showToast() 当前所在 Context 的实例」，于是就可以在所有 Context 类及其子类下，使用我们自定义的 showToast 语法糖：

class ContextA : Context() {
    fun toast() {
        // normal
        Toast.makeText(ContextA.this, "hello", Toast.LENGTH_SHORT).show()

        // used extensions
        showToast("hello")
    }
}

其他的一些关于 Extensions 语法糖的例子可以参考 Sugar.kt （会不断完善），这是 kotlin 中十分强大的 feature，通过为类实现 Extensions 方法，创建各种语法糖，极大地缩减了代码量。

而 Activity 间，可以使用 broadcast() 来广播消息。假如，我们实现了一个 LogoutActivity 用来处理用户的账户登出交互。在登出成功后，可以使用 broadcast() 广播一条 LOGOUT 消息给所有 Activity，通知 Activity 账户已经登出，以便进行相应操作。

public class LogoutActivity : BaseActivity() {
    fun logoutSuccess() {
        broadcast(msg(BaseActivity.MSG.LOGOUT))
    }

    override fun handler(msg: Message) {
    }
}

回到 BaseActivity.kt 中，我们来看看核心 MyHandler 的具体实现：

abstract class BaseActivity : AppCompatActivity() {
    companion object {
        private val handlers = arrayListOf<MyHandler>()

        class MyHandler : Handler {
            private val mOuter: WeakReference<BaseActivity>

            constructor(activity: BaseActivity) {
                mOuter = WeakReference(activity)
            }

            override fun handleMessage(msg: Message) {
                if(mOuter.get() == null) {
                    BaseActivity.deleteHandler(this)
                    return
                } else {
                    // ...
                    mOuter.get().handler(msg)
                }
            }
        }
    }
}

这里，MyHandler 被定义为 MainActivity 的内部类，关于 kotlin 中内部类的详细说明可以看 这里 ，在 kotlin 中，默认不加任何修饰词的内部类，都相当于 Java 中的静态内部类，也就是该内部类不持有外部类的实例。而添加了 inner 修饰词的内部类，会持有外部类的实例，可以通过BaseActivity.this 来访问外部类的实例。

• 默认内部类静态化，可以一定程度上降低初学者发生内存泄露的概率。很多时候内部类仅被用来存储数据，并不需要访问外部类中的属性。

我们在 companion object 中维护了一个静态全局 MyHandler 列表，在 Activity 执行 onCreate() 和 finish() 时分别入列和出列自己的 handler。这样我们就获得了一个动态储存所有运行中 Activity 的 Handler 列表。

当然，维护这个列表是为了实现 Activity 间 boradcast 功能。MyHandler 更详细的逻辑实现请自行看完整代码。

下面，我们来看看 runDelayed() 的具体实现：

public fun runDelayed(runnable: ()->Unit, delayMillis: Int) {
    val msg = Message()
    msg.what = -101
    msg.arg1 = -102
    msg.arg2 = -103
    msg.obj = runnable
    handler.sendMessageDelayed(msg, delayMillis.toLong())
}

这是一个 高阶函数 ，它把 runnable()匿名函数当做参数传入。注意，runnable 的类型定义为 ()->Unit。这个类型表示为：传参为空，返回为 Unit （空返回） 的匿名函数。

• 匿名函数是使用 Lambda 表达式的方法来书写的，所以也可以叫做『Lambda 表达式』

这样，我们就可以在 runDelayed() 中用使用 Lambda 表达式 ：

runDelayed({ showToast("hello") }, 1000)

相信有不少朋友使用过 gradle-retrolambda 插件，但这是一种侵入式的 lambda 实现模拟。相对来说，kotlin 的原生 lambda 支持显得更为彻底，用起来也更加爽快，要知道 「在 kotlin 中，函数和其他值类型一样是一等公民」。

而 kotlin-android-extensions 已经默认为我们将大部分以前使用匿名类传参的各种系统接口，添加上 lambda 的支持，Cool！(｡・`ω´･)

另外，在这里解释一下，我们利用 android.os.Message 中的三个参数来标志这是个带 runnable 的消息，在 MyHandler 处理消息时，通过三个参数标志来判断是否是个带 runnable 的消息，如果是的话，就执行该 runnable 函数：

if (msg.what == -101 && msg.arg1 == -102 && msg.arg2 == -103) {
    val runnable = msg.obj as ()->Unit
    runnable.invoke()
    return
}

SingleFragmentActivity.kt

这是一个含有单个 Toolbar 和 Fragment 的 Activity 抽象类。在很多场景下，我们仅需要含有单个 Fragment 的 Activity，这时候就可以继承 SingleFragmentActivity：

public class MainActivity : SingleFragmentActivity() {
    override val fragmentClass = TestFragment::class.java

    override val fragmentBundle = {
        null
    }

    override fun afterCreate() {
        toolbar.title = "TestActivity"
    }

    override fun handler(msg: Message) {
    }
}

是的，仅仅需要这几行代码就可以创建一个用 TestFragment 填充的 Activity。

我们来看看布局的具体实现：

relativeLayout {
    include<Toolbar>(R.layout.toolbar) {
        id = id_toolbar
    }.lparams(width = matchParent, height = dip(50))

    frameLayout {
        id = id_fragment_content
    }.lparams(width = matchParent, height = matchParent) {
        below(id_toolbar)
    }
}

我们使用了 anko 库来用 DSL 描述我们 SingleFragmentActivity 的 UI 布局，关于 anko 更详细介绍请查阅 该处 。

我们在 SingleFragmentActivity 中定义了两个抽象变量 fragmentClass，fragmentBundle（在 kotlin 中，支持在抽象类中定义抽象变量）。这样，我们在子类 override 这两个变量，就可以指定使用哪个 Fragment 来填充 Activity 了。

另外需要说明的两个地方是：

1. TestFragment::class.java 返回的是 TestFragment 的 java Class 对象，不添加.java 的话返回的是 kotlin Class 对象。在这里，因为 Fragment.instantiate() 传入的是 java Class 对象，所以使用::class.java。
2. override val fragmentBundle = { null } 表示一个返回为 null 的匿名函数。在 lambda 表达式中，默认省去 return 关键字的最后的变量，表示为返回值。

结语

感觉这篇废话有些多了（kotlin 以外的东西讲得有些多），以后会多抽精华的地方来讲。心情好的话，也会讲一下 Android 上的一些东西。但是大家都知道的东西，就不多讲了。

顺便解释下，标题乱起的 =_=

前言

前段时间抽空对框架做了些修改，主要包括下面几点：

• 将之前用于序列化与持久化的 Kryo 换成更强大的 Hawk 。
• 将之前用于测试 Retrofit（使用 Gson 进行反序列）的 Java Class 替换成 Kotlin 的 Data Class。

Local Repo

先来讲讲新添加到 Local Repo 的 Storage.kt ，它简单地封装了 Hawk 来进行本地 Key-Value 类型数据的储存。选择使用 Hawk 取代 Kryo 是因为它有以下的一些 features：

• 使用 AES 加密
• 使用 SharedPreferences 或者 Sqlite 进行数据储存
• 使用 Gson 进行序列反序列
• 储存任意类型的数据
• Rx support

当然，付出的代价就是速度降低了，但是它在反序列化时不像 Kryo 那样需传入类型的 class 对象：

// Before
val strtest = Cache["test", String::class.java]

// After
val model: Model.ParcelableTest? = Storage["test"]

Implement

Hawk 是使用 Java 编写的。我们可以创建一个 Storage 类并重载 Kotlin 中的 [ ] 操作符，来实现以下的调用：

Storage["test"] = Model(5, 1)
var test: Model? = Storage["test"]

我在前几篇文章中已经对 companion object 做了些介绍：

public class Storage {
    companion object {
        fun init(context: Context) {
            Hawk.init(context)
                    .setEncryptionMethod(HawkBuilder.EncryptionMethod.MEDIUM)
                    .setStorage(HawkBuilder.newSqliteStorage(context))
                    .setLogLevel(LogLevel.FULL)
                    .build();
        }

        operator fun set(key: String, obj: Any?) {
            if(obj != null) {
                Hawk.put(key, obj)
            } else {
                Hawk.remove(key)
            }
        }

        operator fun <T> get(key: String): T? = Hawk.get(key)
    }
}

companion object 是 Storage 类的伴生对象，它在类加载时就生成，具体实现其实就是在该类中添加一个静态子类 Companion，所以在 companion object 中的方法是 Storage 类的静态方法。

另外我们使用 operator 关键字修饰 get 和 set 方法来实现重载 Storage 的 [ ] 操作符，一些常见的可重载操作符以及其对应的转译方法：

更多可重载操作符请查阅 Operator overloading 。

Entity

在 base_framework 中我使用了 Retrofit 来与服务端进行交互，并使用了提供的 Gson Converter 来进行内部的隐藏的 Json 数据与实体类之间的转换。

之前是用 Java Class 来当作实体类，后来测试了下，Kotlin 下的 Data Class 也能在 Gson 下正常转换，内嵌也没问题，于是我把原先的 Weather.java 删除掉，用下面一个全局单例的 Model 对象来保存各种实体类：

object Model {
    data class WeatherInfo(val city: String)
    data class Weather(@SerializedName("weatherinfo") val weatherInfo: WeatherInfo)
}

注意一下 Gson 的 SerializedName 注解 可添加在 Data Class 的 Primary Constructor 中的对应属性声明前。而且注意一下，这里在 Weather 类中包含了同样为 Data Class 类型的 weatherInfo 属性，Gson 一样可以正常地转换，所以，没什么理由继续用 Java Class（又长又臭）了。

实践是检验真理的唯一标准

已经开始带着一个 Team 在实践 Kotlin 到最近一个的项目中，到目前为止，已经产出了一些挺有趣的东西，有空会继续分享出来。