मेरे पास एक बड़ी जावा परियोजना है, और हम अपने निर्माण चक्र के लिए मावेन का उपयोग करते हैं। इस एक परियोजना का बड़े पैमाने पर उपयोग किया जाता है - अन्य परियोजनाओं में, विभिन्न अनुप्रयोगों में, जिनमें से कुछ इसमें निहित हैं और कुछ जो अन्यत्र हैं ... ईमानदार होने के लिए, यह एक गड़बड़ है (विशिष्ट समय के लिए अलग-अलग समय पर जोड़े गए विभिन्न बिट्स) प्रयोजनों), और मैं इसे थोड़ा साफ करना चाहूंगा। इसके अलावा, यह पूरी तरह से परीक्षण नहीं किया गया है (बहुत सारे बिट्स को उचित इकाई और एकीकरण परीक्षण के बिना जोड़ा गया है), और कुछ परीक्षण ऐसे हैं जिन्हें चलाने में लंबा समय लगता है या वास्तव में पास नहीं होता है ... (उह-ओह) - तो परीक्षण मावेन बिल्ड चक्र (फिर, उह-ओह) में स्विच किए जाते हैं।
मैं इस बड़ी परियोजना को छोटे विशिष्ट परियोजनाओं में अलग करने के बारे में सोच रहा हूं, जैसे कि 'अंतिम' उप-परियोजना (या कई उप-परियोजनाएं) विभिन्न उप-परियोजनाओं को उठाएगा जिनकी इसे आवश्यकता होगी।
मेरी सोच इस प्रकार है:
- यदि मैं बड़ी परियोजना को विभिन्न उप-परियोजनाओं में अलग करता हूं, तो यह स्पष्ट करता है कि प्रत्येक परियोजना की जिम्मेदारी क्या है।
- उप-परियोजनाओं में अलग करके, मैं तब प्रत्येक उप-परियोजना के परीक्षण को व्यक्तिगत रूप से साफ कर सकता हूं, और मावेन बिल्ड चक्र में उस उप-परियोजना के लिए परीक्षण चालू कर सकता हूं।
मैं इस बात से थोड़ा चिंतित हूं कि निर्माण समय पर इसका क्या प्रभाव पड़ सकता है।
- बड़ी परियोजना (यानी छोटी उप-परियोजनाओं में) संरचना को लागू करने से कंपाइलर धीमा हो जाएगा?
इसके अलावा, मुझे इस बात पर थोड़ी चिंता है कि आईडीई में संपादन का समय क्या हो सकता है (हम मुख्य रूप से इंटेलीज का उपयोग करते हैं)। Intellij निर्भरता के पेड़ के माध्यम से बदले में प्रत्येक परियोजना का निर्माण करने के लिए लगता है - यानी अगर C B पर निर्भर करता है A, और मैं A को बदलता है, तो यह तब तक B बनाने का प्रयास नहीं करेगा जब तक कि A संकलन न हो जाए, और इसी तरह। यकीनन यह लाभप्रद है, लेकिन मैंने पाया है कि अगर - उदाहरण के लिए, मैं ए में एक इंटरफ़ेस बदलता हूं जिसका व्यापक रूप से बी और सी में उपयोग किया जाता है, तो उस परिवर्तन से सभी त्रुटियों को ठीक करने में कुछ समय लगता है ...
एक और सवाल यह है कि फैक्ट्री कक्षाओं का उपयोग कैसे किया जाए। परियोजना के कुछ पहलू बाहरी जार पर निर्भर करते हैं। कभी-कभी (शुक्र है कि अक्सर नहीं) ये अपडेट किए जाते हैं, और हमें पलायन करना होगा। हम एक फैक्ट्री क्लास का उपयोग करके इसे संभालते हैं जो बाहरी कोड के सही संस्करणों की ओर इशारा करता है (इसलिए हमें पूरे कोड बेस में सभी कार्यान्वयन को बदलने की आवश्यकता नहीं है)।
फिलहाल यह सब बड़ी परियोजना में है, लेकिन मैं सोच रहा हूं कि उप-परियोजनाओं पर स्विच करके, मैं नए बाहरी कोड के कार्यान्वयन के लिए एक नई परियोजना विकसित कर सकता हूं, सुनिश्चित करें कि उप-परियोजना पूरी तरह कार्यात्मक और परीक्षण की गई है, और फिर उपयोगकर्ता प्रोजेक्ट में निर्भरता / फ़ैक्टरी वर्ग को स्विच करें। हालांकि, बड़े प्रोजेक्ट के दौरान इंटरफेस के व्यापक उपयोग से इसे और अधिक जटिल बना दिया जाता है। उदाहरण के लिए
- उप-परियोजना ए - में इंटरफेस है
- उप-प्रोजेक्ट बी - इंटरफेस और पुराने बाहरी जार के लिए ए पर निर्भर करता है
- उप-परियोजना सी - बी पर निर्भर करता है (और इस तरह ए और पुराने बाहरी जार), और इसमें एक कारखाना वर्ग शामिल है जो बी के कार्यान्वयन के इंटरफेस का उपयोग करता है
अगर मुझे B के बाहरी जार को बदलने की आवश्यकता है, तो मैं कर सकता हूं:
- उप-प्रोजेक्ट B_ii बनाएं - फिर से A पर निर्भर करता है, और अब नया बाहरी जार
- एक बार पूरी तरह कार्यात्मक होने के बाद, मैं B_ii में C की निर्भरता जोड़ सकता हूं, और इंटरफेस के नए कार्यान्वयन का उपयोग करने के लिए फ़ैक्टरी वर्ग को बदल सकता हूं।
जब यह सब काम कर रहा है, तो मैं मूल बी में सी की निर्भरता को हटा सकता हूं, और यदि वांछित हो, तो उप-परियोजना बी को हटा दें।
क्या इस बारे में जाने का एक समझदार तरीका है?
तो, सामान्य तौर पर, मेरे प्रश्न हैं:
- क्या किसी के पास बड़ी परियोजनाओं को तोड़ने का कोई अनुभव नहीं है? क्या कोई सुझाव / तरकीब है जिसे आप साझा करने के लिए तैयार होंगे?
- आपके विकास और निर्माण समय पर इसका क्या प्रभाव पड़ा?
- ऐसी परियोजना के टूटने की संरचना पर आप क्या सलाह दे सकते हैं?