कोटलिन में इवेंट बस और ऑब्ज़र्वर पैटर्न: कार्यान्वयन और उदाहरण

कोटलिन में इवेंट बस और ऑब्ज़र्वर पैटर्न: इवेंट-संचालित अनुप्रयोगों की आर्किटेक्चर

कोटलिन में आधुनिक विकास, विशेष रूप से Android और सर्वर अनुप्रयोगों के संदर्भ में, घटकों के बीच बातचीत के लिए लचीले तंत्र की आवश्यकता होती है। ऑब्ज़र्वर पैटर्न और इसका व्यावहारिक कार्यान्वयन — इवेंट बस — ढीली-युग्मित आर्किटेक्चर के लिए एक सुरुचिपूर्ण समाधान प्रदान करता है, जहां एक वस्तु (प्रकाशक) उनके विशिष्ट कार्यान्वयन को जाने बिना कई सब्सक्राइबर्स को किसी इवेंट के घटित होने की सूचना देती है। इस लेख में, हम कोरूटीन और सुरक्षित टाइपिंग का उपयोग करके कोटलिन में अपना स्वयं का इवेंट बस बनाने का तरीका समझेंगे।

ऑब्ज़र्वर पैटर्न: सैद्धांतिक आधार

ऑब्ज़र्वर पैटर्न (प्रेक्षक) वस्तुओं के बीच "एक-से-अनेक" निर्भरता को परिभाषित करता है। जब विषय (प्रकाशक) की स्थिति बदलती है, तो सभी आश्रित वस्तुओं (प्रेक्षकों) को स्वचालित रूप से सूचित और अद्यतन किया जाता है। कोटलिन में, इस पैटर्न को इंटरफेस, लैम्ब्डा या अधिक उन्नत निर्माणों के माध्यम से कार्यान्वित किया जा सकता है।

पैटर्न के प्रमुख तत्व:

• Subject (विषय) — वह वस्तु जो प्रेक्षकों की सूची का प्रबंधन करती है और सूचनाएं भेजती है।
• Observer (प्रेक्षक) — वह वस्तु जो विषय से सूचनाएं प्राप्त करती है।
• ConcreteSubject — अपनी स्वयं की स्थिति वाले विषय का विशिष्ट कार्यान्वयन।
• ConcreteObserver — परिवर्तनों पर प्रतिक्रिया देने वाले प्रेक्षक का विशिष्ट कार्यान्वयन।

कोटलिन में सबसे सरल कार्यान्वयन का उदाहरण:

interface Observer {    fun update(event: String)}

class ConcreteSubject {    private val observers = mutableListOf<Observer>()

    fun attach(observer: Observer) {        observers.add(observer)    }

    fun detach(observer: Observer) {        observers.remove(observer)    }

    fun notifyObservers(event: String) {        observers.forEach { it.update(event) }    }}

class ConcreteObserver(private val name: String) : Observer {    override fun update(event: String) {        println("$name को इवेंट मिला: $event")    }}

fun main() {    val subject = ConcreteSubject()    val observer1 = ConcreteObserver("प्रेक्षक 1")    val observer2 = ConcreteObserver("प्रेक्षक 2")

    subject.attach(observer1)    subject.attach(observer2)    subject.notifyObservers("डेटा अपडेट किया गया")}

इवेंट बस: व्यावहारिक इवेंट बस

इवेंट बस एक केंद्रीकृत तंत्र है जो ऑब्ज़र्वर पैटर्न का विस्तार करता है। प्रत्येक विषय द्वारा अपने स्वयं के प्रेक्षकों के प्रबंधन के बजाय, एक एकल बस बनाई जाती है जिसके माध्यम से सभी इवेंट गुजरते हैं। यह जटिल अनुप्रयोगों में विशेष रूप से घटकों के बीच संचार को सरल बनाता है।

इवेंट बस के लाभ:

• ढीली युग्मन: प्रकाशक और सब्सक्राइबर एक दूसरे के बारे में नहीं जानते।
• मौजूदा कोड को बदले बिना नए सब्सक्राइबर जोड़ने में आसानी।
• प्रकार या टैग के अनुसार इवेंट को फ़िल्टर करने की क्षमता।
• कोरूटीन के माध्यम से अतुल्यकालिक प्रसंस्करण के लिए समर्थन।

कोरूटीन के साथ कोटलिन में इवेंट बस का कार्यान्वयन

इवेंट बस के आधुनिक कार्यान्वयन को मल्टीथ्रेडिंग को ध्यान में रखना चाहिए और मेमोरी लीक से बचना चाहिए। Coroutines और Channel का उपयोग थ्रेड-सुरक्षित और कुशल बस बनाने की अनुमति देता है।

इवेंट बस का मूल कार्यान्वयन:

import kotlinx.coroutines.*import kotlinx.coroutines.channels.Channelimport kotlinx.coroutines.flow.*

sealed class Event {    data class UserLoggedIn(val userId: String) : Event()    data class DataUpdated(val data: String) : Event()    object NetworkError : Event()}

class EventBus {    private val _events = MutableSharedFlow<Event>(extraBufferCapacity = 64)    val events: SharedFlow<Event> = _events.asSharedFlow()

    suspend fun publish(event: Event) {        _events.emit(event)    }

    fun subscribe(scope: CoroutineScope, action: (Even