www.2527.com_澳门新葡8455手机版_新京葡娱乐场网址_
做最好的网站

极简教程,Kotlin极简教程

2019-10-05 20:31 来源:未知

使用Kotlin 结合SpringBoot 开拓二个RESTFul版本的 Hello World

“Hello, World"程序是指在微型Computer显示器上输出“Hello,world”那行字符串的微管理器程序,“hello, world”的汉语意思是“世界,你好”。这几个顺序在Brian Kernighan 和Dennis M. Ritchie合著的《The C Programme Language》使用而广泛流行。因为它的洗练、实用,表达了叁个编制程序语言的极简功能。

第16章 使用 Kotlin Native


只要单单Kotlin 笔者是不相信任在长期内有发出多大的平地风波,可是只要Kotlin​ 能和 Java 开拓神器 SpringBoot 结合起来,笔者倍感能飞。。。

咱俩在本章将介绍使用Kotlin程序设计语言,分别使用命令行、应用程序、Web RESTFul、Android、Kotlin JavaScript等办法向世界问好:你好,世界。

《Kotlin极简教程》正式上架:

点击这里 > 去京东商号买卖阅读

点击这里 > 去天猫购买阅读

打开IDEA ,File->New->Project

安装配置完Kotlin命令行情形之后,大家一向命令行输入kotlinc, 就能够进入Kotlin REPL界面。

极其感激您贴心的读者,大家请多帮衬!!!有别的难点,招待随时与自己调换~


只得说 JetBrains 是一家务实的小卖部,种种IDE令人击节叹赏,用起来也是非常溜。同样的,诞生自 JetBrains 的 Kotlin 也是一门务实的编制程序语言,Kotlin以工程实用性为导向,足够借鉴了Java, Scala, Groovy, C#, Gosu, JavaScript, Swift等等语言的杰出,让大家写起代码来可谓是分外温婉却又不失工程质量与频率。Kotlin Native能把 Kotlin代码直接编写翻译成机器码,也正是站在了跟 C/C 、Go和Rust的同四个档期的顺序,于是这些小圈子又添壹个人竞争对手。

在眼下的有所章节中,大家利用的 Kotlin 都以依照 JVM 的运营条件。本章我们将从 JVM 的运作碰到中远距离,走向直接编写翻译生成原生机器码的类别编制程序的生态系统:Kotlin Native 。

图片 1New->Project

$ kotlincWelcome to Kotlin version 1.1.2-2 (JRE 1.8.0_40-b27)Type :help for help, :quit for quit>>> println("Hello,World!")Hello,World!>>> import java.util.Date>>> Date()Wed Jun 07 14:19:33 CST 2017

16.1 Kotlin Native 简介

Kotlin Native利用LLVM来编写翻译到机器码。Kotlin Native 主若是依照LLVM后端编写翻译器(Backend Compiler)来生开销地机器码。

Kotlin Native 的统一盘算初志是为着帮衬在非JVM设想机平台景况的编制程序,如 ios、嵌入式平台等。同一时候支持与 C 互操作。

输入相关音讯之后下一步:

我们即使想有所学习Kotlin的对立较好的经验,就不建议选拔eclipse了。终归Kotlin是JetBrains家族的亲孙子,跟AMDli IDEA是血浓于水啊。

16.1.1 LLVM

LLVM最先是Low Level Virtual Machine的缩写,定位是一个虚构机,可是是相比较底层的设想机。LLVM是构架编写翻译器(compiler)的框架种类,以C 编写而成,用于优化以自由程序语言编写的前后相继的编写翻译时间(compile-time)、链接时间(link-time)、运行时刻(run-time)以及空闲时间(idle-time),对开辟者保持开放,并协作已有脚本。

LLVM的产出正是为了消除编译器代码重用的问题,LLVM一上来就站在可比高的角度,制订了LLVM I奥迪Q5这一中间代码表示语言。LLVM IEscort丰盛思考了各样应用场景,譬喻在IDE中调用LLVM进行实时的代码语法检查,对静态语言、动态语言的编写翻译、优化等。

一般GroupId为公司域名反着写,加上项目名字

我们应用IDEA新建gradle项目,选拔Java,Kotlin框架协理,如下图:

16.1.2 协理平台

Kotlin Native以后已匡助以下平台:

平台名称 target 配置
Linux linux
Mac OS macbook
Windows mingw
Android arm32 android_arm32
Android arm64 android_arm64
iOS iphone
Raspberry Pi raspberrypi

那表示大家能够在这一个平台上欢快地从头感受了!方今Kotlin Native 已经昭示的新星预发表版本是 v0.3 。

图片 2image

图片 3

16.1.3 解释型语言与编写翻译型语言

编写翻译型语言,是在程序试行从前有三个独自的编写翻译进度,将顺序翻译成机器语言,未来执行那么些程序的时候,就毫无再开展翻译了。比如,C/C 等都是编写翻译型语言。

解释型语言,是在运作的时候将前后相继翻译成机器语言,所以运营速度相对于编写翻译型语言要慢。譬如,Java,C#等都以解释型语言。

虽说Java程序在运转此前也许有一个编译进度,不过实际不是将前后相继编写翻译成机器语言,而是将它编写翻译成字节码(可以知道为八当中等语言)。在运营的时候,由JVM将字节码再翻译成机器语言。

建议选中 Use auto-import,自动导包 ,使用本地 Gradle,然而供给先安装Gradle(

新建完项目,大家写一个HelloWorld.kt类

16.2 飞速开首 Hello World

图片 4Use auto-import

package com.easy.kotlin/*** Created by jack on 2017/5/29.*/import java.util.Dateimport java.text.SimpleDateFormatfun main(args: Array<String>) {println("Hello, world!")println(SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format}

16.2.1 运维条件筹划

我们平昔去 Github上边去下载 kotlin-native 编写翻译器的软件包。下载地址是 :https://github.com/JetBrains/kotlin-native/releases 。

图片 5

螢幕快速照相 2017-07-29 13.23.30.png

下载解压之后,大家能够看看 Kotlin Native 编写翻译器 konan 的目录如下:

-rw-r--r--@  1 jack  staff   6828  6 20 22:47 GRADLE_PLUGIN.md
-rw-r--r--@  1 jack  staff  16286  6 20 22:47 INTEROP.md
-rw-r--r--@  1 jack  staff   1957  6 21 01:03 README.md
-rw-r--r--@  1 jack  staff   4606  6 20 22:47 RELEASE_NOTES.md
drwxr-xr-x@  8 jack  staff    272  6 20 23:04 bin
drwxr-xr-x   6 jack  staff    204  7 28 17:08 dependencies
drwxr-xr-x@  3 jack  staff    102  6 20 23:01 klib
drwxr-xr-x@  5 jack  staff    170  5 12 00:02 konan
drwxr-xr-x@  4 jack  staff    136  5 12 00:02 lib
drwxr-xr-x@ 22 jack  staff    748  6 22 19:04 samples

关于那个目录里面包车型客车剧情大家在前面小节中介绍。

别的,咱们也得以本人下载源码编写翻译,这里就非常少说了。

假设未有选取 使用本地 Gradle 项目成立达成之后Gradle的包须要下载,这些日子有一些长,在此以前做Android就异常受其苦,全体要做好感情筹划,除非你有贰个好用的FQ工具。

完整的种类目录结构如下

16.2.2新建 Gradle 工程

在本小节中,大家先来行使IDEA 来创建一个普普通通的 Gradle 工程。

第1步,张开 File -> New -> Project ,如下图所示

图片 6

螢幕快速照相 2017-07-29 13.35.12.png

第2步,新建Gradle项目。大家直接在侧面栏中选拔 Gradle,点击 Next

图片 7

螢幕快速照相 2017-07-29 13.36.01.png

第3步,设置项目标 GroupId、ArtifactId、Version 新闻

图片 8

螢幕快速照相 2017-07-29 13.36.47.png

第4步,配置 Gradle 项指标为主设置。大家直接选拔本地的 Gradle 景况目录,省去下载的岁月(一时候互连网倒霉,要下载半天),具体安顿如下图所示

图片 9

螢幕快照 2017-07-29 13.37.11.png

第5步,配置项目名称和种类贮存目录,点击 Finish

图片 10

螢幕快速照相 2017-07-29 13.37.23.png

第6步,等待 IDEA 创造实现,大家将获取二个之类的Gradle 工程

图片 11

螢幕快速照相 2017-07-29 13.38.50.png

这段日子这么些工程里面什么都未有。上边大家就来最先原始的手工业新建文件编码。

图片 12Gradle 库下载中

.├── README.md├── build│ ├── classes│ │ └── main│ │ ├── META-INF│ │ │ └── easykotlin_main.kotlin_module│ │ └── com│ │ └── easy│ │ └── kotlin│ │ └── HelloWorldKt.class│ └── kotlin-build│ └── caches│ └── version.txt├── build.gradle├── settings.gradle└── src├── main│ ├── java│ ├── kotlin│ │ └── com│ │ └── easy│ │ └── kotlin│ │ └── HelloWorld.kt│ └── resources└── test├── java├── kotlin└── resources21 directories, 7 files

16.2.3 源代码目录

率先我们在工程根目录下边新建 src 目录,用来寄存源代码。在 src 上边新建 c 目录贮存 C 代码,新建 kotlin 目录存放 Kotlin 代码。大家的源代码组织结构划设想计如下

src
├── c
│   ├── cn_kotlinor.c
│   ├── cn_kotlinor.h
└── kotlin
    └── main.kt

品类创设实现之后会变动二个Gradle文件build.gradlesettings.gradle,settings.gradle文本大家权且不论,先看看build.gradle文件:

直接运行HelloWorld.kt,输出结果如下

16.2.4 C 代码文件

group 'name.quanke.kotlin.restful'version '1.0-SNAPSHOT'buildscript {ext.kotlin_version = '1.2.10'repositories {mavenCentral()}dependencies {classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"}}apply plugin: 'kotlin'repositories {mavenCentral()}dependencies {compile "org.jetbrains.kotlin:kotlin-stdlib-jre8:$kotlin_version"}compileKotlin {kotlinOptions.jvmTarget = "1.8"}compileTestKotlin {kotlinOptions.jvmTarget = "1.8"}
Hello, world!2017-05-29 01:15:30

cn_kotlinor.h

C头文件中评释如下

#ifndef CN_KOTLINOR_H
#define CN_KOTLINOR_H
void printHello();
int factorial(int n);
int fib(int n);
#endif

小编们简要证明了3个函数。

图片 13下载Gradle 依赖

有关工程的编写翻译、营造、运转,是由gradle协同kotlin-gradle-plugin,在kotlin-stdlib-jre8,kotlin-stdlib宗旨信赖下完了的。build.gradle配置文件如下:

cn_kotlinor.c

C 源代码文件内容如下

#include "cn_kotlinor.h"
#include <stdio.h>

void printHello(){
    printf("[C]HelloWorldn");
}

int factorial(int n){
    printf("[C]calc factorial: %dn", n);
    if(n == 0) return 1;
    return n * factorial(n - 1);
}

int fib(int n){
    printf("[C]calc fibonacci: %dn", n);
    if(n==1||n==2) return 1;
    return fib(n-1)   fib(n-2);
}

那正是我们听得多了就能说的详细的 C 语言代码。

下载正视和插件也是三个旷日长久痛楚的进度。各位不要心急,逐步来,三回特别多试四次。

group 'com.easy.kotlin'version '1.0-SNAPSHOT'buildscript {ext.kotlin_version = '1.1.1'repositories {mavenCentral()}dependencies {classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"}}apply plugin: 'java'apply plugin: 'kotlin'sourceCompatibility = 1.8repositories {mavenCentral()}dependencies {compile "org.jetbrains.kotlin:kotlin-stdlib-jre8:$kotlin_version"testCompile group: 'junit', name: 'junit', version: '4.12'}

16.2.5 Kotlin 代码文件

main.kt 文件内容如下

import ckotlinor.*

fun main(args: Array<String>) {
    printHello()
    (1..7).map(::factorial).forEach(::println)
    (1..7).map(::fib).forEach(::println)
}

其中,import kotlinor.* 是 C 语言代码通过 clang 编写翻译之后的C 的接口包路线,我们将要底下的 build.gradle 配置文件中的konanInterop中配置那几个路子。

从扭转的安插文件看,IDEA已经自行把Gradle构建Kotlin工程插件kotlin-gradle-plugin,以及Kotlin

工程源码地址:

16.2.6 konan插件配置

首先,我们在 build.gradle 里面加多构建脚本 buildscript 闭包

buildscript {
    repositories {
        mavenCentral()
        maven {
            url "https://dl.bintray.com/jetbrains/kotlin-native-dependencies"
        }
    }
    dependencies {
        classpath "org.jetbrains.kotlin:kotlin-native-gradle-plugin:0.3"
    }
}

此间大家增多了Gradle 营造 Kotlin Native 工程的 DSL 插件 kotlin-native-gradle-plugin:0.3 。这里的版本号,对应我们下载的 konan 编写翻译器的本子号,大家运用的是 v0.3,所以这里大家也选用0.3本子的插件。这么些插件公布在https://dl.bintray.com/jetbrains/kotlin-native-dependencies酒馆里,所以大家在repositories里面加多了这么些库房。

然后,我们使用插件 konan

apply plugin: 'konan' 

konan 就是用来编写翻译 Kotlin 为 native 代码的插件。

标准库kotlin-stdlib添加到build.gradle文件中了。

本节介绍使用 Kotlin 结合 SpringBoot 开垦三个RESTFul版本的 Hello.World

16.2.7 konanInterop 互操作配置

konanInterop {
    ckotlinor {
        defFile 'kotlinor.def' // interop 的配置文件
        includeDirs "src/c" // C 头文件目录,可以传入多个
    }
}

konanInterop 首要用来配置 Kotlin 调用 C 的接口。konanInterop 的布署是由konan 插件API中的 KonanInteropTask.kt来管理的(那些类的源码在: https://github.com/JetBrains/kotlin-native/blob/master/tools/kotlin-native-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/KonanInteropTask.kt)。

此间大家评释的 ckotlinor 是插件中的KonanInteropConfig 对象。大家在下边包车型大巴konanArtifacts里面会援用那几个 ckotlinor 。

至于konanInterop的安顿选项有

  konanInterop {
       pkgName {
           defFile <def-file>  
           pkg <package with stubs>
           target <target: linux/macbook/iphone/iphone_sim>
           compilerOpts <Options for native stubs compilation>
           linkerOpts <Options for native stubs >
           headers <headers to process> 
           includeDirs <directories where headers are located> 
           linkFiles <files which will be linked with native stubs>
           dumpParameters <Option to print parameters of task before execution>
       }

       // TODO: add configuration for konan compiler
 }

我们大约表达如下表所示

配置项 功能说明
defFile 互操作映射关系配置文件
pkg C 头文件编译后映射为 Kotlin 的包名
target 编译目标平台:linux/macbook/iphone/iphone_sim等
compilerOpts 编译选项
linkerOpts 链接选项
headers 要处理的头文件
includeDirs 包括的头文件目录
linkFiles 与native stubs 链接的文件
dumpParameters 打印 Gradle 任务参数选项配置

其间,kotlinor.def 是Kotlin Native 与 C 语言互操作的布署文件,大家在kotlinor.def 里面配备 C 源码到 kotlin 的照射关系。这么些文件内容如下

kotlinor.def

headers=cn_kotlinor.h
compilerOpts=-Isrc/c

一模二样的配备,若是大家写在 build.gradle 文件中的konanInterop配置里如下

konanInterop {
    ckotlinor {
        // defFile 'kotlinor.def' // interop 的配置文件
        compilerOpts '-Isrc/c'
        headers 'src/c/cn_kotlinor.h' // interop 的配置文件
        includeDirs "src/c" // C 头文件存放目录,可以传入多个
    }
}

至于那些布局文件的分析原理能够参见 KonanPlugin.kt 文件的源码(https://github.com/JetBrains/kotlin-native/blob/master/tools/kotlin-native-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/KonanPlugin.kt)。

group 'name.quanke.kotlin.rest'version '1.0-SNAPSHOT'buildscript {ext.kotlin_version = '1.2.10'ext.spring_boot_version = '1.5.4.RELEASE'repositories {mavenCentral()}dependencies {classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"classpath "org.jetbrains.kotlin:kotlin-allopen:$kotlin_version" // See https://kotlinlang.org/docs/reference/compiler-plugins.html#kotlin-spring-compiler-plugin// org.jetbrains.kotlin:kotlin-allopen 是全开放编译器插件。我们使用Kotlin 调用Java的Spring AOP框架和库,需要类为 open,而Kotlin 类和函数都是默认 final 的,这样我们需要为每个类和函数前面加上open修饰符。// 这样的代码写起来,可费事了。还好,我们有all-open 编译器插件。它会适配 Kotlin 以满足这些框架的需求,并使用指定的注解标注类而其成员无需显式使用 open 关键字打开。 例如,当我们使用 Spring 时,就不需要打开所有的类,跟我们在Java中写代码一样,只需要用相应的注解标注即可。classpath "org.springframework.boot:spring-boot-gradle-plugin:$spring_boot_version"}}apply plugin: 'kotlin'apply plugin: "kotlin-spring" // See https://kotlinlang.org/docs/reference/compiler-plugins.html#kotlin-spring-compiler-pluginapply plugin: 'org.springframework.boot'jar {baseName = '0_2RestfulApi-service'version = '0.1.0'}repositories {mavenCentral()}dependencies {compile "org.jetbrains.kotlin:kotlin-stdlib-jre8:$kotlin_version"compile 'org.springframework.boot:spring-boot-starter-web'testCompile('org.springframework.boot:spring-boot-starter-test')}compileKotlin {kotlinOptions.jvmTarget = "1.8"}compileTestKotlin {kotlinOptions.jvmTarget = "1.8"}

1.新建gradle,kotlin工程:

16.2.8 konanArtifacts 配置

在 konan 插件中,我们使用konanArtifacts来配置编写翻译职责实行。

konanArtifacts { 
    KotlinorApp { // (1)
        inputFiles fileTree("src/kotlin") // (2)
        useInterop 'ckotlinor' // (3)
        nativeLibrary fileTree('src/c/cn_kotlinor.bc') // (4)
        target 'macbook' // (5)
    }
}

内部,(1)处的KotlinorApp名称,在 build 之后会生成以那个称号命名的 KotlinorApp.kexe 可实行程序。
(2)处的inputFiles配置的是 kotlin 代码目录,程序试行的输入 main 定义在那边。

(3)处的useInterop 配置的是应用哪个互操作配置。我们应用的是这段日子的 konanInterop 里面包车型地铁安插 ckotlinor 。

(4) 处的nativeLibrary配置的是本地库文件。关于'src/c/cn_kotlinor.bc'文件的编写翻译生成我们在底下讲。

(5) 处的target 配置的是编写翻译的目的平台,这里大家配备为 'macbook' 。

有关konan阿特ifacts可选的配备如下所示

 konanArtifacts {

       artifactName1 {

           inputFiles "files" "to" "be" "compiled"

           outputDir "path/to/output/dir"

           library "path/to/library"
           library File("Library")

           nativeLibrary "path/to/library"
           nativeLibrary File("Library")

           noStdLib
           produce "library"|"program"|"bitcode"
           enableOptimization

           linkerOpts "linker" "args"
           target "target"

           languageVersion "version"
           apiVersion "version"

     }
      artifactName2 {

           extends artifactName1

           inputDir "someDir"
           outputDir "someDir"
      }

   }

konan 编写翻译职责安排管理类是KonanCompileTask.kt (https://github.com/JetBrains/kotlin-native/blob/master/tools/kotlin-native-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/KonanCompileTask.kt)。

在kotlin目录上面创设:

打开IDEA的File > New > Project , 如下图

16.2.9 完整的 build.gradle 配置

全体的 build.gradle 配置文件内容如下

group 'com.easy.kotlin'
version '1.0-SNAPSHOT'


buildscript {
    repositories {
        mavenCentral()
        maven {
            url "https://dl.bintray.com/jetbrains/kotlin-native-dependencies"
        }
    }
    dependencies {
        classpath "org.jetbrains.kotlin:kotlin-native-gradle-plugin:0.3"
    }
}

apply plugin: 'konan' // konan 就是用来编译 Kotlin 为 native 代码的插件


konanInterop { // konanInterop 主要用来配置 Kotlin 调用 C 的接口
    ckotlinor {
        defFile 'kotlinor.def' // interop 的配置文件
        includeDirs "src/c" // C 头文件目录,可以传入多个
    }
}

konanArtifacts { //konanArtifacts 配置我们的项目
    KotlinorApp { // build 之后会生成 KotlinorApp.kexe 可执行程序
        inputFiles fileTree("src/kotlin") //kotlin 代码配置,项目入口 main 需要定义在这里
        useInterop 'ckotlinor' //使用前面的 konanInterop 里面的配置  kotlinor{ ... }
        nativeLibrary fileTree('src/c/cn_kotlinor.bc') //自己编译的 llvm 字节格式的依赖
        target 'macbook' // 编译的目标平台
    }
}

唤醒:关于konan 插件详细布署文书档案:Gradle DSL https://github.com/JetBrains/kotlin-native/blob/master/GRADLE_PLUGIN.md

name.quanke.kotlin.rest

图片 14螢幕快照2017-03-11 12.40.05.png

16.2.10 使用 clang 编译 C 代码

为了实用性,大家新建二个 shell 脚本 kclang.sh 来简化 clang 编写翻译的命令行输入参数

#!/usr/bin/env bash
clang -std=c99 -c $1 -o $2 -emit-llvm

那般,大家把 kclang.sh 放到 C 代码目录下,然后直接使用脚本来编写翻译:

 kclang.sh cn_kotlinor.c cn_kotlinor.bc

大家将赢得三个 cn_kotlinor.bc 库文件。

唤醒:clang是四个C 编写、基于LLVM、宣布于LLVM BSD许可证下的C/C /Objective-C/Objective-C 编写翻译器。它与GNU C语言标准大约统统相称。越多关于 clang 的始末可参照他事他说加以考察 : http://clang.llvm.org/docs/index.html 。

在意:不能够直接在kotlin目录上边写Application 类,不然会报错

根据分界面操作,输入相应的工程名等音信,就能够新建一个用到Gradle营造的专门的学业Kotlin工程。

16.2.11 配置 konan 编写翻译器主目录

终极,在进行 Gradle 创设此前,大家还索要钦命konan 编写翻译器主目录。大家在工程根目录下边新建 gradle.properties 那么些性子配置文件,内容如下

konan.home=/Users/jack/soft/kotlin-native-macos-0.3
Your ApplicationContext is unlikely to start due to a @ComponentScan of the default package

2.build.gradle 主干配备

16.2.12 实施营造操作

咱俩一贯在 IDEA 右边的 Gradle 工具栏点击Tasks ->build -> build 命令施行营造操作

图片 15

螢幕快照 2017-07-30 03.42.19.png

我们拜访到终端输出

15:12:02: Executing external task 'build'...
:assemble UP-TO-DATE
:check UP-TO-DATE
:downloadKonanCompiler
:genKotlinerInteropStubs
:compileKotlinerInteropStubs
KtFile: kotliner.kt
:compileKonanKotliner
KtFile: main.kt
ld: warning: object file (/var/folders/q5/kvt7_nsd6ngdw5qry4d99xv00000gn/T/combined697750051437954502.o) was built for newer OSX version (10.12) than being linked (10.11)
:compileKonan
:build

BUILD SUCCESSFUL in 29s
4 actionable tasks: 4 executed
15:12:31: External task execution finished 'build'.

营造产生之后,会在build/konan/bin/目录下面生成二个KotlinorApp.kexe可试行程序,它直接在 Mac OS 上运转,不再信赖JVM 情状了。大家获取的欧洲经济共同体的构建输出目录树如下

build
└── konan
    ├── bin
    │   ├── KotlinorApp.kexe
    │   └── KotlinorApp.kt.bc
    ├── interopCompiledStubs
    │   └── ckotlinorInteropStubs
    │       ├── ckotlinorInteropStubs
    │       │   ├── linkdata
    │       │   │   ├── module
    │       │   │   ├── package_ckotlinor
    │       │   │   └── root_package
    │       │   ├── manifest
    │       │   ├── resources
    │       │   └── targets
    │       │       └── macbook
    │       │           ├── kotlin
    │       │           │   └── program.kt.bc
    │       │           └── native
    │       └── ckotlinorInteropStubs.klib
    ├── interopStubs
    │   └── genCkotlinorInteropStubs
    │       └── ckotlinor
    │           └── ckotlinor.kt
    └── nativelibs
        └── genCkotlinorInteropStubs
            └── ckotlinorstubs.bc

16 directories, 10 files

其间在 ckotlinor.kt中,我们能够见到 konan 编写翻译器还为大家转移了 C 代码对应的 Kotlin 的接口

@file:Suppress("UNUSED_EXPRESSION", "UNUSED_VARIABLE")
package ckotlinor

import konan.SymbolName
import kotlinx.cinterop.*

fun printHello(): Unit {
    val res = kni_printHello()
    return res
}

@SymbolName("ckotlinor_kni_printHello")
private external fun kni_printHello(): Unit

fun factorial(n: Int): Int {
    val _n = n
    val res = kni_factorial(_n)
    return res
}

@SymbolName("ckotlinor_kni_factorial")
private external fun kni_factorial(n: Int): Int

fun fib(n: Int): Int {
    val _n = n
    val res = kni_fib(_n)
    return res
}

@SymbolName("ckotlinor_kni_fib")
private external fun kni_fib(n: Int): Int

我们在Kotlin 代码中,调用的正是这个映射到 C 中的函数接口。

3.创设数据模型Greeting类:

IDEA自动生成的Gradle配置文件如下:

16.2.12 推行 kexe 应用程序

大家直接在命令行中实践 KotlinorApp.kexe 如下

chatper16_kotlin_native_helloworld$ build/konan/bin/KotlinorApp.kexe  

小编们得以观看如下输出:

[C]HelloWorld
[C]calc factorial: 1
[C]calc factorial: 0
[C]calc factorial: 2
...
[C]calc factorial: 2
[C]calc factorial: 1
[C]calc factorial: 0
1
2
6
24
120
720
5040
[C]calc fibonacci: 1
[C]calc fibonacci: 2
[C]calc fibonacci: 3
...
[C]calc fibonacci: 3
[C]calc fibonacci: 2
[C]calc fibonacci: 1
1
1
2
3
5
8
13

至此,大家达成了贰遍轻巧的Kotlin Native 与 C 语言互操作在系统级编制程序的心得之旅。

咱俩看看,Kotlin Native照旧重视互操作性(Interoperability)。它能一点也不慢地调用C函数,以至还能够从C头文件自动生成了对应的Kotlin接口,发扬了JetBrains为开荒者服务的好美观法!

只是,在感受的长河中大家也开掘一切经过比较手工业化,显得相比较麻烦(举例手工业新建各样配置文件、手工业使用 clang 编写翻译C 代码等)。

但是,Kotlin Native 的 Gradle 插件用起来依然非常不错的。相信未来 IDEA 会对 Kotlin Native 开拓进展智能的购并,以便于系统编制程序的开拓者更加好越来越快的产生项目标安顿以及支付编码职业。

package name.quanke.kotlin.rest/*** Created by http://quanke.name on 2018/1/9.*/data class Greeting(val id: Long, val content: String)
group 'com.easy.kotlin'version '1.0-SNAPSHOT'buildscript {ext.kotlin_version = '1.1.2-2'repositories {mavenCentral()}dependencies {// Kotlin Gradle插件classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"}}apply plugin: 'java'apply plugin: 'kotlin'sourceCompatibility = 1.8targetCompatibility = 1.8repositories {mavenCentral()}dependencies {compile "org.jetbrains.kotlin:kotlin-stdlib-jre8:$kotlin_version"testCompile group: 'junit', name: 'junit', version: '4.12'}

16.3 Kotlin Native 编译器 konan 简介

本小节大家简单介绍一下Kotlin Native 编写翻译器的相干内容(首要以 Mac OS 平台示例)。

固然是Java写的话,想象一下这亟需多少行代码,看看kotlin,不明则厉。。。

从地方的布局文件我们得以看看,IDEA已经自行把Gradle 营造Kotlin工程插件 kotlin-gradle-plugin,以及Kotlin标准库kotlin-stdlib加多到布署文件中了。

bin目录

bin目录上边是举行命令行

cinterop       klib           konanc         kotlinc        kotlinc-native  run_konan

run_konan 是真正的入口 shell,它的实行逻辑是

TOOL_NAME="$1"
shift

if [ -z "$JAVACMD" -a -n "$JAVA_HOME" -a -x "$JAVA_HOME/bin/java" ]; then
    JAVACMD="$JAVA_HOME/bin/java"
else
    JAVACMD=java
fi
[ -n "$JAVACMD" ] || JAVACMD=java
...
java_opts=(-ea 
            -Xmx3G 
            "-Djava.library.path=${NATIVE_LIB}" 
            "-Dkonan.home=${KONAN_HOME}" 
           -Dfile.encoding=UTF-8)

KONAN_JAR="${KONAN_HOME}/konan/lib/backend.native.jar"
KOTLIN_JAR="${KONAN_HOME}/konan/lib/kotlin-compiler.jar"
STUB_GENERATOR_JAR="${KONAN_HOME}/konan/lib/StubGenerator.jar"
INTEROP_INDEXER_JAR="${KONAN_HOME}/konan/lib/Indexer.jar"
INTEROP_JAR="${KONAN_HOME}/konan/lib/Runtime.jar"
HELPERS_JAR="${KONAN_HOME}/konan/lib/helpers.jar"
KLIB_JAR="${KONAN_HOME}/konan/lib/klib.jar"
UTILITIES_JAR="${KONAN_HOME}/konan/lib/utilities.jar"
KONAN_CLASSPATH="$KOTLIN_JAR:$INTEROP_JAR:$STUB_GENERATOR_JAR:$INTEROP_INDEXER_JAR:$KONAN_JAR:$HELPERS_JAR:$KLIB_JAR:$UTILITIES_JAR"
TOOL_CLASS=org.jetbrains.kotlin.cli.utilities.MainKt

LIBCLANG_DISABLE_CRASH_RECOVERY=1 
$TIMECMD "$JAVACMD" "${java_opts[@]}" "${java_args[@]}" -cp "$KONAN_CLASSPATH" "$TOOL_CLASS" "$TOOL_NAME" "${konan_args[@]}"

小编们能够看出,Kotlin Native 编写翻译器 konan 的周转条件照旧在 JVM 上,不过它生成的机器码的可实践程序是直接运维在相应的平台种类上(直接编译成机器语言)。

package name.quanke.kotlin.restimport org.springframework.web.bind.annotation.GetMappingimport org.springframework.web.bind.annotation.RequestParamimport org.springframework.web.bind.annotation.RestControllerimport java.util.concurrent.atomic.AtomicLong/*** Created by http://quanke.name on 2018/1/9.*/@RestControllerclass GreetingController {val counter = AtomicLong()@GetMapping("/greeting")fun greeting(@RequestParam(value = "name", defaultValue = "World") name: String) =Greeting(counter.incrementAndGet(), "Hello, $name")}

package name.quanke.kotlin.restimport org.springframework.boot.SpringApplicationimport org.springframework.boot.autoconfigure.SpringBootApplication/*** Created by http://quanke.name on 2018/1/9.*/@SpringBootApplicationclass Applicationfun main(args: Array<String>) {SpringApplication.run(Application::class.java, *args)}

3.安顿SpringBoot相关内容

konan目录

konan目录是 Kotlin Native 编写翻译器的核心完成部分。目录结构如下:

kotlin-native-macos-0.3$ tree konan
konan/
├── konan.properties
├── lib
│   ├── Indexer.jar
│   ├── Runtime.jar
│   ├── StubGenerator.jar
│   ├── backend.native.jar
│   ├── callbacks
│   │   └── shared
│   │       └── libcallbacks.dylib
│   ├── clangstubs
│   │   └── shared
│   │       └── libclangstubs.dylib
│   ├── helpers.jar
│   ├── klib.jar
│   ├── kotlin-compiler.jar
│   ├── protobuf-java-2.6.1.jar
│   └── utilities.jar
└── nativelib
    ├── libcallbacks.dylib
    ├── libclangstubs.dylib
    ├── libllvmstubs.dylib
    └── liborgjetbrainskotlinbackendkonanhashstubs.dylib

6 directories, 16 files

大家得以见见在 run_konan 命令行 shell 中依附了上边的这个 jar 包。上边的目录文件是 Mac OS 平台上的。

相应的 Linux 平台上的konan目录文件如下

kotlin-native-linux-0.3$ tree konan
konan
├── konan.properties
├── lib
│   ├── Indexer.jar
│   ├── Runtime.jar
│   ├── StubGenerator.jar
│   ├── backend.native.jar
│   ├── callbacks
│   │   └── shared
│   │       └── libcallbacks.so
│   ├── clangstubs
│   │   └── shared
│   │       └── libclangstubs.so
│   ├── helpers.jar
│   ├── klib.jar
│   ├── kotlin-compiler.jar
│   ├── protobuf-java-2.6.1.jar
│   └── utilities.jar
└── nativelib
    ├── libcallbacks.so
    ├── libclangstubs.so
    ├── libllvmstubs.so
    └── liborgjetbrainskotlinbackendkonanhashstubs.so

6 directories, 16 files

Windows 平台上的 konan 目录文件如下

kotlin-native-windows-0.3$ tree konan
konan
├── konan.properties
├── lib
│   ├── Indexer.jar
│   ├── Runtime.jar
│   ├── StubGenerator.jar
│   ├── backend.native.jar
│   ├── callbacks
│   │   └── shared
│   │       └── callbacks.dll
│   ├── clangstubs
│   │   └── shared
│   │       └── clangstubs.dll
│   ├── helpers.jar
│   ├── klib.jar
│   ├── kotlin-compiler.jar
│   ├── protobuf-java-2.6.1.jar
│   └── utilities.jar
└── nativelib
    ├── callbacks.dll
    ├── clangstubs.dll
    ├── llvmstubs.dll
    └── orgjetbrainskotlinbackendkonanhashstubs.dll

6 directories, 16 files

点击Gradle的bootRun:

上面大家来布局SpringBoot相关内容。首先在构建脚本里面增多ext变量springBootVersion。

klib 目录

klib 目录下是 Kotlin 的标准库的关联元数据文件以及 Kotlin Native 针对各种指标平台的 bc 文件

kotlin-native-macos-0.3$ tree klib
klib/
└── stdlib
    ├── linkdata
    │   ├── module
    │   ├── package_konan
    │   ├── package_konan.internal
    │   ├── package_kotlin
    │   ├── package_kotlin.annotation
    │   ├── package_kotlin.collections
    │   ├── package_kotlin.comparisons
    │   ├── package_kotlin.coroutines
    │   ├── package_kotlin.coroutines.experimental
    │   ├── package_kotlin.coroutines.experimental.intrinsics
    │   ├── package_kotlin.experimental
    │   ├── package_kotlin.internal
    │   ├── package_kotlin.io
    │   ├── package_kotlin.properties
    │   ├── package_kotlin.ranges
    │   ├── package_kotlin.reflect
    │   ├── package_kotlin.sequences
    │   ├── package_kotlin.text
    │   ├── package_kotlin.text.regex
    │   ├── package_kotlin.util
    │   ├── package_kotlinx
    │   ├── package_kotlinx.cinterop
    │   └── root_package
    ├── manifest
    ├── resources
    └── targets
        ├── android_arm32
        │   ├── kotlin
        │   │   └── program.kt.bc
        │   └── native
        │       ├── launcher.bc
        │       ├── runtime.bc
        │       └── start.bc
        ├── android_arm64
        │   ├── kotlin
        │   │   └── program.kt.bc
        │   └── native
        │       ├── launcher.bc
        │       ├── runtime.bc
        │       └── start.bc
        ├── iphone
        │   ├── kotlin
        │   │   └── program.kt.bc
        │   └── native
        │       ├── launcher.bc
        │       ├── runtime.bc
        │       ├── start.bc
        │       ├── start.kt.bc
        │       └── stdlib.kt.bc
        └── macbook
            ├── kotlin
            │   └── program.kt.bc
            └── native
                ├── launcher.bc
                ├── runtime.bc
                └── start.bc

16 directories, 42 files

上面包车型客车目录是 kotlin-native-macos-0.3 平台的本子。大家得以观望,在Mac OS上,大家能够使用 Kotlin Native 编写翻译android_arm32、android_arm64、iphone、macbook等目的平台的机器码可推行的程序。

别的,对应的 Linux 平台的目录文件如下

kotlin-native-linux-0.3$ tree klib
klib/
└── stdlib
    ├── linkdata
    │   ├── module
    │   ├── package_konan
    │   ├── package_konan.internal
    │   ├── package_kotlin
    │   ├── package_kotlin.annotation
    │   ├── package_kotlin.collections
    │   ├── package_kotlin.comparisons
    │   ├── package_kotlin.coroutines
    │   ├── package_kotlin.coroutines.experimental
    │   ├── package_kotlin.coroutines.experimental.intrinsics
    │   ├── package_kotlin.experimental
    │   ├── package_kotlin.internal
    │   ├── package_kotlin.io
    │   ├── package_kotlin.properties
    │   ├── package_kotlin.ranges
    │   ├── package_kotlin.reflect
    │   ├── package_kotlin.sequences
    │   ├── package_kotlin.text
    │   ├── package_kotlin.text.regex
    │   ├── package_kotlin.util
    │   ├── package_kotlinx
    │   ├── package_kotlinx.cinterop
    │   └── root_package
    ├── manifest
    ├── resources
    └── targets
        ├── android_arm32
        │   ├── kotlin
        │   │   └── program.kt.bc
        │   └── native
        │       ├── launcher.bc
        │       ├── runtime.bc
        │       └── start.bc
        ├── android_arm64
        │   ├── kotlin
        │   │   └── program.kt.bc
        │   └── native
        │       ├── launcher.bc
        │       ├── runtime.bc
        │       └── start.bc
        ├── linux
        │   ├── kotlin
        │   │   └── program.kt.bc
        │   └── native
        │       ├── launcher.bc
        │       ├── runtime.bc
        │       └── start.bc
        └── raspberrypi
            ├── kotlin
            │   └── program.kt.bc
            └── native
                ├── launcher.bc
                ├── runtime.bc
                ├── start.bc
                ├── start.kt.bc
                └── stdlib.kt.bc

16 directories, 42 files

也正是说大家得以在 Linux 平台上编写翻译android_arm32、android_arm64、linux、raspberrypi等平台上的指标程序。

对应Windows 平台的如下

kotlin-native-windows-0.3$ tree klib
klib/
└── stdlib
    ├── linkdata
    │   ├── module
    │   ├── package_konan
    │   ├── package_konan.internal
    │   ├── package_kotlin
    │   ├── package_kotlin.annotation
    │   ├── package_kotlin.collections
    │   ├── package_kotlin.comparisons
    │   ├── package_kotlin.coroutines
    │   ├── package_kotlin.coroutines.experimental
    │   ├── package_kotlin.coroutines.experimental.intrinsics
    │   ├── package_kotlin.experimental
    │   ├── package_kotlin.internal
    │   ├── package_kotlin.io
    │   ├── package_kotlin.properties
    │   ├── package_kotlin.ranges
    │   ├── package_kotlin.reflect
    │   ├── package_kotlin.sequences
    │   ├── package_kotlin.text
    │   ├── package_kotlin.text.regex
    │   ├── package_kotlin.util
    │   ├── package_kotlinx
    │   ├── package_kotlinx.cinterop
    │   └── root_package
    ├── manifest
    ├── mingw
    │   ├── kotlin
    │   │   └── program.kt.bc
    │   └── native
    │       ├── launcher.bc
    │       ├── runtime.bc
    │       └── start.bc
    ├── resources
    └── targets
        └── mingw
            ├── kotlin
            │   └── program.kt.bc
            └── native
                ├── launcher.bc
                ├── runtime.bc
                └── start.bc

10 directories, 32 files

在 Windows 平新竹,Kotlin Native 使用的是 mingw 库来贯彻的。近些日子,在 V0.3预透露版本,我们在 Windows 平台上得以感受的事物比相当少,像 Android,iOS,Raspberrypi都还不协理。

提拔:MinGW,是Minimalist GNUfor Windows的缩写。它是三个可轻便使用和轻松公布的Windows特定头文件和使用GNU工具集导入库的成团,允许你在GNU/Linux和Windows平台湾学生开支地的Windows程序而无需第三方C运营时(C Runtime)库。MinGW 是一组富含文件和端口库,其职能是同意调整台形式的先后行使微软的标准C运维时(C Runtime)库(MSVCRT.DLL),该库在具备的 NT OS 上有效,在享有的 Windows 95发行版以上的 Windows OS 有效,使用基本运作时,你能够使用 GCC 写调控台形式的切合U.S.规范协会(ANSI)程序,能够应用微软提供的 C 运营时(C Runtime)扩大,与主导运作时相结合,就足以有丰富的职分既使用 CRT(C Runtime)又利用 WindowsAPI功效。

图片 16bootRun

ext.kotlin_version = '1.1.2-2'ext.springboot_version = '1.5.2.RELEASE'

samples目录

samples目录下边是法定给出的局地实例。关于那个实例的文书档案介绍以及源码工程是: https://github.com/JetBrains/kotlin-native/tree/master/samples 。想进一步入木陆分领会学习的同学能够参见。

抑或点击

下一场在塑造注重里增多spring-boot-gradle-plugin

本章小结

本章工程源码: https://github.com/EasyKotlin/chatper16_kotlin_native_helloworld

前几日大家能够把 Kotlin 像C 同样地平素编写翻译成的机器码来运行,这样在 C 语言出现的地方(举个例子使用于嵌入式等对品质供给相比较高的景观),Kotlin 也来了。Kotlin 将会在嵌入式系统和物联网、数据分析和科学总括、游戏开荒、服务端开拓和微服务等世界不断发力。

Kotlin 整个语言的架构不可谓不宏大:上的了云端(服务端程序),下的了手提式有线电话机端( Kotlin / Native ),写的了前边一个(JS,HTML DSL 等),嵌的了智能双门电冰箱(Kotlin Native)。Kotlin 简直已改成一门长于八个世界的言语了。

在网络世界,近些日子在Web服务端应用开荒、Android移动端支付是Kotlin 最活跃的世界。 Kotlin 将会更增添地进去 Java 程序猿们的视线, Java 技士们会日渐爱上 Kotlin 。

未来的或然性有不菲。可是真正的前景要么要我们去创立。

图片 17Run图片 18运维成功的典型

buildscript {...dependencies {// Kotlin Gradle插件classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"// SpringBoot Gradle插件classpath("org.springframework.boot:spring-boot-gradle-plugin:$springboot_version")// Kotlin整合SpringBoot的默认无参构造函数,默认把所有的类设置open类插件classpath("org.jetbrains.kotlin:kotlin-noarg:$kotlin_version")classpath("org.jetbrains.kotlin:kotlin-allopen:$kotlin_version")}}

假诺未有病魔,访谈

4.安插无参、全开放插件

其中,org.jetbrains.kotlin:kotlin-noarg是无参加编写译器插件,它为富有特定评释的类生成贰个附加的零参数构造函数。 那些变化的构造函数是合成的,因而无法从 Java 或 Kotlin 中从来调用,但足以采纳反射调用。 那样大家就能够应用 Java Persistence API实例化 data 类。

输出:

其中,org.jetbrains.kotlin:kotlin-allopen 是全开放编写翻译器插件。大家利用Kotlin 调用Java的Spring AOP框架和库,要求类为 open,而Kotlin 类和函数都以暗中认可 final 的,那样我们必要为每种类和函数前边加上open修饰符。

图片 19image

那般的代码写起来,可麻烦了。幸好,大家有all-open 编写翻译器插件。它会适配 Kotlin 以满足那么些框架的须求,并应用内定的注脚表明类而其成员无需显式使用 open 关键字张开。 举例,当大家选取 Spring 时,就无需开垦全部的类,跟大家在Java中写代码一样,只要求用相应的申明标记就能够。

那么恭喜你,一个kotlin 和spring boot的web服务就像此解决了。。。

Kotlin 1.0.6 及其之后的本子里提供了 kotlin-spring 插件,用上边包车型大巴笺注把Kotlin的类或成员函数设置为open:

服务默许是8080端口,如若8080端口刚好被并吞了,那在resources目录下新建二个application.yml文件:

@Component

@Async

@Transactional

@Cacheable

server: port: 1234

那样的注释补助,意味着我们应用 @Configuration,@Controller,@RestController,@Service 或 @Repository 表明的类会自动安装为 open ,因为那些证明使用了@Component。

把端口改成你想要的。

总体的build.gradle配置文件如下

本来那只是始于的演示,么有何卵用。。。之后能够用于生产的demo,涉笔成趣。

group 'com.easy.kotlin'version '1.0-SNAPSHOT'buildscript {ext.kotlin_version = '1.1.2-2'ext.springboot_version = '1.5.2.RELEASE'repositories {mavenCentral()}dependencies {// Kotlin Gradle插件classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"// SpringBoot Gradle插件classpath("org.springframework.boot:spring-boot-gradle-plugin:$springboot_version")// Kotlin整合SpringBoot的默认无参构造函数,默认把所有的类设置open类插件// 无参编译器插件为具有特定注解的类生成一个额外的零参数构造函数。 这个生成的构造函数是合成的,因此不能从 Java 或 Kotlin 中直接调用,但可以使用反射调用。 这允许 Java Persistence API实例化 data 类,虽然它从 Kotlin 或 Java 的角度看没有无参构造函数classpath("org.jetbrains.kotlin:kotlin-noarg:$kotlin_version")// 全开放插件(kotlin-allopen)classpath("org.jetbrains.kotlin:kotlin-allopen:$kotlin_version")}}apply plugin: 'java'apply plugin: 'kotlin'//Kotlin整合SpringBoot需要的spring,jpa,org.springframework.boot插件//Kotlin-spring 编译器插件,它根据 Spring 的要求自动配置全开放插件。apply plugin: 'kotlin-spring'//该插件指定 @Entity 和 @Embeddable 注解作为应该为一个类生成无参构造函数的标记。apply plugin: 'kotlin-jpa'apply plugin: 'org.springframework.boot'sourceCompatibility = 1.8targetCompatibility = 1.8repositories {mavenCentral()}dependencies {compile "org.jetbrains.kotlin:kotlin-stdlib-jre8:$kotlin_version"testCompile group: 'junit', name: 'junit', version: '4.12'compile("org.springframework.boot:spring-boot-starter-web")testCompile("org.springframework.boot:spring-boot-starter-test")compile("org.springframework.boot:spring-boot-starter-data-jpa")compile('mysql:mysql-connector-java:5.1.13')}

《Spring Boot in kotlin 实战》,迎接关心!

5.配置application.properties

图片 20全栈架构

spring.datasource.url = jdbc:mysql://localhost:3306/easykotlinspring.datasource.username = rootspring.datasource.password = root#spring.datasource.driverClassName = com.mysql.jdbc.Driver# Specify the DBMSspring.jpa.database = MYSQL# Keep the connection alive if idle for a long time (needed in production)spring.datasource.testWhileIdle = truespring.datasource.validationQuery = SELECT 1# Show or not log for each sql queryspring.jpa.show-sql = true# Hibernate ddl auto (create, create-drop, update)spring.jpa.hibernate.ddl-auto = update# Naming strategyspring.jpa.hibernate.naming-strategy = org.hibernate.cfg.ImprovedNamingStrategy# The SQL dialect makes Hibernate generate better SQL for the chosen databasespring.jpa.properties.hibernate.dialect = org.hibernate.dialect.MySQL5Dialectserver.port=8000

6.完好无缺乏工人程架构

UNIX操作系统说,“一切都以文件”。所以,大家的具有的源代码、字节码、工程能源文件等等,一切都以文件。文件里面存的是字符串。种种框架、库、编写翻译器,解释器,都以对这么些字符串流举行过滤,最终映射成01机器码(大概CPU微指令码等),最终诞生到硬件上的高低电平。

总体育工作程目录如下:

.├── README.md├── build│ └── kotlin-build│ └── caches│ └── version.txt├── build.gradle├── easykotlin.sql├── settings.gradle└── src├── main│ ├── java│ ├── kotlin│ │ └── com│ │ └── easy│ │ └── kotlin│ │ ├── Application.kt│ │ ├── controller│ │ │ ├── HelloWorldController.kt│ │ │ └── PeopleController.kt│ │ ├── entity│ │ │ └── People.kt│ │ ├── repository│ │ │ └── PeopleRepository.kt│ │ └── service│ │ └── PeopleService.kt│ └── resources│ ├── application.properties│ └── banner.txt└── test├── java├── kotlin└── resources19 directories, 13 files

全方位尽在不言中,静静地看工程文件结构。

一直写个HelloWorldController

package com.easy.kotlin.controllerimport org.springframework.web.bind.annotation.GetMappingimport org.springframework.web.bind.annotation.RestController/*** Created by jack on 2017/6/7.*/@RestControllerclass HelloWorldController {@GetMapping(value = *arrayOf("/helloworld", "/"))fun helloworld(): Any {return "Hello,World!"}}

咱俩再写个访问数据库的正统四层代码

写领域模型类People

package com.easy.kotlin.entityimport java.util.*import javax.persistence.Entityimport javax.persistence.GeneratedValueimport javax.persistence.GenerationTypeimport javax.persistence.Id/*** Created by jack on 2017/6/6.*/@Entityclass People(@Id @GeneratedValue(strategy = GenerationType.AUTO)val id: Long?,val firstName: String?,val lastName: String?,val gender: String?,val age: Int?,val gmtCreated: Date,val gmtModified: Date) {override fun toString(): String {return "People(id=$id, firstName='$firstName', lastName='$lastName', gender='$gender', age=$age, gmtCreated=$gmtCreated, gmtModified=$gmtModified)"}}

写PeopleRepository

package com.easy.kotlin.repositoryimport com.easy.kotlin.entity.Peopleimport org.springframework.data.repository.CrudRepository/*** Created by jack on 2017/6/7.*/interface PeopleRepository : CrudRepository<People, Long> {fun findByLastName(lastName: String): List<People>?}

写PeopleService

package com.easy.kotlin.serviceimport com.easy.kotlin.entity.Peopleimport com.easy.kotlin.repository.PeopleRepositoryimport org.springframework.beans.factory.annotation.Autowiredimport org.springframework.stereotype.Service/*** Created by jack on 2017/6/7.*/@Serviceclass PeopleService : PeopleRepository {@Autowiredval peopleRepository: PeopleRepository? = nulloverride fun findByLastName(lastName: String): List<People>? {return peopleRepository?.findByLastName}override fun <S : People?> save(entity: S): S? {return peopleRepository?.save}override fun <S : People?> save(entities: MutableIterable<S>?): MutableIterable<S>? {return peopleRepository?.save}override fun delete(entities: MutableIterable<People>?) {}override fun delete(entity: People?) {}override fun delete(id: Long?) {}override fun findAll(ids: MutableIterable<Long>?): MutableIterable<People>? {return peopleRepository?.findAll}override fun findAll(): MutableIterable<People>? {return peopleRepository?.findAll()}override fun exists(id: Long?): Boolean {return peopleRepository?.exists!!}override fun count(): Long {return peopleRepository?.count()!!}override fun findOne(id: Long?): People? {return peopleRepository?.findOne}override fun deleteAll() {}}

写PeopleController

package com.easy.kotlin.controllerimport com.easy.kotlin.service.PeopleServiceimport org.springframework.beans.factory.annotation.Autowiredimport org.springframework.stereotype.Controllerimport org.springframework.web.bind.annotation.GetMappingimport org.springframework.web.bind.annotation.RequestParamimport org.springframework.web.bind.annotation.ResponseBody/*** Created by jack on 2017/6/7.*/@Controllerclass PeopleController {@Autowiredval peopleService: PeopleService? = null@GetMapping(value = "/hello")@ResponseBodyfun hello(@RequestParam(value = "lastName") lastName: String): Any {val peoples = peopleService?.findByLastNameval map = HashMap<Any, Any>()map.put("hello", peoples!!)return map}}

7.周转测量试验

率先在本地mysql数据库中新建schema

CREATE SCHEMA `easykotlin` DEFAULT CHARACTER SET utf8 ;

然后,点击Gradle的bootRun , 如下图

图片 21螢幕快照2017-06-07 11.47.42.png

假若未有极度,运维成功,大家将看见以下输出:

图片 22螢幕快速照相2017-06-07 11.50.07.png

打开浏览器,访谈央求:

输出响应:

Hello,World!

访问

// 20170607115700// http://127.0.0.1:8000/hello?lastName=chen{"hello": [{"id": 1,"firstName": "Jason","lastName": "Chen","gender": "Male","age": 28,"gmtCreated": 1496768497000,"gmtModified": 1496768497000},{"id": 3,"firstName": "Corey","lastName": "Chen","gender": "Female","age": 20,"gmtCreated": 1496768497000,"gmtModified": 1496768497000}...]}

本节示范工程源代码:

2017谷歌(Google)I/O大会:发布 Kotlin 成 Android 开拓一流语言。

图片 23

2017谷歌(Google)I/O大会上,Google发表,将Kotlin语言作为安卓开辟的一流编制程序语言。Kotlin由JetBrains集团开销,与Java百分之百互通,并具有好多Java尚不辅助的新特点。Google称还将与JetBrains公司同盟,为Kotlin设立三个非毛利基金会。

JetBrains在二〇〇八年第一遍推出Kotlin编制程序语言,并在次年将之开源。下一版的AndroidStudio也将提供支撑。

下边大家简介怎样在Android上开首叁个Kotlin的HelloWorld程序。

对此大家程序猿来讲,咱们正处在二个美好的时日。得益于网络的迈入、工具的前行,大家前日求学一门新技术的财力和难度都比过去低了成都百货上千。

一旦你从前从没行使过Kotlin,那么从头开头写二个HelloWorld的app也只须要这么几步:

1.率先,你要有一个Android Studio。本节中,大家用的是2.2.3版本,别的版本应该也完全相同。

Android Studio 2.3.1Build #AI-162.3871768, built on April 1, 2017JRE: 1.8.0_112-release-b06 x86_64JVM: OpenJDK 64-Bit Server VM by JetBrains s.r.o

2.其次,安装三个Kotlin的插件。

逐条展开:Android Studio > Preferences > Plugins,

图片 24

然后选拔『Browse repositories』,在搜寻框中寻找Kotlin,结果列表中的『Kotlin』插件,如下图

图片 25

点击安装,安装完毕现在,重启Android Studio。

3.新建三个Android项目

重复打开Android Studio,新建七个Android项目吧,加多贰个私下认可的MainActivity——像以前同样就可以。

4.转换Java to Kotlin

安装完插件的AndroidStudio未来一度持有开荒Kotlin的效应。大家先来品尝它的改变职能:Java -> Kotlin,能够把现成的java文件翻译成Kotlin文件。

开垦MainActivity文件,在Code菜单上边可以看出贰个新的功效:Convert Java File to Kotlin File。

图片 26

点击转变,

图片 27

能够观望转变后的Kotlin文件:MainActivity.kt

package com.kotlin.easy.kotlinandroidimport android.support.v7.app.AppCompatActivityimport android.os.Bundleclass MainActivity : AppCompatActivity() {override fun onCreate(savedInstanceState: Bundle?) {super.onCreate(savedInstanceState)setContentView(R.layout.activity_main)}}

其一转变职能,对大家Java技士在就学Kotlin是丰富实用。大家得以依靠大家前面包车型地铁Java编码的阅历来异常快学习Kotlin编制程序。

5.配置gradle文件

MainActivity已经被调换来了Kotlin完毕,不过项目前段时间gradle编写翻译、营造、运转还不可能实践,还要求更进一竿布置一下,让项目帮衬grade的编写翻译、运营。当然,这一步也不须要我们做太多干活儿——IDEA都早就帮我们做好了。

在Java代码转换来Kotlin代码之后,打开MainActivity.kt文件,编写翻译器会唤醒"Kotlin not configured",点击一下Configure开关,IDEA就能活动帮大家把布署文件写好了。

我们能够见见,首要的信赖项是:

kotlin-gradle-pluginplugin: 'kotlin-android'kotlin-stdlib-jre7

一体化的布局文件如下:

Project build.gradle

// Top-level build file where you can add configuration options common to all sub-projects/modules.buildscript {ext.kotlin_version = '1.1.2-4'repositories {jcenter()}dependencies {classpath 'com.android.tools.build:gradle:2.3.1'classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"// NOTE: Do not place your application dependencies here; they belong// in the individual module build.gradle files}}allprojects {repositories {jcenter()}}task clean(type: Delete) {delete rootProject.buildDir}

Module build.gradle

apply plugin: 'com.android.application'apply plugin: 'kotlin-android'android {compileSdkVersion 25buildToolsVersion "25.0.2"defaultConfig {applicationId "com.kotlin.easy.kotlinandroid"minSdkVersion 14targetSdkVersion 25versionCode 1versionName "1.0"testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"}buildTypes {release {minifyEnabled falseproguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'}}}dependencies {compile fileTree(dir: 'libs', include: ['*.jar'])androidTestCompile('com.android.support.test.espresso:espresso-core:2.2.2', {exclude group: 'com.android.support', module: 'support-annotations'})compile 'com.android.support:appcompat-v7:25.3.1'compile 'com.android.support.constraint:constraint-layout:1.0.2'testCompile 'junit:junit:4.12'compile "org.jetbrains.kotlin:kotlin-stdlib-jre7:$kotlin_version"}repositories {mavenCentral()}

就此说选取IDEA来写Kotlin代码,这工具的两全集成会让你用起来如丝般润滑。毕竟Kotlin的亲阿爸JetBrains是特意做工具的,而且速龙li IDEA又是那么快捷、智能。

安插之后,等Gradle Sync完毕,就能够运维。

6.运行

运维结果如下

图片 28

工程源码:

在Kotlin 1.第11中学,最初帮忙JavaScript和协程是路人皆知的独到之处。本节我们差相当少介绍Kotlin代码编写翻译转化为JavaScript的点子。

为了极差不离观地感受那个进度,大家先在指令行REPL情形体验一下Kotlin源码被编写翻译生成对应的JavaScript代码的长河。

第一,使用编辑器新建叁个HelloWord.kt

fun helloWorld(){println("Hello,World!")}

命令行使用kotlinc-js编译

kotlinc-js -output HelloWorld.js HelloWorld.kt

运作实现,大家会在当前目录下看看HelloWorld.js, 其剧情如下

if (typeof kotlin === 'undefined') {throw new Error("Error loading module 'HelloWorld'. Its dependency 'kotlin' was not found. Please, check whether 'kotlin' is loaded prior to 'HelloWorld'.");}var HelloWorld = function (_, Kotlin) {'use strict';var println = Kotlin.kotlin.io.println_s8jyv4$;function helloWorld() {println('Hello,World!');}_.helloWorld = helloWorld;Kotlin.defineModule('HelloWorld', _);return _;}(typeof HelloWorld === 'undefined' ? {} : HelloWorld, kotlin);

咱俩来看,使用kotlinc-js 调换到的js代码信任'kotlin'模块。这些模块是Kotlin扶助JavaScript脚本的内部封装模块。也等于说,如若大家想要使用HelloWorld.js,先要援引kotlin.js。这个kotlin.js 在kotlin-stdlib-js-1.1.2.jar里面。

上边我们运用IDEA新建一个Kotlin(JavaScript)工程。在那几个进程中,大家将拜见到使用Kotlin来开垦js的经过。

率先依照以下步骤新建筑工程程

图片 29螢幕快照2017-06-07 21.32.23.png图片 30螢幕快速照相2017-06-07 21.33.40.png图片 31螢幕快速照相2017-06-07 21.33.57.png图片 32螢幕快照2017-06-07 21.34.08.png

等候Gradle最初化学工业程告竣,大家将获取一个Gradle KotlinJS 工程,其目录如下

.├── build│ └── kotlin-build│ └── caches│ └── version.txt├── build.gradle├── settings.gradle└── src├── main│ ├── java│ ├── kotlin│ └── resources└── test├── java├── kotlin└── resources12 directories, 3 files

里面,build.gradle配置文件为

group 'com.easy.kotlin'version '1.0-SNAPSHOT'buildscript {ext.kotlin_version = '1.1.2'repositories {mavenCentral()}dependencies {classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"}}apply plugin: 'kotlin2js'repositories {mavenCentral()}dependencies {compile "org.jetbrains.kotlin:kotlin-stdlib-js:$kotlin_version"}

个中,apply plugin: 'kotlin2js' 是Gradle的kotlin编写翻译成js的插件。org.jetbrains.kotlin:kotlin-stdlib-js是KotlinJS的运维库。

除此以外,大家须要再配置一下Kotlin代码编写翻译成JS的编写翻译法规,以及文件放置目录等属性,如下所示

build.doLast {configurations.compile.each { File file ->copy {includeEmptyDirs = falsefrom zipTree(file.absolutePath)into "${projectDir}/web"include { fileTreeElement ->def path = fileTreeElement.pathpath.endsWith && (path.startsWith("META-INF/resources/") || !path.startsWith("META-INF/"))}}}}compileKotlin2Js {kotlinOptions.outputFile = "${projectDir}/web/js/app.js"kotlinOptions.moduleKind = "plain" // plain ,AMD,commonjs,umdkotlinOptions.sourceMap = truekotlinOptions.verbose = truekotlinOptions.suppressWarnings = truekotlinOptions.metaInfo = true}

其中,kotlinOptions.moduleKind布局项是Kotlin代码编写翻译成JavaScript代码的档期的顺序。 辅助普通JS,英特尔(Asynchronous Module Definition,异步模块定义)、CommonJS和UMD(Universal Model Definition,通用模型定义)。

英特尔平日在浏览器的顾客端应用。英特尔是异步加载模块,可用性和总体性相对会好。

CommonJS是服务器端上选取的模块系统,经常用于nodejs。

UMD是想综合AMD、CommonJS那二种模型,同期协助它们在客户端或服务器端上运用。

咱俩那边为了极简化演示,直接选取了常备JS plain 类型。

除却输出的 JavaScript 文件,该插件默许会创制一个带二进制描述符的额外 JS 文件。 假诺你是创设别的 Kotlin 模块能够依附的可重用库,那么该文件是不可缺少的,並且应该与转移结果一块分发。 其变动由 kotlinOptions.metaInfo 选项决定。

成套布置完成,大家来写Kotlin代码App.kt

package com.easy.kotlin/*** Created by jack on 2017/6/7.*/fun helloWorld() {println("Hello,World!")}

下一场,大家直接使用Gradle创设筑工程程,如下图所示

图片 33螢幕快照2017-06-07 23.48.23.png

决定台出口

23:47:05: Executing external task 'build'...Using a single directory for all classes from a source set. This behaviour has been deprecated and is scheduled to be removed in Gradle 5.0at build_3e0ikl0qk0r006tvk0olcp2lu.run(/Users/jack/easykotlin/chapter2_hello_world_kotlin2js/build.gradle:15):compileJava NO-SOURCE:compileKotlin2Js:processResources NO-SOURCE:classes:jar:assemble:compileTestJava NO-SOURCE:compileTestKotlin2Js NO-SOURCE:processTestResources NO-SOURCE:testClasses UP-TO-DATE:test NO-SOURCE:check UP-TO-DATE:buildBUILD SUCCESSFUL in 2s3 actionable tasks: 3 executed23:47:08: External task execution finished 'build'.

那时候,大家得以看出工程目录变为

.├── build│ └── kotlin-build│ └── caches│ └── version.txt├── build.gradle├── settings.gradle└── src├── main│ ├── java│ ├── kotlin│ └── resources└── test├── java├── kotlin└── resources12 directories, 3 filesjack@jacks-MacBook-Air:~/easykotlin/chapter2_hello_world_kotlin2js$ tree ..├── build│ ├── kotlin│ │ └── sessions│ ├── kotlin-build│ │ └── caches│ │ └── version.txt│ ├── libs│ │ └── chapter2_hello_world_kotlin2js-1.0-SNAPSHOT.jar│ └── tmp│ └── jar│ └── MANIFEST.MF├── build.gradle├── settings.gradle├── src│ ├── main│ │ ├── java│ │ ├── kotlin│ │ │ └── com│ │ │ └── easy│ │ │ └── kotlin│ │ │ └── App.kt│ │ └── resources│ └── test│ ├── java│ ├── kotlin│ └── resources└── web├── js│ ├── app│ │ └── com│ │ └── easy│ │ └── kotlin│ │ └── kotlin.kjsm│ ├── app.js│ ├── app.js.map│ └── app.meta.js├── kotlin.js└── kotlin.meta.js26 directories, 14 files

其一web目录正是Kotlin代码通过kotlin-stdlib-js-1.1.2.jar编写翻译的输出结果。

其中,app.js代码如下

if (typeof kotlin === 'undefined') {throw new Error("Error loading module 'app'. Its dependency 'kotlin' was not found. Please, check whether 'kotlin' is loaded prior to 'app'.");}var app = function (_, Kotlin) {'use strict';var println = Kotlin.kotlin.io.println_s8jyv4$;function helloWorld() {println('Hello,World!');}var package$com = _.com || (_.com = {});var package$easy = package$com.easy || (package$com.easy = {});var package$kotlin = package$easy.kotlin || (package$easy.kotlin = {});package$kotlin.helloWorld = helloWorld;Kotlin.defineModule;return _;}(typeof app === 'undefined' ? {} : app, kotlin);//@ sourceMappingURL=app.js.map

其间这段自动生成的代码显得略微绕

var package$com = _.com || (_.com = {});var package$easy = package$com.easy || (package$com.easy = {});var package$kotlin = package$easy.kotlin || (package$easy.kotlin = {});package$kotlin.helloWorld = helloWorld;Kotlin.defineModule;return _;

简化之后的意思表明如下

_.com.easy.kotlin.helloWorld = helloWorld;

指标是树立Kotlin代码跟JavaScript代码的映射关系。那样大家在后边一个代码中调用

function helloWorld() {println('Hello,World!');}

本条函数时,只要这么调用就能够

app.com.easy.kotlin.helloWorld()

下边大家来新建三个index.html页面,使用大家转移的app.js。代码如下

<!DOCTYPE html><html lang="en"><head><meta charset="UTF-8"><title>KotlinJS</title></head><body><!-- 优先加载kotlin.js,再加载应用程序代码app.js--><script type="text/javascript" src="kotlin.js"></script><script type="text/javascript" src="jquery.js"></script><script type="text/javascript" src="js/app.js"></script><script>var kotlinJS = app;console.log(kotlinJS.com.easy.kotlin.helloWorld</script></body></html>

我们须要事先加载kotlin.js,再加载应用程序代码app.js。当然,大家照旧能够像此前同样采用诸如jquery.js那样的库。

在浏览器中张开index.html

图片 34螢幕快照2017-06-08 00.11.15.png

咱俩得以观望浏览器调整台出口

图片 35螢幕快速照相2017-06-08 00.14.57.png

这个helloWorld() JavaScript函数

var println = Kotlin.kotlin.io.println_s8jyv4$;function helloWorld() {println('Hello,World!');}

对应kotlin.js代码中的3755行处的代码:

BufferedOutputToConsoleLog.prototype.flush = function() {console.log(this.buffer);this.buffer = "";};

本节工程源代码:

1.

2.

境内第一Kotlin 开荒者社区公众号,主要分享、沟通 Kotlin 编制程序语言、Spring Boot、Android、React.js/Node.js、函数式编制程序、编制程序观念等生死相依宗旨。

图片 36开荒者社区 QRCode.jpg

TAG标签:
版权声明:本文由澳门新葡8455手机版发布于www.2527.com,转载请注明出处:极简教程,Kotlin极简教程