राक्षसी स्ट्रेट्स क्रियाओं से निपटने के लिए कैसे?

Question

मुझे स्ट्रैट्स 1.2.4 का उपयोग करके इस विशाल विरासत जावा वेब ऐप को विरासत में मिला। मेरे पास क्रियाओं के बारे में एक विशिष्ट सवाल है। अधिकांश पृष्ठों में बिल्कुल एक क्रिया होती है, और प्रक्रिया निष्पादन() विधियां घृणित राक्षस हैं (अनुरोध पैरामीटर के आधार पर बयान के बहुत लंबे और घोंसला घोंसला)।

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

1. क्या यह सही दिशा है?
2. क्या कोई मध्यवर्ती कदम है जो मैं ले सकता हूं, एक पैटर्न जो मोनोलिथिक कार्यों के अंदर गड़बड़ी से संबंधित है? शायद कार्रवाई के अंदर एक और कमांड पैटर्न?

Answer 1

इस से निपटने का मेरे तरीका होगा:

• न 'सब कुछ एक ही बार में' कर
• जब भी आप कुछ भी बदलने के लिए, की तुलना में आप पाया यह
  • जगह सशर्त, यह बेहतर छोड़ अलग-अलग कार्य कार्यान्वयन के साथ एक कदम है।
  • अभी तक बेहतर: अपने कार्यान्वयन कार्रवाई वर्गों से अलग ताकि आप इसे उपयोग कर सकते हैं जब आप चौखटे
  • बदलने Struts के लिए संदर्भ के बिना अपने नए आदेश कार्यान्वयन बिल्कुल रखें, इन कार्यान्वयन के आसपास आवरण के रूप में अपनी नई क्रियाओं का उपयोग करें।
  • आपको अपने स्ट्रैट्स एक्शनफॉर्म पर इंटरफेस प्रदान करने की आवश्यकता हो सकती है ताकि वे सभी डेटा कॉपी किए बिना उन्हें पास कर सकें। दूसरी ओर - आप ActionForms कि आम तौर पर तार का एक समूह रहे हैं के अलावा अन्य वस्तुओं के आसपास पारित करने के लिए चाहते हो सकता है
• नए & बेहतर प्रौद्योगिकी के लिए भागों की ओर पलायन शुरू (अपने अन्य प्रश्न के बारे में Struts 1.2 ActionForms देखें)। स्ट्रेट्स 1.2 बहुत अच्छा था जब यह निकला, लेकिन निश्चित रूप से वह नहीं है जिसे आप अनंत काल में समर्थन देना चाहते हैं। अब बेहतर ढांचे की कुछ पीढ़ियां हैं।

वहाँ निश्चित रूप से अधिक है - क्षमा करें, मैं समय यहाँ से बाहर चल रहा हूँ ...

Answer 2

कठिन समस्या लेकिन जल्दी वेब अनुप्रयोग विकास की विशिष्ट।

पहली चीजें सबसे पहले आपको यह सोचने की आवश्यकता है कि कौन सा तर्क व्यवसाय व्यवहार का गठन करता है, जो तर्क "प्रवाह" (यानी उपयोगकर्ता क्या देखता है) का गठन करता है, और जो तर्क उसे देखता है उसके लिए सामग्री प्राप्त करता है।

आपको कारखानों और इंटरफेस के मार्ग और नीचे जाने की ज़रूरत नहीं है; रेट्रोएक्टिव कार्यान्वयन बहुत कम उपयोगी है ... लेकिन व्यापार तर्क और डेटा पुनर्प्राप्ति तर्क को किसी तरह के प्रतिनिधियों में समेकित करना ... और उस तर्क की सफलता/विफलता के आधार पर पृष्ठ प्रवाह निर्धारित करने के लिए स्ट्रेट क्रियाओं को छोड़ना।

वहां से आप बस कुछ ही हफ्तों लेने के लिए और इसे बाहर पीसने

Answer 3

एक लंबे विधि करने के लिए है जब तक कि यह एक एकल स्विच बयान जहां मामलों में बहुत ही कम हैं (टोकन पार्स या कुछ और की तरह होता है, अच्छा नहीं है उस)।

आप कम से कम वर्णनात्मक नामों के साथ छोटी विधियों में लंबी विधि को दोबारा प्रतिक्रिया दे सकते हैं।

यदि संभव हो तो आप यह सुनिश्चित करने के साथ अपनी विधि शुरू कर सकते हैं कि यह फ़ॉर्म की जांच करके क्या करना चाहिए, और फिर यदि अन्य विकल्पों के लिए आपका तरीका है। हालांकि कोई घोंसला नहीं है, वे कोड को पढ़ने योग्य नहीं करते हैं। बस

enum Operation { 
    ADD, DELETE; 
} 

... 

Operation operation = determineOperation(form); 
if (operation == Operation.DELETE) { 
    doDelete(form); 
} else if (operation == Operation.ADD) { 
    doAdd(form); 
} 

यदि आप अभी तक जा सकते हैं तो आपके पास तर्क अच्छा और साफ है और आप जो भी रेफैक्टरिंग चाहते हैं वह कर सकते हैं।

कठिन हिस्सा अपने तर्क को स्पष्ट करना है, और आप इसे चरणों में कर सकते हैं। एक पैटर्न का चयन न करें जब तक कि आप समझें कि आपकी समस्या क्या है।

Answer 4

यदि आप कोड को दोबारा लिखने की योजना बना रहे हैं तो आपको पहले मौजूदा कोड के लिए परीक्षण लिखना सुनिश्चित करना चाहिए ताकि आप सुनिश्चित कर सकें कि आपने रिफैक्टरिंग शुरू करने के बाद इसकी कार्यक्षमता में बदलाव नहीं किया है।

Answer 5

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

Original Hierarchy:  New Hierarchy: 

    Action     Action 
     |      | 
     |      BaseA 
    (old)ClassA     | 
         +--------+----------+ 
         |  |   | 
        ClassB (new)ClassA ClassC 

Answer 6

Struts क्रिया, मेरे मन में, बहुत ज्यादा कोड उन में बिल्कुल नहीं होना चाहिए। उन्हें सीधे अनुरोध और प्रतिक्रिया के साथ सीधे बातचीत करनी चाहिए - किसी फॉर्म या अनुरोध पैरामीटर से कुछ डेटा लेना, उस सेवा को सेवा परत पर बंद करना, और फिर कुछ सामान को प्रतिक्रिया ऑब्जेक्ट में रखें या शायद उपयोगकर्ता के सत्र में कुछ डेटा सहेजें।

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

यह सिर्फ मेरा व्यक्तिगत अनुभव है। एक समय

रिकार्ड कुछ परीक्षण मामलों आप बाद में वापस खेल सकते हैं पर

Answer 7

1. जाओ एक विधि। Example here (जैसा कि आप कर सकते हैं कोड के माध्यम से कई पथों को हिट करना सुनिश्चित करें, यानी इस क्रिया को कॉल करने वाले पृष्ठ पर सभी उपयोगकर्ता संकेत)
2. छोटी चीजें करने वाली छोटी विधियों को बनाकर इसकी जटिलता को कम करने के तरीके को दोहराएं।
3. आप के रूप में फिर से चलाने के परीक्षण इस बिंदु पर इस

करते हैं, आप बड़े विशाल कष्टप्रद विधि के संस्करण पुनर्संशोधित है। अब आप वास्तव में विशिष्ट क्रियाएं बनाना शुरू कर सकते हैं।

आप अपने नए रिफैक्चरर्ड क्लास को बेस क्लास के रूप में उपयोग कर सकते हैं, और प्रत्येक विशिष्ट क्रिया को उन रिफैक्टेड छोटी विधियों का उपयोग करके उप-वर्ग के रूप में कार्यान्वित कर सकते हैं।

एक बार ऐसा करने के बाद, आपके पास कक्षाओं के बीच साझा तर्क की अच्छी तस्वीर होनी चाहिए और आवश्यकतानुसार उन तरीकों को पुल-अप या पुश-डाउन कर सकते हैं।

यह मजेदार नहीं है, लेकिन यदि आप थोड़ी देर के लिए कोडबेस पर काम करेंगे, तो यह आपको समय और सिरदर्द बचाएगा।