Metody fabrykujące z companion object

Wzorzec metody fabrykującej

Prywatny konstruktor + fabryka

class Token private constructor(val value: String) {
    companion object {
        fun generate() = Token(java.util.UUID.randomUUID().toString())
        fun fromString(s: String) = Token(s.trim())
    }
}
val t = Token.generate()

Nazwane metody fabrykujące

class Duration private constructor(val ms: Long) {
    companion object {
        fun ofMillis(ms: Long) = Duration(ms)
        fun ofSeconds(s: Long) = Duration(s * 1000)
        fun ofMinutes(m: Long) = Duration(m * 60_000)
    }
}
val d = Duration.ofMinutes(5)

Zwracanie wartości null z fabryki

class Percentage private constructor(val value: Int) {
    companion object {
        fun of(value: Int): Percentage? {
            return if (value in 0..100) Percentage(value) else null
        }
    }
}
val p = Percentage.of(75) ?: error("Invalid")

Buforowane instancje

class Direction private constructor(val name: String) {
    companion object {
        private val cache = mutableMapOf<String, Direction>()
        fun of(name: String) = cache.getOrPut(name.uppercase()) {
            Direction(name.uppercase())
        }
    }
}

Operator invoke jako fabryka przypominająca konstruktor

class Email private constructor(val address: String) {
    companion object {
        operator fun invoke(raw: String): Email {
            require("@" in raw) { "Invalid email" }
            return Email(raw.lowercase())
        }
    }
}
val e = Email("Test@Example.com")  // looks like a constructor

Fabryka abstrakcyjna z klasami sealed

sealed class Shape {
    data class Circle(val r: Double) : Shape()
    data class Rect(val w: Double, val h: Double) : Shape()
    companion object {
        fun circle(r: Double) = Circle(r)
        fun rect(w: Double, h: Double) = Rect(w, h)
    }
}

Fabryka uwzględniająca zależności

class Repository(private val db: Database) {
    companion object {
        fun create(db: Database = Database.instance) = Repository(db)
    }
    fun findAll() = db.query("SELECT * FROM items")
}

Fabryka w testach

class Order private constructor(
    val id: Long, val items: List<String>, val paid: Boolean
) {
    companion object {
        fun unpaid(id: Long, items: List<String>) = Order(id, items, false)
        fun paid(id: Long, items: List<String>) = Order(id, items, true)
    }
}

Z JSON-u lub konfiguracji

class AppConfig private constructor(
    val baseUrl: String, val timeout: Int
) {
    companion object {
        fun fromEnv() = AppConfig(
            baseUrl = System.getenv("BASE_URL") ?: "http://localhost",
            timeout = System.getenv("TIMEOUT")?.toInt() ?: 30
        )
    }
}

Kiedy NIE używać prywatnego konstruktora

Szybkie sprawdzenie

Podsumowanie