Miten luodaan Singleton-luokka Kotlinissa?

Android-sovelluksessa käytetään Singleton-mallia objektille, joka on luotava vain kerran ja jota on käytettävä kaikkialla. Singleton Pattern on ohjelmistojen suunnittelumalli, joka rajoittaa luokan instansoinnin vain ”yhteen” instanssiin. Toteuttaaksemme Singleton-mallin projektissamme tai ohjelmistossamme, luomme singleton-luokan. Tässä blogissa opimme, miten tehdä singleton-luokka Kotlinissa? Aloitetaan siis.

Singleton-luokka

Singleton-luokka on luokka, joka on määritelty siten, että vain yksi instanssi luokasta voidaan luoda ja sitä voidaan käyttää kaikkialla.

Sitä käytetään silloin, kun tarvitsemme vain yhden instanssin luokasta, kuten VerkkoPalvelu, TietokantaPalvelu, jne.

Yleisesti se tehdään siksi, että se vie järjestelmän resursseja luoda näitä objekteja uudelleen ja uudelleen. On siis parempi luoda vain kerran ja käyttää samaa objektia yhä uudelleen.

Singleton-luokan ominaisuudet

Tyypillisen singleton-luokan ominaisuuksia ovat seuraavat:

1. Vain yksi instanssi: Singleton-luokalla on vain yksi instanssi ja tämä tapahtuu tarjoamalla luokan instanssi, luokan sisällä. Myös ulompien luokkien ja alaluokkien tulisi estää instanssin luominen.
2. Globaalisti saatavilla: Singleton-luokan instanssin tulisi olla globaalisti käytettävissä, jotta jokainen luokka voi käyttää sitä.

Säännöt Singleton-luokan tekemiseksi

Singleton-luokan tekemisessä noudatetaan seuraavia sääntöjä:

1. Yksi yksityinen konstruktori
2. Oman luokkansa staattinen viittaus
3. Yksi staattinen metodi
4. Globaalisesti saatavilla oleva objektiviittaus
5. Yksilukuisuus useiden säikeiden välillä

Singleton-esimerkki

Seuraavana on esimerkki Singleton-luokasta javassa:

public class Singleton { private static Singleton instance = null; private Singleton() { } public static Singleton getInstance() { if (instance == null) { synchronized (Singleton.class) { if (instance == null) { instance = new Singleton(); } } } return instance; }}

Laadittaessa instanssia, jotta varmistetaan, ettei säikeiden välillä ole häiriöitä, käytämme synkronoitua avainsanaa.

Katsotaanpa Kotlin-koodia samaa varten. Alla on Kotlin-koodi Singleton-luokalle:

object Singleton

Okei, mitä tämän jälkeen tehdään?

Ei mitään! Oletko tosissasi? Ei, tämä on koodi Singleton-luokan käyttämiseen Kotlinissa. Hyvin yksinkertaista? Älä huoli, katsotaanpa selitystä.

Kotlinissa meidän täytyy käyttää object-avainsanaa käyttääksemme Singleton-luokkaa. Objektiluokalla voi olla funktioita, ominaisuuksia ja init-metodi. Konstruktorimetodi ei ole sallittu objektissa, joten voimme käyttää init-metodia, jos tarvitaan jotain alustusta ja objekti voidaan määritellä luokan sisällä. Objekti instantioidaan, kun sitä käytetään ensimmäistä kertaa.

Katsotaanpa esimerkki Singleton-luokasta Kotlinissa.

object Singleton{ init { println("Singleton class invoked.") } var variableName = "I am Var" fun printVarName(){ println(variableName) }}fun main(args: Array<String>) { Singleton.printVarName() Singleton.variableName = "New Name" var a = A()}class A { init { println("Class init method. Singleton variableName property : ${Singleton.variableName}") Singleton.printVarName() }}

Tässä yllä olevassa esimerkissä meillä on yksi funktio nimeltä printVarName() ja yksi ominaisuus nimeltä ”variableName”. Kun luokka instantioidaan, niin muutokset voivat heijastua objektiluokkaan. Yllä olevan koodin tulos on siis:

Singleton class invoked.I am VarClass init method. Singleton variableName property : New NameNew Name

Objekti, joka laajentaa luokkaa

Kotlinissa voi käyttää objektia laajentamaan jotakin luokkaa tai toteuttamaan jotakin rajapintaa aivan kuten tavallinen luokka. Otetaan esimerkki samasta:

fun main(args: Array<String>) { var a = A() Singleton.printVarName()}open class A { open fun printVarName() { print("I am in class printVarName") } init { println("I am in init of A") }}object Singleton : A() { init { println("Singleton class invoked.") } var variableName = "I am Var" override fun printVarName() { println(variableName) }}

Ja yllä olevan koodin tuloste on:

I am in init of AI am in init of ASingleton class invoked.I am var

Voit siis käyttää objektiluokkaa aivan kuten normaalia luokkaa useimmissa tapauksissa.

Opi järjestelmäsuunnittelua seuraavaa haastatteluasi varten täältä.

Singleton-luokka argumentilla Kotlinissa

Blogin aiemmassa osassa opimme, että singleton-luokassa ei voi olla konstruktoreita. Jos haluamme alustaa jotakin, voimme tehdä sen käyttämällä init:tä singleton-luokassa. Mutta entä jos on tarpeen välittää jokin argumentti alustusta varten aivan kuten parametrisoiduissa konstruktoreissa? Koska emme voi käyttää konstruktoreita tässä. Joten meidän on löydettävä jokin muu tapa tehdä sama.

Jos puhumme erityisesti Androidista, tiedämme, että Androidissa meidän on yleensä syötettävä konteksti-instanssi singletonin init-lohkoon. Tämä voidaan tehdä käyttämällä Early initialization ja Lazy initialization. Varhaisessa alustuksessa kaikki komponentit alustetaan Application.onCreate()-lohkossa käyttämällä init()-funktioita. Tämä kuitenkin hidastaa sovelluksen käynnistystä estämällä pääsäikeen. Siksi on yleensä suositeltavaa käyttää laiskan alustuksen tapaa. Laiskassa alustuksessa käytämme kontekstia argumenttina funktiolle, joka palauttaa singletonin instanssin. Saamme tämän aikaan käyttämällä SingletonHolder-luokkaa. Lisäksi säiketurvallisena tarvitsemme synkronointitavan ja kaksoistarkistetun lukituksen.

open class SingletonHolder<out T: Any, in A>(creator: (A) -> T) { private var creator: ((A) -> T)? = creator @Volatile private var instance: T? = null fun getInstance(arg: A): T { val checkInstance = instance if (checkInstance != null) { return checkInstance } return synchronized(this) { val checkInstanceAgain = instance if (checkInstanceAgain != null) { checkInstanceAgain } else { val created = creator!!(arg) instance = created creator = null created } } }}

Yllä oleva koodi on tehokkain koodi kaksoistarkistettua lukitusjärjestelmää varten, ja koodi on jotenkin samanlainen kuin Kotlinin lazy()-funktio, ja siksi sitä kutsutaankin laiskaksi alustukseksi. Aina kun siis halutaan singleton-luokka argumentteineen, voidaan käyttää SingletonHolder-luokkaa.

Tässä yllä olevassa koodissa SingletonHolder-luokalle argumenttina välitettävän Creator-funktion sijasta voidaan myös inline julistaa oma lambda tai välittää viittaus singleton-luokan yksityiseen konstruktoriin. Koodi on siis:

class YourManager private constructor(context: Context) { init { // do something with context } companion object : SingletonHolder<YourManager, Context>(::YourManager)}

Nyt singletonia voidaan helposti kutsua ja alustaa kirjoittamalla alla oleva koodi, ja tämä on sekä laiska että säikeenkestävä 🙂

YourManager.getInstance(context).doSomething()

Se siitä Singleton-blogista. Toivottavasti pidät tästä blogista. Voit myös tutustua Kotlinin sivustoon. Jos haluat oppia lisää joistakin Androidin hienoista aiheista, voit vierailla blogisivustollamme ja voit liittyä oppimismatkaamme.

Keep Learning 🙂

Team MindOrks!