पीएचपी OOP डिजाइन - विशिष्ट बच्चे कक्षाओं के लिए मानकों को सीमित करते हुए सामान्य इंटरफेस

Question

को लागू करने मैं अक्सर करते हैं पीएचपी परियोजनाओं वेब पृष्ठों से श्रेणीबद्ध स्क्रैप डेटा और उन्हें डीबी (अनिवार्य रूप से, संरचना के आंकड़ों के बचाने के लिए डिज़ाइन किया गया - लगता है scraping सरकारी वेबसाइटों की क्या ज़रूरत है कि डेटा, लेकिन इसे संरचित तरीके से प्रदान न करें)। मामले में मूल वेब पेज में परिवर्तन

की आसान एक्सटेंशन को अनुमति दें

• आसानी से नए लोगों को साथ वर्तमान HTML पार्स स्क्रिप्ट की जगह,: हर बार, मैं एक OOP डिजाइन कि मेरा पीछा प्राप्त करने की अनुमति होगी आने की कोशिश डेटा स्क्रैप और सहेजा गया, क्योंकि ये परियोजनाएं दूसरों के लिए लेने और बनाने के लिए भी हैं। मेरा लक्ष्य "आधार" डेटा एकत्र करना है, जबकि अन्य कुछ अतिरिक्त शामिल करने का निर्णय ले सकते हैं, इसे सहेजने के तरीके को बदल सकते हैं और आदि

अभी तक मुझे समाधान मिल गया है, लेकिन निकटतम मुझे मिला यह कुछ इस तरह:

मैं डेटा कंटेनर है कि आम पेड़ traversing कार्यों को लागू होता है के लिए एक अमूर्त वर्ग को परिभाषित:

abstract class DataContainer { 

    protected $parent = NULL; 
    protected $children = NULL; 

    public function getParent() { 
    return $this->parent; 
    } 

    public function getChildren() { 
    return $this->children; 
    }    
} 

और फिर मैं वास्तविक डेटा कंटेनरों की है। कल्पना कीजिए, मैं संसदीय सत्रों में "बैठे बैठे" स्तर पर भागीदारी पर डेटा स्क्रैप कर रहा हूं। मेरे पास SessionContainer, SittingContainer, QuestionContainer होगा जो सभी DataContainer का विस्तार करेंगे।

प्रत्येक सत्र, बैठे और प्रश्न डेटा को एक अलग यूआरएल से हटा दिया जाता है। यूआरएल सामग्री को अलग करने के तंत्र को छोड़कर, मान लीजिए कि मुझे स्क्रैपर कक्षाएं चाहिए, जो वास्तविक पार्सिंग के लिए कंटेनर और डीओएमडी दस्तावेज़ ले लेंगे। फिर सत्र के प्रत्येक

interface Scraper { 
    public function scrapeData(DOMDocument $Dom, DataContainer $DataContainer); 
} 

, बैठे और सवाल अपने स्वयं के स्क्रेपर्स, जो इंटरफ़ेस को लागू करना होगा: तो मैं इस तरह एक सामान्य इंटरफेस को परिभाषित करेगा। लेकिन मैं यह भी सुनिश्चित करना चाहता हूं कि वे केवल उन कंटेनरों को स्वीकार कर सकें जिनके लिए वे हैं। तो यह देखने के लिए की तरह होगा:

class SessionScraper implements Scraper { 
    public function scrapeData(DOMDocument $DOM, SessionContainer $DataContainer) { 
    } 
} 

अंत में, मैं एक सामान्य Factory वर्ग भी स्क्रैपर इंटरफ़ेस लागू करता है और सिर्फ प्रासंगिक स्क्रेपर्स के लिए scraping वितरित करता होगा। इस तरह:

public function scrapeData(DOMDocument $DOM, DataContainer $DataContainer) { 
    //get the scraper from configuration array 
    $class = $this->config[get_class($DataContainer)]; 
    $craper = new $class(); 
    $class->scrapeData($DOM, $DataContainer); 
} 

यह वह वर्ग है जिसे वास्तव में कोड में बुलाया जाएगा। इसी तरह, मैं डीबी को बचाने के साथ सौदा कर सकता था - प्रत्येक डेटा कंटेनर में इसकी डीबीएसएवर कक्षा हो सकती है, जो डीबीएसवर इंटरफ़ेस को कार्यान्वित करेगी। दोबारा, सभी कॉल Factory कक्षा के माध्यम से की जा सकती हैं, जो डीबीएसएवर इंटरफेस को भी लागू करेगी।

सबकुछ सही होगा, लेकिन समस्या यह है कि इंटरफ़ेस को लागू करने वाले वर्गों को इंटरफ़ेस के सटीक हस्ताक्षर को लागू करना चाहिए। जैसे विधि SessionScraper::scrapeDataकेवलSessionContainer वस्तुओं स्वीकार नहीं कर सकते, यह सब DataContainer वस्तुओं स्वीकार करना चाहिए। लेकिन इसका मतलब यह नहीं है!

अंत में, सवाल:

• मेरी डिजाइन गलत है और मैं एक पूरी तरह से अलग तरीके से सब कुछ की संरचना की जानी चाहिए? (किस तरह?), या:
• मेरे डिजाइन ठीक है, यह सिर्फ है कि मैं प्रकार typehinting के माध्यम से इसे लागू करने के बजाय instanceof और इसी तरह के चेक के तरीकों के भीतर लागू करने की आवश्यकता है? सभी सुझावों/आलोचनाओं के लिए पहले से

धन्यवाद। अगर आवश्यक हो तो मैं इस कोड को अपने सिर पर उलझाने से पूरी तरह से खुश हूं! आंख में

Answer 1

Container स्प्रिंग्स। यह नाम बहुत सामान्य है, आपको कुछ और गतिशील की आवश्यकता हो सकती है। मुझे लगता है कि आपके पास Data है और आप classify हैं, इसलिए इसमें type है।

बजाय आप प्रकार हिंट करने में सटीक इंटरफ़ेस हार्डकोड, तो आप इस गतिशील रूप से हल करना चाहिए।

तो अब प्रत्येक Container एक type होगा, Scraper संकेत/बता चाहे या नहीं यह Container की type के लिए लागू है सकता है।

scraping के ठोस रूप वास्तव में रणनीति आप विशिष्ट डेटा यह पार्स करने के लिए के लिए इस्तेमाल करते हैं। आपका कंटेनर encapsulates इस रणनीति सामान्यीकृत डेटा के लिए एक इंटरफ़ेस प्रदान करता है।

तुम बस केवल Container और Scraper के बीच कुछ तर्क/अनुबंध को जोड़ने के लिए इतना है कि वे एक दूसरे से बात कर सकते हैं की जरूरत है। यह अनुबंध आप दोनों के इंटरफ़ेस के अंदर रख सकते हैं।

इससे आपको Scraper भी मिल सकता है जो कि आप इसे खींचना चाहते हैं तो कई types से निपट सकते हैं।

अपने Container के लिए, एसपीएल में एक नज़र डालें, साथ ही आप कुछ इंटरफेस को लागू करते हैं ताकि आपके पास इटरेटर (और रिकर्सिव इटेटरेटर्स) उपलब्ध हों। यह सामान्य संरचना हो सकती है जिसका आप उल्लेख कर रहे हैं, और एसपीएल आपके Container कक्षाओं की उपयोगिता को बढ़ावा दे सकता है।

आप आप चीजों को गतिशील रख सकते और विशेष रूप से PHP में आप सामान्य रूप से रनटाइम पर चीजों को हल OOP में सब कुछ हार्डकोड करने की जरूरत नहीं है,।

यह भी आप आसान एक नए संस्करण के साथ Scrapers को बदलने के लिए अनुमति देगा। Scrapers अब परिभाषा के अनुसार एक प्रकार होगा (जैसा ऊपर बताया गया है), आप रनटाइम पर हल कर सकते हैं कि कंक्रीट क्लास को स्क्रैपिंग करना चाहिए, उदा। एक अच्छी फ़ाइल-सिस्टम संरचना में उन्हें .php फ़ाइल से गतिशील रूप से लोड करना।

बस मेरे 2 सेंट।