Skip to main content

Kotlin Builder Pattern

Introduction​

The Builder Pattern is a creational design pattern that allows for the step-by-step construction of complex objects. In Kotlin, this pattern becomes even more powerful thanks to language features like named parameters, default arguments, and extension functions.

In this tutorial, we'll explore how Kotlin's unique features can be used to implement the Builder Pattern in an elegant and concise way. We'll also see how this pattern serves as a foundation for creating Domain-Specific Languages (DSLs) in Kotlin.

Understanding the Builder Pattern​

The Builder Pattern is particularly useful when:

  • You need to create an object with many optional parameters
  • You want to ensure the constructed object is in a valid state
  • You want to make the code more readable and maintainable

In traditional object-oriented languages, the Builder Pattern might require a separate builder class. However, Kotlin provides more concise ways to achieve the same goals.

Basic Implementation in Kotlin​

Let's start with a simple example of building a Person object:

kotlin
class Person(
    val name: String,
    val age: Int,
    val email: String?,
    val address: String?
)

// Using Kotlin's named parameters
val person = Person(
    name = "John Smith",
    age = 30,
    email = "[email protected]",
    address = null
)

While Kotlin's named parameters already provide some benefits of the Builder Pattern, we can go further by creating a dedicated builder.

Traditional Builder Pattern in Kotlin​

Here's how a traditional Builder Pattern might look in Kotlin:

kotlin
class Person private constructor(
    val name: String,
    val age: Int,
    val email: String?,
    val address: String?
) {
    class Builder {
        private var name: String = ""
        private var age: Int = 0
        private var email: String? = null
        private var address: String? = null

        fun name(name: String) = apply { this.name = name }
        fun age(age: Int) = apply { this.age = age }
        fun email(email: String?) = apply { this.email = email }
        fun address(address: String?) = apply { this.address = address }
        
        fun build() = Person(name, age, email, address)
    }
    
    companion object {
        fun builder() = Builder()
    }
}

// Usage
val person = Person.builder()
    .name("John Smith")
    .age(30)
    .email("[email protected]")
    .build()

This approach provides a fluent API for constructing objects, but Kotlin offers even more elegant solutions.

Kotlin-Style Builder Pattern​

Using Kotlin's DSL capabilities, we can create a more concise builder:

kotlin
data class Person(
    val name: String = "",
    val age: Int = 0,
    val email: String? = null,
    val address: String? = null
)

fun person(block: PersonBuilder.() -> Unit): Person {
    return PersonBuilder().apply(block).build()
}

class PersonBuilder {
    var name: String = ""
    var age: Int = 0
    var email: String? = null
    var address: String? = null
    
    fun build() = Person(name, age, email, address)
}

// Usage
val person = person {
    name = "John Smith"
    age = 30
    email = "[email protected]"
}

This approach leverages Kotlin's function literals with receiver (PersonBuilder.() -> Unit) to create a mini-DSL for building Person objects.

Type-Safe Builders​

Kotlin allows us to create type-safe builders, which are the foundation of Kotlin DSLs. Let's create a more complex example for constructing an HTML document:

kotlin
class HTML {
    private val content = StringBuilder()
    
    fun head(block: Head.() -> Unit) {
        content.append("<head>")
        Head().apply(block)
        content.append("</head>")
    }
    
    fun body(block: Body.() -> Unit) {
        content.append("<body>")
        Body().apply(block).content.toString().also { content.append(it) }
        content.append("</body>")
    }
    
    override fun toString() = "<html>${content}</html>"
}

class Head {
    private val content = StringBuilder()
    
    fun title(text: String) {
        content.append("<title>$text</title>")
    }
}

class Body {
    val content = StringBuilder()
    
    fun p(text: String) {
        content.append("<p>$text</p>")
    }
    
    fun h1(text: String) {
        content.append("<h1>$text</h1>")
    }
}

fun html(block: HTML.() -> Unit): HTML = HTML().apply(block)

// Usage
val htmlDocument = html {
    head {
        title("Kotlin Builder Pattern")
    }
    body {
        h1("Welcome to Kotlin Builders")
        p("This is an example of a type-safe builder in Kotlin")
    }
}

println(htmlDocument)

Output:

<html><head><title>Kotlin Builder Pattern</title></head><body><h1>Welcome to Kotlin Builders</h1><p>This is an example of a type-safe builder in Kotlin</p></body></html>

Real-World Application: Configuration Builder​

Let's look at a practical example of using the Builder Pattern for application configuration:

kotlin
data class DatabaseConfig(
    val url: String,
    val username: String,
    val password: String,
    val poolSize: Int = 10,
    val timeout: Long = 30_000,
    val ssl: Boolean = false
)

data class ServerConfig(
    val host: String = "localhost",
    val port: Int = 8080,
    val contextPath: String = "/"
)

data class AppConfig(
    val appName: String,
    val version: String,
    val database: DatabaseConfig,
    val server: ServerConfig
)

class AppConfigBuilder {
    var appName: String = ""
    var version: String = "1.0.0"
    lateinit var database: DatabaseConfig
    var server: ServerConfig = ServerConfig()
    
    fun database(block: DatabaseConfigBuilder.() -> Unit) {
        val builder = DatabaseConfigBuilder()
        builder.block()
        database = builder.build()
    }
    
    fun server(block: ServerConfigBuilder.() -> Unit) {
        val builder = ServerConfigBuilder()
        builder.block()
        server = builder.build()
    }
    
    fun build() = AppConfig(appName, version, database, server)
}

class DatabaseConfigBuilder {
    var url: String = ""
    var username: String = ""
    var password: String = ""
    var poolSize: Int = 10
    var timeout: Long = 30_000
    var ssl: Boolean = false
    
    fun build() = DatabaseConfig(url, username, password, poolSize, timeout, ssl)
}

class ServerConfigBuilder {
    var host: String = "localhost"
    var port: Int = 8080
    var contextPath: String = "/"
    
    fun build() = ServerConfig(host, port, contextPath)
}

fun appConfig(block: AppConfigBuilder.() -> Unit): AppConfig {
    val builder = AppConfigBuilder()
    builder.apply(block)
    return builder.build()
}

// Usage
val config = appConfig {
    appName = "MyKotlinApp"
    version = "0.1.0"
    
    database {
        url = "jdbc:postgresql://localhost:5432/mydb"
        username = "admin"
        password = "secret"
        poolSize = 20
        ssl = true
    }
    
    server {
        port = 9000
        contextPath = "/api"
    }
}

println("Application: ${config.appName} ${config.version}")
println("Database URL: ${config.database.url}")
println("Server: ${config.server.host}:${config.server.port}${config.server.contextPath}")

Output:

Application: MyKotlinApp 0.1.0
Database URL: jdbc:postgresql://localhost:5432/mydb
Server: localhost:9000/api

Benefits of the Kotlin Builder Pattern​

  1. Readability: The code becomes more expressive and self-documenting
  2. Flexibility: Builders can enforce validation rules and business logic
  3. Maintainability: Easy to add new properties without breaking existing code
  4. Immutability: Can produce immutable objects after construction
  5. Type Safety: Compiler checks ensure correct usage

When to Use the Builder Pattern in Kotlin​

  • When constructing complex objects with many parameters
  • When you need to enforce specific rules during object construction
  • When you want to create a fluent, declarative API
  • As a foundation for creating domain-specific languages (DSLs)

Summary​

The Builder Pattern in Kotlin leverages the language's powerful features to create a more concise and expressive way to construct complex objects. By using function literals with receivers, extension functions, and DSL capabilities, Kotlin allows for creating type-safe builders that serve as the foundation for domain-specific languages.

We've explored:

  • Basic implementation using Kotlin's named parameters
  • Traditional Builder Pattern implementation
  • Kotlin-style builders using DSL features
  • Type-safe builders for creating structured content
  • A practical application for configuration management

These techniques enable you to write more readable, maintainable, and expressive code when dealing with complex object construction.

Exercises​

  1. Create a builder for a TodoItem class with properties like title, description, dueDate, priority, and status.
  2. Extend the HTML builder example to include more HTML elements like div, a, img, etc.
  3. Implement a builder for creating SQL queries, with methods for select, from, where, etc.
  4. Create a builder pattern for a EmailMessage class that allows for setting recipients, subject, body, and attachments.

Additional Resources​


If you spot any mistakes on this website, please let me know at [email protected]. I’d greatly appreciate your feedback! :)