[Ktor] 实现动态化

众所周知的，我们的服务器不可能因为一点小的改动就要编译整个 jar 包，也不可能直接就进行完整的部署流程。正常的做法是把功能模块做成插件，然后动态的去进行加载，这样就不需要重启服务了。

那么在 Ktor 里如何实现呢，其实也是很简单的。Ktor 是基于 JVM 的，自然拥有 JVM 上可以做的各类骚操作，下面我们先来写一个简单的插件。

---

插件(1) 改造 Ktor 项目模板

经过改造后的项目模板如下所示，可以看到它不具备 Application，也没有 main 函数，因为插件并不需要这些，它只需要确保自己可以被 Routing 找到即可。

SamplePlugin
  |-- src
  |    |-- PluginRouting.kt
  |-- build.gradle
  |-- gradle.properties
  |-- settings.gradle

对于 PluginRouting.kt 而言，内容很简单，只要写出要响应的请求等即可：

fun Routing.pluginRouting() {
    get("/plug") {
        call.respondText { """{"result":0,"from":"plugin"}""" }
    }
}

然后其他的可以什么都不修改，使用 Ktor 项目的标准模板即可。

插件(2) 编译

通常我们使用 gradle build 来编译一个 Ktor 项目，而对于插件则要使用 gradle jar 来编译。

编译完成后我们可以得到一个名为 SamplePlugin-1.0.0.jar 的文件，这即是插件了。

需要说明的是，对于 Kotlin 代码中的扩展，其编译后的代码是静态方法，并且传入被扩展对象作为参数，如上述代码在编译后生成的代码是:

public class PluginRoutingKt {
    public static final void pluginRouting(Routing $routing$this);
}

到此，插件已经开发完毕了，非常的简单，它提供了一个 /plug 的请求响应。

---

宿主(1) 编写加载插件的代码

既然有了插件，那就得用宿主去加载它，利用 JVM 内的方法就可以轻松实现了，如上面的插件，我们可以这样加载:

fun loadPlugin(r: Routing) {
    val jar = File("SamplePlugin-1.0.0.jar").toURI().toURL()
    val loader = URLClassLoader(arrayOf(jar))
    val clz = loader.loadClass("com.rarnu.sample.plugin.PluginRoutingKt")
    val m = clz.getDeclaredMethod("pluginRouting", Routing::class.java)
    m.invoke(null, r)
}

当然你可以把代码写得更灵活一些，比如说从配置文件读取要加载的路由:

fun loadPlugin(r: Routing, filePath: String, clsName: String, routingName: String) = 
    URLClassLoader(arrayOf(File(filePath).toURI().toURL()))
        .loadClass(clsName)
        .getDeclaredMethod(routingName, Routing::class.java)
        .invoke(null, r)

然后就可以写一个 Routing 来实现加载了:

get("/load/{file}/{cls}/{routing}") {
    val f = call.parameters["file"] ?: ""
    val cls = call.parameters["cls"] ?: ""
    val routing = call.parameters["routing"] ?: ""
    loadPlugin(this@sampleRouting, f, cls, routing)
    call.respondText { "OK" }
}

宿主(2) 请求动态加载

跑起项目后，就可以在浏览器内访问以下 URL 以实现动态加载插件了

http://0.0.0.0/load/SamplePlugin-1.0.0.jar/com.rarnu.sample.plugin.PluginRoutingKt/pluginRouting

成功后即可在浏览器内访问以下 URL 来验证结果:

http://0.0.0.0/plug

宿主(3) 动态卸载插件

如果只是用来测试或者要更新插件，那就必须先把插件卸载，否则会造成一个协程崩溃的异常:

io.ktor.server.engine.BaseApplicationResponse$ResponseAlreadySentException: Response has already been sent

其根本原因是一个 request 只能有一个 response，如果有两个同名的路由，则会发送两次 response 引起该错误。

Ktor 并没有提供动态卸载路由的能力，只能研究源码了，所幸的是这部分源码非常容易找到:

@ContextDsl
open class Route(val parent: Route?, val selector: RouteSelector) : ApplicationCallPipeline() {

    val children: List<Route> get() = childList
    private val childList: MutableList<Route> = ArrayList()
    @Volatile private var cachedPipeline: ApplicationCallPipeline? = null
    internal val handlers = ArrayList<PipelineInterceptor<Unit, ApplicationCall>>()

    fun createChild(selector: RouteSelector): Route {
        val existingEntry = childList.firstOrNull { it.selector == selector }
        if (existingEntry == null) {
            val entry = Route(this, selector)
            childList.add(entry)
            return entry
        }
        return existingEntry
    }
  
    ... ...
}

可以清楚的看到，添加路由的过程，其实就是调用了 createChild 并且将新增的内容放到 childList 内，所以删去 childList 里的内容，就可以实现卸载路由。由此也可以轻松的写下代码了:

fun unloadRoute(r: Routing, routes: Array<String>) {
    val list = r.javaClass.superclass.getDeclaredField("childList").apply { isAccessible = true }.get(r) as MutableList<*>
    list.removeIf { "$it" in routes }
}

同样的，现在可以写一个路由来完成卸载:

get("/unload/{routing}") {
    val routing = call.parameters["routing"] ?: ""
    unloadRoute(this@sampleRouting, arrayOf(routing))
    call.respondText { "OK" }
}

---

好了，就写到这吧，Ktor 动态化的能力已经具备了，如果要投入实用，还需要加入一定的配置文件与读写的机制。不需要使用路由请求的方式来加载，而是在监视到文件变化时自动实现加载，才是最好的解决方案。