स्प्रिंग एकीकरण में सभी धागे खत्म होने की प्रतीक्षा

Question

मेरे पास एक स्व-निष्पादन योग्य जार प्रोग्राम है जो वसंत एकीकरण पर भारी निर्भर करता है। मेरी समस्या यह है कि प्रोग्राम अन्य स्प्रिंग बीन्स पूरी तरह से समाप्त होने से पहले समाप्त हो रहा है।

नीचे कोड का एक कट-डाउन संस्करण है जिसका उपयोग मैं कर रहा हूं, यदि आवश्यक हो तो मैं अधिक कोड/कॉन्फ़िगरेशन की आपूर्ति कर सकता हूं।

public static void main(String[] args) { 
    ctx = new ClassPathXmlApplicationContext("flow.xml"); 
    DataImporter importer = (DataImporter)ctx.getBean("MyImporterBean"); 
    try { 
     importer.startImport(); 
    } catch (Exception e) { 
     e.printStackTrace(); 
    } finally { 
     ctx.close(); 
    } 
} 

DataImporter एक सरल पाश है कि एक स्प्रिंग एकता प्रवेश द्वार को संदेश आग में शामिल हैं: प्रवेश बिंदु एक main() प्रणाली है, जो वसंत bootstraps और आयात की प्रक्रिया शुरू होता है। यह डेटा के लिए मतदान के आम दृष्टिकोण के बजाय प्रवाह के लिए एक सक्रिय "धक्का" दृष्टिकोण प्रदान करता है। यह जहां मेरी समस्या में आता है:

public void startImport() throws Exception { 
    for (Item item : items) { 
     gatewayBean.publish(item); 
     Thread.sleep(200); // Yield period 
    } 
} 

पूर्णता के लिए, प्रवाह एक्सएमएल इस तरह दिखता है:

<gateway default-request-channel="inChannel" service-interface="GatewayBean" /> 

<splitter input-channel="inChannel" output-channel="splitChannel" /> 

<payload-type-router input-channel="splitChannel"> 
    <mapping type="Item" channel="itemChannel" /> 
    <mapping type="SomeOtherItem" channel="anotherChannel" /> 
</payload-type-router> 

<outbound-channel-adapter channel="itemChannel" ref="DAOBean" method="persist" /> 

प्रवाह शुरू होता है और प्रभावी रूप से आइटम प्रोसेस करता है, लेकिन एक बार startImport() पाश खत्म मुख्य धागा तुरंत सभी वसंत एकीकरण धागे को समाप्त करता है और आँसू देता है। इसका परिणाम दौड़ की स्थिति में होता है, जब कार्यक्रम समाप्त हो जाता है तो अंतिम (एन) आइटम पूरी तरह से संसाधित नहीं होते हैं।

मेरे पास प्रसंस्करण की जा रही वस्तुओं की संदर्भ संख्या बनाए रखने का एक विचार है, लेकिन यह काफी जटिल साबित हो रहा है, क्योंकि प्रवाह अक्सर संदेशों को कई सेवा सक्रियताओं में विभाजित/रूट करता है - जिसका अर्थ है कि यह निर्धारित करना मुश्किल है या नहीं प्रत्येक आइटम "समाप्त" है।

मुझे लगता है कि मुझे यह देखने का कोई तरीका है कि कोई वसंत बीन्स अभी भी निष्पादित नहीं कर रहा है, या ध्वजांकित करने के लिए गेटवे पर भेजे गए सभी आइटमों को पूरी तरह से संसाधित करने से पहले संसाधित किया गया है।

मेरा सवाल यह है कि, मैं इनमें से किसी एक को करने के बारे में कैसे जा सकता हूं, या क्या मेरी समस्या का बेहतर दृष्टिकोण है, मैंने सोचा नहीं है?

Answer 1

आप यहां अनुरोध-प्रतिक्रिया पैटर्न का उपयोग नहीं कर रहे हैं।

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

Answer 2

आप या एक Item निर्धारित करने के लिए, चाहे वह अभी भी जरूरत है प्राप्त कर सकते हैं नहीं (processingFinished() या कुछ इसी तरह बैक-एंड-चरणों में मार डाला), आप सभी Item एक केंद्रीय सत्ता पर, रजिस्टर कर सकते हैं जो गैर-समाप्त Item एस की संख्या का ट्रैक रखता है और effecitvely एक समाप्ति-शर्त निर्धारित करता है।

यदि यह दृष्टिकोण संभव है, तो आप आइटम को FutureTask -objects में पैकेजिंग के बारे में भी सोच सकते हैं या java.util.concurrent से समान अवधारणाओं का उपयोग कर सकते हैं।

संपादित करें: दूसरा विचार:

आप चैनलों अधिक बुद्धिमान बनाने के बारे में सोचा है? एक बार प्रेषक चैनल बंद कर देता है जब वह कोई और डेटा नहीं भेजता है। इस परिदृश्य में, कार्यकर्ता-बीन्स को डीमॉन धागे होने की आवश्यकता नहीं है लेकिन बंद और खाली इनपुट चैनल के आधार पर उनके समापन-मानदंड को निर्धारित कर सकते हैं।