Pattern at Singleton - para sa lahat na nakatagpo ng mga ito sa unang pagkakataon

Ang artikulong ito ay naglalayong sa mga unang nakatagpo ng konsepto ng mga pattern, narinig ang tungkol sa Singleton'e, o kahit papaano ginawa ito, ngunit hindi pa rin naiintindihan ang anuman. Maligayang pagdating! Ang mga mag-aaral ng JavaRush ay nakatagpo ng mga pattern sa unang pagkakataon sa antas 15, kapag hindi inaasahang hiniling ng cap na "ayusin" at ipatupad ang isang pattern Singletonna may tamad na pagpapatupad. Ang mga mag-aaral na nakarinig tungkol dito sa unang pagkakataon Singletonay agad na may maraming mga katanungan: ano ang isang pattern, bakit ito kailangan, anong uri ng pattern ito, Singletonat sa wakas, kung anong uri ng tamad na pagpapatupad ito. Simulan natin ang pagsagot sa pagkakasunud-sunod:

Ano pa rin ang pattern?

Para sa isang mas mahusay na pag-unawa, sa tingin ko ito ay nagkakahalaga ng pagsagot sa tanong na ito mula sa kasaysayan. Kabilang sa mga programmer ay mayroong isang sikat na apat na may-akda: Erich Gamma, Richard Helm, Ralph Johnson at John Vlissides, na nakaisip ng isang kawili-wiling ideya. Napansin nila na kapag nagsusulat ng mga programa ay madalas nilang kailangang lutasin ang humigit-kumulang sa parehong mga problema at magsulat ng code ng parehong uri sa istraktura. Samakatuwid, nagpasya silang ilarawan sa anyo ng mga pattern ang mga tipikal na pattern na kadalasang ginagamit sa object-oriented na programming. Ang libro ay nai-publish noong 1995 sa ilalim ng pamagat na "Techniques of Object-Oriented Design. Mga Pattern ng Disenyo" . Masyadong mahaba ang pamagat ng libro, at nakilala na lang ito bilang The Book of the Gang of Four . Sa unang edisyon, 23 mga pattern ang nai-publish, pagkatapos kung saan dose-dosenang iba pa ang natuklasan. Kaya, sa pagsagot sa tanong sa talatang ito, "Ano ang mga pattern?" , ibubuod natin sa ilang salita lang: At Singletonito ay isa lamang sa mga pattern na ito.

Bakit kailangan natin ng mga pattern (mga pattern ng disenyo)

Maaari kang mag-program nang hindi alam ang mga pattern; maaari mong i-verify ito sa pamamagitan lamang ng pag-unawa sa katotohanan na sa ika-15 na antas sa JavaRush ay nakapagsulat ka na ng daan-daang mini-program nang hindi nalalaman ang tungkol sa kanilang pag-iral. Iminumungkahi nito na ang isang pattern ay isang uri ng tool, ang pagkakaroon nito ay nakikilala ang isang master mula sa isang baguhan: Inilalarawan ng mga pattern kung paano lutasin nang tama ang isa sa mga karaniwang problema. Bilang resulta, ang pag-alam sa mga pattern ay nakakatipid sa iyo ng oras. Ang isang pagkakatulad ay maaaring gawin sa mga algorithm. Halimbawa, maaari kang makabuo ng sarili mong algorithm sa pag-uuri na may blackjack at mga numero at gumugol ng maraming oras dito, o maaari mong gamitin ang isa na matagal nang inilarawan at ipatupad ito. Ito ay pareho sa mga pattern. Dagdag pa, sa paggamit ng mga pattern, nagiging mas standardized ang code, at kapag gumagamit ng mga tamang pattern, mas mababa ang posibilidad na magkamali ka, dahil nakita na ang mga ito at inalis sa pattern na ito. Well, kasama ang lahat, ang kaalaman sa mga pattern ay nagpapahintulot sa mga programmer na mas maunawaan ang bawat isa. Ang pagsasabi lang ng pangalan ng template ay sapat na, sa halip na subukang ipaliwanag sa iyong mga kapwa programmer kung ano ang gusto mong gawin nila. Kaya, upang ibuod, nakakatulong ang mga pattern ng disenyo: Sa pagtatapos ng seksyong ito, tandaan namin na ang buong iba't ibang mga pattern ay maaaring gawing simple sa tatlong malalaking grupo:

Sa wakas ay isang pattern ng Singleton

Singletonay tumutukoy sa mga generative pattern . Ang literal na pagsasalin nito ay loner. Tinitiyak ng pattern na ito na ang isang klase ay mayroon lamang isang object (isang instance ng klase) at ang isang global access point ay ibinibigay sa object na iyon. Dapat itong maging malinaw mula sa paglalarawan na ang pattern na ito ay dapat gamitin sa dalawang kaso:

1. kapag hindi hihigit sa isang bagay ng anumang klase ang dapat gawin sa iyong programa. Halimbawa, sa isang laro sa computer mayroon kang klase na "Character", at ang klase na ito ay dapat magkaroon lamang ng isang bagay na naglalarawan sa karakter mismo.


2. kapag kailangan mong magbigay ng isang pandaigdigang access point sa isang object ng klase. Sa madaling salita, kailangan mong tiyakin na ang bagay ay tinatawag mula sa kahit saan sa programa. At, sayang, para dito ay hindi sapat na lumikha lamang ng isang pandaigdigang variable, dahil hindi ito protektado ng pagsulat at kahit sino ay maaaring baguhin ang halaga ng variable na ito at ang global access point sa object ay mawawala. Ang mga katangiang ito Singletonay kailangan, halimbawa, kapag mayroon kang object ng isang klase na gumagana sa isang database, at kailangan mo ang database na ma-access mula sa iba't ibang bahagi ng programa. At Singletonito ay magagarantiya na walang ibang code ang pumalit sa naunang ginawang instance ng klase.

Ang dalawang problemang ito ay nareresolba sa pamamagitan ng Singleton: dapat mayroong isang bagay lamang sa programa at dapat mayroong pandaigdigang pag-access dito. Sa halimbawa sa antas 15, hinihiling ng cap na ipatupad ang pattern na ito para sa sumusunod na gawain (narito ang paglalarawan nito): Pagkatapos maingat na basahin ang kondisyon, nagiging malinaw kung bakit eksaktong Singleton(Single) ang kailangan dito. Pagkatapos ng lahat, hinihiling ka ng programa na lumikha ng isang bagay ng bawat klase: Sun, Moon, Earth. At lohikal na ipagpalagay na ang bawat klase sa programa ay dapat lumikha ng hindi hihigit sa isang Araw/Buwan/Earth, kung hindi, ito ay magiging walang katotohanan, maliban kung siyempre ikaw ay nagsusulat ng iyong sariling bersyon ng Star Wars. Ang tampok ng pagpapatupad ng SingletonJava sa tatlong hakbang na pag-uugali ng Singleton sa Java ay hindi maipapatupad gamit ang isang regular na constructor dahil ang constructor ay palaging nagbabalik ng isang bagong bagay. Samakatuwid, ang lahat ng mga pagpapatupad ng Singleton'a ay bumaba upang itago ang tagabuo at lumikha ng isang pampublikong static na pamamaraan na magkokontrol sa pagkakaroon ng isang bagay at "sirain" ang lahat ng mga bagong lalabas na bagay. Kung Singletontinawag ang 'a, dapat itong lumikha ng isang bagong bagay (kung wala pa ito sa programa) o ibalik ang isa na nalikha na. Upang gawin ito: #1. – Kailangan mong magdagdag ng pribadong static na field sa klase na naglalaman ng isang bagay:

public class LazyInitializedSingleton {
	private static LazyInitializedSingleton instance; //#1
}

#2. – Gawing pribado ang tagabuo ng klase (default na tagabuo) (upang ang pag-access dito ay sarado sa labas ng klase, kung gayon hindi na nito maibabalik ang mga bagong bagay):

public class LazyInitializedSingleton {
	private static LazyInitializedSingleton instance;
private LazyInitializedSingleton(){} // #2
}

#3 . – Magdeklara ng static na paraan ng paglikha na gagamitin para makuha ang singleton:

public class LazyInitializedSingleton {
    private static LazyInitializedSingleton instance;
        private LazyInitializedSingleton(){}
        public static LazyInitializedSingleton getInstance(){ // #3
        if(instance == null){		//if the object has not been created yet
            instance = new LazyInitializedSingleton();	//create a new object
        }
        return instance;		// return the previously created object
    }
}

Ang halimbawa sa itaas ay medyo clumsy, dahil itinatago lang namin ang constructor at nagbibigay ng sarili naming pamamaraan sa halip na ang karaniwang constructor. Dahil ang artikulong ito ay naglalayong bigyang-daan ang mga mag-aaral ng JavaRush na makipag-ugnayan sa pattern na ito (at mga pattern sa pangkalahatan) sa unang pagkakataon, ang mga feature ng pagpapatupad ng mas kumplikadong Singletons ay hindi ibibigay dito. Tandaan lamang namin na depende sa pagiging kumplikado ng programa, maaaring kailanganin ang mas detalyadong pagpipino ng pattern na ito. Halimbawa, sa isang multi-threaded na kapaligiran (tingnan ang paksa ng Threads), maraming magkakaibang mga thread ang maaaring sabay-sabay na tumawag sa pamamaraan ng getter ng Singleton, at ang code na inilarawan sa itaas ay hihinto sa paggana, dahil ang bawat indibidwal na thread ay makakagawa ng maraming pagkakataon ng klase sabay-sabay. Samakatuwid, mayroon pa ring ilang iba't ibang mga diskarte sa paglikha ng tamang Thread-safe singleton. Pero ibang kwento na yun =) At sa wakas. Ano ang Lazy Initialization na hiniling ng cap ? Ang Lazy Initialization ay tinatawag ding lazy initialization. Ito ay isang programming technique kung saan ang isang resource-intensive na operasyon (at ang paglikha ng isang object ay isang resource-intensive na operasyon) ay isinasagawa sa demand, sa halip na maaga. Alin ang karaniwang nangyayari sa aming code Singleton'a. Sa madaling salita, ang aming bagay ay nilikha sa sandaling ito ay na-access, at hindi nang maaga. Hindi dapat ipagpalagay na ang konsepto ng lazy initialization ay sa paanuman ay mahigpit na konektado sa Singleton'om. Ang lazy initialization ay ginagamit din sa iba pang generative na mga pattern ng disenyo, halimbawa sa Proxy at Factory Method, ngunit iyon ay isa pang kuwento =) Ang mga sumusunod na mapagkukunan ay ginamit sa paghahanda ng artikulo:

1. Mga Pinakamahuhusay na Kasanayan sa Java Singleton Design Pattern na may Mga Halimbawa
2. Mga Pattern ng Disenyo
3. Tamang Singleton sa Java