Mga Pattern at Singleton sa Java

Ang artikulong ito ay naglalayon sa sinumang, sa unang pagkakataon, ay nakatagpo ng konsepto ng mga pattern ng disenyo, nakarinig ng terminong singleton , o kahit papaano ay nagpatupad ng singleton pattern ngunit hindi naiintindihan kung ano ang nangyayari. Maligayang pagdating! Ang mga mag-aaral ng CodeGym ay nakatagpo ng mga pattern ng disenyo sa unang pagkakataon sa Level 15, nang hindi inaasahang hiniling ng kapitan sa kanila na "palakasin" ang kanilang pang-unawa sa pamamagitan ng pagpapatupad ng Java Singleton pattern na may tamad na pagpapatupad. Ang mga mag-aaral na nakarinig tungkol sa singleton pattern sa unang pagkakataon ay agad na may maraming katanungan: ano sa mundo ang isang pattern ng disenyo? Bakit kailangan natin ito? Ano ang singleton ? At sa wakas, ano ang tamad na pagpapatupad? Sagutin natin ang mga tanong na ito sa pagkakasunud-sunod.

Ano sa mundo ang isang pattern ng disenyo?

Naniniwala ako na ang isang maliit na kasaysayan ay upang masagot ang tanong na ito nang may pinakamahusay na pag-unawa. Mayroong apat na sikat na may-akda ng programming (Erich Gamma, John Vlissides, Ralph Johnson, at Richard Helm) na nakaisip ng isang kawili-wiling ideya. Napansin nila na ang software development ay kadalasang nangangailangan sa kanila na lutasin ang humigit-kumulang sa parehong mga problema at magsulat ng code na nakabalangkas sa parehong paraan. Kaya't nagpasya silang ilarawan ang mga tipikal na pattern na kadalasang kailangang gamitin sa object-oriented na programming. Ang kanilang libro ay nai-publish noong 1994 sa ilalim ng pamagat na Design Patterns: Elements of Reusable Object-Oriented Software. Masyadong mahaba ang pangalan ng libro at nagsimulang tawagin ng mga tao ang libro ng Gang of Four. Kasama sa unang edisyon ang 23 pattern. Pagkatapos, dose-dosenang iba pang mga pattern ang natuklasan. At ang singleton pattern ay isa lamang sa kanila.

Bakit kailangan natin ng mga pattern ng disenyo?

Maaari kang mag-program nang hindi alam ang mga pattern: pagkatapos ng lahat, sa pamamagitan ng Level 15, nakapagsulat ka na ng daan-daang mini-program sa CodeGym nang hindi alam na umiiral ang mga ito. Iminumungkahi nito na ang mga pattern ng disenyo ay isang uri ng tool na ang paggamit ay nagpapakilala sa master mula sa baguhan: Ang mga pattern ng disenyo ay naglalarawan kung paano maayos na lutasin ang isang karaniwang problema. Nangangahulugan ito na ang pag-alam sa mga pattern ay nakakatipid sa iyo ng oras. Sa ganoong paraan, sila ay katulad ng mga algorithm. Halimbawa, maaari kang lumikha ng iyong sariling algorithm sa pag-uuri gamit ang blackjack at mga numeroat gumugol ng maraming oras sa paggawa nito, o maaari mong ipatupad ang isa na naiintindihan at inilarawan sa mahabang panahon. Ang parehong ay totoo sa mga pattern ng disenyo. Bukod pa rito, sa mga pattern ng disenyo, nagiging mas pamantayan ang code, at kapag ginagamit ang naaangkop na pattern, mas malamang na magkamali ka, dahil ang mga karaniwang pitfalls ng pattern ay natukoy at naalis na noon pa man. Higit sa lahat, ang kaalaman sa mga pattern ay nakakatulong sa mga programmer na mas maunawaan ang isa't isa. Maaari mo lamang sabihin ang pangalan ng isang pattern sa halip na subukang magbigay ng isang mahabang paliwanag sa iyong mga kapwa programmer. Summing up, nakakatulong sa iyo ang mga pattern ng disenyo: Upang tapusin ang seksyong ito, tandaan namin na ang buong katawan ng mga pattern ng disenyo ay maaaring nahahati sa tatlong malalaking grupo:

Panghuli, ang singleton pattern

Ang Singleton ay isang pattern ng paglikha . Tinitiyak ng pattern na ito na mayroon lamang isang instance ng isang klase at nagbibigay ng pandaigdigang access point para sa object na ito. Mula sa paglalarawan, dapat na malinaw na ang pattern na ito ay dapat ilapat sa dalawang kaso:

1. kapag ang iyong programa ay nangangailangan na hindi hihigit sa isang bagay ng isang partikular na klase ang dapat gawin. Halimbawa, maaaring may Hero class ang isang computer game at isang Hero object lang na naglalarawan sa nag-iisang bayani sa laro.


2. kapag kailangan mong magbigay ng punto para sa pandaigdigang pag-access sa isang bagay. Sa madaling salita, kailangan mong gawing available ang bagay mula saanman sa programa. Sa kasamaang palad, hindi sapat na lumikha lamang ng isang pandaigdigang variable, dahil hindi ito protektado ng sulat: kahit sino ay maaaring baguhin ang halaga ng variable, kaya maaaring mawala ang global access point ng object. Ang mga katangian ng isang Singleton ay kinakailangan, halimbawa, kapag mayroon kang isang bagay na gumagana sa isang database, at kailangan mong i-access ang database mula sa iba't ibang bahagi ng programa. Sisiguraduhin ng Singleton na walang magsusulat ng code na pumapalit sa naunang ginawang instance.

Kaya't nasiyahan ang isang Singleton sa dalawang pangangailangang ito: dapat mayroon lamang isa sa isang partikular na uri ng bagay sa programa at dapat mayroong pandaigdigang pag-access dito. Sa halimbawa sa Level 15, hinihiling sa iyo ng kapitan na ipatupad ang pattern na ito para sa sumusunod na gawain:

1. Maghanap ng isang halimbawa ng Singleton na may tamad na pagsisimula.

2. Lumikha ng tatlong singleton classes — Sun, Moon, Earth — sa magkahiwalay na file gamit ang parehong prinsipyo.

3. IpatupadPlanetainterface sa mga klase ng Sun , Moon at Earth .

4. Sa static na bloke ng klase ng Solution , tawagan angreadKeyFromConsoleAndInitPlanetparaan.

5. Ipatupad angreadKeyFromConsoleAndInitPlanetpag-andar ng pamamaraan:

   • 5.1. Basahin ang isang String parameter mula sa console

   • 5.2. Kung ang parameter ay katumbas ng isa saPlanetamga constants ng interface, lumikha ng angkop na bagay sa Planet .

Pagkatapos maingat na basahin ang mga kondisyon ng gawain, malinaw na makikita natin kung bakit kailangan ang Singleton dito. Sa katunayan, hinihiling sa amin na lumikha ng isang instance ng bawat isa sa mga sumusunod na klase: Sun , Moon , Earth . Makatuwirang ipagpalagay na dapat tayong lumikha ng hindi hihigit sa isang Araw/Buwan/Earth. Kung hindi, napupunta tayo sa isang walang katotohanan na sitwasyon, maliban kung siyempre sinusulat mo ang iyong bersyon ng Star Wars. Pagpapatupad ng pattern ng Singleton sa Java sa tatlong hakbang Sa Java, hindi maipapatupad ang pag-uugali ng Singleton gamit ang isang ordinaryong constructor, dahil palaging nagbabalik ng bagong object ang isang constructor. Samakatuwid, ang lahat ng mga pagpapatupad ng Singletonpakuluan upang itago ang constructor, na lumilikha ng isang pampublikong static na pamamaraan na kumokontrol sa buhay ng singleton object, at "pagsira" sa lahat ng mga bagong lalabas na bagay. Kung ang isang Singleton ay na-access, dapat itong lumikha ng isang bagong bagay (kung ang isa ay wala pa sa programa), o ibalik ang isang umiiral na. Upang magawa ito:

1. Kailangan mong bigyan ang klase ng pribadong static na field na nag-iimbak ng isang bagay:

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

2. Gawing pribado ang (default) constructor. Nangangahulugan ito na hindi ito ma-access sa labas ng klase at hindi 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 yet been created
               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 isang standard na constructor. Dahil ang artikulong ito ay naglalayong tiyakin na ang mga mag-aaral ng CodeGym ay nakakaugnay sa pattern na ito (at mga pattern ng disenyo sa pangkalahatan), ang mga nuances ng mas kumplikadong mga pagpapatupad ng singleton ay hindi ilalarawan dito. Napansin lang namin na, depende sa pagiging kumplikado ng programa, ang pattern na ito ay maaaring kailanganin pang pinuhin. Halimbawa, sa isang multithreaded na kapaligiran (tingnan ang mga artikulo tungkol sa mga thread), maaaring ma-access ng ilang magkakaibang thread ang singleton method nang sabay-sabay, at ang code na inilarawan sa itaas ay hihinto sa paggana, dahil ang bawat hiwalay na thread ay maaaring lumikha ng isang instance ng klase. Bilang resulta, mayroon pa ring ilang iba't ibang mga diskarte sa paglikha ng wastong thread-safe singleton. Pero ibang kwento na yun =)

At sa wakas... Ano itong tamad na initialization na tinanong ng kapitan?

Ang tamad na pagsisimula ay tinatawag ding deferred initialization. Ito ay programming trick 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. Kaya ano talaga ang nangyayari sa aming Singleton Java code? Sa madaling salita, ang aming bagay ay nilikha sa oras na ito ay na-access, hindi nang maaga. Hindi mo dapat ipagpalagay na ang tamad na pagsisimula ay sa paanuman ay mahigpit na nakatali sa pattern ng Singleton . Ginagamit din ang lazy initialization sa iba pang mga pattern ng disenyo ng paglikha, tulad ng Proxy at Factory Method, ngunit isa rin itong kwento =)