最近 JetBarin 公司发布了 Compose Desktop。是的，你没听错，就是 Google 用于Android 上的 Compose。

Jetpack Compose 是用于构建原生 Android 界面的新工具包。Jetpack Compose 使用更少的代码、强大的工具和直观的 Kotlin API 简化并加快了 Android 上的界面开发。

而现在，就可以编写同样的UI层代码，然后运行到 Android 和 DeskTop 了。不难发现，这是 kotlin 一直在搞的套路，多平台共享代码。

使用了 Skia 进行硬件加速( 就是Flutter使用的 Skia )，可以与 AWT 和 Swing 进行互操作。

让我们先来一个 Hello World 试试水。

新建 Compose 项目

你可以更新到最新的idea 2020.3(目前还是beta)，或者从 Github 上拉取它的模板。这里我选择使用 idea。

在 kotlin 选项中找到 JetBrains Compose ,选择 Desktop uses Kotlin。

创建完成后等待 gradle 依赖下载。

但是在这里会出现问题，运行是报下面的错。

org/jetbrains/kotlin/cli/common/PropertiesKt

org.jetbrains.kotlin.cli.common.PropertiesKt

Try: Run with –stacktrace option to get the stack trace. Run with –info or –debug option to get more log output. Run with –scan to get full insights.

经过排查，这是由 Gradle 和 java 14 引起的，Gradle 6.6 的版本会引起该问题，可以将gradle更改到 6.7 或者 6.5 重新进行构建。我这里修改到 6.5.1

目前 compose 的版本为 113 , 而通过 idea 创建的 版本为 63，所以更新版本。

以下为官方的 gradle.kts 配置

import org.jetbrains.compose.compose
import org.jetbrains.compose.desktop.application.dsl.TargetFormat
import org.jetbrains.kotlin.gradle.tasks.KotlinCompile

plugins {
    kotlin("jvm") version "1.4.0"
    // __UPDATE_COMPOSE_VERSION_MARKER__
    id("org.jetbrains.compose") version (System.getenv("COMPOSE_TEMPLATE_COMPOSE_VERSION") ?: "0.1.0-build113")
}


group = "me.young"
version = "1.0-SNAPSHOT"

dependencies {
    implementation(compose.desktop.currentOs)
}

compose.desktop {
    application {
        mainClass = "MainKt"

        nativeDistributions {
            targetFormats(TargetFormat.Dmg, TargetFormat.Msi, TargetFormat.Deb)
            packageName = "KotlinJvmComposeDesktopApplication"
        }
    }
}
repositories {
    jcenter()
    maven("https://maven.pkg.jetbrains.space/public/p/compose/dev")
}

运行

打开 main.kt, 运行 main 函数。

看样子还行，还是熟悉的界面 JavaFx , 还是熟悉的味道 Material Design 。让我们来瞅瞅代码。

fun main() = Window {
    var text by remember { mutableStateOf("Hello, World!") }

    MaterialTheme {
        Button(onClick = {
            text = "Hello, Desktop!"
        }) {
            Text(text)
        }
    }
}

通过通过点击按钮，来更改 text，从而来刷新界面。基本和其他声明式 UI ，大同小异，比如 flutter，swiftUI 等。

基本使用控件使用可以参考 androidx.compose 文档。

针对桌面做了一些扩展，比如鼠标，键盘事件，系统的原生通知，系统的托盘菜单。

具体文档可以参考官方 JetBrains/compose-jb 仓库

打包

开发完成的应用可以直接打包为平台可执行文件。我使用的是 windows 平台。通过 packageMsi 命令打包为 exe 应用。

这里会下载 wix3 。

这里可能会出现下载失败，如果下载失败，请手动到 Github 下载 wix311-binaries.zip。然后将文件命名为 wix311.zip 放在 build/wixToolset 下，重新运行 packageMsi 。

当你认为你要编译成功时， Gradle 再次报错。

������������, �����˴������MSI ��װ�����: �汾�ַ��������� MSI ���� [1.0-SNAPSHOT] �޸�����: �������¹������ô��������� “win.msi.productVersion”��https://msdn.microsoft.com/en-us/library/aa370859%28v=VS.85%29.aspx��

夺命�错，打开连接一看，好像是指定版本有问题， 微软要求版本必须按照 major.minor.build 这样的方式进行指定，而且 major 的范围是 0-255，minor的范围是 0-255，最后的 build 的范围是 0-65535 。

在 Gradle 中添加版本号。

nativeDistributions {
    targetFormats(TargetFormat.Dmg, TargetFormat.Msi, TargetFormat.Deb)
    packageName = "Hello World"
    version = "0.1.0"
}

更新 gradle 后重新 packageMsi。

仍旧是报错。这次是 IO 异常。

在Gradle 中添加新的配置 vendor 。

nativeDistributions {
    targetFormats(TargetFormat.Dmg, TargetFormat.Msi, TargetFormat.Deb)
    packageName = "Hello World"
    version = "0.1.0"
    vendor = "Example vendor"
}

经历了一番波折后终于可以打包成功。

打包后的 msi 在 build\compose\binaries\main\msi\Hello World-0.1.0.msi。

一个简单的Hello World 大小在 40 mb 左右。

总结

目前来说，项目还有很多 bug，毕竟才 Alpha，而且官方文档也有错误。例如打包这一块，很多问题需要自己摸索。

例如中文输入法的输入的情况下报错。

Exception in thread “AWT-EventQueue-0 @coroutine#2” java.lang.NullPointerException: event.text must not be null。

图标显示问题，在我这里显示一个黑框框。

但是，jvm 上的 GUi 技术有了新的发展未尝不是一件好事，可以一处编写，多端运行。

参考资料

compose-jb

JetBrains/compose-jb

androidx.compose

Jetpack Compose 基础知识

说起微服务，对于一直使用 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

Kotlin 不仅仅是能写Android，而且可以写服务端，可以说只要可以写Java的地方，就可以用Kotlin来进行替换。当然Kotlin远不止这些。目前Kotlin可以做到以下平台的开发和使用。jvm,android,js和native(beta)。正因为可以开发 Native ，所以Kotlin现在对 ios 开发也是支持的，虽然看起来效果不是那么的好。

今天进行的 Kotlin 进行 react 开发，这只是对 KotlinJs 的一次尝试和使用。

环境

• 浏览器：Microsoft Edge 77.0.235.5 (官方内部版本) dev(64 位)

• Kotlin: 1.3.12

安装环境

很早以前，kotlin 官网就出现了两个库，这两个库基本就是来完善 react 在 kotlin 中的生态，第一个是 JetBrains/create-react-kotlin-app ，一个生成 React 工程的脚手架；第二个是JetBrains/kotlin-wrappers ，该库里存放了 react 周边生态组件，比如说 router，redux 等等。

按照脚手架文档，一行代码便能生成我们的项目。

npx create-react-kotlin-app my-app

在项目生成后，打开项目，使用 npm start 或者 yarn start 启动项目。

项目会自动打开浏览器，然后看到我们的项目，说明我们的项目便启动了。

我们可以看看官方提供的 wrappers 库里有什么，好像什么都有就是缺少一个成熟的 UI 组件库。难道说所有的样式都要我们自己写？

当然不是。

kotlinjs 是可以调用到 nodejs 模块的，只不过啊，有点烦。

安装 ant

ant 是 阿里前端 开发的一套 UI 组件，其中有着 React 版本。首先要安装该库。

通过 yarn add antd 进行安装,等待安装完成。

安装结束后，我们将 ant的演示引入到我们的项目中，打开 index.css 引入项目。

@import '~antd/dist/antd.css';

我们尝试的引入一个 Button 看看。

然后我们看到页面上，还是原来的button ，和 ant 的风格没有半毛钱关系。说明我们还是没有讲ant的组件使用到我们的项目中去。

绑定 UI 控件

新建立一个包 ui/ant 来存放我们与 ant 组件的绑定类。

如何编写我们的绑定类？这是我遇到的第一个难题。

首先要找到我们的 node_modules中的antd目录，找到我们要绑定的控件目录。

我们用 @file:JsModule("antd/lib/button") 来表明绑定目录。通过 @JsName("default") 来进行绑定，此时需要该控件是以 export default Button;

@file:JsModule("antd/lib/button")

package ui.ant

import react.RClass
import react.RProps

@JsName("default")
external val button: RClass<RProps>

在我们的 Main.kt 中重新引入我们刚刚写的 button。此时的 button 不同于 react.dom.button ,我们所声明的 button 无法直接设置任何属性，方法等。当然我们会给他设置的。

package app

import react.RBuilder
import react.RComponent
import react.RProps
import react.RState
import react.dom.div

class App : RComponent<RProps, RState>() {
    override fun RBuilder.render() {
        div {
            ui.ant.button {
                +"Button"
            }
        }
    }
}

fun RBuilder.app() = child(App::class) {}

等待自动编译和刷新完成，查看我们的页面。

终于见到了我们的按钮了，而且样式和 Ant 官方文档上所示一致。

说明我们的绑定现在已经成功。

然后如法炮制，把其他的要使用控件进行同样的绑定。

我们 input 和 search 进行绑定。

此次绑定与上次有所改变，我们对这两个属性可以设置一些值，以便我们在 HTML DSL 中直接使用。这里我们通过实现 RProps 来重新定制了我们要使用的属性,对 Input 设置了一个 placeholder,而 SeacherRPorps 可以直接继承 InputRProps 来进行属性上的扩展。

@file:JsModule("antd/lib/input/Input")

package ui.antd

import react.*

external interface InputRProps:RProps {
    var placeholder:String
}

@JsName("default")
external val input: RClass<InputProps>

对 search 控件进行绑定

@file:JsModule("antd/lib/input/Search")
 
package ui.antd

import org.w3c.dom.events.Event

import react.*

external interface SearchProps : InputRProps {
    var onChange: (Event) -> Unit
    var value: String
}

@JsName("default")
external val search: RClass<SearchProps>

新建独立控件

我们重新独立出来一个组件，叫做 Home.kt 。将我们的 Button 存放进去，然后在 App.kt 上 使用 Home.kt。

package home

import react.RBuilder
import react.RComponent
import react.RProps
import react.RState
import react.dom.div
import ui.ant.button

class Home : RComponent<RProps, RState>() {
    override fun RBuilder.render() {
        div{
           button{
               +"Button"
           }
        }
    }
}

fun RBuilder.home() = child(Home::class) {}

等待页面刷新完毕，仍旧是原来的样子。

添加点击事件

因为我们的按钮中没有声明点击事件，所以无法直接调用，但是 kotlinjs 可以动态属性调用，通过 asDynamic 便可以调用我们想要使用的任何 html 中存在的属性。

 button {
	+"Button"
	attrs {
		asDynamic().onClick = {
			console.log("on click")
		}
	}
}

此时就完成了按钮的点击事件，当我们在页面中点击时，可以看到浏览器控制台上的信息进行打印。

进行双向绑定

对我们要使用的数据存放在 RState 中，我们重写来写 RState。 state 和 props 是 react 中两个重要的属性，state 是用来进行内部数据的修改更新，而 props 是可以将外部数据进行传入。

自定义 HomeState 来继承 RState，来进行对内部数据的修改。

interface HomeState : RState {
    var inputValue: Int
}

将我们 Home 中的 RState 类型改为 HomeState

class Home : RComponent<RProps, HomeState>()

这样便可以在下方使用 state 中的数据。

用一个 div 来写我们的数据。

div {
	+"${state.inputValue}"
}

对 button 中的点击事件进行微小的修改，在 react 中对数据进行修改都需要调用 setState 。

button {
	+"Button"
	attrs.asDynamic().onClick ={
		setState {
			inputValue += 1
		}
	}
}

然而，页面刷新后却是一个报错。TypeError: Cannot read property ’toString’ of undefined 无法读取 undefinded 的 toString 方法。

原来，单在 HomeState 中声明是不够的，还需要在 HomeState.init() 的重写方法中进行初始值的赋值。

重新等待页面刷新，出现了我们预想的结果。每次点击按钮就会数字就会进行累加。

配合 Axios

axios 是前端中常用的一个 http 请求框架，kotlin 官方已经对它进行了一次简单的封装。我们这里直接就可以使用。

首先仍旧是先安装 axios

yarn add axios

安装完成后新建一个文件夹axios，再新建Axios.js。

package axios

import kotlin.js.Promise

@JsModule("axios")
external fun <T> axios(config: AxiosConfigSettings): Promise<AxiosResponse<T>>

// Type definition
external interface AxiosConfigSettings {
    var url: String
    var method: String
    var baseUrl: String
    var timeout: Number
    var data: dynamic
    var transferRequest: dynamic
    var transferResponse: dynamic
    var headers: dynamic
    var params: dynamic
    var withCredentials: Boolean
    var adapter: dynamic
    var auth: dynamic
    var responseType: String
    var xsrfCookieName: String
    var xsrfHeaderName: String
    var onUploadProgress: dynamic
    var onDownloadProgress: dynamic
    var maxContentLength: Number
    var validateStatus: (Number) -> Boolean
    var maxRedirects: Number
    var httpAgent: dynamic
    var httpsAgent: dynamic
    var proxy: dynamic
    var cancelToken: dynamic
}

external interface AxiosResponse<T> {
    val data: T
    val status: Number
    val statusText: String
    val headers: dynamic
    val config: AxiosConfigSettings
}

我们做一个简单的应用，通过输入名字，到 Github 上寻找相关的仓库。

首先定义我们的数据类，来存放我们请求获取到的数据。

data class Result(
        val total_count: Int,
        val items: Array<Item>
)

data class Item(val id: Long,
                val node_id: String,
                val name: String,
                val full_name: String,
                val html_url: String)

然后在 HomeState 中声明所使用的类。

interface HomeState : RState {
    var inputValue: String
    var repos: Array<Item>
}

下面是界面定义的代码

div(classes = "search-input") {
    search {
        attrs {
            onChange = {
                val element = it.target as HTMLInputElement
                setState {
                    inputValue = element.value
                }
            }
            placeholder = "请输入 Github 仓库名称"
        }
    }
}

button {
    +"搜索"
    attrs {
        asDynamic().onClick = {

        }
    }
}

div(classes = "list") {
    if (state.repos.isNotEmpty()) {
        ul {
            for ((index, item) in state.repos.withIndex()) {
                li {
                    a(href = item.html_url) {
                        +"${index + 1} / ${item.full_name}"
                    }
                }
            }
        }
    }
}

不过当我们此时预览界面的时候，发现又又又错了，提示 repos 无法进行迭代。

明明是数组为什么无法迭代呢？原来是在 Home 组件创建的时候，还没有对 repos 进行初始化。这里需要了解 react 的生命周期，在组件建立前，对数据进行初始化。

    override fun componentWillMount() {
        setState {
            repos = emptyArray()
        }
    }

此时页面可以正常展示了。

完善 button 的点击事件。

 button {
    +"搜索"
    attrs {
        asDynamic().onClick = {
            //https://api.github.com/search/repositories?q=
            val config: AxiosConfigSettings = jsObject {
                url = "https://api.github.com/search/repositories?q=${state.inputValue}"
            }
            axios.axios<Result>(config).then { response ->
                setState {
                    repos = response.data.items
                }
            }.catch { error ->
                console.log("error", error)
            }
        }
    }
}

此时便完成了项目。

总结

首先声明 作者并非专业前端，所以文章中有错误还望指正；本文更重要的目的是为了表明 kotlin 在其他领域的使用和使用体验。

kotlin 写 react,在书写习惯上应该和 ts 写是差不多的，而且给后端同学带来了写前端的体验。但是生态不完整，就一个 UI 组件库没有一个官方用 kt 写的，而且编译速度慢，报错有时不明显，可查阅资料少。不过要说硬着头皮开发，个人感觉是完全可以的，不过估计要自己造不少轮子。

这可不是什么希腊神话，更没有什么圣斗士，这只是我给我的项目起的名字而已，当然它也不叫黄道十二宫。

其实刚刚开始并没有这些名字，只是有一天，突然觉得我的后端项目有所寓意，叫做 天秤座 很好，由此一来，就有了其他星座的名称。目前一共是有六个模块，六大模块来组成这个完整的项目。分别有天秤座，水瓶座，处女座，摩羯座和一个还不知道要起什么名字的项目。

天秤座

先说说天秤座， 这是我维护了最久的一个项目，像对一个新生婴儿般呵护。项目从2017年就开始做，先后经历大约三个大版本，现在正在维护第三个版本。第一个版本是课程设计的时候，用 Java 和 Kotlin 混合写的，一个人写完了后台，当时前端第一次用 vue ，大家还是用两周的时间完成了项目，虽然简陋，很多东西都没有，但是已经有了项目雏形，基本解决了核心问题，这个只能叫做一个 DEOM。而后，利用寒假时间，和对象，舍友重构了整个前端和后台，重新对数据库进行了整理，这段时间过得很紧张，各种事情比较多，再加上过年，但是还是开学半个月左右完成了该项目的重写和重构，紧接着就是上线，这样就是 1.0.0 版本。这个版本无论是前端还是后端，相较于 DEMO 得完成度太高了，基本实现了所要的功能，但是有些功能有问题，在线代码评测，完成了一部分功能，加上服务器环境有问题，使得这部分功能被一直耽搁，直到开发下个版本的时候，才完成了该项目，也就是摩羯座，这是后话。

上线并不是一帆风顺的，出现了很多问题，当时服务器是在腾讯云上托管，买的基本是最低的配置吧， 单核两G1MB。第一天测试的时候，刚好赶上我下午有课，只能等下了课去看情况。一进实验室，老师就说：150 个人同时无法进入，我让50个人先进，还是卡着进不去。心想，这种小水管，这么多人肯定加载不出网页来。随后在控制台上验证了我的猜想，除了出网流量满核，无论是内存还是 CPU 使用率都很稳定。随后添加到 5M ， 为什么只添加怎么一点点，因为带宽实在太贵了。本来想着这下子应该可以了，用了一个压测工具，并发到了1000多才会出现连接失败，这下子应该没有问题了。然而事不遂人愿，50 名同学同时访问的时候还是卡在哪里一动不动，心里很慌，因为不知道问题出现在哪里，感觉带宽不够。过了大概一到两分钟，才有几名同学的电脑上陆续出现了登录页面，慢慢的，大多数同学都打开了登录页面。心里总算是出了一口气，第一份试题同学们陆续提交，判题系统开始运作，判题系统是很快的，基本每个同学的答案都是秒出。但是也有问题，因为前端上有些地方体验不是很好，加上后端对这个没有进行处理，有些同学提交的答案不符合规范，此时就会出现：后端系统从消息队列里取数据，取到数据不符合规范，导致抛出异常，该数据获取失败，下次还是获取该数据，形成了一个死循环，导致后面提交的试题都积压在消息队列中。第一份试卷试题相对容易，对格式要求不是太高，偶尔有一两个手动处理一下就好。第二张试卷才是噩梦的开始。

第二张试卷的试题对格式有要求，可能是我在说要求的时候同学们没有听得很明白，导致了大批试卷格式错误，格式一错误就发生了上述情况。提交完试卷，老师就继续给他们讲课，而我只能用她讲课的这个空余时间修复这个 BUG 。一张两张手动还好处理，问题是我不知道有多少张，处理了一份又一份，这样手动处理已经不是办法了。当所有人都提交完试卷后，服务器停机，写了一个处理逻辑，基本就是检查该试卷是否符合规范，不符合直接 0 分。这样简单粗暴的处理方式，导致很多同学的分数为 0 分。于是乎又组织重新进行了一次考试。当然最后对这块的逻辑进行了重新调整，不会如此简单粗暴。在这里写这段话，永远没有当时感觉惊心动魄。

后续进行了很多测试，每次都会发现问题，需要及时的解决问题，只不过后边的问题也来越少。还有一次，对一个小小的逻辑进行了修改，使打分机制更加合理，心想这小小的逻辑应该不会有问题，没有测试代码，直接部署上线。悲剧的事情发生了，该题题型全部是 0 分。

此后进行了很多次考试，每次考试都会出现加载缓慢的情况，而我的理解也一直认为是带宽不足。直到服务器停机也一直认为是带宽不足。而在九月的某一天，我重新编译前端的时候，瞬间想明白了为什么加载缓慢。前端的 SPA 项目达到了 6MB 多，没有任何优化，每个人访问就要从服务器上去下载 6MB 的代码，怪不得缓慢。因为是第一次使用 SPA 并不知道性能上和体积上的优化，吃了大亏。

天秤座指的是这个后端项目，和前端 vue 并没有多大关系。到了 1.0.0 的项目，完全使用了 kotlin 。到了目前维护的 2.0.0 的项目，依旧是 100% kotlin。kotlin 这个语言是我目前为止最喜欢的语言，没有之一。官方宣称的 100% 的兼容 java 也使我尝到了甜头，在不改变原来的生态，框架的基础上，使用了新的语言，不仅仅是简化了繁琐的 Java，而且比 java 更加现代化，了解了一些 java 没有的语言特性等。

在学习 kotlin 的过程中，个人感觉，语法其实很重要，语言特性很重要，掌握一个语言的语言特性，才能更加的写出地道的代码，就好比如说一口地道的英文一般。而且今天的kotlin，也今非昔比，很多人还认为 kotlin 仅仅是 java 的语法糖。过去一周，尝试了一下 kotlin native，以我猜测，估计过不了多久，官网上就会写出 100% 兼容C/C++ ，虽然个人对 C/C++ 至只剩少，但是通过体验来说，基本可以实现，而且这应该也是 kotlin 团队的愿景，毕竟目前是能寄人篱下。

水瓶座

先讲一个笑话

Angular是两个框架。

前面说到了 SPA 加载缓慢等问题，因为写前端的同学找到了工作，没有时间去维护这套代码。还有一个原因就是当时写的时候时间紧张，功能实现为主，结构，代码混乱，技术债欠的太多，与其去还技术债，不如另起炉灶，重写前端项目。这便是水瓶座的由来。

经过对比了一下前端技术，选择了 Angular 作为开发。相较于其他两个技术来说，Typescript 的完美支持，依赖注入和Rxjs这些后端常常使用的技术等，由此选择了 Angular。当然也有一些缺点，学习曲线陡峭，并不像 vue 一般简单。

水瓶座基本是对上个版本的重写，但是界面设计基本和上个版本一致，将上个版本中用户体验很差的填空题答题部分进行了完善，完成了答题卡功能（上个版本也有这个功能，只是一直有一个 bug ）。经过了上个版本对单页应用的简单了解，这次非常注意应用体积，虽说 Angular 的打包体积本来就要比其他两个体积要大（ Angular 7，日后版本开启 lvy 之后应该体积是差不多的），基本所有的路由都启用了懒加载，而且还注意体积优化，再也不会像之前那样，做一个那么大体积的应用了。水瓶座目前正在经历从零到一的过程，这个过程相对痛苦，但是一旦完成也是最有成就感的阶段。

其实有时候会想 是不是选错了技术栈， react 的生态可要比 Angular 丰富的多，但是有时候也会想 Angular 真的好厉害，基本把你需要的东西都考虑了，开箱即用。cli 如一把神兵利器，太强了，可能是我见识短，这是我目前讲过最强 cli。对于这次技术栈选择，并没有将 vue 考虑进来，并不是说 vue 不够优秀，而是对 Typescript 支持不够好，为什么非要用 TypeScript 呢？说白了还是类型问题。之前用 python flask 开发过一个 web 基本算是试水，发现编写速度的确快，但是 debug 的确痛苦，没有完善的类型提示，很多不必要的错误只有在运行的时候才会发现，后来 vue 的版本， js 也在类型上没有严格的定义，所以在技术选型上，必须有完善的类型检查机制。曾经也试想过用 kotlin react 作为开发，看了一下官方支持，基本常用的库都有了 kotlin 版本，唯独缺少的就是一个 ui 库。其实在团队技术选型上要做好多考虑，组内是否可以快速转变，是否愿意逃离舒适区，新的技术栈性能怎么样，生态怎么样，日后更新维护怎么样，官方支持怎么样？等等一系列问题。每做一个决定就是要对所有人负责。还好，我只要对女盆友负责就可以，毕竟这个团队就两个人。

我们都是学生，没有舒适区，也不喜欢舒适区，喜欢尝鲜。就目前三大框架来说，react 无疑是生态最好的一个，但是我没有选他。而官方的维护和日后更新也是关注的一个重点。现在的 Angular 来说，基本会在 谷歌内部的 600 多个项目上先行使用。有着 谷歌爸爸的支持，虽然可能再坑一次。。。

总体来说，直到目前 Angular 给我带来的惊喜多余惊吓。

摩羯座

摩羯座可大有来头，这个项目花了我三天的时间。

之前学院里是大一上学期开设 c语言，下学期开设 面向对象（Java），大二上学期开设 数据结构( C 语言描述)。这样的排课其实有问题，要不然就把数据结构放到 c 语言后面，要不然数据结构就用 java 语言描述的版本。遮掩的课程不知道已经用了多少年了，就在今年将采用大一下学期数据结构。

所以，要改判题系统中的代码题判题规则，数据结构基本都是算法题，所以我的要求也是按照 oj 系统的算法测评机规则来做。基本对输入数据和输出数据进行判断，而且要求不能超时，不能去破坏系统等。

写这个第一时间想到是 C 语言 去写，因为相对于其他语言来说，C 语言更加的底层，更好的控制一些条件。但是也有一些问题，C 语言非跨平，也就是意味着相同的功能既要在Windows 下写一遍， Linux 写一套，无疑增加了成本，而且尝试使用了C语言进行编写后，发现C语言的接口晦涩难懂，不是很好理解。经过短暂的尝试，放弃了C语言，转而投向了 Kotlin ，前面说过， kotlin 已经向 Native 方向发展，所以个人感觉使用 kotlin native 也是一个不错的选择。然而使用 kotlin native 却发现和c语言一样的问题，他并没有去自己实现一些接口，而是直接使用了C语言的接口，同样也是没有研究明白。

就这样耽搁了两三天，一直没有进展。

偶尔一天，看到了一篇关于 java 调用 Go 语言的博文，将 Go 写的应用打包为动态库，然后通过 jni 调用。就这样边学边写，用了大约三天的时间，基本写出了 windows 平台下的测评机，因为在 windows 下和 linux 下所执行的脚本命令不同，所以要适当的判断一下操作系统。 Go 语言写起来还是很轻松的，也很方便的调用系统底层。

处女座

处女座是一个有意思的项目，它本不在计划中，只是项目需要写文档，（其实我是不喜欢写文档的） ，于是乎看到了 vuepress 这个项目。正好使用这个项目快速写文档。 vuepress 上手很简单，只要通过简单的配置就可以写文档，而且通过 GitHub page Firebase Hosting 进行部署，简单高效。Vuepress 的确很有效的解决了

前言

最近要使用 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/

打个广告

开发的小程序 生活小程序

kotlin 对集合问题的支持很好，有很多方法可以方便又直观的对集合进行操作。比如 map，count，reduce，filter等方法，这个博客会持续总结些方法。

any

any 这个函数返回值是一个 boolean 类型，用于判断集合内元素是否用满足条件的，如果有任意一个集合满足该条件，则返回 true 否是为 false。

示例代码

fun main(args: Array<String>) {
    val list: List<Int> = listOf(1, 2, 4, 67, 7, 23, 55, 34) //sum = 193
    val l = list.any {
        it > 30
    }
    println("判断结果为 $l")
}

输出结果为

判断结果为 true

这里的 it 可以理解为 iterator 既为集合中的每个元素。之后有很多函数都是对 it 进行操作。

all

all 几乎和 any 很相似，只是用于判断每个元素，要集合内每个元素满足条件才会返回ture，否则为 false

示例代码

fun main(args: Array<String>) {
    val list: List<Int> = listOf(1, 2, 4, 67, 7, 23, 55, 34) //sum = 193
    val l = list.all {
        it > 30
    }
    println("判断结果为 $l")
}

判断结果为 false

map

map 这个函数对集合内的每一个元素进行迭代遍历，基本可以替代for循环。

示例

fun main(args: Array<String>) {

    val list: List<Int> = listOf(1, 2, 4, 67, 7, 23, 55, 34)

    list.map {
        print("$it ")
    }
}

输出结果为：

1 2 4 67 7 23 55 34

这样就完成了对集合的迭代输出。

filter

顾名思义，filter为一个过滤器，可以对我们集合元素进行一次过滤，留下我们想要的元素。 例如我们要集合中的偶数元素。

示例代码

fun main(args: Array<String>) {

    val list: List<Int> = listOf(1, 2, 4, 67, 7, 23, 55, 34)

    list.filter { it % 2 == 0 }.map { print("$it ") }
}

输出

2 4 34

完成了对偶数元素的过滤，结合map进行一下输出。如果我们不用filter和map进行输出，那么我们将会写下下面的这种代码，而且 IDEA 也会给我们警告，让我们及时改进。

    for (i in 0 until list.size) {
        if (list[i] % 2 == 0) {
            print("${list[i]} ")
        }
    }

此时就会感觉到了这些语法对于代码的简洁和易用。

count

即使对集合元素进行统计，如果直接使用 count() 对集合元素统计和直接用 size 没有什么区别，所以说 count 有更加高级的用法。

比如对集合内的某个元素进行统计或者某种类型的元素进行统计，比如统计集合中偶数的个数。

fun main(args: Array<String>) {
    val list: List<Int> = listOf(1, 2, 4, 67, 7, 23, 55, 34)
    val count = list.count {
        it % 2== 0
    }
    println("集合中的偶数个数为 $count")
}

输出

集合中的偶数个数为 3

groupBy

这个用于分组，对元素进行按要求分组，最后的结果也会保存在两个集合中， true 和 false

示例代码

对奇偶数进行分组

    val list: List<Int> = listOf(1, 2, 4, 67, 7, 23, 55, 34) //sum = 193
    val result = list.groupBy {
        it % 2 == 0
    }
    println("$result")
}

输出结果

{false=[1, 67, 7, 23, 55], true=[2, 4, 34]}

这是一个尝试，之前没有翻译过任何技术文章，做一个尝试，也算是学习，尽管现在这个译文在网上已经是满天飞了。

原文地址Kotlin 1.2 Released: Sharing Code between Platforms

正文

今天，我们将要发布 Kotlin 1.2。这是一个重要的新版本和一个大的步伐在我们朝着使用 Kotlin 在现代应用程序中的道路上。

在 Kotlin 1.1 中，我们正式的发布了 JavaScript 目标，允许你去编译 Kotlin 代码成为 JS 并且运行在浏览器上。在 Kotlin 1.2 中，我们将要添加 JVM 和 JavaScript 的代码重用成为可能。现在你可以写一次应用程序的逻辑代码，而在你的应用程序中所有层重用它——后端，浏览器前端和Android移动应用。我们也会在库上进行工作，帮助你重用更多的代码。比如跨平台库。

Kotlin 1.2 是已经绑定在 IntelliJ IDEA 2017.3中，将会在本周发布。如果你正在使用的是 Android Studio 或者 一个旧版本的 Intellij IDEA，你可以从 Tools | Kotlin | Configure Kotlin Plugin 更新框中安装新的版本。

这个版本包括了大量外部贡献者的工作，并且我们想感谢向我们反馈，提交问题和尤其是提交了PR的每个人。

多平台项目

一个多平台项目允许你编译在你的应用程序的多层 —— 后端，前端和Android应用 —— 在相同的代码基础上。这样的一个项目包含了 相同模块,与平台无关以及特定平台的模块，包含了特定平台的代码( JVM 或者 JS )和使用了特定平台的库。从通用模块调用特定平台的代码，你可以指定预期的声明——所有平台特定模块需要提供实际实现声明。

有关该功能的更多信息，请查看这个文档

如前所述，我们也在编写一组公共库允许你将更多的逻辑代码转移到公共代码：

• kotlin.test,包括开箱即用的Kotlin1.2，让你写一次测试并且运行在JVM 和 JS 下；

• kotlin.html支持 同构渲染 — 用相同的代码渲染 HTML 在后端和在前端；

• kotlinx.serialization允许你轻松的对 Kotlin对象编组在你的应用程序的不同的层之间，使用 JSON 或者 ProtoBuf 进行序列化格式化。

请注意，多平台项目目前是一个实验性功能；这意味着这个功能是准备使用，但是我们也许需要去改变设计在之后的版本(并且如果我们这样做，我们将会提供代码迁移工具)。

编译性能

在1.2的发展过程中，我们花费了很多精力来使编译过程更快。我们已经比Kotlin1.1提高了大约 25% 并且我们看见进一步改进的巨大潜力，它将会在发布在 1.2.x的更新中。

下方的图片展示了两个用Kotlin的大型JetBrains项目不同的编译时间：

其他语言和库的改进

我们也做了许多小的改进在语言和标准库：

• 更简洁的语法 用于将多个参数传递给注解(数组 文字(literals)) 不知如何翻译literals 译者注

• 支持 lateinit 修饰在全局属性和局部属性，以及检查一个 lateinit 是否被初始化；

• 更加聪明的智能推导和改进的类型推断在一些情况下。

• 标准库和 Java9 中引入的分包限制的兼容；

• 新的 kotlin.math包在标准库中；

• 新的标准库函数在处理序列和集合，包含了一组函数 为了拆分集合和序列为可能重叠的固定大小的组。

更多的信息和代码示例，请看 Kotlin1.2中新功能

世界各地的Kotlin

自从今年3月发布的Kotlin1.1以来，Kotlin已经取得了巨大的收获在世界各地。这是 KotlinConf 的高潮，我们第一次全球会议，有着1200参会者在11月2，3日的旧金山。我们已经记录了所有的会谈，并且视频已经可以看。

Kotlin现在是一个Android开发官方支持的语言，开箱即用的Android Studio 3.0，已经谷歌发布了官方示例和风格指南。结果是，在Android Studio中超过了 17% 的项目使用 Kotlin，包含来自很多热门的创业公司以及财富500强公司的许多应用程序。

在服务器端，Spring 5.0 已经发布，有着许多Kotlin支持的功能,而且 vert.x 已经支持Kotlin在3.4.0后。当然，Gradle支持开箱即用Kotlin DSL，而且 Gradle Kotlin DSL 项目正在迅速的接近1.0版本。

在Github上，开源的Kotlin代码行数已经超过了2.5亿。而在 Stack Overflow，Kotlin是增长最快的语言之一和最不反感的语言之一

围绕Kotlin的社区建立同样也是令人吃惊的，已经有超过100用户组在全世界，我们很难追踪到所有的人 —— 但是针对我们所知道的，这个会谈地图给了你一个很好的想法，kotlin是多么广泛的使用。

对于刚刚学习Kotlin的人来说，书籍的数量是不断的增长(包含我们自己的 “Kotlin in Action”,现在有英文，俄语，日语，中文和葡萄牙语),线上课程，教程和其他资源

团队见面：网络研讨会和Reddit AMA

分享你更多的信息关于新版本，我们计划组织一个网络研讨会关于Kotlin1.2多平台项目在12月7日，18:00 CET。请注册；空间有限。

Kotlin团队也将会举办 AMA(Ask Me Anything) 在 Kotlin Reddit 上在12月5号。我们将开始中午开始(CET),并且我们接下来的24小时和你在一起。

如何升级

一如既往，你可以在线尝试Kotlin在try.kotlinlang.org

• 在 Maven，Gradle和npm中：使用1.2.0作为编译器和标准库的版本号。看这里

• IntelliJ IDEA：2017.3已经和Kotlin1.2绑定，在早期版本中安装或者升级 Kotlin 插件到1.2.0版本。

• Android Studio：安装或者升级插件通过 Plugin Manager。

• Eclips：安装插件在 MarketPlace。

• 命令行编译可以从Github发布页面上下载。

兼容性 在Kotlin1.2的语言和标准库是向后兼容的(模块错误):如果一些编译和运行在1.0或者1.1，将会继续在1.2上运行。帮助逐渐共享的打团队，我们将提供不使用新特性的编译开关。这里是一个包含可能的缺陷文档

扩展函数和扩展属性在 Java 里面是没有的，这样的话很好的弥补了 Java 的缺陷。所谓扩展方法或者属性是指在原来没有的方法或者属性上进行扩展，不会改变原来的属性和方法。

扩展函数

声明扩展函数的方法是先写上要扩展的类名，之后在写扩展方法。

对 Book 这个类进行扩展，这个类只有一个方法，在我们不修改 Book 类的前提下对其进行扩展。

class Book(val name: String, var price: Int) {
    val ISBN: Int = 123456789
    fun add() {
        println("Add a book,name is $name,price is $price,ISBN is $ISBN")
    }
}

fun Book.show() = add()

这样我们便完成了对 Book 类进行扩展。

在扩展函数中，可以使用原有类的方法，变量。

fun main(args: Array<String>) {
    val book = Book("红楼梦", 50)
    book.show()
}

扩展是静态解析的
扩展不能真正的修改他们所扩展的类。通过定义一个扩展，你并没有在一个类中插入新成员， 仅仅是可以通过该类型的变量用点表达式去调用这个新函数。

扩展属性

扩展属性不能初始化器,所以只能是使用显示 get/set 方法进行定义。

任就采用上面的例子。给 Book 添加一个 profit 属性。

像这个样子，我们就定义了这个类的扩展属性

val Book.profit: Int
    get() = price - 20

fun main(args: Array<String>) {
    val book = Book("红楼梦", 50)
    book.show()
    println("book's profit is ${book.profit}")
}

更多关于扩展函数/方法的例子可以参考官方网站

kotlin官方文档(中文)

kotlin官方文档(英文)

感受

关于 Kotlin 的最大的感受就是：代码少写了很多。

相遇

最开始知道这个语言是在使用 IDEA 的时候，当时只是知道，并没有过多的关心，也并没有去了解，更不要说是使用了。直到今年的 Google I/O 提出来 Kotlin 被上升到 Android 开发的一级开发语言。整个互联网沸腾了一把，大家纷纷百度 Kotlin 是什么？当然也包括我。

相识

Kotlin 的学习使我感觉到了欣喜，为什么这么说呢？语法简洁，和 Java 基本兼容。也就是 Kotlin 一出生便是站在 Java 的肩膀上。很好的融入了 Java 生态，基本上说 Java 能做的 Kotlin 都能做，而且在代码方面更加简洁高效。

从 Kotlin 诞生开始，便有了 JetBrains 的编译器支持，毕竟是自己家的语言，而且 IDEA 也一直宣传做 Capable and Emic IDE rgonofor JVM ，而且目前还有了 Google 的支持。前两天 Jake Wharton 加入了 Google 的 Android Formwork 的 Kotlin 团队。 就当前情况看来 Kotlin 会有一个不错的发展。

相遇

前面说了 Kotlin 从一诞生就有强大的编译器支持。刚刚开始不会 Kotlin 的时候，全靠 IDEA 的 Java 转 Kotlin

通过对比 Java 和 Kotlin 的语法，也就慢慢的掌握了 Kotlin 的语法规则。

后来开始使用 Kotlin 写了一下 struts2,表示完全兼容。

尝试用 Kotlin 写了一下 SpringMVC 4 应该是不兼容或者是我的打开方式不对， 在 Controller 发生错误，不过其他层并没有错误。好的是 Spring 5 已经支持 Kotlin 。

在 Android 方面(并没有使用 Anko)，只是简单的使用了扩展。

apply plugin: 'Kotlin-android-extensions'

再也不用写 findViewById(),直接用控件 id 就可以完成操作。

其他

慢慢尝试一些 黑魔法 😝

待补充(毕竟我也才开始慢慢学习)

学习资源推荐

官方文档(英文)

官方文档(中文)

冰封博客

Kotlin 社区