vertx web开发（一）

vertx web开发

最近在开发中，由于spring 的大而全，反而不实用于一下小项目，因为spring boot在空载的情况，至少其内存占用超过150M.而对于一些简单的项目反到不适用。而反观vertx，这是一个全异步编程的框架，具体可查,其异步编程从某种角度来说可以使并发量极大的提高。而且内存占用远低于springboot.特别使vertx 配合kotlin，可以让你拥有同步的思想来进行异步开发。

• 创建HTTP server

引进相关的包，gradle项目添加相关依赖

    // vert core
    implementation 'io.vertx:vertx-web:4.0.3'
    // vert route
    implementation 'io.vertx:vertx-web:4.0.3'
    // kotlin coroutine and kotlin >= 4.0.3
    implementation 'io.vertx:vertx-lang-kotlin-coroutines:4.0.3'
    // kotlin 相关工具包
    implementation 'com.github.isyscore:common-jvm:1.6.1'

查阅vertx 文档文档，创建一个verticle 可以通过以下方式，

class HttpVerticle :AbstractVerticle() {
    override fun start() {
        super.start()
    }

    override fun stop() {
        super.stop()
    }
}

重写AbstractVerticle中的start以及stop方法皆可，但如在verticle在启动的时候的添加一下耗时的操作，比如一下IO操作，这个时候就应该用重写future start来启动。如下所示：

 override fun start(startPromise: Promise<Void>) {
        server.requestHandler {
            it.response().end("Hello world")
        }.listen(8080, "127.0.0.1") { res ->
            if (res.succeeded()) {
                startPromise.complete()
            } else {
                startPromise.fail(res.cause())
            }
        }
    }

此处创建一个http服务器，在listen处监听端口是耗时操作，在起回调的时候用complete(),来告诉vertx已经部署完成。但是采用的是kotlin开发，结合vertx可以更方便的集成回调。如下在kotlin下需要引入，io.vertx:vertx-lang-kotlin-coroutines:4.0.3 包，在创建verticle 可以采用如下方式:

class HttpVerticle : CoroutineVerticle() {
    override suspend fun start() {
        server.requestHandler {
            it.response().end("Hello world");
        }.listen(8080).await()
    }

    override suspend fun stop() {
        server.close().await()
    }
}

在这里看到kotlin的suspend关键字，这表示你可以用同步的思想来组织suspend里面的异步代码,而future可以通过await方法将future转成suspend形式,通过suspend避免了future回调地狱的场景.熟悉js的同学，应该知道这个思想和js的promise和像，只不过这里把，promise换成了future对象，async换成suspend,但对比两种方式其核心思想是一致的。

• 请求异常处理

由于vertx 中的future可以通过compose函数进行顺序合并，也就说中间在合并的中，如果有一个future抛出异常，那么顺序合并的future也是异常的future，通过这个思路，在结合kotlin语言的特性，可以为future扩展一个请求异常处理 函数。

inline fun<reified T> Future<T>.end(context: RoutingContext){
	val response = context.response()
	 this.onSuccess{  response.end("ok") }
	 this.onFailure { reponse.end("error,$it.message") }
}

通过以上的扩展函数，可以将future中抛出异常的future进行合并处理。

• Future类型转化

在future一般是future里面装一个泛型T,在kotlin中有高阶函数 run ,also将一个类型转化成另外一个类型，对比这样的思路，可以将future里面的T -> R ,有了这个思路，其实现如下：

// 对比also函数
inline fun<T,R> Future<T>.ownAlso(crossinline callback: (obj: T) -> R):Future<R>
 = compose { Future.future<R> { promise ->
            try {
                promise.complete(callback(it))
            }catch (e:Exception){
                promise.fail(e)
            }
        }
    }

inline fun<T,R> Future<T>.ownRun(crossinline callback: T.() -> R):Future<R> = compose { 
    Future.future<R> { promise ->
    try {
        promise.complete(callback(it))
    }catch (e:Exception){
        promise.fail(e)
    }
}
}

• Iterable 转 future

kotlin 中对list,map 等操作有个高阶函数map，可以将Iterable里面的类型转化成其他类型，这里我们可以借用这个思想，对Iterable里面的元素进行并发合并成一个future，其代码如下:

inline fun<T,R> Iterable<T>.merge(crossinline callback: (obj: T) -> Future<R>) :CompositeFuture =
       map { callback(it) }
      .run { CompositeFuture.all(this)  }

以上是kotlin集成vertx，所探索出来的几个比较有用的扩展函数

• 结语

本篇初次探索vertx，并且结合koltin语言的特性，探索出对开发有用的帮助的几个扩展函数。下篇文章，介绍基于vertx的路由拦截，所实现的路由工厂。