M

MLOG

தமிழ்

பொருள்-நோக்கு வடிவமைப்பு முறைகளில் தேர்ச்சி பெற்று, உறுதியான, அளவிடக்கூடிய குறியீட்டை உருவாக்குங்கள். உலகளாவிய டெவலப்பர்களுக்கான நடைமுறை வழிகாட்டி.

மென்பொருள் கட்டமைப்பில் தேர்ச்சி: பொருள்-நோக்கு வடிவமைப்பு முறைகளைச் செயல்படுத்துவதற்கான ஒரு நடைமுறை வழிகாட்டி

மென்பொருள் மேம்பாட்டு உலகில், சிக்கலானதுதான் மிகப்பெரிய எதிரி. பயன்பாடுகள் வளரும்போது, புதிய அம்சங்களைச் சேர்ப்பது ஒரு புதிர்ப்பாதையில் செல்வது போல் உணரலாம், அங்கு ஒரு தவறான திருப்பம் பிழைகள் மற்றும் தொழில்நுட்பக் கடன்களின் தொடர் விளைவுகளுக்கு வழிவகுக்கும். அனுபவமிக்க கட்டமைப்பாளர்களும் பொறியாளர்களும் சக்திவாய்ந்தவை மட்டுமல்ல, நெகிழ்வான, விரிவாக்கக்கூடிய மற்றும் பராமரிக்க எளிதான அமைப்புகளை எவ்வாறு உருவாக்குகிறார்கள்? பதில் பெரும்பாலும் பொருள்-நோக்கு வடிவமைப்பு முறைகள் (Object-Oriented Design Patterns) பற்றிய ஆழமான புரிதலில் உள்ளது.

வடிவமைப்பு முறைகள் என்பவை உங்கள் பயன்பாட்டில் நகலெடுத்து ஒட்டக்கூடிய ஆயத்தக் குறியீடுகள் அல்ல. மாறாக, அவற்றை உயர்நிலை வரைபடங்களாகச் சிந்தியுங்கள்—ஒரு குறிப்பிட்ட மென்பொருள் வடிவமைப்புச் சூழலில் பொதுவாக ஏற்படும் சிக்கல்களுக்கு நிரூபிக்கப்பட்ட, மீண்டும் பயன்படுத்தக்கூடிய தீர்வுகள். இதற்கு முன் இதே போன்ற சவால்களை எதிர்கொண்ட எண்ணற்ற டெவலப்பர்களின் செறிவூட்டப்பட்ட அறிவை அவை பிரதிநிதித்துவப்படுத்துகின்றன. 1994-ஆம் ஆண்டில் எரிக் காமா, ரிச்சர்ட் ஹெல்ம், ரால்ப் ஜான்சன் மற்றும் ஜான் விலிசிடெஸ் (பிரபலமாக "நால்வர் குழு" அல்லது GoF என அழைக்கப்படுபவர்கள்) எழுதிய "வடிவமைப்பு முறைகள்: மீண்டும் பயன்படுத்தக்கூடிய பொருள்-நோக்கு மென்பொருளின் கூறுகள்" என்ற முக்கிய நூலால் முதன்முதலில் பிரபலப்படுத்தப்பட்ட இந்த முறைகள், நேர்த்தியான மென்பொருள் கட்டமைப்பை உருவாக்குவதற்கான ஒரு சொல்லகராதியையும் ஒரு யுக்திசார் கருவித்தொகுப்பையும் வழங்குகின்றன.

இந்த வழிகாட்டி, கோட்பாடுகளைத் தாண்டி, இந்த அத்தியாவசிய முறைகளின் நடைமுறைச் செயல்பாட்டிற்குள் ஆழமாகச் செல்லும். அவை என்ன, நவீன மேம்பாட்டுக் குழுக்களுக்கு (குறிப்பாக உலகளாவிய குழுக்களுக்கு) ஏன் முக்கியமானவை, மற்றும் தெளிவான, நடைமுறை எடுத்துக்காட்டுகளுடன் அவற்றை எவ்வாறு செயல்படுத்துவது என்பதை நாம் ஆராய்வோம்.

உலகளாவிய மேம்பாட்டுச் சூழலில் வடிவமைப்பு முறைகள் ஏன் முக்கியமானவை

இன்றைய இணைக்கப்பட்ட உலகில், மேம்பாட்டுக் குழுக்கள் பெரும்பாலும் கண்டங்கள், கலாச்சாரங்கள் மற்றும் நேர மண்டலங்களில் பரவியுள்ளன. இந்தச் சூழலில், தெளிவான தொடர்பு மிக முக்கியமானது. இங்குதான் மென்பொருள் கட்டமைப்பிற்கான ஒரு உலகளாவிய மொழியாகச் செயல்பட்டு, வடிவமைப்பு முறைகள் உண்மையில் பிரகாசிக்கின்றன.

மூன்று தூண்கள்: வடிவமைப்பு முறைகளை வகைப்படுத்துதல்

"நால்வர் குழு" தங்கள் 23 முறைகளை அவற்றின் நோக்கத்தின் அடிப்படையில் மூன்று அடிப்படைக் குழுக்களாக வகைப்படுத்தியது. இந்தக் வகைகளைப் புரிந்துகொள்வது, ஒரு குறிப்பிட்ட சிக்கலுக்கு எந்த முறையைப் பயன்படுத்த வேண்டும் என்பதைக் கண்டறிய உதவுகிறது.

  1. உருவாக்கும் முறைகள் (Creational Patterns): இந்த முறைகள் பல்வேறு பொருள் உருவாக்கும் வழிமுறைகளை வழங்குகின்றன, இது நெகிழ்வுத்தன்மையை அதிகரித்து, ஏற்கனவே உள்ள குறியீட்டின் மறுபயன்பாட்டைக் கூட்டுகிறது. அவை பொருள் உருவாக்கும் செயல்முறையைக் கையாளுகின்றன, பொருள் உருவாக்கத்தின் 'எப்படி' என்பதை நுட்பமாக்குகின்றன.
  2. கட்டமைப்பு முறைகள் (Structural Patterns): இந்த முறைகள் பொருட்களை மற்றும் வகுப்புகளை பெரிய கட்டமைப்புகளாக எப்படி இணைப்பது என்பதை விளக்குகின்றன, அதே நேரத்தில் இந்தக் கட்டமைப்புகளை நெகிழ்வாகவும் திறமையாகவும் வைத்திருக்கின்றன. அவை வகுப்பு மற்றும் பொருள் கலவையில் கவனம் செலுத்துகின்றன.
  3. நடத்தை முறைகள் (Behavioral Patterns): இந்த முறைகள் நெறிமுறைகள் மற்றும் பொருட்களுக்கு இடையேயான பொறுப்புகளை ஒதுக்குவது தொடர்பானது. அவை பொருட்கள் எவ்வாறு தொடர்பு கொள்கின்றன மற்றும் பொறுப்பைப் பகிர்கின்றன என்பதை விவரிக்கின்றன.

ஒவ்வொரு வகையிலிருந்தும் சில மிக முக்கியமான முறைகளின் நடைமுறைச் செயலாக்கங்களை ஆழமாகப் பார்ப்போம்.

ஆழமான பார்வை: உருவாக்கும் முறைகளைச் செயல்படுத்துதல்

உருவாக்கும் முறைகள் பொருள் உருவாக்கும் செயல்முறையை நிர்வகிக்கின்றன, இந்த அடிப்படைச் செயல்பாட்டின் மீது உங்களுக்கு அதிகக் கட்டுப்பாட்டைக் கொடுக்கின்றன.

1. சிங்கிள்டன் முறை: ஒன்றே ஒன்று என்பதை உறுதி செய்தல்

சிக்கல்: ஒரு வகுப்பிற்கு ஒரே ஒரு பொருள் (instance) மட்டுமே இருப்பதை நீங்கள் உறுதி செய்ய வேண்டும் மற்றும் அதற்கான உலகளாவிய அணுகல் புள்ளியை வழங்க வேண்டும். இது ஒரு தரவுத்தள இணைப்புத் தொகுப்பு, ஒரு பதிவான் (logger) அல்லது ஒரு உள்ளமைவு மேலாளர் போன்ற பகிரப்பட்ட வளங்களை நிர்வகிக்கும் பொருட்களுக்குப் பொதுவானது.

தீர்வு: சிங்கிள்டன் முறையானது, வகுப்பையே அதன் சொந்தப் பொருள் உருவாக்கத்திற்குப் பொறுப்பாக்குவதன் மூலம் இதைத் தீர்க்கிறது. இது பொதுவாக நேரடி உருவாக்கத்தைத் தடுக்க ஒரு தனிப்பட்ட கட்டமைப்பாளரையும் (private constructor) மற்றும் அந்த ஒரே ஒரு பொருளைத் திருப்பியளிக்கும் ஒரு நிலையான முறையையும் (static method) உள்ளடக்கியது.

நடைமுறைச் செயலாக்கம் (பைத்தான் உதாரணம்):

ஒரு பயன்பாட்டிற்கான உள்ளமைவு மேலாளரை மாதிரியாகக் கொள்வோம். அமைப்புகளை நிர்வகிக்க எப்போதும் ஒரே ஒரு பொருள் மட்டுமே இருக்க வேண்டும்.


class ConfigurationManager:
    _instance = None

    # ஒரு பொருளை உருவாக்கும் போது __init__ க்கு முன் __new__ முறை அழைக்கப்படுகிறது.
    # உருவாக்கும் செயல்முறையைக் கட்டுப்படுத்த நாம் இதை மேலெழுதுகிறோம்.
    def __new__(cls):
        if cls._instance is None:
            print('ஒரே ஒரு பொருளை உருவாக்குகிறேன்...')
            cls._instance = super(ConfigurationManager, cls).__new__(cls)
            # அமைப்புகளை இங்கே தொடங்கவும், எ.கா., ஒரு கோப்பிலிருந்து ஏற்றுதல்
            cls._instance.settings = {"api_key": "ABC12345", "timeout": 30}
        return cls._instance

    def get_setting(self, key):
        return self.settings.get(key)

# --- கிளையன்ட் குறியீடு ---
manager1 = ConfigurationManager()
print(f"மேலாளர் 1 API கீ: {manager1.get_setting('api_key')}")

manager2 = ConfigurationManager()
print(f"மேலாளர் 2 API கீ: {manager2.get_setting('api_key')}")

# இரண்டு மாறிகளும் ஒரே பொருளையே சுட்டுகின்றனவா எனச் சரிபார்க்கவும்
print(f"மேலாளர் 1 மற்றும் மேலாளர் 2 ஒரே பொருளா? {manager1 is manager2}")

# வெளியீடு:
# ஒரே ஒரு பொருளை உருவாக்குகிறேன்...
# மேலாளர் 1 API கீ: ABC12345
# மேலாளர் 2 API கீ: ABC12345
# மேலாளர் 1 மற்றும் மேலாளர் 2 ஒரே பொருளா? True

உலகளாவியக் கருத்தாய்வுகள்: ஒரு பன்னூலிழைச் சூழலில் (multi-threaded environment), மேலே உள்ள எளிய செயலாக்கம் தோல்வியடையக்கூடும். இரண்டு நூலிழைகள் ஒரே நேரத்தில் `_instance` என்பது `None` ஆ எனச் சரிபார்க்கலாம், இரண்டும் அது உண்மை எனக் கண்டறிந்து, இரண்டுமே ஒரு பொருளை உருவாக்கலாம். இதை நூலிழை-பாதுகாப்பானதாக (thread-safe) மாற்ற, நீங்கள் ஒரு பூட்டுதல் பொறிமுறையைப் (locking mechanism) பயன்படுத்த வேண்டும். இது உலகளவில் பயன்படுத்தப்படும் உயர் செயல்திறன், ஒரேநேரப் பயன்பாடுகளுக்கு ஒரு முக்கியமான கருத்தாகும்.

2. ஃபேக்டரி முறை பேட்டர்ன்: பொருள் உருவாக்கத்தை ஒப்படைத்தல்

சிக்கல்: உங்களிடம் ஒரு வகுப்பு உள்ளது, அது பொருட்களை உருவாக்க வேண்டும், ஆனால் தேவைப்படும் பொருட்களின் சரியான வகுப்பை அதனால் கணிக்க முடியாது. இந்தப் பொறுப்பை அதன் துணை வகுப்புகளுக்கு ஒப்படைக்க நீங்கள் விரும்புகிறீர்கள்.

தீர்வு: ஒரு பொருளை உருவாக்குவதற்கான ஒரு இடைமுகத்தை அல்லது சுருக்க வகுப்பை ("ஃபேக்டரி முறை") வரையறுக்கவும், ஆனால் எந்த உறுதியான வகுப்பை உருவாக்க வேண்டும் என்பதைத் துணை வகுப்புகள் தீர்மானிக்கட்டும். இது கிளையன்ட் குறியீட்டை அது உருவாக்க வேண்டிய உறுதியான வகுப்புகளிலிருந்து பிரிக்கிறது.

நடைமுறைச் செயலாக்கம் (பைத்தான் உதாரணம்):

ஒரு போக்குவரத்து நிறுவனம் வெவ்வேறு வகையான போக்குவரத்து வாகனங்களை உருவாக்க வேண்டும் என்று கற்பனை செய்து பாருங்கள். முக்கிய போக்குவரத்துப் பயன்பாடு `Truck` அல்லது `Ship` வகுப்புகளுடன் நேரடியாகப் பிணைக்கப்படக்கூடாது.


from abc import ABC, abstractmethod

# தயாரிப்பு இடைமுகம் (Product Interface)
class Transport(ABC):
    @abstractmethod
    def deliver(self, destination):
        pass

# உறுதியான தயாரிப்புகள் (Concrete Products)
class Truck(Transport):
    def deliver(self, destination):
        return f"ஒரு டிரக்கில் தரைவழியாக {destination}க்கு வழங்கப்படுகிறது."

class Ship(Transport):
    def deliver(self, destination):
        return f"ஒரு கொள்கலன் கப்பலில் கடல் வழியாக {destination}க்கு வழங்கப்படுகிறது."

# உருவாக்குபவர் (Creator) (சுருக்க வகுப்பு)
class Logistics(ABC):
    @abstractmethod
    def create_transport(self) -> Transport:
        pass

    def plan_delivery(self, destination):
        transport = self.create_transport()
        result = transport.deliver(destination)
        print(result)

# உறுதியான உருவாக்குபவர்கள் (Concrete Creators)
class RoadLogistics(Logistics):
    def create_transport(self) -> Transport:
        return Truck()

class SeaLogistics(Logistics):
    def create_transport(self) -> Transport:
        return Ship()

# --- கிளையன்ட் குறியீடு ---
def client_code(logistics_provider: Logistics, destination: str):
    logistics_provider.plan_delivery(destination)

print("பயன்பாடு: சாலைப் போக்குவரத்துடன் தொடங்கப்பட்டது.")
client_code(RoadLogistics(), "நகர மையம்")

print("\nபயன்பாடு: கடல் போக்குவரத்துடன் தொடங்கப்பட்டது.")
client_code(SeaLogistics(), "சர்வதேச துறைமுகம்")

செயல்படுத்தக்கூடிய நுண்ணறிவு: ஃபேக்டரி முறை பேட்டர்ன் உலகெங்கிலும் பயன்படுத்தப்படும் பல கட்டமைப்புகள் மற்றும் நூலகங்களின் அடித்தளமாகும். இது தெளிவான விரிவாக்கப் புள்ளிகளை வழங்குகிறது, மற்ற டெவலப்பர்கள் கட்டமைப்பின் முக்கிய குறியீட்டை மாற்றாமல் புதிய செயல்பாடுகளை (எ.கா., `AirLogistics` ஒரு `Plane` பொருளை உருவாக்குதல்) சேர்க்க அனுமதிக்கிறது.

ஆழமான பார்வை: கட்டமைப்பு முறைகளைச் செயல்படுத்துதல்

கட்டமைப்பு முறைகள், பெரிய, நெகிழ்வான கட்டமைப்புகளை உருவாக்க பொருட்கள் மற்றும் வகுப்புகள் எவ்வாறு இணைக்கப்படுகின்றன என்பதில் கவனம் செலுத்துகின்றன.

1. அடாப்டர் முறை: பொருந்தாத இடைமுகங்களை ஒன்றாக வேலை செய்ய வைத்தல்

சிக்கல்: ஏற்கனவே உள்ள ஒரு வகுப்பை (`Adaptee`) நீங்கள் பயன்படுத்த விரும்புகிறீர்கள், ஆனால் அதன் இடைமுகம் உங்கள் கணினியின் மற்ற குறியீடுகளுடன் (`Target` இடைமுகம்) பொருந்தவில்லை. அடாப்டர் முறை ஒரு பாலமாகச் செயல்படுகிறது.

தீர்வு: உங்கள் கிளையன்ட் குறியீடு எதிர்பார்க்கும் `Target` இடைமுகத்தைச் செயல்படுத்தும் ஒரு உறை வகுப்பை (`Adapter`) உருவாக்கவும். உள்ளுக்குள், அடாப்டர் இலக்கு இடைமுகத்திலிருந்து வரும் அழைப்புகளை அடாப்டீயின் இடைமுகத்திற்கான அழைப்புகளாக மொழிபெயர்க்கிறது. இது சர்வதேச பயணத்திற்கான ஒரு உலகளாவிய பவர் அடாப்டரின் மென்பொருள் சமமானதாகும்.

நடைமுறைச் செயலாக்கம் (பைத்தான் உதாரணம்):

உங்கள் பயன்பாடு அதன் சொந்த `Logger` இடைமுகத்துடன் செயல்படுகிறது என்று கற்பனை செய்து பாருங்கள், ஆனால் நீங்கள் வேறுபட்ட முறை-பெயரிடும் மரபு கொண்ட ஒரு பிரபலமான மூன்றாம் தரப்பு பதிவு நூலகத்தை ஒருங்கிணைக்க விரும்புகிறீர்கள்.


# இலக்கு இடைமுகம் (Target Interface) (நமது பயன்பாடு பயன்படுத்துவது)
class AppLogger:
    def log_message(self, severity, message):
        raise NotImplementedError

# அடாப்டீ (Adaptee) (பொருந்தாத இடைமுகத்துடன் கூடிய மூன்றாம் தரப்பு நூலகம்)
class ThirdPartyLogger:
    def write_log(self, level, text):
        print(f"ThirdPartyLog [{level.upper()}]: {text}")

# அடாப்டர்
class LoggerAdapter(AppLogger):
    def __init__(self, external_logger: ThirdPartyLogger):
        self._external_logger = external_logger

    def log_message(self, severity, message):
        # இடைமுகத்தை மொழிபெயர்க்கவும்
        self._external_logger.write_log(severity, message)

# --- கிளையன்ட் குறியீடு ---
def run_app_tasks(logger: AppLogger):
    logger.log_message("info", "பயன்பாடு தொடங்குகிறது.")
    logger.log_message("error", "ஒரு சேவையுடன் இணைப்பதில் தோல்வி.")

# நாம் அடாப்டீயை உருவாக்கி அதை நமது அடாப்டரில் இணைக்கிறோம்
third_party_logger = ThirdPartyLogger()
adapter = LoggerAdapter(third_party_logger)

# நமது பயன்பாடு இப்போது அடாப்டர் வழியாக மூன்றாம் தரப்பு லாகரைப் பயன்படுத்தலாம்
run_app_tasks(adapter)

உலகளாவிய சூழல்: இந்த முறை உலகமயமாக்கப்பட்ட தொழில்நுட்பச் சூழலில் இன்றியமையாதது. இது பல்வேறு சர்வதேச கட்டண நுழைவாயில்களை (PayPal, Stripe, Adyen), கப்பல் வழங்குநர்கள் அல்லது பிராந்திய கிளவுட் சேவைகளை இணைப்பது போன்ற வேறுபட்ட அமைப்புகளை ஒருங்கிணைக்கத் தொடர்ந்து பயன்படுத்தப்படுகிறது, ஒவ்வொன்றும் அதன் தனித்துவமான API-யைக் கொண்டுள்ளது.

2. டெக்கரேட்டர் முறை: பொறுப்புகளை மாறும் வகையில் சேர்த்தல்

சிக்கல்: நீங்கள் ஒரு பொருளுக்குப் புதிய செயல்பாட்டைச் சேர்க்க வேண்டும், ஆனால் மரபுரிமையைப் (inheritance) பயன்படுத்த விரும்பவில்லை. துணைவகுப்பு முறை நெகிழ்வற்றதாகவும், நீங்கள் பல செயல்பாடுகளை இணைக்க வேண்டியிருந்தால் (எ.கா., `CompressedAndEncryptedFileStream` மற்றும் `EncryptedAndCompressedFileStream`) ஒரு "வகுப்பு வெடிப்புக்கு" வழிவகுக்கும்.

தீர்வு: டெக்கரேட்டர் முறை, பொருட்களைச் சிறப்பு உறைப் பொருட்களுக்குள் வைப்பதன் மூலம் புதிய நடத்தைகளை இணைக்க உங்களை அனுமதிக்கிறது. இந்த உறைகள் அவை மூடியிருக்கும் பொருட்களின் அதே இடைமுகத்தைக் கொண்டுள்ளன, எனவே நீங்கள் ஒன்றன் மேல் ஒன்றாகப் பல டெக்கரேட்டர்களை அடுக்கலாம்.

நடைமுறைச் செயலாக்கம் (பைத்தான் உதாரணம்):

ஒரு அறிவிப்பு அமைப்பை உருவாக்குவோம். நாம் ஒரு எளிய அறிவிப்புடன் தொடங்கி, பின்னர் அதை SMS மற்றும் Slack போன்ற கூடுதல் சேனல்களுடன் அலங்கரிப்போம்.


# கூறு இடைமுகம் (Component Interface)
class Notifier:
    def send(self, message):
        raise NotImplementedError

# உறுதியான கூறு (Concrete Component)
class EmailNotifier(Notifier):
    def send(self, message):
        print(f"மின்னஞ்சல் அனுப்புகிறது: {message}")

# அடிப்படை டெக்கரேட்டர் (Base Decorator)
class BaseNotifierDecorator(Notifier):
    def __init__(self, wrapped_notifier: Notifier):
        self._wrapped = wrapped_notifier

    def send(self, message):
        self._wrapped.send(message)

# உறுதியான டெக்கரேட்டர்கள் (Concrete Decorators)
class SMSDecorator(BaseNotifierDecorator):
    def send(self, message):
        super().send(message)
        print(f"SMS அனுப்புகிறது: {message}")

class SlackDecorator(BaseNotifierDecorator):
    def send(self, message):
        super().send(message)
        print(f"Slack செய்தி அனுப்புகிறது: {message}")

# --- கிளையன்ட் குறியீடு ---
# ஒரு அடிப்படை மின்னஞ்சல் அறிவிப்பாளருடன் தொடங்கவும்
notifier = EmailNotifier()

# இப்போது, ஒரு SMS அனுப்பவும் இதை அலங்கரிப்போம்
notifier_with_sms = SMSDecorator(notifier)
print("--- மின்னஞ்சல் + SMS உடன் அறிவித்தல் ---")
notifier_with_sms.send("கணினி எச்சரிக்கை: ഗുരുതരமான தோல்வி!")

# அதன் மேல் ஸ்லாக்கையும் சேர்ப்போம்
full_notifier = SlackDecorator(notifier_with_sms)
print("\n--- மின்னஞ்சல் + SMS + Slack உடன் அறிவித்தல் ---")
full_notifier.send("கணினி மீண்டது.")

செயல்படுத்தக்கூடிய நுண்ணறிவு: டெக்கரேட்டர்கள் விருப்ப அம்சங்களைக் கொண்ட அமைப்புகளை உருவாக்கப் சரியானவை. எழுத்துப்பிழை சரிபார்ப்பு, தொடரியல் சிறப்பம்சங்கள் மற்றும் தானியங்கு நிறைவு போன்ற அம்சங்கள் பயனரால் மாறும் வகையில் சேர்க்கப்படக்கூடிய அல்லது அகற்றப்படக்கூடிய ஒரு உரை திருத்தியைச் சிந்தியுங்கள். இது மிகவும் கட்டமைக்கக்கூடிய மற்றும் நெகிழ்வான பயன்பாடுகளை உருவாக்குகிறது.

ஆழமான பார்வை: நடத்தை முறைகளைச் செயல்படுத்துதல்

நடத்தை முறைகள், பொருட்கள் எவ்வாறு தொடர்பு கொள்கின்றன மற்றும் பொறுப்புகளை ஒதுக்குகின்றன என்பதைப் பற்றியது, அவற்றின் தொடர்புகளை மேலும் நெகிழ்வானதாகவும் தளர்வாக இணைக்கப்பட்டதாகவும் ஆக்குகிறது.

1. அப்சர்வர் முறை: பொருட்களைத் தகவலறிந்து வைத்திருத்தல்

சிக்கல்: உங்களிடம் பொருட்களுக்கு இடையே ஒன்று-பல உறவு உள்ளது. ஒரு பொருள் (`Subject`) அதன் நிலையை மாற்றும்போது, அதன் அனைத்து சார்புடையவைகளும் (`Observers`) தானாகவே அறிவிக்கப்பட்டுப் புதுப்பிக்கப்பட வேண்டும், ஆனால் பொருள் (Subject) அதன் சார்புடையவைகளின் (Observers) உறுதியான வகுப்புகளைப் பற்றி அறிய வேண்டியதில்லை.

தீர்வு: `Subject` பொருள் அதன் `Observer` பொருட்களின் பட்டியலைப் பராமரிக்கிறது. இது அப்சர்வர்களை இணைக்கவும் பிரிக்கவும் முறைகளை வழங்குகிறது. ஒரு நிலை மாற்றம் ஏற்படும்போது, சப்ஜெக்ட் அதன் அப்சர்வர்கள் மூலம் மீண்டும் மீண்டும் சென்று ஒவ்வொன்றிலும் ஒரு `update` முறையை அழைக்கிறது.

நடைமுறைச் செயலாக்கம் (பைத்தான் உதாரணம்):

ஒரு உன்னதமான உதாரணம், பல்வேறு ஊடக நிறுவனங்களுக்கு (அப்சர்வர்கள்) செய்தித் துணுக்குகளை அனுப்பும் ஒரு செய்தி நிறுவனம் (சப்ஜெக்ட்).


# பொருள் (Subject) (அல்லது வெளியீட்டாளர்)
class NewsAgency:
    def __init__(self):
        self._observers = []
        self._latest_news = None

    def attach(self, observer):
        self._observers.append(observer)

    def detach(self, observer):
        self._observers.remove(observer)

    def notify(self):
        for observer in self._observers:
            observer.update(self)

    def add_news(self, news):
        self._latest_news = news
        self.notify()

    def get_news(self):
        return self._latest_news

# அப்சர்வர் இடைமுகம் (Observer Interface)
class Observer(ABC):
    @abstractmethod
    def update(self, subject: NewsAgency):
        pass

# உறுதியான அப்சர்வர்கள் (Concrete Observers)
class Website(Observer):
    def update(self, subject: NewsAgency):
        news = subject.get_news()
        print(f"இணையதளக் காட்சி: முக்கியச் செய்தி! {news}")

class NewsChannel(Observer):
    def update(self, subject: NewsAgency):
        news = subject.get_news()
        print(f"நேரலை டிவி டிக்கர்: ++ {news} ++")

# --- கிளையன்ட் குறியீடு ---
agency = NewsAgency()

website = Website()
agency.attach(website)

news_channel = NewsChannel()
agency.attach(news_channel)

agency.add_news("புதிய தொழில்நுட்ப அறிவிப்பால் உலகச் சந்தைகள் உயர்வு.")

agency.detach(website)
print("\n--- இணையதளம் சந்தாவை ரத்து செய்துள்ளது ---")
agency.add_news("உள்ளூர் வானிலை அறிக்கை: கனமழை எதிர்பார்க்கப்படுகிறது.")

உலகளாவியப் பொருத்தம்: அப்சர்வர் முறை நிகழ்வு-சார்ந்த கட்டமைப்புகள் மற்றும் எதிர்வினை நிரலாக்கத்தின் முதுகெலும்பாகும். நவீன பயனர் இடைமுகங்களை (எ.கா., React அல்லது Angular போன்ற கட்டமைப்புகளில்), நிகழ்நேர தரவு டாஷ்போர்டுகள் மற்றும் உலகளாவிய பயன்பாடுகளுக்கு ஆற்றலளிக்கும் பரவலாக்கப்பட்ட நிகழ்வு-ஆதார அமைப்புகளை உருவாக்க இது அடிப்படையானது.

2. ஸ்ட்ரேட்டஜி முறை: நெறிமுறைகளை உள்ளடக்குதல்

சிக்கல்: உங்களிடம் தொடர்புடைய நெறிமுறைகளின் ஒரு குடும்பம் உள்ளது (எ.கா., தரவை வரிசைப்படுத்த அல்லது ஒரு மதிப்பைக் கணக்கிட வெவ்வேறு வழிகள்), மற்றும் அவற்றை ஒன்றுக்கொன்று மாற்றக்கூடியதாக மாற்ற விரும்புகிறீர்கள். இந்த நெறிமுறைகளைப் பயன்படுத்தும் கிளையன்ட் குறியீடு எந்தவொரு குறிப்பிட்ட ஒன்றுடனும் இறுக்கமாக இணைக்கப்படக்கூடாது.

தீர்வு: அனைத்து நெறிமுறைகளுக்கும் ஒரு பொதுவான இடைமுகத்தை (`Strategy`) வரையறுக்கவும். கிளையன்ட் வகுப்பு (`Context`) ஒரு ஸ்ட்ரேட்டஜி பொருளுக்கான குறிப்பைப் பராமரிக்கிறது. சூழல் (Context) நடத்தையைத் தானே செயல்படுத்துவதற்குப் பதிலாக, ஸ்ட்ரேட்டஜி பொருளுக்கு வேலையை ஒப்படைக்கிறது. இது நெறிமுறையை இயக்க நேரத்தில் (runtime) தேர்ந்தெடுக்கவும் மாற்றவும் அனுமதிக்கிறது.

நடைமுறைச் செயலாக்கம் (பைத்தான் உதாரணம்):

பல்வேறு சர்வதேச கேரியர்களின் அடிப்படையில் கப்பல் செலவுகளைக் கணக்கிட வேண்டிய ஒரு இ-காமர்ஸ் செக்அவுட் அமைப்பைக் கவனியுங்கள்.


# ஸ்ட்ரேட்டஜி இடைமுகம் (Strategy Interface)
class ShippingStrategy(ABC):
    @abstractmethod
    def calculate(self, order_weight_kg):
        pass

# உறுதியான ஸ்ட்ரேட்டஜிகள் (Concrete Strategies)
class ExpressShipping(ShippingStrategy):
    def calculate(self, order_weight_kg):
        return order_weight_kg * 5.0 # ஒரு கிலோவுக்கு $5.00

class StandardShipping(ShippingStrategy):
    def calculate(self, order_weight_kg):
        return order_weight_kg * 2.5 # ஒரு கிலோவுக்கு $2.50

class InternationalShipping(ShippingStrategy):
    def calculate(self, order_weight_kg):
        return 15.0 + (order_weight_kg * 7.0) # $15.00 அடிப்படை + ஒரு கிலோவுக்கு $7.00

# சூழல் (Context)
class Order:
    def __init__(self, weight, shipping_strategy: ShippingStrategy):
        self.weight = weight
        self._strategy = shipping_strategy

    def set_strategy(self, shipping_strategy: ShippingStrategy):
        self._strategy = shipping_strategy

    def get_shipping_cost(self):
        cost = self._strategy.calculate(self.weight)
        print(f"ஆர்டர் எடை: {self.weight}கி.கி. யுக்தி: {self._strategy.__class__.__name__}. செலவு: ${cost:.2f}")
        return cost

# --- கிளையன்ட் குறியீடு ---
order = Order(weight=2, shipping_strategy=StandardShipping())
order.get_shipping_cost()

print("\nவாடிக்கையாளர் வேகமான கப்பல் போக்குவரத்தை விரும்புகிறார்...")
order.set_strategy(ExpressShipping())
order.get_shipping_cost()

print("\nமற்றொரு நாட்டிற்கு அனுப்புகிறது...")
order.set_strategy(InternationalShipping())
order.get_shipping_cost()

செயல்படுத்தக்கூடிய நுண்ணறிவு: இந்த முறை பொருள்-நோக்கு வடிவமைப்பின் SOLID கொள்கைகளில் ஒன்றான திறந்த/மூடிய கொள்கையை (Open/Closed Principle) வலுவாக ஊக்குவிக்கிறது. `Order` வகுப்பு விரிவாக்கத்திற்குத் திறந்திருக்கிறது (நீங்கள் `DroneDelivery` போன்ற புதிய கப்பல் யுக்திகளைச் சேர்க்கலாம்) ஆனால் மாற்றத்திற்கு மூடப்பட்டுள்ளது (`Order` வகுப்பை நீங்கள் ஒருபோதும் மாற்ற வேண்டியதில்லை). புதிய போக்குவரத்து கூட்டாளர்கள் மற்றும் பிராந்திய விலை விதிகளுக்கு தொடர்ந்து மாற்றியமைக்க வேண்டிய பெரிய, வளர்ந்து வரும் இ-காமர்ஸ் தளங்களுக்கு இது மிகவும் முக்கியமானது.

வடிவமைப்பு முறைகளைச் செயல்படுத்துவதற்கான சிறந்த நடைமுறைகள்

சக்தி வாய்ந்ததாக இருந்தாலும், வடிவமைப்பு முறைகள் ஒரு வெள்ளித் தோட்டா அல்ல. அவற்றை தவறாகப் பயன்படுத்துவது அதிகப்படியான பொறியியல் மற்றும் தேவையற்ற சிக்கலான குறியீட்டிற்கு வழிவகுக்கும். இதோ சில வழிகாட்டும் கொள்கைகள்:

முடிவுரை: வரைபடத்திலிருந்து ஒரு தலைசிறந்த படைப்பு வரை

பொருள்-நோக்கு வடிவமைப்பு முறைகள் வெறும் கல்விசார் கருத்துக்களை விட மேலானவை; அவை காலத்தின் சோதனையைத் தாங்கும் மென்பொருளை உருவாக்குவதற்கான ஒரு நடைமுறைக் கருவித்தொகுப்பாகும். அவை உலகளாவிய குழுக்களைத் திறம்பட ஒத்துழைக்க அதிகாரம் அளிக்கும் ஒரு பொதுவான மொழியை வழங்குகின்றன, மேலும் அவை மென்பொருள் கட்டமைப்பின் தொடர்ச்சியான சவால்களுக்கு நிரூபிக்கப்பட்ட தீர்வுகளை வழங்குகின்றன. கூறுகளைப் பிரிப்பதன் மூலமும், நெகிழ்வுத்தன்மையை ஊக்குவிப்பதன் மூலமும், சிக்கலை நிர்வகிப்பதன் மூலமும், அவை உறுதியான, விரிவாக்கக்கூடிய மற்றும் பராமரிக்கக்கூடிய அமைப்புகளை உருவாக்க உதவுகின்றன.

இந்த முறைகளில் தேர்ச்சி பெறுவது ஒரு பயணம், ஒரு இலக்கு அல்ல. நீங்கள் தற்போது எதிர்கொள்ளும் ஒரு சிக்கலைத் தீர்க்கும் ஒன்று அல்லது இரண்டு முறைகளைக் கண்டறிந்து தொடங்குங்கள். அவற்றைச் செயல்படுத்தி, அவற்றின் தாக்கத்தைப் புரிந்துகொண்டு, படிப்படியாக உங்கள் திறமையை விரிவுபடுத்துங்கள். கட்டமைப்பு அறிவில் செய்யப்படும் இந்த முதலீடு, ஒரு டெவலப்பர் செய்யக்கூடிய மிகவும் மதிப்புமிக்க ஒன்றாகும், இது நமது சிக்கலான மற்றும் ஒன்றோடொன்று இணைக்கப்பட்ட டிஜிட்டல் உலகில் ஒரு தொழில் வாழ்க்கை முழுவதும் பலனளிக்கும்.