मदर लेखक में मानदंड के आधार पर आइटम लेखक में एकाधिक फ़ाइलों को डेटा राउटिंग मानदंड

Question

मुझे अपने पाठक में आइटमों की एक सूची मिल रही है।

प्रत्येक आइटम ऑब्जेक्ट में Code नामक एक संपत्ति है जिसमें हाथ से पहले मुझे ज्ञात कई संभावित मूल्य नहीं हैं।

1) प्रत्येक आइटम में Code के मान के आधार पर, मैं उस विशेष आइटम को Code से संबंधित आउटपुट फ़ाइल में लिखना चाहता हूं। उदाहरण के लिए अगर मेरा वर्तमान आइटम Code "एबीसी" है, तो आइटम को लेखक में abc.txt में लिखा जाना चाहिए।

2) यदि वर्तमान आइटम में Code "xyz" है, जिसके लिए फ़ाइल मौजूद नहीं है, तो एक नई फ़ाइल बनाई जानी चाहिए और आइटम उस फ़ाइल पर जाना चाहिए।

3) Code पर आधारित ऐसी सभी एकाधिक फ़ाइलों के लिए, मैं कुछ विवरण दर्ज करने के लिए हेडर और पाद लेख कॉल भी जोड़ना चाहता हूं उदा। प्रत्येक फ़ाइल में वस्तुओं की गिनती।

क्या एक लेखक होना संभव है, जो 3 आवश्यकताओं से अधिक संतुष्ट है?

मुझे पता है कि multiresourceitemwriter का उपयोग करके, कोई डेटा एकाधिक आउटपुट फ़ाइलों के बीच विभाजित कर सकता है। लेकिन जहां तक ​​मुझे पता है, यह विभाजन वस्तुओं की संख्या पर आधारित है। उदाहरण के लिए फ़ाइल 1 में पहले 10 आइटम, फ़ाइल 2 में अगले 10 और इसी तरह।

लेकिन मेरे प्रश्न में उल्लिखित किसी आइटम प्रॉपर्टी के आधार पर आउटपुट फ़ाइलों को डेटा कैसे रूट किया जाए?

मैं स्प्रिंग बैच से अच्छी तरह से परिचित हूं और मुझे थोड़ा मार्गदर्शन चाहिए क्योंकि यह पहली बार है जब मुझे इस तरह के मुद्दे का सामना करना पड़ रहा है।

पढ़ने के लिए धन्यवाद!

Answer 1

मैं कम से कम 2 रणनीति

1. साथ यह कोशिश करेंगे बैच एक अस्थायी डेटाबेस तालिका और सरल उपकरण/बैच/लिपि में सभी डेटा लिखते हैं अलग-अलग फ़ाइलें बनाता है - मैं के बारे में शीर्षलेख/पादलेख यकीन नहीं है लेकिन हमेशा के रूप में कोई भी कह सकता है "चलो इसे सस्ता रखें"
2. आइटमवाइटर मक्खी पर आवश्यक लेखकों को बनाता है और प्रबंधित करता है, शायद एक अमूर्त पूर्व-कॉन्फ़िगर किए गए लेखक/बीन टेम्पलेट के रूप में, जब तक आप पुनरारंभ परिदृश्यों को अनदेखा करते हैं, यह " आसान "

Answer 2

एक और विकल्प 3 सूचियों का निर्माण करना होगा जिसमें उनके कोड से अलग तत्व शामिल हैं। फिर, इन सूचियों को फाइल सिस्टम में लिखने के लिए एक अलग चरण का उपयोग करें।

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

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

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

Answer 3

यदि मैं आपकी समस्या को सही ढंग से समझता हूं, तो आपको कुछ आइटम चाहिए।

सबसे पहले, एक वर्गीकारक कि Classifier इंटरफ़ेस

public class ItemCodeClassifier { 
    @Classifier 
    public String classify(Item item) { 
     return item.getCode().getKey();// returns "abc", "xyz" 
    } 
} 

दूसरा एक रूटर कार्यान्वयन कि उपरोक्त विधि

<bean id="classifier" class="org.springframework.batch.classify.BackToBackPatternClassifier"> 
    <property name="routerDelegate"> 
     <bean class="ItemCodeClassifier" /> 
    </property> 
    <property name="matcherMap"> 
     <map> 
     <entry key="abc" value-ref="abcItemWriter" /> 
     <entry key="xyz" value-ref="xyzItemWriter" /> 
     </map> 
    </property> 
</bean> 

और सभी के पिछले खपत को लागू करता है, एक ClassifierCompositeItemWriter

<bean id="ItemWriter" class="org.springframework.batch.item.support.ClassifierCompositeItemWriter"> 
<property name="classifier" ref="classifier" /> 
</bean 

उपरोक्त संकलित नहीं किया था लेकिन उम्मीद थी था यह मदद करता है।

Answer 4

I आज सुबह इसी समस्या का सामना करना पड़ा। और अंत में मैंने पाया कि वर्तमान में क्लासिफायरकंपोसाइट आईटमवाइटर स्प्रिंग बैच के नवीनतम रिलीज 2.1.9 संस्करण में अपने प्रतिनिधि आइटमवाइटर के रूप में FlatFileItemWriter का समर्थन नहीं करता है।

WriterNotOpenException नीचे की तरह फेंक दिया जाता है:

org.springframework.batch.item.WriterNotOpenException: Writer must be open before it can be written to 
    at org.springframework.batch.item.file.FlatFileItemWriter.write(FlatFileItemWriter.java:236) 
    at org.springframework.batch.item.support.ClassifierCompositeItemWriter.write(ClassifierCompositeItemWriter.java:65) 
    at org.springframework.batch.core.step.item.SimpleChunkProcessor.writeItems(SimpleChunkProcessor.java:171) 
    at org.springframework.batch.core.step.item.SimpleChunkProcessor.doWrite(SimpleChunkProcessor.java:150) 
    at org.springframework.batch.core.step.item.SimpleChunkProcessor.write(SimpleChunkProcessor.java:269) 
    at org.springframework.batch.core.step.item.SimpleChunkProcessor.process(SimpleChunkProcessor.java:194) 
    at org.springframework.batch.core.step.item.ChunkOrientedTasklet.execute(ChunkOrientedTasklet.java:74) 
    at org.springframework.batch.core.step.tasklet.TaskletStep$ChunkTransactionCallback.doInTransaction(TaskletStep.java:386) 
    at org.springframework.transaction.support.TransactionTemplate.execute(TransactionTemplate.java:130) 
    at org.springframework.batch.core.step.tasklet.TaskletStep$2.doInChunkContext(TaskletStep.java:264) 
    at org.springframework.batch.core.scope.context.StepContextRepeatCallback.doInIteration(StepContextRepeatCallback.java:76) 
    at org.springframework.batch.repeat.support.RepeatTemplate.getNextResult(RepeatTemplate.java:367) 
    at org.springframework.batch.repeat.support.RepeatTemplate.executeInternal(RepeatTemplate.java:214) 
    at org.springframework.batch.repeat.support.RepeatTemplate.iterate(RepeatTemplate.java:143) 
    at org.springframework.batch.core.step.tasklet.TaskletStep.doExecute(TaskletStep.java:250) 
    at org.springframework.batch.core.step.AbstractStep.execute(AbstractStep.java:195) 
    at org.springframework.batch.core.job.SimpleStepHandler.handleStep(SimpleStepHandler.java:135) 
    at org.springframework.batch.core.job.flow.JobFlowExecutor.executeStep(JobFlowExecutor.java:61) 
    at org.springframework.batch.core.job.flow.support.state.StepState.handle(StepState.java:60) 
    at org.springframework.batch.core.job.flow.support.SimpleFlow.resume(SimpleFlow.java:144) 
    at org.springframework.batch.core.job.flow.support.SimpleFlow.start(SimpleFlow.java:124) 
    at org.springframework.batch.core.job.flow.FlowJob.doExecute(FlowJob.java:135) 
    at org.springframework.batch.core.job.AbstractJob.execute(AbstractJob.java:281) 
    at org.springframework.batch.core.launch.support.SimpleJobLauncher$1.run(SimpleJobLauncher.java:120) 
    at org.springframework.core.task.SyncTaskExecutor.execute(SyncTaskExecutor.java:48) 
    at org.springframework.batch.core.launch.support.SimpleJobLauncher.run(SimpleJobLauncher.java:114) 

Answer 5

समाधान नीचे मेरे लिए काम किया। कोड संकलित और यह ठीक काम कर रहा है।

सबसे पहले, आपको क्लासिफायर की आवश्यकता होगी। या तो क्लासिफायर इंटरफेस को लागू करें या @ क्लासिफायर के साथ वर्गीकृत वर्गीकरण() विधि को एनोटेट करें।

यहां मैंने एनोटेशन का उपयोग किया है।

public class MyClassifier { 
    @Classifier 
    public String classify(Policy pol) { 
     return pol.getPolCode;// returns "01", "02" 
    } 
} 

जोड़ें वर्गीकरणकर्ता सेम

<bean id="myClassifier" class="org.springframework.batch.classify.BackToBackPatternClassifier"> 
    <property name="routerDelegate"> 
     <bean class="MyClassifier" /> 
    </property> 
    <property name="matcherMap"> 
     <map> 
     <entry key="01" value-ref="pol01ItemWriter" /> 
     <entry key="02" value-ref="pol02ItemWriter" /> 
     </map> 
    </property> 
</bean> 

अपने लेखक सेम के रूप में की तरह

नीचे

<bean id="ItemWriter" class="org.springframework.batch.item.support.ClassifierCompositeItemWriter"> 
    <property name="myClassifier" ref="myClassifier" /> 
</bean> 

से ऊपर कोड WriterNotOpenException फेंक सकता है जोड़ें। इसके लिए आपको बैच जोड़ने की आवश्यकता है: चरण में स्ट्रीम करें।

<batch:step id="step1"> 
    <batch:tasklet> 
     <batch:chunk reader="reader" processor="processor" writer="ItemWriter" commit-interval="3"> 
      <batch:streams> 
       <batch:stream ref="pol01ItemWriter"/> 
       <batch:stream ref="pol02ItemWriter"/> 
      </batch:streams> 
     </batch:chunk> 
    </batch:tasklet> 
</batch:step>