လွယ်လွယ်ပြောရရင် Design Pattern ဆိုတာ Code ရေးတဲ့အခါ ထပ်ခါထပ်ခါ ကြုံရတဲ့ ပြဿနာတွေအတွက် အဆင်သင့် ဖြေရှင်းနည်းပုံစံပါ။ Library လို Copy ကူးပြီး သုံးလို့ရတဲ့ Code အတုံး မဟုတ်ပါဘူး။ ပုံစံကိုပဲ မှတ်ထားပြီး ကိုယ့်ပြဿနာနဲ့ ကိုက်အောင် ပြန်ရေးရတာပါ။

ကျွန်တော် ဒါကို ဟင်းချက်နည်းနဲ့ ဥပမာပေးချင်တယ်။ ကြက်ဥကြော်တိုင်း ချက်နည်းစာအုပ် အသစ်ဖွင့်စရာ မလိုပါဘူး။ “ကြက်ဥဖောက်၊ ဆားထည့်၊ ဆီပူရင် ထည့်၊ မွှေ” ဆိုတဲ့ ပုံစံကို သိထားပြီးသားမို့ ကြက်ဥအသစ်နဲ့လည်း ဒီပုံစံအတိုင်း ချက်လို့ရပါတယ်။ Design Pattern လည်း အတူတူပါပဲ။ “ဒီလိုပြဿနာမျိုးဆို ဒီလိုပုံစံနဲ့ ဖြေရှင်းတယ်” ဆိုတဲ့ အတွေ့အကြုံကို နာမည်တပ်ပြီး မှတ်ထားတာပါ။ အခုဆိုရင် Gang of Four လို့ခေါ်တဲ့ စာအုပ်မှာ Pattern ၂၃ ခု စုထားပြီး Programmer တိုင်း သိကြပါတယ်။

Singleton: တစ်ခုတည်းပဲ ရှိရမယ့်အရာ

Singleton Pattern က “ဒီအရာက တစ်ခုတည်းပဲ ရှိရမယ်” ဆိုတဲ့ ပြဿနာကို ဖြေရှင်းပေးပါတယ်။

ဥပမာ ရုံးမှာ Printer တစ်လုံးတည်း ရှိတယ်ဆိုပါစို့။ လူ ၁၀ ယောက် တစ်ပြိုင်နက် Print ထုတ်မယ်ဆိုရင် Printer ကို တစ်ယောက်ချင်းစီက အသစ်ဝယ်စရာ မလိုပါဘူး။ တစ်ခုတည်းသော Printer ကို တန်းစီပြီး သုံးရတာပါ။ Database Connection လည်း ဒီလိုပါပဲ။ App တစ်ခုမှာ Database ချိတ်ဆက်မှုကို တစ်ခုတည်းပဲ ဖွင့်ထားပြီး နေရာတိုင်းက အဲဒီတစ်ခုတည်းကို မျှသုံးတာက ပိုမြန်ပြီး ပိုသက်သာပါတယ်။ Connection အသစ်တွေ ထပ်ထပ်ဖွင့်နေရင် Database က ဝန်ပိပြီး နှေးသွားပါလိမ့်မယ်။

Python မှာ Singleton ကို အရိုးရှင်းဆုံး ရေးရင် ဒီလိုပါ။


class Database:
    _instance = None

    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
            print("Database ချိတ်ဆက်မှု ဖွင့်လိုက်ပြီ")
        return cls._instance

db1 = Database()
db2 = Database()
print(db1 is db2)  # True — နှစ်ခုလုံး အတူတူပဲ

db1 နဲ့ db2 က နှစ်ခုလို့ ထင်ရပေမယ့် တကယ်တော့ Object တစ်ခုတည်းပါ။ ဒါက Singleton ရဲ့ အဓိက အချက်ပါ။ ဒါပေမယ့် သတိထားပါ — အရာတိုင်းကို Singleton လုပ်ပစ်ရင် နောက်ပိုင်းမှာ Test လုပ်ရခက်ပြီး Code က ရှုပ်သွားတတ်ပါတယ်။ တကယ် တစ်ခုတည်းပဲ ရှိသင့်တဲ့အရာမှာပဲ သုံးပါ။

Factory: ဖန်တီးပေးတဲ့ စက်ရုံ

Factory Pattern က “Object တစ်ခုကို ဘယ်လိုဖန်တီးရမလဲ” ဆိုတဲ့ ပြဿနာကို ဖြေရှင်းပေးပါတယ်။

စားသောက်ဆိုင်ကို စဉ်းစားကြည့်ပါ။ စားသုံးသူက “ကြက်သားကြော် တစ်ပွဲ” လို့ မှာလိုက်တာနဲ့ မီးဖိုချောင်က လုပ်ပေးပါတယ်။ စားသုံးသူက ကြက်သားကို ဘယ်လိုလှီးလဲ၊ ဘယ်ဆီနဲ့ ကြော်လဲဆိုတာ သိစရာ မလိုပါဘူး။ မှာလိုက်ရုံပဲ။ Factory လည်း ဒီလိုပါပဲ။ ကိုယ်လိုချင်တဲ့ Object အမျိုးအစားကို ပြောလိုက်တာနဲ့ Factory က ဖန်တီးပေးပါတယ်။ ဖန်တီးတဲ့ အသေးစိတ် လုပ်ငန်းစဉ်ကို ကိုယ်သိစရာ မလိုပါဘူး။


class Dog:
    def sound(self):
        return "ဟောင်း ဟောင်း"

class Cat:
    def sound(self):
        return "ညောင် ညောင်"

def animal_factory(kind):
    if kind == "dog":
        return Dog()
    if kind == "cat":
        return Cat()

pet = animal_factory("dog")
print(pet.sound())  # ဟောင်း ဟောင်း

အနာဂတ်မှာ Bird ဆိုတဲ့ အမျိုးအစား အသစ်ထည့်ချင်ရင် Factory ထဲမှာပဲ တစ်နေရာတည်း ပြင်လိုက်ရုံပါ။ Factory ကို သုံးတဲ့ နေရာတိုင်းကို လိုက်ပြင်စရာ မလိုပါဘူး။ ဒါက Factory ရဲ့ အကြီးဆုံး အားသာချက်ပါ။

နောက်ထပ် သိထားသင့်တဲ့ Pattern ၃ ခု

Observer — YouTube Channel ကို Subscribe လုပ်ထားသလိုပါ။ Channel မှာ Video အသစ်တင်တာနဲ့ Subscriber အားလုံးဆီ Notification ရောက်ပါတယ်။ Event တစ်ခု ဖြစ်တာနဲ့ စောင့်နေသူအားလုံးကို အလိုလို အကြောင်းကြားတဲ့ ပုံစံပါ။
Strategy — ငွေပေးချေတဲ့နည်း ရွေးသလိုပါ။ Card နဲ့ပေးမလား၊ QR နဲ့ပေးမလား၊ Cash နဲ့ပေးမလား ဆိုတာ အချိန်နဲ့တပြေးညီ လဲသုံးလို့ရပါတယ်။ Algorithm ကို အလွယ်တကူ လဲသုံးနိုင်တဲ့ ပုံစံပါ။
Decorator — အရင်က ရေးခဲ့တဲ့ Decorator ဆောင်းပါးမှာ ပြောခဲ့သလိုပါပဲ။ Function တစ်ခုကို မပြင်ဘဲ အပေါ်ကနေ အလွှာထပ်ပြီး လုပ်ဆောင်ချက် ထပ်ဖြည့်တဲ့ ပုံစံပါ။

Pattern သုံးတဲ့အခါ သတိထားပါ

Design Pattern က အကူကောင်းပေမယ့် ဆေးတော့ မဟုတ်ပါဘူး။

ပြဿနာ မရှိဘဲ Pattern မသုံးပါနဲ့ — Code သေးသေးလေးကို Pattern နဲ့ ဖုံးလိုက်ရင် ရိုးရိုးရှင်းရှင်း ရေးထားတာထက် ပိုရှုပ်သွားတတ်ပါတယ်။ “ဒီ Pattern သုံးမှ ဂုဏ်ရှိတယ်” ဆိုတဲ့ စိတ်နဲ့ မသုံးပါနဲ့။
နာမည်ကို အရင်လေ့လာပါ — Pattern နာမည်တွေ သိထားရင် အဖွဲ့နဲ့ စကားပြောရတာ အရမ်း လွယ်ပါတယ်။ “ဒီနေရာ Singleton သုံးမယ်” လို့ ပြောလိုက်တာနဲ့ အားလုံး ဘာပြောမှန်း သိသွားပါတယ်။ Code ရှည်ကြီး ရှင်းပြစရာ မလိုတော့ပါဘူး။
တစ်နေ့တည်း အကုန်လုံး မသင်ပါနဲ့ — အခုပြောခဲ့တဲ့ Singleton, Factory, Observer ဒီ ၃ ခုက စပါ။ ကိုယ့် Project မှာ တကယ် ကြုံလာမှ ကျန်တာတွေ ဆက်လေ့လာပါ။ လက်တွေ့ ကြုံဖူးမှ Pattern က တကယ် မှတ်မိပါတယ်။

Design Pattern ဆိုတာ Programmer တွေရဲ့ အတွေ့အကြုံ စုဗူးပါ။ တစ်ယောက်တည်း ပြဿနာကို အစကနေ ဖြေရှင်းနေမယ့်အစား လူထောင်ပေါင်းများစွာ စမ်းပြီးသား နည်းကို ယူသုံးတာပါ။ ကိုယ့် Code ကို တစ်နေ့မှာ ပြန်ဖတ်ရင် “ဒါကို ဘာလို့ ဒီလို ရေးခဲ့တာလဲ” ဆိုပြီး နားလည်နေရင် Pattern သုံးတာ အောင်မြင်ပါပြီ။ 🙂

—

Avatar photo
Min SiThu
@itsmeminsithu

Software Engineer & Tech Content Creator

View all posts