by Adam Arold

亚当·阿罗德(Adam Arold)

超越Android：Kotlin在后端的工作方式 (Going Beyond Android: how Kotlin works on the Backend)

This article is part of a series.

本文是系列文章的一部分。

While most developers use Kotlin on Android, it is also a viable option on other platforms. In this article, we’ll look at how it works on the backend.

尽管大多数开发人员在Android上使用Kotlin，但在其他平台上也是可行的选择。 在本文中，我们将研究它在后端的工作方式。

As I have written about this before, I think that the interop between Java and Kotlin is quite seamless. This also means that using Kotlin in place of Java on the backend is rather easy. Apart from a few nuisances, you can pretty much start writing your new features in Kotlin within your Java project. Or if you just want to try it out, you can start by writing your tests with it.

正如我之前所写 ，我认为Java和Kotlin之间的互操作是无缝的。 这也意味着在后端使用Kotlin代替Java很容易。 除了一些麻烦之外，您几乎可以开始在Java项目中的Kotlin中编写新功能。 或者，如果您只想尝试一下，则可以开始编写测试。

If you look around, it seems that companies with a big slice of the backend pie also have the same thought: the new version of Spring has some features dedicated to Kotlin, and you can even use Kotlin to write your Gradle scripts using the kotlin-dsl.

如果环顾四周，似乎后端派中有很大一部分的公司也有相同的想法：Spring的新版本具有一些Kotlin专用的功能，您甚至可以使用Kotlin使用kotlin-编写Gradle脚本- dsl 。

What is interesting to note here is that you don’t need Kotlin support for any of these libraries, because the Java interop features of Kotlin are so good.

这里有趣的是您不需要这些库中的任何一个Kotlin支持 ，因为Kotlin的Java互操作性非常好。

决定 (Decisions)

When you start to work with Kotlin on the backend, you have several options at your disposal.

当您开始在后端使用Kotlin时，可以使用多种选择。

If you choose to use a library written in Kotlin, you get some major advantages: there will be no compatibility issues related to the language you use since everything is written in Kotlin. Another thing worth mentioning is that there are some things which are only present in Kotlin, such as Coroutines and reified generics.

如果您选择使用用Kotlin编写的库，您将获得一些主要优势：由于所有内容都是用Kotlin编写的，因此不会出现与您使用的语言相关的兼容性问题。 值得一提的另一件事是，有些东西仅在Kotlin中存在，例如协程和通用泛型。

The trade-off is that most of these libraries are not very old and might have the typical problems with new projects: lack of documentation and eventual bugs or design issues.

需要权衡的是，这些库中的大多数都不是很老，并且在新项目中可能会遇到典型的问题：缺少文档和最终的错误或设计问题。

If you need something that is battle-tested, you can’t go wrong with tools like Spring or Mockito. What you get with these is that most issues are well-documented, and you’ll get answers for your questions pretty quickly. What you lose, though, is some of the nice things about Kotlin: they don’t have Kotlin DSLs, and the code will be quite Java-ish.

如果您需要经过考验的东西，那么使用Spring或Mockito之类的工具就不会出错。 您得到的是大多数问题都有据可查，并且您很快就会得到问题的答案。 但是，您失去的是有关Kotlin的一些好处：它们没有Kotlin DSL ，并且代码非常像Java。

Another option is to pick a library which has built-in support for Kotlin. RxKotlin and vert.x are good examples of this. I’ll call these projects hybrids from now on. With them you get the best of both worlds: you will usually have a good API which is idiomatic from a Kotlin perspective, and behind it there will be something which is well-known and battle-hardened.

另一个选择是选择一个内置了对Kotlin支持的库。 RxKotlin和vert.x就是很好的例子。 从现在开始，我将这些项目称为混合项目。 有了它们，您将两全其美：通常，您将拥有一个良好的API，从Kotlin的角度来看这是惯用的，在它的后面将有一个众所周知的且经过艰苦训练的东西。

Let’s look at some libraries which you might want to try out.

让我们看一些您可能想尝试的库。

Note that the following are just my opinions, and as such they are subjective.

请注意，以下只是我的观点，因此，它们是主观的。

克托 (Ktor)

Ktor is one of the newer web frameworks written in Kotlin. It comes with embedded Netty and a nice DSL to boot. What is interesting in this one is that it takes advantage of Kotlin’s Coroutine support. This is how it looks in practice:

Ktor是用Kotlin编写的较新的Web框架之一。 它带有嵌入式Netty和不错的DSL引导。 有趣的是，它利用了Kotlin的协程支持。 在实际中是这样的：

I was concerned when I tried it out that the documentation is quite lacking. When you bump into a problem, you are more likely to get stuck. It also does not perform well, and interop with Java is a bit sketchy.

当我尝试了一下，该文档我而言相当缺乏 。 当您遇到问题时，您更有可能陷入困境。 它的性能也不佳 ，与Java的互操作有点粗略。

Javalin (Javalin)

Javalin is an other web framework which has a very simple, fluent, and readable API. It can also work with multiple embedded web servers like Netty or Undertow. What I liked most is that it strikes a balance between the minimalistic approach of Spark (not to be confused with Apache Spark) and the low-level nature of vert.x. The documentation is also very good so you can get started in no time:

Javalin是另一个Web框架，具有非常简单，流利且易读的API。 它还可以与Netty或Undertow等多个嵌入式Web服务器一起使用。 我最喜欢的是，它在Spark的简约方法(不要与Apache Spark混淆)和vert.x的低级特性之间取得平衡 。 该文档也非常好，因此您可以立即开始：

I like that the API is a little more Java-ish than Ktor’s, so if you come from a Java background it might be easier to get started with.

我喜欢API比Ktor的Java风格多一​​点，因此，如果您来自Java背景，那么上手可能会更容易。

六边形 (Hexagon)

Hexagon is an interesting choice for writing web applications. The name choice is not random: it encourages using the hexagonal architecture (more commonly known as clean architecture), and it is also more performant than ktor or even the Spring framework! The DSL which you get is also pretty descriptive:

Hexagon是编写Web应用程序的有趣选择。 名称的选择不是随机的：它鼓励使用六角形体系结构 (通常称为clean体系结构 )，并且比ktor甚至是Spring框架性能更高！ 您获得的DSL也很具有描述性：

脱网 (Off the web)

It is worth noting that there are a lot of tools written in Kotlin which you can pick from. Kotlin has a very useful specification framework. If you don’t like the fact that there are no good HTTP clients for Java, you can now take advantage of Fuel which is a very handy tool for interfacing with REST endpoints and beyond. You even have tools for writing games in Kotlin.

值得注意的是，有很多用Kotlin编写的工具可供选择。 Kotlin有一个非常有用的规范框架 。 如果您不喜欢没有适用于Java的HTTP客户端的事实，那么现在就可以利用Fuel这个非常方便的工具，它可以与REST端点及其他接口交互。 您甚至拥有使用Kotlin 编写游戏的工具。

Java框架 (Java frameworks)

版本号 (vert.x)

vert.x is a multi-module web framework akin to Spring. What is important to note here is that there is a documentation section dedicated to Kotlin. vert.x might be your choice for writing web applications if performance is paramount to you: vert.x has very good benchmark scores. This should not be a surprise, since it implements the multi reactor pattern (the reactor pattern might be familiar to you from node.js).

vert.x是类似于Spring的多模块Web框架。 这里要注意的重要一点是，有一个专门针对Kotlin的文档部分 。 如果性能对您至关重要，那么vert.x可能是您编写Web应用程序的选择：vert.x具有非常好的基准得分 。 这并不奇怪，因为它实现了多React堆模式 (您可能会从node.js熟悉React堆模式)。

It is worth noting that there are very good Kotlin examples for vert.x. You’ll need them because it has some concepts which are not present elsewhere and setting it up is also a bit more involved:

值得注意的是，vert.x有很好的Kotlin示例 。 您将需要它们，因为它具有一些其他地方没有的概念，并且还需要更多地进行设置：

弹簧 (Spring)

For a lot of Java developers, Spring is the de facto tool for writing Java applications. The good news is that since 5.0 Spring has built-in support for Kotlin. There is a whole plethora of Spring projects which you can pick from. If you are interested, there is a simple tutorial which will get you started using Spring with Kotlin. Here is how Hello World looks with it:

对于许多Java开发人员而言， Spring实际上是编写Java应用程序的工具。 好消息是，自5.0以来，Spring 内置了对Kotlin的支持 。 您可以从中选择大量的Spring项目 。 如果您有兴趣，这里有一个简单的教程 ，可以帮助您开始使用Spring和Kotlin。 这是Hello World的外观：

Sparkjava的 (Sparkjava)

Sparkjava is a minimalistic (micro)web framework. You can get started with it with practically zero time investment, and if you come from node.js it is also a very good choice. You also can’t get more minimal than this:

Sparkjava是一个简约的(微型)Web框架。 您可以从几乎零时间的投资开始使用它，如果您来自node.js，它也是一个很好的选择。 您还不能获得比这更多的最小：

混合选项 (Hybrid options)

While interfacing with Java tools is usually pretty convenient, some of the tools above have tooling support written for Kotlin:

虽然与Java工具的接口通常很方便，但是上面的一些工具具有为Kotlin编写的工具支持：

Spark-kotlin provides a more streamlined experience for Kotlin users, and it is also worth noting that it is written by perwendel, the original author of Sparkjava.

Spark-kotlin为Kotlin用户提供了更简化的体验，还值得注意的是，它是由Sparkjava的原始作者perwendel编写的。

vertx-lang-kotlin provides useful Kotlin-specific options for vert.x like coroutines, one-shot workers, or reactive streams.

vertx-lang-kotlin为vert.x提供有用的Kotlin特定选项，例如协程，单发工作程序或React流。

While using Mockito from Kotlin is mostly pleasant, mockito-kotlin improves upon that by giving you a nice DSL and taking care of some issues.

虽然使用Kotlin的Mockito大部分是令人愉快的，但mockito-kotlin通过为您提供漂亮的DSL并解决了一些问题来改进了它。

Hamkrest is a re-implementation of Hamcrest with syntactic sugars, extensibility and more.

Hamkrest是Hamcrest的重新实现，其中包含语法糖，可扩展性等。

RxKotlin adds convenient extension functions, SAM helpers, and more to RxJava. The only problem is that the documentation is behind a paywall.

RxKotlin向RxJava添加了方便的扩展功能 ，SAM帮助器等 。 唯一的问题是文档在付费专线后面。

一个有效的例子 (A working example)

Now let’s look at a step-by-step example. We’ll use Spring Boot with Spring Initializr.

现在，让我们看一个分步示例。 我们将结合使用Spring Boot和Spring Initializr 。

The source code of this tutorial can be found here.

本教程的源代码可以在这里找到。

入门 (Getting started)

Spring Boot comes with Spring Initializr, which is a handy tool with which you can quickly kick off your project. I recommend selecting Gradle Project with Kotlin and Spring Boot 2.0.0 for this example, since with 2.0.0 you’ll get the features of Spring 5.0.

Spring Boot带有Spring Initializr ，它是一个方便的工具，您可以使用它快速启动项目。 我建议在此示例中选择使用Kotlin和Spring Boot 2.0.0的 Gradle Project ，因为使用2.0.0时，您将获得Spring 5.0的功能。

If you click “Switch to full version” you’ll also be able to piece together a fine-grained skeleton. There is a cornucopia of topics from which you can pick tools ranging from Web to AWS and more. For this exercise I picked Web only.

如果您点击“切换到完整版本”，您还可以拼凑出细粒度的骨架。 主题众多，您可以从中选择各种工具，从Web到AWS等等。 对于本练习，我只选择了Web。

After setting up Initializr, click “Generate Project” and open it in your IDE. You might notice that compared to a simple Java project, you don’t have to add much to your build.gradle which is Kotlin-specific. I’ve extracted them in this example:

设置Initializr后，单击“ Generate Project”并在IDE中打开它。 您可能会注意到，与简单的Java项目相比，无需向Kotlin特定的build.gradle添加太多内容。 在此示例中，我提取了它们：

添加一个简单的控制器 (Adding a simple Controller)

If you look at the entry point of the application, it is rather minimalistic:

如果您查看应用程序的入口点，那么它非常简单：

Now the only thing we need for a working Hello World is to add a RestController to our project:

现在， RestController Hello World正常运行，我们唯一需要的是将RestController添加到我们的项目中：

and Bam! you are done! You can go and check out the result at http://localhost:8080/ after starting it up with ./gradlew bootRun :

和班！ 大功告成！ 使用./gradlew bootRun启动结果后，您可以在http://localhost:8080/上./gradlew bootRun ：

You can learn more about how this works in this tutorial. Or if you want to see how the Kotlin APIs and the functional way looks, there is a nice tutorial here.

您可以在本教程中了解有关其工作原理的更多信息。 或者，如果您想了解Kotlin API和功能方式的外观，可以在此处找到一个不错的教程。

结语 (Wrapping up)

In this article, we have explored some of the more well-known options for backend development with Kotlin. We have also seen that prominent actors on the market have embraced Kotlin, and backend development can be a lot simpler with it compared to pure Java.

在本文中，我们探讨了Kotlin进行后端开发的一些更知名的选项。 我们还看到，市场上的杰出参与者已经拥抱Kotlin，并且与纯Java相比，后端开发可以用它简单得多。

In the next article we’ll explore how Kotlin can be used in your project instead of Javascript!

在下一篇文章中，我们将探讨如何在您的项目中使用Kotlin而不是Javascript！

Thanks for reading! You can read more of my articles on my blog.

谢谢阅读！ 您可以在我的博客上我的文章。

翻译自: https://www.freecodecamp.org/news/going-beyond-android-kotlin-on-the-backend-2a75eef2582b/