Ktor - 标签 - ISLAND

Ktor整合nacos注册中心

Tue, 03 Nov 2020 08:56:31 +0000

说起微服务，对于一直使用 java 生态的用户来说，首先想到的应该是 spring cloud 。Spring cloud 已经成为了 java 微服务中重要的标杆。但是同样是 jvm 语言的 kotlin 就没有这样好的环境了，虽然 kotlin 可以使用 spring 生态，而且 spring 在逐步整合 kotlin 的特性。

ktor 是 JetBrains 开发的 kotlin 框架，完全基于 kotlin。kror 提供了官方提供了很多 feature 使用。但是在使用过程中总会有一些功能是官方没有提供的。这时候就需要我们自己去完成。

什么是 feature

ktor 程序是有一系列的feature组成的。通过feature，我们可以自由的更改请求和响应。通过 install 方法将 feature 安装到应用里。例如：

fun Application.main() {
    install(DefaultHeaders)
    install(CallLogging)
    install(Routing) {
        get("/") {
            call.respondText("Hello, World!")
        }
    }
}

而官方提供的一系列 feature 中，不可能满足我们所有的需求，此时就需要自定义我们的feature。

自定义 feature

针对自定义feature，官方也给了一篇简短的文档来说明如何自定义。定义一个 feature 主要是实现新的 ApplicationFeature 接口的伴生对象，并且去实现它的方法。

这里面主要有一个属性 key 和一个方法 install 。

public val key: AttributeKey<TFeature>

public fun install(pipeline: TPipeline, configure: TConfiguration.() -> Unit): TFeature

key 属性是一个唯一的标识，用来标识当前的 feature。而 install 方法为 feature 的主要实现功能。

在 install 方法中可以初始化 feature 功能。

服务注册 feature

通过查阅 nacos 的官方文档，可以了解到如何将服务注册到 naocs 上。在install里完成逻辑代码，install里面的逻辑只会执行一次，但是如果想每次请求和响应都需要执行方法，那么可以使用 pipeline.intercept 。

以下是 naocs 的注册实现，当然还有很多功能去完成。方法内有 NacosCOnfig 方法，通过该方法来读取 ktor 的 application.conf 配置文件。其中一些配置是我们需要写在 application.conf 中的，比如 nacos 的端口和地址。

nacos {
    port: 8848
    address: 127.0.0.1
}

@KtorExperimentalAPI
override fun install(pipeline: ApplicationCallPipeline, configure: Configuration.() -> Unit): NacosDiscover {
    val nacosConfig = NacosConfig()
    val config = HoconApplicationConfig(ConfigFactory.load())
    val ktorConfig = config.config("ktor")
    val ktorPort = ktorConfig.propertyOrNull("deployment.port")?.getString()?.toInt() ?: 8080
    val configuration = Configuration().apply(configure)
    val feature = NacosDiscover(configuration)
    val addr = InetAddress.getLocalHost();
    val serverAddress = addr.hostAddress
    // 应用启动时进行
    val naming = NamingFactory.createNamingService("${nacosConfig.nacosAddress}:${nacosConfig.nacosPort}")
    val instance = Instance()
    instance.ip = serverAddress
    instance.port = ktorPort
    instance.serviceName = feature.serverName
    instance.isHealthy = true
    val mateData = HashMap<String, String>()
    mateData["framework"] = "ktor"
    instance.metadata = mateData
    naming.registerInstance(feature.serverName, instance)
    return feature
}

具体代码可以看 Github ktor-nacos ,这样就完成了服务注册。

服务请求

当服务注册到 naocs 上的时候，此时就需要通过客户端进行请求。所以需要编写客户端的 feature。

客户端的 feature 主要作用是通过服务名获取服务的详细信息，然后去请求对应的服务。

override fun install(feature: NacosClient, scope: HttpClient) {

    val nacosConfig = NacosConfig()
    val naming = NamingFactory.createNamingService("${nacosConfig.nacosAddress}:${nacosConfig.nacosPort}")
    scope.requestPipeline.intercept(HttpRequestPipeline.Render) {
        val instances = naming.getAllInstances(context.url.host).filter { it.isHealthy and it.isEnabled }
        val selectedNode = instances[currentNodeIndex]
        context.url.host = selectedNode.ip
        context.url.port = selectedNode.port
        currentNodeIndex = (currentNodeIndex + 1) % instances.size
    }
}

并且添加了负载均衡，每次将请求转发到不同的服务上。

总结

通过对 ktor 的基本了解，主要是通过编写 feature 和 pipeline 进行插件功能的实现。目前 ktor 的生态还很不完善，只提供了基础的组件，还有很多组件需要自己去整合完成，还需要社区不断的贡献。

项目已经开源到Github上。youngxhui/ktor-nacos

补充一个 ktor 资源网站 https://www.kotlinresources.com/#

参考链接

https://ktor.io/docs/advanced-features.html

https://github.com/piomin/sample-kotlin-ktor-microservices

Ktor 入门

Sat, 02 Feb 2019 14:54:34 +0000

前言

最近要使用 netty 作为消息推送，之前一直想着集成在 Springboot 中使用，但是转念一想，netty 本身就可以作为服务器，为什么不再开一个服务呢？于是就想到了使用 Ktor 构建一个服务。

Ktor 是一个使用强大的 Kotlin 语言在互联系统中构建异步服务器与客户端的框架。并且正在努力的向其他平台构建，比如 JavaScript，iOS 和 Android ，且逐步尝试支持原生环境( Native )。

使用 Ktor 可以很快的写出一个 HelloWorld

工欲善其事必先利其器

ktor 是以 kotlin 为基础的一个异步框架，那么开发采用 IDEA 成了我们更加友好的选择。

在 IDEA 中 setting Plugins 中的 MarketPlace 搜索 Ktor 。我们安装这个插件将更快的初始化我们的项目。

完成了基础工作，就可以开始我们的 Ktor 之旅了。

Hello World

暂时不需要选择任何模块。之后便可以下一步下一步等，直到项目建立。

在 gradle 界面选择 auto-import

此时只要耐心等待所有的依赖安装完成

如果多次安装失败可以修改一下gradle的地址,将原有地址注释掉，修改为阿里镜像。这样安装速度会很快，而且不容易失败

repositories {
    mavenLocal()
    //jcenter()
    maven { url 'https://maven.aliyun.com/nexus/content/groups/public' 
}

当项目构建完成的时候，在 src 目录下 Application.kt 中已经为我们生成了部分代码。

fun main(args: Array<String>): Unit = io.ktor.server.netty.EngineMain.main(args)

@Suppress("unused") // Referenced in application.conf
@kotlin.jvm.JvmOverloads
fun Application.module(testing: Boolean = false) {
}

开始编写我们的代码。

在 Application.module 中，编写我们要使用的路由。

fun Application.module(testing: Boolean = false) {
    routing {
        get("/") {
            call.respondText("Hello World")
        }
    }
}

启动项目，访问 http://127.0.0.1:8080 此时就可以看到我们的 Hello World。

routing 是 Ktor 中的核心模块，所以我们可以直接去使用。

构建一个 HTML 页面

ktor 中有 HTML DSL ，所以我们可以直接使用 Kotlin代码构建一个 html 页面。添加 html dsl 依赖

 compile "io.ktor:ktor-html-builder:$ktor_version"

之后就可以愉快的写 dsl 了

get("/") {
            call.respondHtml {
                head {
                    title {
                        +"Ktor 入门"
                    }
                }
                body {
                    a {
                        href = "http://127.0.0.1:8080/register"
                        +"注册"
                    }

                    form {
                        action = "http://127.0.0.1：8080/user/login"
                        method=FormMethod.post
                        input {
                            type = InputType.text
                            value = ""
                            name="username"
                        }
                        input {
                            type = InputType.password
                            value = ""
                            name="password"
                        }
                        input {
                            type = InputType.submit
                            value = "登录"
                        }
                    }
                }
            }
        }

重新启动一下

此时我们的页面就出现了。

目前这个表单无法访问 action 地址已向 ktor 提交 Issues

用Locations路由

但是当我们的路由很多的时候，如果都写在一个文件里，不仅仅文件回变得很大，而且不利于维护和团队协作。所以有了另一个模块 locations 。

首先要安装这个模块，在 gradle 中添加，注：功能目前还是实验性功能

dependencies {
    compile "io.ktor:ktor-locations:$ktor_version"
}

安装完成后启动我们的模块。

fun Application.module(testing: Boolean = false) {
    install(Locations) // 启用 Locations
    routing {
      // ...
    }
}

首先是编写 route 采用 class 的形式

@Location("/user")
class User {
    @Location("/login")
    data class UserLogin(val username: String, val password: String)

    @Location("/register")
    data class UserRegister(val username: String, val password: String)
}

该代码目前必须和 Application 在一起。

我们这样就编写了我们的路由和子路由。

新建一个 UserController.kt

fun Route.user() {
    post<User.UserLogin> {
        call.respondText("登录成功")
    }

    post<User.UserRegister> { user ->
        run {
            call.respondText("用户 ${user.username} ${user.password}")
        }
    }
}

并且在我们的 Application 文件中声明该路由即可。

   routing {
       // …………
        user()
       
       //…………
   }

此时访问的时候就可以访问到我们的子路由。

参考资料

Ktor 中文网 https://ktor.kotlincn.net/

打个广告

开发的小程序生活小程序