Vert.x for Kotlin

If you are using Maven or Gradle, add the following dependency to the dependencies section of your project descriptor to access the Vert.x Core API and enable the Kotlin support:

Maven (in your pom.xml):

<dependency>
<groupId>io.vertx</groupId>
<artifactId>vertx-core</artifactId>
<version>4.5.7</version>
</dependency>
<dependency>
 <groupId>io.vertx</groupId>
 <artifactId>vertx-lang-kotlin</artifactId>
 <version>4.5.7</version>
</dependency>

Gradle (in your build.gradle file):

compile "io.vertx:vertx-core:4.5.7"
compile "io.vertx:vertx-lang-kotlin:4.5.7"

Verticles

Writing Verticles

Writing a Verticle with Kotlin is achieved the same way you write a Java Verticle by extending the AbstractVerticle.

Here’s an example verticle:

import io.vertx.core.AbstractVerticle

class MyVerticle : AbstractVerticle() {

 // Called when verticle is deployed
 override fun start() {
 }

 // Optional - called when verticle is undeployed
 override fun stop() {
 }
}

Please refer to the Java documentation.

Data Objects builders

Data Objects play an essential role in the Vert.x stack (a Data Object is a type that can be converted to/from JSON).

For example, Vert.x modules often use Data Objects for the configuration of servers:

val classic: HttpServerOptions = HttpServerOptions()
 .setIdleTimeout(5)
 .setIdleTimeoutUnit(TimeUnit.MINUTES)
 .setLogActivity(true)

While the above construct is valid, there is a more idiomatic way of configuring Data Objects. In Kotlin, all Data Objects have a builder method suffixed with Of:

val options = httpServerOptionsOf(idleTimeout = 5, idleTimeoutUnit = TimeUnit.MINUTES, logActivity = true)

JSON

Unlike some other languages, Java does not have first class support for JSON, so we provide two classes to make handling JSON in your Vert.x applications a bit easier.

Use the JsonObject class to represent JSON objects and the JsonArray class to represent JSON arrays, you can refer to the Java documentation for more details.

Builders

Builders are provided to provide a more fluent JSON construction:

// The json builder declares a JSON structure
val result = json {

 // in this structure the obj function can be used

 // takes a vararg of Kotlin pairs
 obj(
   "key_1" to 1,
   "key_2" to 2,
   "key_3" to 3
 )
}

// Or, with a iterable of Kotlin pairs
val result1 = json {
 obj((1..3).map { "key_$it" to it })
}

// Or, with a a Map<String, Any?>
val result2 = json {
 obj(someMap)
}

// Or, apply function on object receiver
val result3 = json {
 obj {
   for (i in 1..3) {
     put("key_$i", i)
   }
 }
}

Similarly, you can build JSON arrays:

// Takes a vararg of values
val result = json {
 array("1", "2", "3")
}

// Or, an iterable of values
val result1 = json {
 array((1..3).map { "$it" })
}

// Or, apply function on array receiver
val result2 = json {
 array {
   for (i in 1..3) {
     add("$i")
   }
 }
}

Of course, it is possible to mix objects and arrays

// The json builder declares a JSON structure
val result = json {
     obj(
       "firstName" to "Dale",
       "lastName" to "Cooper",
       "age" to 64,
       "names" to array("Dale", "Bartholomew")
     )
}

Postscript operator overloading

The Kotlin postscript operator is overloaded for JSON object and array:

print(someObject["firstName"]);
print(someArray[4]);