Kotlin是JVM中的一种现代静态类型语言。 Kotlin是JetBrains根据Apache 2.0许可开发的一种跨平台，多用途，免费和开源的语言，具有面向对象和功能编程风格的构造，可以混合使用。 使用大多数Java IDE，它可以用于Web开发，服务器和客户端以及移动开发。
Kotlin是Java开发人员的绝佳选择，因为它简洁，易表达且安全。 根据JetBrains的估计，它可以将应用程序中的总代码行减少多达40％。 Kotlin还有助于防止空指针异常s提供不可为空类型。
According to GitHub Octoverse Report 2018, Kotlin is the number one fastest-growing language. With 2.2M users, its popularity increases every month, and big companies are using it. Android and JVM developers are falling in love with its features. Let’s learn why.
在这篇文章中，您将发现：
- An overview of Kotlin’s features
- A guide for building a “Hello, World!” app and solving a basic algorithm problem
- A quick step by step for running a Kotlin Spring Boot application with authentication via Okta
为了完成整个教程，您需要以下工具：
- Java 8
- Apache Maven
- IntelliJ (or another IDE)
在深入学习本教程之前，让我们先谈谈为什么Kotlin可能是您下一个项目的正确选择。
Kotlin vs. Java, aka Why this Tutorial?
Kotlin旨在解决许多Java问题：
空引用：Java允许使用空引用值，如上所示，Kotlin类型系统有助于消除对空引用成员的访问，这将导致等价于空指针异常。
不变数组：在Java中，数组是协变的，而数组整数[]是...的子类型数[]，因此编译器允许分配一个双到数[]引用，但如果实例为，则程序可能会在运行时引发异常整数[]。 Kotlin不允许您分配Array
// Compiles but will raise java.lang.ArrayStoreException
Integer[] intArray = new Integer[1];
Number[] numberArray = intArray;
numberArray = intArray;
numberArray[0] = 1.0;
在科特林：
var intArray = arrayOf(1)
var numArray = arrayOf(1.0)
numArray = intArray // Compiler error Type mismatch
一种ny is the root of the Kotlin class hierarchy, but it is not equivalent to Object. However, java.lang.Object is mapped to kotlin.一种ny!, and the ! notation means it can be 一种ny or 一种ny? (nullable or not). As Object, other Java types are not used “as is”, but mapped to Kotlin types. A complete list of mappings is available in the Kotlin Reference.
没有原始类型：由于泛型不同，因此Kotlin中没有原始类型。 例如，Java原始类型清单，转换为星状投影清单<*>!, which are similar to raw types, but provide runtime safety. How? The compiler will not allow write operations if the type argument is unknown, as it might cause a cast exception when reading. In Java, you can add any object to a raw 清单, but in Kotlin adding to a start projected list won’t compile.
使用地点差异：Java的类型系统使用有界通配符来提高API的灵活性，因为泛型类型是不变的（与Java数组相反，它们是协变的），这意味着List<串>不是的子类型List
package com.okta.developer
fun main() {
val a = arrayOf("uno", "dos", "tres")
readMethod(a)
}
fun readMethod(a: Array<out Any>) {
println(a[0])
a.set(0, 1) // Out-projected type prohibits the use of fun set
}
上面的示例在Kotlin中无法编译，因为readMethod（）接收超出预期的数组（仅允许读操作），并且正在调用写操作组（）。
无检查异常：必须以某种方式处理Java检查的异常才能使程序进行编译，并且被空的catch块吞没了很多次。 Kotlin没有检查异常，因为建议在大型软件项目中它会降低生产率。
正确的功能类型：与Java SAM（单一抽象方法）转换相反，在Java SAM中，lambda表达式可根据某些规则转换为SAM类型，Kotlin使用一系列函数类型，例如(Int) -> String，并带有与函数签名相对应的特殊符号（参数和返回值）。
A complete list of Kotlin features, not supported in Java, is available at Kotlin Reference.
Java and Kotlin Interoperability
Kotlin与Java具有100％的互操作性，可以从Java调用Kotlin代码，反之亦然。可以使用现有的Java代码，但要考虑一些因素，例如，Java getter和setter由Kotlin中的属性表示：
val calendar = Calendar.getInstance()
calendar.firstDayOfWeek = Calendar.MONDAY // setFirstOfWeek()
使用IntelliJ IDEA之类的IDE，只需创建一个Java即可将Java源代码添加到Kotlin项目中。.java文件。
来自Java的对象称为平台类型出于实际原因放宽了空检查，并且安全性与Java中的相同。 Kotlin不会通知编译错误，但是调用可能会在运行时失败。 例如，如果Kotlin调用Java代码返回一个数组列表，则Kotlin中的推断类型将为数组列表
在下面的Java代码中，空值已作为项目添加到列表中。
import java.util.ArrayList;
public class ArrayWithNulls {
public static ArrayList<String> create(){
ArrayList<String> strings = new ArrayList();
strings.add(null);
strings.add("foo");
return strings;
}
}
在下面的Kotlin行中，我们正在调用以前的Java代码，因此安全性得到了放松。 该程序可以编译，但是作为第一项是空值，它将在运行时失败IllegalStateException。
val list = ArrayWithNulls.create()
val item = list.get(0) // platform type inferred (ordinary Java object)
item.substring(1) // IllegalStateException: item must not be null
Pre-Tutorial: A Taste of Kotlin
To avoid the programmer’s curse, let’s not skip trying a simple “Hello, World!” example with Kotlin. An easy way to get started with Kotlin is to download and install IntelliJ IDEA Community Edition from JetBrains, which is also free. And also, install Maven for dependency management and to run the application from the command line.
选择启动IntelliJ IDEA并创建一个新的Kotlin项目Kotlin / JVM。
设置项目名称，位置和Java 8 SDK。 创建项目后，右键单击项目并选择Maven，以添加Maven支持。添加框架支持。 然后选中“ Maven”复选框并单击好。
改名src /主/ java至src / main / kotlin和src /测试/ java至src / test / kotlin。
将新的Kotlin文件/类添加到src / main / kotlin夹。 将文件名设置为应用程式。 IDE将自动添加扩展名.kt，表示它是Kotlin文件。 添加以下代码：
package com.okta.developers
fun main() {
println("Hello, World!")
}
In the lines above, you can see a package declaration, which is optional. If not present, everything goes to the default package. The main function is the entry point to the application and can be declared without parameters (if your program does not need to accept command line arguments) and return nothing. The println function is part of the Kotlin Standard Library and prints the message and the line separator to the standard output stream.
ñOTE: In Kotlin, it is not required to match directories and packages. Source files can be placed arbitrarily in the file system, and one file can contain multiple classes. For pure Kotlin projects, the common root package com.okta.developers is omitted in the filesystem.
编辑你的pom.xml添加Kotlin依赖项和Kotlin Maven插件。
xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
使用以下Maven命令构建并运行应用程序：
mvn package exec:java
它应该输出问候消息：
Hello, World!
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
Kotlin Idioms
Now, let’s apply some Kotlin idioms to solve a common interview problem: finding anagrams in substrings. Given a string, find the number of pairs of substrings that are anagrams of each other.
首先，更新主要发挥作用应用程式使它扫描字符串以从标准输入中进行分析：
package com.okta.developers
fun main() {
val string = readLine()
val result = string?.let { Anagrams().count(it) }
println(result)
}
In the code above, we declare two immutable variables, using the keyword val. Mutable variables must be declared with the keyword var. Kotlin also does type inference, so as you can see, none of the variables declare type. readLine() is a function from the kotlin-stdlib that reads a line from the standard input stream, available for JVM and Native targets.
然后，将新的Kotlin File / Class添加到现有项目中，名称为字谜在src / main / kotlin。 延伸串 to add a function that returns a 串 with the same characters在lexicographic order, appending the following code to 字谜.kt：
package com.okta.developer
fun String.sort(): List<Char> = this.toList().sorted()
的扩展功能idiom提供了一种在不使用继承的情况下扩展类的机制，从而允许为无法修改的第三方库中的类编写新函数，即使它们是最终类也是如此。 在上面的代码中，我们声明了该函数分类（）作为扩展串类，没有参数和返回类型List
以下分类（），定义字谜类如下：
class Anagrams {
fun count(s: String): Int {
var count = 0
for (i in 1 until s.length) {
var substrings = s.windowed(i, 1)
.map { it.sort() }
.toMutableList()
while (substrings.isNotEmpty()) {
val substring = substrings.removeAt(0)
count += substrings.count{ it == substring }
}
}
return count
}
}
for循环count（s：字符串）函数将迭代一世 一世n a 半开范围，来自1个至长度, not 一世nclud一世ng 长度. That way, 一世n each 一世terat一世on us一世ng the w一世ndowed funct一世on of Str一世ng, we create all the poss一世ble substr一世ngs of the current length 一世。 然后分类（） all the substr一世ngs and create a MutableL一世st,至be able至remove elements later. Each collect一世on type 一世n the Kotl一世n Standard L一世brary (set, l一世st, map) prov一世des a 只读还有一个易变的 一世nterface that def一世nes wr一世te operat一世ons.
在对子字符串进行排序时，可以将它们相互比较以找到字谜。使用清单功能计数（）并传递一个用它参数，将返回匹配数。很多时候，lambda表达式只有一个参数，而implic它nameofasingleparameter它allowsashortersyntax.
添加以下测试用例字谜新的Kotlin文件中的课程src/test/kotlin/字谜sTest.kt：
package com.okta.developers
import org.junit.Test
import kotlin.test.assertEquals
class AnagramsTest {
val anagrams = Anagrams()
@Test
fun `given abba count returns 4`(){
assertEquals(4, anagrams.count("abba"))
}
@Test
fun `given ifailuhkqq count returns 3`(){
assertEquals(3, anagrams.count("ifailuhkqq"))
}
}
使用Maven运行测试用例：
mvn test
测试结果将显示在控制台中：
-------------------------------------------------------
T E S T S
-------------------------------------------------------
Running com.okta.developer.AnagramsTest
Tests run: 2, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.083 sec
Results :
Tests run: 2, Failures: 0, Errors: 0, Skipped: 0
以与以前相同的方式运行程序，在控制台中键入要分析的字符串，然后键入Enter键。 您应该看到类似以下的输出：
[INFO] --- exec-maven-plugin:1.2.1:java (default) @ kotlin-hello-world ---
abba
4
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
Tutorial: Use Kotlin With Spring Boot Securely
最后，让我们看看使用Okta OpenID Connect（OIDC）身份验证创建Kotlin Spring Boot应用程序有多么容易。
Using the Spring Initializr API, create a Maven project with the following command:
curl https://start.spring.io/starter.zip -d dependencies=web,okta \
-d language=kotlin \
-d type=maven-project \
-d groupId=com.okta.developer \
-d artifactId=kotlin-spring-boot \
-d name="Kotlin Spring Boot" \
-d description="Demo project of a Kotlin Spring Boot application" \
-d packageName=com.okta.developer \
-o kotlin-spring-boot.zip
解压缩文件：
unzip kotlin-spring-boot.zip -d kotlin-spring-boot
cd kotlin-spring-boot
Secure your Application with OpenID Connect
如果您已经有Okta帐户，请参见下面的在Okta中创建Web应用程序。 否则，我们创建了一个Maven插件，该插件配置了一个免费的Okta开发人员帐户+一个OIDC应用程序（不到一分钟！）。
./mvnw com.okta:okta-maven-plugin:setup
您应该看到以下输出：
First name: Jimena
Last name: Garbarino
Email address: ***
Company: ***
Creating new Okta Organization, this may take a minute:
OrgUrl: https://dev-123456.okta.com
Check your email address to verify your account.
Writing Okta SDK config to: /home/indiepopart/.okta/okta.yaml
Configuring a new OIDC, almost done:
Created OIDC application, client-id: ***
检查您的电子邮件，然后按照说明激活您的Okta帐户。
If you already have an Okta Developer account
Log in and create a new Application:
- From the Applications page, choose Add Application.
- On the Create New Application page, select Web.
- Give your app a memorable name, add
http://localhost:8080/login/oauth2/code/oktaas a Login redirect URI.Copy the issuer (found under API > Authorization Servers ), client ID, and client secret into
src/main/resources/application.properties.okta.oauth2.issuer=$issuer okta.oauth2.client-id=$clientId okta.oauth2.client-secret=$clientSecret
编辑KotlinSpringBoot应用程序位于包装中com.okta.developer添加控制器映射，该映射将在浏览器窗口中显示欢迎消息。
package com.okta.developer
import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.runApplication
import org.springframework.security.core.annotation.AuthenticationPrincipal
import org.springframework.security.oauth2.client.authentication.OAuth2AuthenticationToken
import org.springframework.web.bind.annotation.GetMapping
import org.springframework.web.bind.annotation.RestController
@SpringBootApplication
@RestController
class KotlinSpringBootApplication {
@GetMapping("/")
fun hello(@AuthenticationPrincipal authenticationToken: OAuth2AuthenticationToken): String {
return "Welcome ${authenticationToken.principal.attributes["name"]}"
}
}
fun main(args: Array<String>) {
runApplication<KotlinSpringBootApplication>(*args)
}
如您所见，在你好（）功能，通过身份验证的用户authenticationToken。 的@AuthenticationPrincipal annotation from Spring Security helps to resolve the principal to the expected principal type。 的welcome message is built using 字符串插值，一种Kotlin惯用语，用于字符串内的变量替换。
使用以下命令运行该应用程序：
./mvnw spring-boot:run
浏览到http：//本地主机：8080并且应用程序应该启动OAuth 2.0身份验证代码流，并重定向到Okta登录页面。
登录后，您应该看到欢迎消息：
Welcome, Jimena Garbarino
现在，您仅需几行Kotlin即可获得一个安全的应用程序，并借助Spring Boot！
Learn More about Kotlin, Java, and Secure Authentication with these Tutorials
I hope this blog post helped you grasp how succinct and expressive Kotlin is and why developers are loving it. You can find all the tutorial code in repositories kotlin-hello-world and kotlin-spring-boot on GitHub. To learn more about Kotlin, check out the following links:
- Build a Basic CRUD App in Android with Kotlin
- Build an Application with Spring Boot and Kotlin
- Kotlin Reference
Questions? Requests for a future post? Drop them in the comments! And don’t forget to follow @oktadev on Twitter and subscribe to our YouTube channel.
