Delegates für Preferences, Map-basierte Properties und Logging
Verwenden Sie Delegates für SharedPreferences, Map-Speicher und Audit-Logging.
Delegates für Preferences, Map-basierte Properties und Logging ist eine kostenlose Kotlin Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Kotlin Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Kotlin Academy-Kurs umfasst insgesamt 4 Lektionen.
Map-basierte Properties
Kotlin ermöglicht es, Properties direkt an eine Map zu delegieren. Beim Lesen der Property wird ihr Name in der Map nachgeschlagen.
class User(map: Map<String, Any?>) {
val name: String by map
val age: Int by map
}
fun main() {
val u = User(mapOf("name" to "Alice", "age" to 30))
println(u.name) // Alice
println(u.age) // 30
}MutableMap-Delegate
Bei veränderlichen Properties delegieren Sie an eine MutableMap; Änderungen aktualisieren die zugrunde liegende Map.
class Settings(private val map: MutableMap<String, Any?> = mutableMapOf()) {
var theme: String by map
var fontSize: Int by map
}
fun main() {
val s = Settings()
s.theme = "dark"
s.fontSize = 16
println(s.theme) // dark
println(s.fontSize) // 16
}JSON-Deserialisierung mit Map-Delegate
Analysieren Sie eine JSON-ähnliche Map und stellen Sie ihre Felder mithilfe von Map-Delegation als typisierte Properties bereit – ideal für dynamische Daten.
class ApiResponse(data: Map<String, Any?>) {
val id: Int by data
val title: String by data
val published: Boolean by data
}
fun main() {
val response = ApiResponse(mapOf("id" to 1, "title" to "Kotlin Rocks", "published" to true))
println(response.title) // Kotlin Rocks
println(response.published) // true
}Logging-Delegate-Muster
Umschließen Sie ein beliebiges Delegate mit Logging, um jeden Lese- und Schreibzugriff über alle delegierten Properties hinweg transparent nachzuverfolgen.
import kotlin.properties.ReadWriteProperty
import kotlin.reflect.KProperty
class Logged<T>(private var v: T) : ReadWriteProperty<Any?, T> {
override fun getValue(t: Any?, p: KProperty<*>): T {
println("[READ] ${p.name} = $v"); return v
}
override fun setValue(t: Any?, p: KProperty<*>, value: T) {
println("[WRITE] ${p.name}: $v -> $value"); v = value
}
}
var config: String by Logged("default")
fun main() { println(config); config = "production" }Map und Logging kombinieren
Schalten Sie einen Logging-Wrapper um die Map-Delegation, um dynamische Property-Zugriffe vollständig zu protokollieren.
import kotlin.properties.ReadWriteProperty
import kotlin.reflect.KProperty
class TrackedMap(private val map: MutableMap<String,Any?> = mutableMapOf()) {
inner class Delegate<T> : ReadWriteProperty<Any?,T> {
@Suppress("UNCHECKED_CAST")
override fun getValue(t:Any?,p:KProperty<*>): T {
val v = map[p.name] as T; println("read ${p.name}=$v"); return v
}
override fun setValue(t:Any?,p:KProperty<*>,value:T) {
println("write ${p.name}=$value"); map[p.name]=value
}
}
var host: String by Delegate()
}
fun main() { val m=TrackedMap(); m.host="localhost"; println(m.host) }SharedPreferences-ähnlicher Delegate
Ein Delegate, der Werte in einer zugrunde liegenden Map speichert und damit SharedPreferences simuliert – für echte Android-Prefs ersetzen Sie die Map durch tatsächliche Prefs-Aufrufe.
import kotlin.properties.ReadWriteProperty
import kotlin.reflect.KProperty
val prefs = mutableMapOf<String, Any?>()
fun <T> pref(default: T): ReadWriteProperty<Any?, T> = object : ReadWriteProperty<Any?, T> {
@Suppress("UNCHECKED_CAST")
override fun getValue(t: Any?, p: KProperty<*>): T = prefs.getOrDefault(p.name, default) as T
override fun setValue(t: Any?, p: KProperty<*>, value: T) { prefs[p.name] = value }
}
object UserPrefs {
var username: String by pref("Guest")
var isDarkMode: Boolean by pref(false)
}
fun main() {
println(UserPrefs.username) // Guest
UserPrefs.username = "Alice"
println(UserPrefs.username) // Alice
}Typisierte Preference-Hilfsfunktionen
Erstellen Sie für jeden primitiven Preference-Typ typisierte Hilfsfunktionen, damit die Aufrufstellen übersichtlicher werden.
import kotlin.properties.ReadWriteProperty
import kotlin.reflect.KProperty
val store = mutableMapOf<String,Any?>()
fun stringPref(default: String) = object : ReadWriteProperty<Any?,String> {
@Suppress("UNCHECKED_CAST")
override fun getValue(t:Any?,p:KProperty<*>) = store.getOrDefault(p.name, default) as String
override fun setValue(t:Any?,p:KProperty<*>,v:String) { store[p.name]=v }
}
fun intPref(default: Int) = object : ReadWriteProperty<Any?,Int> {
@Suppress("UNCHECKED_CAST")
override fun getValue(t:Any?,p:KProperty<*>) = store.getOrDefault(p.name, default) as Int
override fun setValue(t:Any?,p:KProperty<*>,v:Int) { store[p.name]=v }
}
object Prefs {
var name: String by stringPref("default")
var count: Int by intPref(0)
}
fun main() { Prefs.name="Bob"; Prefs.count=5; println("${Prefs.name}: ${Prefs.count}") }Audit-Log-Delegate
Zeichnen Sie jede Änderung einer Property zusammen mit einem Zeitstempel in einer Audit-Liste auf – ideal für Compliance- oder Debugging-Szenarien.
import kotlin.properties.ReadWriteProperty
import kotlin.reflect.KProperty
val audit = mutableListOf<String>()
class AuditDelegate<T>(private var v: T) : ReadWriteProperty<Any?, T> {
override fun getValue(t:Any?,p:KProperty<*>) = v
override fun setValue(t:Any?,p:KProperty<*>,value:T) {
audit += "[${System.currentTimeMillis()}] ${p.name}: $v -> $value"
v = value
}
}
var price: Double by AuditDelegate(9.99)
fun main() {
price = 12.99
price = 11.49
audit.forEach(::println)
}Validierung und Map-Speicher
Kombinieren Sie Map-Speicher mit Validierung: Lehnen Sie ungültige Werte ab, bevor sie in die Map geschrieben werden.
import kotlin.properties.ReadWriteProperty
import kotlin.reflect.KProperty
val data = mutableMapOf<String, Any?>()
fun positiveInt(default: Int): ReadWriteProperty<Any?,Int> = object : ReadWriteProperty<Any?,Int> {
@Suppress("UNCHECKED_CAST")
override fun getValue(t:Any?,p:KProperty<*>)=data.getOrDefault(p.name,default) as Int
override fun setValue(t:Any?,p:KProperty<*>,v:Int){
require(v>=0){"${p.name} must be >= 0"}
data[p.name]=v
}
}
object Inventory { var stock: Int by positiveInt(100) }
fun main(){
Inventory.stock=50; println(Inventory.stock)
try { Inventory.stock=-1 } catch(e:Exception){ println(e.message) }
}Muster zur Delegate-Komposition
Kombinieren Sie mehrere Delegate-Verhaltensweisen mithilfe einer Builder-ähnlichen API: Beginnen Sie mit einem Basis-Delegate und fügen Sie Logging, Validierung oder Caching hinzu.
import kotlin.properties.ReadWriteProperty
import kotlin.reflect.KProperty
fun <T> ReadWriteProperty<Any?,T>.withLogging(): ReadWriteProperty<Any?,T> {
val base = this
return object : ReadWriteProperty<Any?,T> {
override fun getValue(t:Any?,p:KProperty<*>): T {
val v = base.getValue(t,p); println("get ${p.name}=$v"); return v
}
override fun setValue(t:Any?,p:KProperty<*>,v:T){
println("set ${p.name}=$v"); base.setValue(t,p,v)
}
}
}Praxis: Muster für Konfigurationsobjekte
Verwenden Sie Map-Delegation, um aus externen Quellen wie Umgebungsvariablen oder einer JSON-Konfigurationsdatei ein Konfigurationsobjekt zu erstellen.
class AppConfig(private val raw: Map<String, Any?>) {
val host: String by raw
val port: Int by raw
val debug: Boolean by raw
}
fun main() {
val env = mapOf("host" to "0.0.0.0", "port" to 8080, "debug" to true)
val cfg = AppConfig(env)
println("${cfg.host}:${cfg.port} debug=${cfg.debug}")
}Schnelltest
Was geschieht, wenn Sie eine Property an eine Map delegieren?
Zusammenfassung
Delegates ermöglichen leistungsfähige Muster: Map-Delegation für dynamische Daten und JSON, SharedPreferences-ähnliche Persistenz, Audit-Logging für Compliance und kombinierbare Validierung – und das alles, ohne die Aufrufstellen zu ändern.
Häufig gestellte Fragen
Ist die Lektion „Delegates für Preferences, Map-basierte Properties und Logging“ kostenlos?
Ja — der vollständige Text von „Delegates für Preferences, Map-basierte Properties und Logging“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Kotlin Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Kotlin Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Delegates für Preferences, Map-basierte Properties und Logging“?
Verwenden Sie Delegates für SharedPreferences, Map-Speicher und Audit-Logging. Du übst Kotlin Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Kotlin Academy zu starten?
Keine Vorkenntnisse erforderlich. Kotlin Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.
Wie lange dauert die Lektion „Delegates für Preferences, Map-basierte Properties und Logging“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Kotlin Academy-Lektion Code schreiben und ausführen?
Ja. Jede Kotlin Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- by lazy: Vertiefung zur verzögerten Initialisierung
- observable- und vetoable-Delegates
- Einen benutzerdefinierten ReadWriteProperty-Delegate schreiben
- Delegates für Preferences, Map-basierte Properties und Logging