Jakarta EE Tutorials, Java EE Tutorials, Kotlin Tutorials

Guide to writing Java EE applications with Kotlin

Last Updated: January 20, 2020 | Published: August 4, 2019

The precise and clean style of writing code with Kotlin is tempting as a Java developer. In addition, switching to Kotlin with a Java background is rather simple. But what about using Kotlin for an existing Java EE application or start using it for a new project? Read this blog post to get a first impression of what it takes to use Kotlin alongside Java EE in your projects.

The following technologies are used in this example: Kotlin 1.3.41, Java 11, Java EE 8, MicroProfile 2.2 running on a dockerized Open Liberty 19.0.0.7 with Eclipse OpenJ9.

Maven project setup for Kotlin

The classic Java EE Maven pom.xml needs just two adjustments: the kotlin-stdlib dependency and the kotlin-maven-plugin:

<project 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">
    <modelVersion>4.0.0</modelVersion>
    <groupId>de.rieckpil.blog</groupId>
    <artifactId>java-ee-with-kotlin</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

    <properties>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>

        <kotlin.version>1.3.41</kotlin.version>
        <kotlin.compiler.incremental>true</kotlin.compiler.incremental>

        <failOnMissingWebXml>false</failOnMissingWebXml>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>javax</groupId>
            <artifactId>javaee-api</artifactId>
            <version>8.0</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.eclipse.microprofile</groupId>
            <artifactId>microprofile</artifactId>
            <version>2.2</version>
            <type>pom</type>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.jetbrains.kotlin</groupId>
            <artifactId>kotlin-stdlib</artifactId>
            <version>${kotlin.version}</version>
        </dependency>
    </dependencies>

    <build>
        <finalName>java-ee-with-kotlin</finalName>

        <sourceDirectory>${project.basedir}/src/main/kotlin</sourceDirectory>
        <testSourceDirectory>${project.basedir}/src/test/kotlin</testSourceDirectory>

        <plugins>
            <plugin>
                <groupId>org.jetbrains.kotlin</groupId>
                <artifactId>kotlin-maven-plugin</artifactId>
                <version>${kotlin.version}</version>
                <configuration>
                    <compilerPlugins>
                        <plugin>jpa</plugin>
                    </compilerPlugins>
                    <jvmTarget>11</jvmTarget>
                </configuration>
                <dependencies>
                    <dependency>
                        <groupId>org.jetbrains.kotlin</groupId>
                        <artifactId>kotlin-maven-noarg</artifactId>
                        <version>${kotlin.version}</version>
                    </dependency>
                </dependencies>
                <executions>
                    <execution>
                        <id>compile</id>
                        <phase>compile</phase>
                        <goals>
                            <goal>compile</goal>
                        </goals>
                    </execution>
                    <execution>
                        <id>test-compile</id>
                        <phase>test-compile</phase>
                        <goals>
                            <goal>test-compile</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

<project 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">

<groupId>de.rieckpil.blog</groupId>

<artifactId>java-ee-with-kotlin</artifactId>

<version>1.0-SNAPSHOT</version>

<maven.compiler.source>11</maven.compiler.source>

<maven.compiler.target>11</maven.compiler.target>

<kotlin.version>1.3.41</kotlin.version>

<kotlin.compiler.incremental>true</kotlin.compiler.incremental>

<failOnMissingWebXml>false</failOnMissingWebXml>

<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>

</properties>

<groupId>javax</groupId>

<artifactId>javaee-api</artifactId>

<scope>provided</scope>

</dependency>

<groupId>org.eclipse.microprofile</groupId>

<artifactId>microprofile</artifactId>

<scope>provided</scope>

</dependency>

<groupId>org.jetbrains.kotlin</groupId>

<artifactId>kotlin-stdlib</artifactId>

<version>${kotlin.version}</version>

</dependency>

</dependencies>

<build>

<finalName>java-ee-with-kotlin</finalName>

<sourceDirectory>${project.basedir}/src/main/kotlin</sourceDirectory>

<testSourceDirectory>${project.basedir}/src/test/kotlin</testSourceDirectory>

<groupId>org.jetbrains.kotlin</groupId>

<artifactId>kotlin-maven-plugin</artifactId>

<version>${kotlin.version}</version>

</compilerPlugins>

</configuration>

<groupId>org.jetbrains.kotlin</groupId>

<artifactId>kotlin-maven-noarg</artifactId>

<version>${kotlin.version}</version>

</dependency>

</dependencies>

<id>compile</id>

<phase>compile</phase>

<goals>

<goal>compile</goal>

</goals>

</execution>

<id>test-compile</id>

<phase>test-compile</phase>

<goals>

<goal>test-compile</goal>

</goals>

</execution>

</executions>

</plugin>

</plugins>

</build>

</project>

For JPA we have to configure the kotlin-maven-noarg plugin to add parameterless constructors to our JPA entities. In addition, I'm activating the incremental Kotlin compiler in the properties sections to decrease repetitive build times, which is optional.

Pitfalls for Java EE using Kotlin

The two most common pitfalls for Java EE with Kotlin are non-final classes & methods and parameterless constructors. Whilst Kotlin makes classes per default final, we need non-final classes for some specifications to work. This is required for example to create proxies and enrich the functionality of public methods (e.g. EJB's transaction management).

With the following sample project, you'll see where and how to solve these requirements. The project provides a REST interface to retrieve books. The JAX-RS resource class looks like the following:

@Path("books")
@Produces(MediaType.APPLICATION_JSON)
class BookResource {

    @Inject
    private lateinit var bookService: BookService;

    @GET
    fun getAllBooks(): Response = Response.ok(bookService.getAllBooks()).build()

    @GET
    @Path("/{id}")
    fun getBookById(@PathParam("id") id: Long): Response {
        var book: Book? = 
           bookService.getBookById(id) ?: 
           return Response.status(Response.Status.NOT_FOUND).build()
        return Response.ok(book).build()
    }
}

@Path("books")

@Produces(MediaType.APPLICATION_JSON)

class BookResource {

@Inject

private lateinit var bookService: BookService;

@GET

fun getAllBooks(): Response = Response.ok(bookService.getAllBooks()).build()

@GET

@Path("/{id}")

fun getBookById(@PathParam("id") id: Long): Response {

var book: Book? =

bookService.getBookById(id) ?:

return Response.status(Response.Status.NOT_FOUND).build()

return Response.ok(book).build()

}

The first thing to pay attention is the injection of other beans. Here I'm injecting the BookService to retrieve both all books and a book by its id. To avoid cumbersome null-checks we have to use lateinit to tell the Kotlin compiler that this instance is injected during runtime. Normally, properties declared as having a non-null type must be initialized in the constructor within Kotlin.

Next, I'm using Book? as the return type of the method to get a book by its id. This is required, as there might be no book in the database for the provided id. The Elvis operator ?: makes the required null-check and returns an HTTP 404 status in case of null.

The corresponding BookService is a singleton EJB and delegates access to the database using the EntityManager:

@Singleton
@Startup
open class BookService {

    @PersistenceContext
    private lateinit var entityManager: EntityManager

    @PostConstruct
    open fun setUp() {
        println("Initializing books ...")
        entityManager.persist(Book(null, "Java EE 8", "Duke"))
        entityManager.persist(Book(null, "Jakarta EE 8", "Duke"))
        entityManager.persist(Book(null, "MicroProfile 2.2", "Duke"))
        println("... finished initializing books")
    }

    open fun getAllBooks(): List<Book> = entityManager
         .createQuery("SELECT b FROM Book b", Book::class.java).resultList
    open fun getBookById(id: Long): Book? = entityManager.find(Book::class.java, id)
}

@Singleton

@Startup

open class BookService {

@PersistenceContext

private lateinit var entityManager: EntityManager

@PostConstruct

open fun setUp() {

println("Initializing books ...")

entityManager.persist(Book(null, "Java EE 8", "Duke"))

entityManager.persist(Book(null, "Jakarta EE 8", "Duke"))

entityManager.persist(Book(null, "MicroProfile 2.2", "Duke"))

println("... finished initializing books")

}

open fun getAllBooks(): List<Book> = entityManager

.createQuery("SELECT b FROM Book b", Book::class.java).resultList

open fun getBookById(id: Long): Book? = entityManager.find(Book::class.java, id)

}

The open keyword on class- and method-level is required to make both non-final.

Writing JPA entities

For writing JPA entities we can utilize Kotlin's data classes. The only thing to keep in mind is that we need a public no-arg constructor for JPA to work. Enabling the JPA plugin in the Maven build section, makes sure we get a parameterless constructor for all our @Entity classes and don't have to worry:

@Entity
@Table(name = "books")
data class Book(
        @Id
        @GeneratedValue
        var id: Long?,

        @Column(nullable = false, unique = true)
        val title: String,

        @Column(nullable = false)
        val author: String) {
}

@Entity

@Table(name = "books")

data class Book(

@Id

@GeneratedValue

var id: Long?,

@Column(nullable = false, unique = true)

val title: String,

@Column(nullable = false)

val author: String) {

}

Final thoughts for Java EE with Kotlin

Converting an existing Java EE application written in Java to Kotlin might not be that simple. You have to make sure that dependency injection, interceptors in general and your JPA entities are working. With this blog post, you might get a first impression of where to pay attention when using Kotlin. If the precise and elegant style of writing source code with Kotlin overweighs the additional pitfalls for you, then give it a try!

You can find the whole example on GitHub.

Further resources on this topic:

Kotlin and Java EE article on DZone
Working with Kotlin and JPA on Baeldung
Kotlin EE: Boost your Productivity by Marcus Fihlon talk
Spring Boot applications with Kotlin and Maven

Have fun using Kotlin for your Java EE project,

Phil

Guide to writing Java EE applications with Kotlin

Maven project setup for Kotlin

Pitfalls for Java EE using Kotlin

Writing JPA entities

Final thoughts for Java EE with Kotlin

Testing Spring Boot Applications Masterclass Testimonials

Become a More Productive and Confident Spring Boot Developer

Quicklinks

Recently Published