Patrones de diseño en Kotlin con ejemplos de código

Patrones de diseño en Kotlin con ejemplos

Los patrones de diseño son soluciones probadas para problemas típicos en el desarrollo de software. Ayudan a crear una arquitectura flexible, escalable y mantenible. En el lenguaje Kotlin, gracias a su sintaxis concisa y capacidades funcionales, muchos patrones clásicos se implementan de manera especialmente elegante. En este artículo analizaremos tres patrones clave: Singleton, Factory Method y Observer, y mostraremos su implementación en Kotlin con ejemplos prácticos.

1. Singleton

El patrón Singleton garantiza que una clase tenga solo una instancia y proporciona un punto de acceso global a ella. En Kotlin existe una construcción incorporada para esto: object. Crea un singleton thread-safe sin código adicional.

Implementación en Kotlin

La forma más sencilla de declarar un singleton es usar la palabra clave object:

object DatabaseConfig {    private val url = "jdbc:postgresql://localhost:5432/mydb"    private val username = "admin"    private val password = "secret"

    fun connect(): String {        return "Conexión a $url como $username"    }}

fun main() {    println(DatabaseConfig.connect())    // Salida: Conexión a jdbc:postgresql://localhost:5432/mydb como admin}

Si se necesita un Singleton clásico con constructor privado (por ejemplo, para heredar de otra clase), use companion object:

class Logger private constructor() {    fun log(message: String) {        println("[LOG]: $message")    }

    companion object {        private val instance: Logger by lazy { Logger() }

        fun getInstance(): Logger {            return instance        }    }}

fun main() {    val logger = Logger.getInstance()    logger.log("Aplicación iniciada")}

La ventaja del enfoque con by lazy es la inicialización perezosa, que se ejecuta solo en el primer acceso.

2. Factory Method

El patrón Factory Method define una interfaz para crear un objeto, pero permite que las subclases modifiquen el tipo de objeto creado. En Kotlin, esto a menudo se implementa mediante sealed class o interfaces.

Implementación en Kotlin

Supongamos que estamos desarrollando un sistema de notificaciones. Tenemos diferentes tipos de notificaciones: Email, SMS y Push. Crearemos una fábrica para generarlas.

// Interfaz para todas las notificacionesinterface Notification {    fun send(message: String)}

// Implementaciones concretasclass EmailNotification : Notification {    override fun send(message: String) {        println("Enviando Email: $message")    }}

class SMSNotification : Notification {    override fun send(message: String) {        println("Enviando SMS: $message")    }}

class PushNotification : Notification {    override fun send(message: String) {        println("Enviando notificación Push: $message")    }}

// Fábricaobject NotificationFactory {    fun createNotification(type: String): Notification {        return when (type.lowercase()) {            "email" -> EmailNotification()            "sms" -> SMSNotification()            "push" -> PushNotification()            else -> throw IllegalArgumentException("Tipo de notificación desconocido: $type")        }    }}

fun main() {    val notification = NotificationFactory.createNotification("sms")    notification.send("Su código de confirmación: 1234")    // Salida: Enviando SMS: Su código de confirmación: 1234}

Si la cantidad de tipos es fija, es mejor usar sealed class para mayor seguridad:

sealed class NotificationType {    object Email : NotificationType()    object SMS : NotificationType()    object Push : NotificationType()}

fun createNotification(type: NotificationType): Notificat