Kotlin Academy · Lección

Patrones prácticos

Decoradores mediante delegación

Patrones prácticos es una lección gratuita de Kotlin Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Kotlin Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Kotlin Academy incluye 4 lecciones en total.

El patrón Decorator

Un decorador envuelve un objeto para añadir comportamiento mientras mantiene la misma interfaz. La palabra clave by de Kotlin hace que los decoradores sean triviales: reenvíe todo y sobrescriba las partes que quiera mejorar.

Un componente base

Comenzamos con una fuente de datos sencilla. Los decoradores la envolverán.

interface DataSource {
    fun fetch(): String
}

class NetworkSource : DataSource {
    override fun fetch() = "raw-data"
}

fun main() {
    println(NetworkSource().fetch())
}

Un decorador de registro

El decorador delega en la fuente envuelta y añade registros alrededor de la llamada que le interesa.

interface DataSource { fun fetch(): String }
class NetworkSource : DataSource { override fun fetch() = "raw-data" }

class LoggingSource(private val inner: DataSource) : DataSource by inner {
    override fun fetch(): String {
        println("fetching...")
        val result = inner.fetch()
        println("done")
        return result
    }
}

fun main() {
    println(LoggingSource(NetworkSource()).fetch())
}

Un decorador de caché

Otro decorador almacena en caché el primer resultado, de modo que las llamadas repetidas omiten la fuente subyacente.

interface DataSource { fun fetch(): String }
class NetworkSource : DataSource { override fun fetch() = "raw-data" }

class CachingSource(private val inner: DataSource) : DataSource by inner {
    private var cached: String? = null
    override fun fetch(): String {
        return cached ?: inner.fetch().also { cached = it }
    }
}

fun main() {
    val s = CachingSource(NetworkSource())
    println(s.fetch())
    println(s.fetch()) // served from cache
}

Apilamiento de decoradores

Como cada decorador es también un DataSource, puede apilarlos. El orden importa: el exterior envuelve al interior.

interface DataSource { fun fetch(): String }
class NetworkSource : DataSource { override fun fetch() = "raw-data" }

class LoggingSource(private val inner: DataSource) : DataSource by inner {
    override fun fetch(): String { println("log"); return inner.fetch() }
}
class CachingSource(private val inner: DataSource) : DataSource by inner {
    private var c: String? = null
    override fun fetch() = c ?: inner.fetch().also { c = it }
}

fun main() {
    val s = LoggingSource(CachingSource(NetworkSource()))
    println(s.fetch())
    println(s.fetch())
}

Un decorador de validación

Los decoradores también pueden validar las entradas. Aquí, un decorador valida antes de delegar en el trabajador real.

interface Processor { fun process(input: String): String }
class UpperProcessor : Processor { override fun process(input: String) = input.uppercase() }

class ValidatingProcessor(private val inner: Processor) : Processor by inner {
    override fun process(input: String): String {
        require(input.isNotBlank()) { "empty input" }
        return inner.process(input)
    }
}

fun main() {
    println(ValidatingProcessor(UpperProcessor()).process("hello"))
}

Envoltorio de colección de solo lectura

La delegación facilita la creación de envoltorios adaptadores. Aquí envolvemos una lista y añadimos un método de resumen personalizado, mientras reenviamos todas las operaciones de la lista.

class SummarizedList(private val inner: List<Int>) : List<Int> by inner {
    fun total() = inner.sum()
}

fun main() {
    val list = SummarizedList(listOf(1, 2, 3))
    println(list.size)
    println(list.total())
}

Contabilización de llamadas

Un decorador puede realizar un seguimiento transparente de las métricas, lo que resulta útil para la supervisión sin tocar la implementación real.

interface Service { fun call(): String }
class RealService : Service { override fun call() = "ok" }

class CountingService(private val inner: Service) : Service by inner {
    var calls = 0
        private set
    override fun call(): String {
        calls++
        return inner.call()
    }
}

fun main() {
    val s = CountingService(RealService())
    s.call(); s.call()
    println(s.calls)
}

Por qué aquí gana la delegación

Crear decoradores mediante herencia obligaría a que la clase base fuera open y vincularía cada decorador a una clase concreta. La delegación solo depende de la interfaz, por lo que los decoradores mantienen un acoplamiento débil y se pueden componer.

Lista de comprobación del patrón

Para crear un decorador mediante delegación:

Reciba el objeto envuelto como private val
Delegue la interfaz con by
Sobrescriba solo los miembros que quiera mejorar
Llame al objeto interno dentro de la sobrescritura

Unir todas las piezas

Los decoradores, adaptadores y proxies surgen de forma natural a partir de la delegación de clases. Combinados con interfaces pequeñas, permiten crear sistemas flexibles y organizados por capas que son fáciles de probar y ampliar.

Comprobación rápida

Compruebe su comprensión de los patrones prácticos de delegación.

Resumen

Ha creado decoradores prácticos mediante delegación:

Envoltorios de registro, caché, validación y contabilización
Decoradores apilados, ya que cada uno implementa la misma interfaz
Sobrescritura solo de los miembros mejorados; reenvío del resto

Con esto concluye el curso sobre delegación de clases.

Preguntas frecuentes

¿La lección «Patrones prácticos» es gratis?

Sí — el texto completo de «Patrones prácticos» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Kotlin Academy, actualiza a CoddyKit PRO. El curso de Kotlin Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Patrones prácticos»?

Decoradores mediante delegación Practicas Kotlin Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Kotlin Academy?

No se requiere experiencia previa. Kotlin Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Patrones prácticos»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Kotlin Academy?

Sí. Cada lección de Kotlin Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Kotlin Academy