मैं एक मौजूदा वेब सेवा के कुछ पहलुओं को फिर से तथ्य पर काम कर रहा हूं। जिस तरह से सेवा API को कार्यान्वित किया जाता है वह एक प्रकार की "प्रसंस्करण पाइपलाइन" होने से होता है, जहाँ ऐसे कार्य होते हैं जो क्रम से किए जाते हैं। अप्रत्याशित रूप से, बाद के कार्यों को पहले के कार्यों द्वारा गणना की गई जानकारी की आवश्यकता हो सकती है, और वर्तमान में यह जिस तरह से किया जाता है वह फ़ील्ड्स को "पाइपलाइन राज्य" वर्ग में जोड़ देता है।
मैं सोच रहा था (और उम्मीद है?) कि वहाँ एक बेहतर तरीका है पाइपलाइन के बीच जानकारी साझा करने के लिए एक zillion क्षेत्रों के साथ एक डेटा ऑब्जेक्ट होने से, जिनमें से कुछ प्रसंस्करण कदम और दूसरों को नहीं समझ में आता है। इस वर्ग को थ्रेड-सेफ बनाने के लिए यह एक बड़ा दर्द होगा (मुझे नहीं पता कि यह संभव भी होगा), इसके आक्रमणकारियों के बारे में तर्क करने का कोई तरीका नहीं है (और यह संभव है कि इसका कोई मतलब नहीं है)।
मैं कुछ प्रेरणा पाने के लिए गैंग ऑफ़ फोर डिज़ाइन पैटर्न बुक के माध्यम से पेजिंग कर रहा था, लेकिन मुझे ऐसा नहीं लगा कि वहाँ कोई समाधान था (मेमेंटो कुछ इसी भावना में था, लेकिन काफी नहीं)। मैंने ऑनलाइन भी देखा, लेकिन दूसरे आप "पाइपलाइन" या "वर्कफ़्लो" की खोज करते हैं जो आपको यूनिक्स पाइप की जानकारी, या मालिकाना वर्कफ़्लो इंजन और चौखटे से भर जाता है।
मेरा सवाल है - आप एक सॉफ्टवेयर प्रोसेसिंग पाइपलाइन के निष्पादन की स्थिति को रिकॉर्ड करने के मुद्दे पर कैसे पहुंचेंगे, ताकि बाद के कार्यों को पहले वाले लोगों द्वारा गणना की गई जानकारी का उपयोग कर सकें? मुझे लगता है कि यूनिक्स पाइप के साथ प्रमुख अंतर यह है कि आप तुरंत पूर्ववर्ती कार्य के आउटपुट के बारे में परवाह नहीं करते हैं।
जैसा कि अनुरोध किया गया है, मेरे उपयोग के मामले को स्पष्ट करने के लिए कुछ छद्मकोड:
"पाइपलाइन संदर्भ" ऑब्जेक्ट में फ़ील्ड का एक गुच्छा होता है जो विभिन्न पाइपलाइन चरणों को आबाद / पढ़ सकता है:
public class PipelineCtx {
... // fields
public Foo getFoo() { return this.foo; }
public void setFoo(Foo aFoo) { this.foo = aFoo; }
public Bar getBar() { return this.bar; }
public void setBar(Bar aBar) { this.bar = aBar; }
... // more methods
}प्रत्येक पाइपलाइन चरण भी एक वस्तु है:
public abstract class PipelineStep {
public abstract PipelineCtx doWork(PipelineCtx ctx);
}
public class BarStep extends PipelineStep {
@Override
public PipelineCtx doWork(PipelieCtx ctx) {
// do work based on the stuff in ctx
Bar theBar = ...; // compute it
ctx.setBar(theBar);
return ctx;
}
}इसी तरह एक काल्पनिक के लिए FooStep, जिसे बारस्टेप द्वारा बार गणना की आवश्यकता हो सकती है, अन्य डेटा के साथ। और फिर हमारे पास असली एपीआई कॉल है:
public class BlahOperation extends ProprietaryWebServiceApiBase {
public BlahResponse handle(BlahRequest request) {
PipelineCtx ctx = PipelineCtx.from(request);
// some steps happen here
// ...
BarStep barStep = new BarStep();
barStep.doWork(crx);
// some more steps maybe
// ...
FooStep fooStep = new FooStep();
fooStep.doWork(ctx);
// final steps ...
return BlahResponse.from(ctx);
}
}