स्प्रिंग बैच - त्वरित गाइड
Batch processingएक प्रोसेसिंग मोड है जिसमें उपयोगकर्ता के संपर्क के बिना स्वचालित जटिल नौकरियों की श्रृंखला का निष्पादन शामिल है। एक बैच प्रक्रिया थोक डेटा को संभालती है और लंबे समय तक चलती है।
कई एंटरप्राइज़ एप्लिकेशन को शामिल करने के लिए बड़े डेटा को संसाधित करने की आवश्यकता है -
समय-समय पर होने वाली घटनाएँ जैसे कि आवधिक गणनाएँ।
आवधिक अनुप्रयोग जो बड़े डेटासेट पर दोहराव से संसाधित होते हैं।
ऐसे अनुप्रयोग जो लेन-देन में उपलब्ध डेटा के प्रसंस्करण और सत्यापन से संबंधित हैं।
इसलिए, इस तरह के लेनदेन को करने के लिए एंटरप्राइज़ एप्लिकेशन में बैच प्रोसेसिंग का उपयोग किया जाता है।
स्प्रिंग बैच क्या है
स्प्रिंग बैच एक है lightweight framework जिसका उपयोग विकसित करने के लिए किया जाता है Batch Applications इसका उपयोग एंटरप्राइज एप्लिकेशन में किया जाता है।
थोक प्रसंस्करण के अलावा, यह ढांचा निम्नलिखित के लिए कार्य प्रदान करता है -
- जिसमें लॉगिंग और ट्रेसिंग शामिल है
- लेन - देन प्रबंधन
- नौकरी प्रसंस्करण के आँकड़े
- नौकरी फिर से शुरू
- छोड़ें और संसाधन प्रबंधन
आप इसकी विभाजन तकनीकों का उपयोग करके स्प्रिंग बैच अनुप्रयोगों को भी माप सकते हैं।
स्प्रिंग बैच की विशेषताएं
स्प्रिंग बैच की उल्लेखनीय विशेषताएं निम्नलिखित हैं -
Flexibility- स्प्रिंग बैच के अनुप्रयोग लचीले होते हैं। आपको बस एक आवेदन में प्रसंस्करण के क्रम को बदलने के लिए एक XML फ़ाइल को बदलने की आवश्यकता है।
Maintainability- स्प्रिंग बैच अनुप्रयोगों को बनाए रखना आसान है। स्प्रिंग बैच की नौकरी में कदम शामिल हैं और प्रत्येक कदम को अन्य चरणों को प्रभावित किए बिना, परीक्षण, और अद्यतन किया जा सकता है।
Scalability- बिदाई तकनीकों का उपयोग करके, आप स्प्रिंग बैच अनुप्रयोगों को स्केल कर सकते हैं। ये तकनीक आपको -
एक नौकरी के चरणों को समानांतर में निष्पादित करें।
समानांतर में एक भी धागा निष्पादित करें।
Reliability - किसी भी विफलता के मामले में, आप ठीक उसी जगह से नौकरी को फिर से शुरू कर सकते हैं, जहां कदम रोककर, इसे रोक दिया गया था।
Support for multiple file formats - स्प्रिंग बैच पाठकों और लेखकों के एक बड़े समूह के लिए समर्थन प्रदान करता है जैसे XML, फ्लैट फ़ाइल, CSV, MYSQL, हाइबरनेट, JDBC, मानगो, Neo4j, आदि।
Multiple ways to launch a job - आप वेब एप्लिकेशन, जावा प्रोग्राम, कमांड लाइन, आदि का उपयोग करके स्प्रिंग बैच जॉब लॉन्च कर सकते हैं।
इन के अलावा, स्प्रिंग बैच अनुप्रयोगों का समर्थन -
विफलता के बाद स्वत: पुनर्प्रयास।
बैच निष्पादन के दौरान और बैच प्रसंस्करण को पूरा करने के बाद स्थिति और आँकड़ों पर नज़र रखना।
समवर्ती नौकरियों को चलाने के लिए।
लॉगिंग, संसाधन प्रबंधन, छोड़ें और प्रसंस्करण को फिर से शुरू करने जैसी सेवाएं।
इस अध्याय में, हम बताएंगे कि ग्रहण आईडीई में स्प्रिंग बैच वातावरण कैसे सेट करें। स्थापना के साथ आगे बढ़ने से पहले, सुनिश्चित करें कि आपने अपने सिस्टम में ग्रहण स्थापित किया है। यदि नहीं, तो अपने सिस्टम में ग्रहण को डाउनलोड और इंस्टॉल करें।
ग्रहण के बारे में अधिक जानकारी के लिए, कृपया हमारे ग्रहण ट्यूटोरियल को देखें ।
ग्रहण पर वसंत बैच की स्थापना
ग्रहण पर स्प्रिंग बैच वातावरण सेट करने के लिए नीचे दिए गए चरणों का पालन करें।
Step 1 - ग्रहण स्थापित करें और एक नया प्रोजेक्ट खोलें जैसा कि निम्नलिखित स्क्रीनशॉट में दिखाया गया है।
Step 2 - जैसा कि नीचे दिखाया गया है, एक नमूना स्प्रिंग बैच परियोजना बनाएं।
Step 3- प्रोजेक्ट पर राइट-क्लिक करें और इसे नीचे दिखाए गए अनुसार Maven प्रोजेक्ट में परिवर्तित करें। एक बार जब आप इसे मावेन परियोजना में परिवर्तित करते हैं, तो यह आपको एPom.xmlजहां आपको आवश्यक निर्भरता का उल्लेख करने की आवश्यकता है। इसके बाद दjar उन फ़ाइलों को स्वचालित रूप से आपकी परियोजना में डाउनलोड किया जाएगा।
Step 4 - अब, में pom.xml परियोजना को कॉपी करें और निम्न सामग्री (स्प्रिंग बैच आवेदन के लिए निर्भरता) पेस्ट करें और परियोजना को ताज़ा करें।
<project xmlns = "http://maven.apache.org/POM/4.0.0"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://maven.apache.org/POM/4.0.0
http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.tutorialspoint</groupId>
<artifactId>SpringBatchSample</artifactId>
<packaging>jar</packaging>
<version>1.0-SNAPSHOT</version>
<name>SpringBatchExample</name>
<url>http://maven.apache.org</url>
<properties>
<jdk.version>1.8</jdk.version>
<spring.version>4.3.8.RELEASE</spring.version>
<spring.batch.version>3.0.7.RELEASE</spring.batch.version>
<mysql.driver.version>5.1.25</mysql.driver.version>
<junit.version>4.11</junit.version>
</properties>
<dependencies>
<!-- Spring Core -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>${spring.version}</version> </dependency> <!-- Spring jdbc, for database --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>${spring.version}</version>
</dependency>
<!-- Spring XML to/back object -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-oxm</artifactId>
<version>${spring.version}</version> </dependency> <!-- MySQL database driver --> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>${mysql.driver.version}</version>
</dependency>
<!-- Spring Batch dependencies -->
<dependency>
<groupId>org.springframework.batch</groupId>
<artifactId>spring-batch-core</artifactId>
<version>${spring.batch.version}</version> </dependency> <dependency> <groupId>org.springframework.batch</groupId> <artifactId>spring-batch-infrastructure</artifactId> <version>${spring.batch.version}</version>
</dependency>
<!-- Spring Batch unit test -->
<dependency>
<groupId>org.springframework.batch</groupId>
<artifactId>spring-batch-test</artifactId>
<version>${spring.batch.version}</version> </dependency> <!-- Junit --> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>${junit.version}</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<finalName>spring-batch</finalName>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-eclipse-plugin</artifactId>
<version>2.9</version>
<configuration>
<downloadSources>true</downloadSources>
<downloadJavadocs>false</downloadJavadocs>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>2.3.2</version>
<configuration>
<source>${jdk.version}</source> <target>${jdk.version}</target>
</configuration>
</plugin>
</plugins>
</build>
</project>
अंत में, यदि आप मावेन निर्भरता का निरीक्षण करते हैं, तो आप यह देख सकते हैं कि सभी आवश्यक हैं jar फ़ाइलों को डाउनलोड किया गया है।
निम्नलिखित स्प्रिंग बैच की वास्तुकला का चित्रण प्रतिनिधित्व है। जैसा कि चित्र में दर्शाया गया है, वास्तुकला में तीन मुख्य घटक हैं,Application, Batch Core, तथा Batch Infrastructure।
Application - इस घटक में सभी नौकरियां और कोड हैं जो हम स्प्रिंग बैच ढांचे का उपयोग करके लिखते हैं।
Batch Core - इस घटक में सभी एपीआई कक्षाएं हैं जो बैच जॉब को नियंत्रित करने और लॉन्च करने के लिए आवश्यक हैं।
Batch Infrastructure - इस घटक में पाठक, लेखक और अनुप्रयोग और बैच कोर घटक दोनों द्वारा उपयोग की जाने वाली सेवाएँ शामिल हैं।
स्प्रिंग बैच के घटक
निम्नलिखित दृष्टांत स्प्रिंग बैच के विभिन्न घटकों को दर्शाता है और वे एक दूसरे के साथ कैसे जुड़े हैं।
काम
स्प्रिंग बैच एप्लिकेशन में, एक नौकरी बैच प्रक्रिया है जिसे निष्पादित किया जाना है। यह बिना किसी रुकावट के शुरू से अंत तक चलता है। यह नौकरी आगे के चरणों में विभाजित है (या नौकरी में चरण शामिल हैं)।
हम XML फ़ाइल या जावा वर्ग का उपयोग करके स्प्रिंग बैच में नौकरी कॉन्फ़िगर करेंगे। स्प्रिंग बैच में एक जॉब का XML कॉन्फ़िगरेशन निम्नलिखित है।
<job id = "jobid">
<step id = "step1" next = "step2"/>
<step id = "step2" next = "step3"/>
<step id = "step3"/>
</job>
एक बैच नौकरी टैग <नौकरी> </ job> के भीतर कॉन्फ़िगर की गई है। इसका एक विशेषता नाम हैid। इन टैग के भीतर, हम चरणों की परिभाषा और क्रम को परिभाषित करते हैं।
Restartable - सामान्य तौर पर, जब कोई नौकरी चल रही होती है और हम इसे फिर से शुरू करने की कोशिश करते हैं जो कि माना जाता है restartऔर इसे फिर से शुरू किया जाएगा। इससे बचने के लिए, आपको सेट करने की आवश्यकता हैrestartable के लिए मूल्य false जैसा की नीचे दिखाया गया।
<job id = "jobid" restartable = "false" >
</job>
कदम
ए step एक नौकरी का एक स्वतंत्र हिस्सा है जिसमें नौकरी को परिभाषित करने और निष्पादित करने के लिए आवश्यक जानकारी शामिल है (इसका हिस्सा)।
जैसा कि आरेख में निर्दिष्ट है, प्रत्येक चरण एक ItemReader, ItemProcessor (वैकल्पिक) और एक ItemWriter से बना होता है। A job may contain one or more steps।
पाठक, लेखक और प्रोसेसर
एक item reader एक विशेष स्रोत से स्प्रिंग बैच एप्लिकेशन में डेटा पढ़ता है, जबकि ए item writer स्प्रिंग बैच एप्लिकेशन के डेटा को किसी विशेष गंतव्य पर लिखते हैं।
एक Item processorएक वर्ग है जिसमें प्रोसेसिंग कोड होता है जो स्प्रिंग बैच में पढ़े गए डेटा को प्रोसेस करता है। अगर आवेदन पढ़ता है"n" रिकॉर्ड, फिर प्रोसेसर में कोड प्रत्येक रिकॉर्ड पर निष्पादित किया जाएगा।
जब कोई पाठक और लेखक नहीं दिया जाता है, तो ए taskletस्प्रिंगबैच के लिए एक प्रोसेसर के रूप में कार्य करता है। यह केवल एक ही कार्य करता है। उदाहरण के लिए, यदि हम इसमें एक सरल कदम के साथ एक नौकरी लिख रहे हैं जहां हम MySQL डेटाबेस से डेटा पढ़ते हैं और इसे संसाधित करते हैं और इसे एक फ़ाइल (फ्लैट) पर लिखते हैं, तो हमारा कदम उपयोग करता है -
ए reader जो MySQL डेटाबेस से पढ़ता है।
ए writer जो एक फ्लैट फ़ाइल को लिखता है।
ए custom processor जो हमारी इच्छा के अनुसार डेटा को संसाधित करता है।
<job id = "helloWorldJob">
<step id = "step1">
<tasklet>
<chunk reader = "mysqlReader" writer = "fileWriter"
processor = "CustomitemProcessor" ></chunk>
</tasklet>
</step>
</ job>
स्प्रिंग बैच की एक लंबी सूची प्रदान करता है readers तथा writers। इन पूर्वनिर्धारित कक्षाओं का उपयोग करके, हम उनके लिए सेम को परिभाषित कर सकते हैं। हम चर्चा करेंगेreaders तथा writers आने वाले अध्यायों में अधिक विस्तार से।
JobRepository
स्प्रिंग बैच में जॉब रिपॉजिटरी जॉबलांचर, जॉब और स्टेप कार्यान्वयन के लिए क्रिएट, रिट्रीव, अपडेट और डिलीट (CRUD) ऑपरेशंस प्रदान करता है। हम एक XML फ़ाइल में नौकरी रिपॉजिटरी को परिभाषित करेंगे जैसा कि नीचे दिखाया गया है।
<job-repository id = "jobRepository"/>
के अतिरिक्त id, कुछ और विकल्प (वैकल्पिक) उपलब्ध हैं। सभी विकल्पों और उनके डिफ़ॉल्ट मानों के साथ कार्य भंडार का विन्यास निम्नलिखित है।
<job-repository id = "jobRepository"
data-source = "dataSource"
transaction-manager = "transactionManager"
isolation-level-for-create = "SERIALIZABLE"
table-prefix = "BATCH_"
max-varchar-length = "1000"/>
In-Memory Repository - यदि आप डेटाबेस में स्प्रिंग बैच के डोमेन ऑब्जेक्ट्स को जारी नहीं रखना चाहते हैं, तो आप नीचे दिखाए अनुसार जॉब रिपॉजिटरी के इन-मेमोरी संस्करण को कॉन्फ़िगर कर सकते हैं।
<bean id = "jobRepository"
class = "org.springframework.batch.core.repository.support.MapJobRepositoryFactoryBean ">
<property name = "transactionManager" ref = "transactionManager"/>
</bean>
JobLauncher
JobLauncher एक इंटरफ़ेस है जो स्प्रिंग बैच की नौकरी के लिए सराहना करता है given set of parameters। SampleJoblauncher वह वर्ग है जो लागू करता है JobLauncherइंटरफेस। निम्नलिखित जॉबलांचर का विन्यास है।
<bean id = "jobLauncher"
class = "org.springframework.batch.core.launch.support.SimpleJobLauncher">
<property name = "jobRepository" ref = "jobRepository" />
</bean>
JobInstance
ए JobInstanceनौकरी के तार्किक रन का प्रतिनिधित्व करता है; यह तब बनता है जब हम नौकरी चलाते हैं। प्रत्येक नौकरी के उदाहरण को नौकरी के नाम से अलग किया जाता है और दौड़ते समय पैरामीटर इसे पास करते हैं।
यदि एक JobInstance निष्पादन विफल हो जाता है, तो उसी JobInstance को फिर से निष्पादित किया जा सकता है। इसलिए, प्रत्येक JobInstance में कई कार्य निष्पादन हो सकते हैं।
JobExecution और StepExecution
JobExecution और StepExecution किसी कार्य / चरण के निष्पादन का प्रतिनिधित्व करते हैं। इनमें नौकरी / कदम की रन जानकारी होती है जैसे कि स्टार्ट टाइम (नौकरी / कदम), अंत समय (नौकरी / कदम)।
इस ट्यूटोरियल के लगभग सभी उदाहरणों में निम्नलिखित फाइलें हैं -
- कॉन्फ़िगरेशन फ़ाइल (XML फ़ाइल)
- टास्कलेट / प्रोसेसर (जावा वर्ग)
- जावा बसने वालों और पाने वालों के साथ (जावा वर्ग (सेम))
- मैपर क्लास (जावा क्लास)
- लॉन्चर क्लास (जावा क्लास)
विन्यास फाइल
कॉन्फ़िगरेशन फ़ाइल (XML) में निम्न शामिल हैं -
job तथा step परिभाषाएँ।
बीन्स को परिभाषित करता है readers तथा writers।
JobLauncher, JobRepository, Transaction Manager, और Data Source जैसे घटकों की परिभाषा।
हमारे उदाहरणों में, बेहतर समझ के लिए, हमने इसे दो फ़ाइलों में विभाजित किया है job.xml फ़ाइल (नौकरी, कदम, पाठक और लेखक को परिभाषित करता है) और context.xml फ़ाइल (नौकरी लांचर, नौकरी भंडार, लेनदेन प्रबंधक और डेटा स्रोत)।
मैपर क्लास
पाठक के आधार पर मैपर वर्ग, जैसे इंटरफेस को लागू करता है row mapper, field set mapper, आदि इसमें पाठक से डेटा प्राप्त करने और इसे जावा वर्ग के साथ सेट करने के लिए कोड है setter तथा getter विधियाँ (जावा बीन)।
जावा बीन क्लास
के साथ एक जावा वर्ग setters तथा getters(जावा बीन) कई मूल्यों के साथ डेटा का प्रतिनिधित्व करता है। यह एक सहायक वर्ग के रूप में कार्य करता है। हम इस वर्ग के ऑब्जेक्ट के रूप में एक घटक (रीडर, लेखक, प्रोसेसर) से दूसरे में डेटा पास करेंगे।
Tasklet / प्रोसेसर
टास्कलेट / प्रोसेसर क्लास में स्प्रिंग बैच एप्लिकेशन का प्रोसेसिंग कोड होता है। प्रोसेसर एक ऐसा वर्ग है जो एक ऑब्जेक्ट को स्वीकार करता है जिसमें डेटा पढ़ा जाता है, इसे संसाधित करता है, और संसाधित डेटा (प्रपत्र ऑब्जेक्ट में) लौटाता है।
लॉन्चर क्लास
इस वर्ग (App.java) में स्प्रिंग बैच एप्लिकेशन लॉन्च करने का कोड है।
स्प्रिंग बैच एप्लिकेशन लिखते समय, हम जॉब, स्टेप, जॉबलांचर, जॉब रिपॉजिटरी, ट्रांजैक्शन मैनेजर, रीडर्स और लेखकों को स्प्रिंग बैच नेमस्पेस में दिए गए XML टैग का उपयोग करके कॉन्फ़िगर करेंगे। इसलिए, आपको नीचे दिखाए गए अनुसार इस नाम स्थान को अपनी XML फ़ाइल में शामिल करना होगा।
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:batch = "http://www.springframework.org/schema/batch"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/batch
http://www.springframework.org/schema/batch/spring-batch-2.2.xsd
http://www.springframework.org/schema/bean
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">
निम्नलिखित अनुभागों में, हम स्प्रिंग बैच नाम स्थान में उपलब्ध विभिन्न टैग, उनकी विशेषताओं और उदाहरणों पर चर्चा करेंगे।
काम
इस टैग का उपयोग स्प्रिंगबैच की नौकरी को परिभाषित / कॉन्फ़िगर करने के लिए किया जाता है। इसमें चरणों का एक सेट होता है और इसे जॉबलांचर का उपयोग करके लॉन्च किया जा सकता है।
इस टैग में नीचे सूचीबद्ध 2 विशेषताएं हैं -
S.No | विशेषता और विवरण |
---|---|
1 | Id यह कार्य का आईडी है, इस विशेषता के लिए मूल्य निर्दिष्ट करना अनिवार्य है। |
2 | restartable यह वह विशेषता है जिसका उपयोग यह निर्दिष्ट करने के लिए किया जाता है कि नौकरी पुनः आरंभ करने योग्य है या नहीं। यह विशेषता वैकल्पिक है। |
स्प्रिंगबच की नौकरी का XML कॉन्फ़िगरेशन निम्नलिखित है।
<job id = "jobid" restartable = "false" >
. . . . . . . .
. . . . . . . .
. . . . . . . . // Step definitions
</job>
कदम
इस टैग का उपयोग स्प्रिंगबैच नौकरी के चरणों को परिभाषित / कॉन्फ़िगर करने के लिए किया जाता है। इसकी निम्नलिखित तीन विशेषताएँ हैं -
S.No | विशेषता और विवरण |
---|---|
1 | Id यह कार्य का आईडी है, इस विशेषता के लिए मूल्य निर्दिष्ट करना अनिवार्य है। |
2 | next यह अगले चरण को निर्दिष्ट करने का शॉर्टकट है। |
3 | parent इसका उपयोग मूल बीन के नाम को निर्दिष्ट करने के लिए किया जाता है जिसमें से कॉन्फ़िगरेशन को वारिस करना चाहिए। |
एक स्प्रिंगबैच के कदम का XML कॉन्फ़िगरेशन निम्नलिखित है।
<job id = "jobid">
<step id = "step1" next = "step2"/>
<step id = "step2" next = "step3"/>
<step id = "step3"/>
</job>
टुकड़ा
इस टैग का उपयोग परिभाषित करने / कॉन्फ़िगर करने के लिए किया जाता है tasklet। इसकी निम्नलिखित चार विशेषताएँ हैं -
S.No | विशेषता और विवरण |
---|---|
1 | reader यह आइटम रीडर बीन के नाम का प्रतिनिधित्व करता है। यह प्रकार के मूल्य को स्वीकार करता हैorg.springframework.batch.item.ItemReader। |
2 | writer यह आइटम रीडर बीन के नाम का प्रतिनिधित्व करता है। यह प्रकार के मूल्य को स्वीकार करता हैorg.springframework.batch.item.ItemWriter। |
3 | processor यह आइटम रीडर बीन के नाम का प्रतिनिधित्व करता है। यह प्रकार के मूल्य को स्वीकार करता हैorg.springframework.batch.item.ItemProcessor। |
4 | commit-interval इसका उपयोग लेन-देन करने से पहले संसाधित होने वाली वस्तुओं की संख्या को निर्दिष्ट करने के लिए किया जाता है। |
एक स्प्रिंगबैच के चंक का XML कॉन्फ़िगरेशन निम्नलिखित है।
<batch:step id = "step1">
<batch:tasklet>
<batch:chunk reader = "xmlItemReader"
writer = "mysqlItemWriter" processor = "itemProcessor" commit-interval = "10">
</batch:chunk>
</batch:tasklet>
</batch:step>
JobRepository
JobRepository बीन का उपयोग एक रिलेशनल डेटाबेस का उपयोग करके JobRepository को कॉन्फ़िगर करने के लिए किया जाता है। यह बीन प्रकार के वर्ग के साथ जुड़ा हुआ हैorg.springframework.batch.core.repository.JobRepository।
S.No | विशेषता और विवरण |
---|---|
1 | dataSource इसका उपयोग सेम नाम को निर्दिष्ट करने के लिए किया जाता है जो डेटा स्रोत को परिभाषित करता है। |
2 | transactionManager इसका उपयोग बीन के नाम को निर्दिष्ट करने के लिए किया जाता है जो लेन-देन करने वाले को परिभाषित करता है। |
3 | databaseType यह कार्य रिपॉजिटरी में प्रयुक्त रिलेशनल डेटाबेस के प्रकार को निर्दिष्ट करता है। |
निम्नलिखित JobRepository का उदाहरण कॉन्फ़िगरेशन है।
<bean id = "jobRepository"
class = "org.springframework.batch.core.repository.support.JobRepositoryFactoryBean">
<property name = "dataSource" ref = "dataSource" />
<property name = "transactionManager" ref="transactionManager" />
<property name = "databaseType" value = "mysql" />
</bean>
JobLauncher
JobLauncher बीन का उपयोग JobLauncher को कॉन्फ़िगर करने के लिए किया जाता है। यह वर्ग के साथ जुड़ा हुआ हैorg.springframework.batch.core.launch.support.SimpleJobLauncher(हमारे कार्यक्रमों में)। इस बीन के नाम एक संपत्ति हैjobrepository, और इसका उपयोग बीन के नाम को निर्दिष्ट करने के लिए किया जाता है जो परिभाषित करता है jobrepository।
निम्नलिखित जॉबलैन्चर का उदाहरण विन्यास है।
<bean id = "jobLauncher"
class = "org.springframework.batch.core.launch.support.SimpleJobLauncher">
<property name = "jobRepository" ref = "jobRepository" />
</bean>
TransactionManager
TransactionManager बीन का उपयोग एक संबंधित डेटाबेस का उपयोग करके TransactionManager को कॉन्फ़िगर करने के लिए किया जाता है। यह बीन प्रकार के वर्ग के साथ जुड़ा हुआ हैorg.springframework.transaction.platform.TransactionManager।
<bean id = "transactionManager"
class = "org.springframework.batch.support.transaction.ResourcelessTransactionManager" />
डेटा स्रोत
डेटासोर्स बीन का उपयोग कॉन्फ़िगर करने के लिए किया जाता है Datasource। यह बीन प्रकार के वर्ग के साथ जुड़ा हुआ हैorg.springframework.jdbc.datasource.DriverManagerDataSource।
S.No | विशेषता और विवरण |
---|---|
1 | driverClassName यह डेटाबेस से कनेक्ट करने के लिए उपयोग किए जाने वाले ड्राइवर का वर्ग नाम निर्दिष्ट करता है। |
2 | url यह डेटाबेस का URL निर्दिष्ट करता है। |
3 | username यह उपयोगकर्ता नाम को डेटाबेस से जोड़ने के लिए निर्दिष्ट करता है। |
4 | password यह डेटाबेस से जुड़ने के लिए पासवर्ड निर्दिष्ट करता है। |
निम्नलिखित का उदाहरण विन्यास है datasource।
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver" />
<property name = "url" value = "jdbc:mysql://localhost:3306/details" />
<property name = "username" value = "myuser" />
<property name = "password" value = "password" />
</bean>
एक Item Reader एक विशेष स्रोत से स्प्रिंग बैच एप्लिकेशन में डेटा पढ़ता है, जबकि ए Item Writer स्प्रिंग बैच एप्लिकेशन के डेटा को किसी विशेष गंतव्य पर लिखते हैं।
एक Item processorएक वर्ग है जिसमें प्रसंस्करण कोड होता है जो स्प्रिंग बैच में पढ़े गए डेटा को संसाधित करता है। यदि एप्लिकेशन एन रिकॉर्ड पढ़ता है तो प्रोसेसर में कोड प्रत्येक रिकॉर्ड पर निष्पादित किया जाएगा।
ए chunk का एक बच्चा तत्व है tasklet। इसका उपयोग पढ़ने, लिखने और प्रसंस्करण कार्य करने के लिए किया जाता है। हम इस तत्व का उपयोग करके पाठक, लेखक और प्रोसेसर को कॉन्फ़िगर कर सकते हैं, जैसा कि नीचे दिखाया गया है।
<batch:job id = "helloWorldJob">
<batch:step id = "step1">
<batch:tasklet>
<batch:chunk reader = "cvsFileItemReader" writer = "xmlItemWriter"
processor = "itemProcessor" commit-interval = "10">
</batch:chunk>
</batch:tasklet>
</batch:step>
</batch:job>
स्प्रिंग बैच पाठकों और लेखकों को विभिन्न फाइल सिस्टम / डेटाबेस जैसे कि MongoDB, Neo4j, MySQL, XML, flatfile, CSV, आदि पढ़ने और लिखने के लिए प्रदान करता है।
अपने आवेदन में एक पाठक को शामिल करने के लिए, आपको उस पाठक के लिए एक बीन को परिभाषित करने की आवश्यकता है, बीन के भीतर सभी आवश्यक गुणों को मान प्रदान करें और पास करें id ऐसे तत्व के गुण के रूप में सेम के रूप में reader (उसी के लिए writer)।
ItemReader
यह एक कदम (एक बैच प्रक्रिया का) की इकाई है जो डेटा पढ़ता है। एक आइटम राइडर एक समय में एक आइटम पढ़ता है। स्प्रिंग बैच एक इंटरफ़ेस प्रदान करता हैItemReader। सबreaders इस इंटरफ़ेस को लागू करें।
विभिन्न स्रोतों से पढ़ने के लिए स्प्रिंग बैच द्वारा प्रदान किए गए कुछ पूर्वनिर्धारित आइटमरीडर कक्षाएं निम्नलिखित हैं।
रीडर | उद्देश्य |
---|---|
FlatFIleItemReader | फ्लैट फ़ाइलों से डेटा पढ़ने के लिए। |
StaxEventItemReader | XML फ़ाइलों से डेटा पढ़ने के लिए। |
StoredProcedureItemReader | एक डेटाबेस की संग्रहीत प्रक्रियाओं से डेटा पढ़ने के लिए। |
JDBCPagingItemReader | रिलेशनल डेटाबेस डेटाबेस से डेटा पढ़ने के लिए। |
MongoItemReader | MongoDB से डेटा पढ़ने के लिए। |
Neo4jItemReader | Neo4jItemReader से डेटा पढ़ने के लिए। |
हमें कॉन्फ़िगर करने की आवश्यकता है ItemReadersफलियाँ बनाकर। निम्नलिखित का एक उदाहरण हैStaxEventItemReader जो XML फ़ाइल से डेटा पढ़ता है।
<bean id = "mysqlItemWriter"
class = "org.springframework.batch.item.xml.StaxEventItemWriter">
<property name = "resource" value = "file:xml/outputs/userss.xml" />
<property name = "marshaller" ref = "reportMarshaller" />
<property name = "rootTagName" value = "Tutorial" />
</bean>
<bean id = "reportMarshaller"
class = "org.springframework.oxm.jaxb.Jaxb2Marshaller">
<property name = "classesToBeBound">
<list>
<value>Tutorial</value>
</list>
</property>
</bean>
जैसा कि देखा गया है, कॉन्फ़िगर करते समय, हमें संबंधित पाठक के संबंधित वर्ग का नाम निर्दिष्ट करना होगा और हमें सभी आवश्यक गुणों को मान प्रदान करना होगा।
ItemWriter
यह का तत्व है stepएक बैच प्रक्रिया जो डेटा लिखती है। एक आइटमविटर एक आइटम को एक बार लिखता है। स्प्रिंग बैच एक इंटरफ़ेस प्रदान करता हैItemWriter। सभी लेखक इस इंटरफ़ेस को लागू करते हैं।
विभिन्न स्रोतों से पढ़ने के लिए स्प्रिंग बैच द्वारा प्रदान किए गए कुछ पूर्वनिर्धारित आईटीडाइटर कक्षाएं निम्नलिखित हैं।
लेखक | उद्देश्य |
---|---|
FlatFIleItemWriter | फ्लैट फ़ाइलों में डेटा लिखने के लिए। |
StaxEventItemWriter | XML फ़ाइलों में डेटा लिखने के लिए। |
StoredProcedureItemWriter | एक डेटाबेस की संग्रहीत प्रक्रियाओं में डेटा लिखने के लिए। |
JDBCPagingItemWriter | संबंधपरक डेटाबेस डेटाबेस में डेटा लिखने के लिए। |
MongoItemWriter | MongoDB में डेटा लिखने के लिए। |
Neo4jItemWriter | Neo4j में डेटा लिखने के लिए। |
उसी तरह, हमें सेम बनाकर ItemWriters को कॉन्फ़िगर करना होगा। निम्नलिखित का एक उदाहरण हैJdbcCursorItemReader जो MySQL डेटाबेस में डेटा लिखता है।
<bean id = "dbItemReader"
class = "org.springframework.batch.item.database.JdbcCursorItemReader" scope = "step">
<property name = "dataSource" ref = "dataSource" />
<property name = "sql" value = "select * from tutorialsdata" />
<property name = "rowMapper">
<bean class = "TutorialRowMapper" />
</property>
</bean>
आइटम प्रोसेसर
ItemProcessor: डेटा को संसाधित करने के लिए एक ItemProcessor का उपयोग किया जाता है। जब दी गई वस्तु मान्य नहीं होती है तो वह वापस लौट आती हैnull, यह दिए गए आइटम को संसाधित करता है और संसाधित परिणाम लौटाता है। अंतरपटलItemProcessor<I,O> प्रोसेसर का प्रतिनिधित्व करता है।
Tasklet class - जब नहीं reader तथा writerदिया जाता है, एक टास्कलेट स्प्रिंगबैच के लिए एक प्रोसेसर के रूप में कार्य करता है। यह केवल एकल कार्य को संसाधित करता है।
हम इंटरफ़ेस को लागू करके एक कस्टम आइटम प्रोसेसर को परिभाषित कर सकते हैं ItemProcessor पैकेज का org.springframework.batch.item.ItemProcessor। यह आइटमप्रोसेसर वर्ग किसी ऑब्जेक्ट को स्वीकार करता है और डेटा को संसाधित करता है और संसाधित डेटा को किसी अन्य ऑब्जेक्ट के रूप में लौटाता है।
एक बैच प्रक्रिया में, यदि "n"रिकॉर्ड या डेटा तत्व पढ़े जाते हैं, फिर प्रत्येक रिकॉर्ड के लिए, यह डेटा को पढ़ेगा, इसे प्रोसेस करेगा, और लेखक में डेटा लिखेगा। डेटा को संसाधित करने के लिए, यह पारित प्रोसेसर पर निर्भर करता है।
उदाहरण के लिए, मान लें कि आपने किसी विशेष PDF दस्तावेज़ को लोड करने के लिए कोड लिखा है, एक नया पृष्ठ बनाएं, डेटा आइटम को एक सारणीबद्ध प्रारूप में पीडीएफ पर लिखें। यदि आप इस एप्लिकेशन को निष्पादित करते हैं, तो यह XML दस्तावेज़ के सभी डेटा आइटम को पढ़ता है, उन्हें MySQL डेटाबेस में संग्रहीत करता है, और उन्हें दिए गए पीडीएफ दस्तावेज़ में अलग-अलग पृष्ठों में प्रिंट करता है।
उदाहरण
निम्नलिखित एक नमूना ItemProcessor वर्ग है।
import org.springframework.batch.item.ItemProcessor;
public class CustomItemProcessor implements ItemProcessor<Tutorial, Tutorial> {
@Override
public Tutorial process(Tutorial item) throws Exception {
System.out.println("Processing..." + item);
return item;
}
}
यह अध्याय आपको मूल स्प्रिंग बैच एप्लिकेशन दिखाता है। यह बस एक निष्पादित करेगाtasklet एक संदेश प्रदर्शित करने के लिए।
हमारे स्प्रिंग बैच एप्लिकेशन में निम्न फाइलें हैं -
Configuration file- यह एक XML फ़ाइल है जहाँ हम नौकरी और नौकरी के चरणों को परिभाषित करते हैं। (यदि एप्लिकेशन में पाठक और लेखक भी शामिल हैं, तो कॉन्फ़िगरेशनreaders तथा writers इस फाइल में भी शामिल है।)
Context.xml - इस फाइल में, हम जॉब रिपॉजिटरी, जॉब लॉन्चर और ट्रांजैक्शन मैनेजर जैसे सेम को परिभाषित करेंगे।
Tasklet class - इस कक्षा में, हम प्रोसेसिंग कोड जॉब लिखेंगे (इस मामले में, यह एक सरल संदेश प्रदर्शित करता है)
Launcher class - इस क्लास में हम जॉब लॉन्चर चलाकर बैच एप्लीकेशन लॉन्च करेंगे।
jobConfig.xml
निम्नलिखित हमारे नमूना स्प्रिंग बैच एप्लिकेशन की कॉन्फ़िगरेशन फ़ाइल है।
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:batch = "http://www.springframework.org/schema/batch"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/batch
http://www.springframework.org/schema/batch/spring-batch-2.2.xsd
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd ">
<import resource="context.xml" />
<!-- Defining a bean -->
<bean id = "tasklet" class = "a_sample.MyTasklet" />
<!-- Defining a job-->
<batch:job id = "helloWorldJob">
<!-- Defining a Step -->
<batch:step id = "step1">
<tasklet ref = "tasklet"/>
</batch:step>
</batch:job>
</beans>
Context.xml
निम्नलिखित है context.xml हमारे वसंत बैच आवेदन की।
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">
<bean id = "jobRepository"
class="org.springframework.batch.core.repository.support.MapJobRepositoryFactoryBean">
<property name = "transactionManager" ref = "transactionManager" />
</bean>
<bean id = "transactionManager"
class = "org.springframework.batch.support.transaction.ResourcelessTransactionManager" />
<bean id = "jobLauncher"
class = "org.springframework.batch.core.launch.support.SimpleJobLauncher">
<property name = "jobRepository" ref = "jobRepository" />
</bean>
</beans>
Tasklet.java
निम्नलिखित टास्कलेट वर्ग है जो एक सरल संदेश प्रदर्शित करता है।
import org.springframework.batch.core.StepContribution;
import org.springframework.batch.core.scope.context.ChunkContext;
import org.springframework.batch.core.step.tasklet.Tasklet;
import org.springframework.batch.repeat.RepeatStatus;
public class MyTasklet implements Tasklet {
@Override
public RepeatStatus execute(StepContribution arg0, ChunkContext arg1) throws Exception {
System.out.println("Hello This is a sample example of spring batch");
return RepeatStatus.FINISHED;
}
}
App.java
निम्नलिखित कोड है जो बैच प्रक्रिया की प्रशंसा करता है।
import org.springframework.batch.core.Job;
import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.JobParameters;
import org.springframework.batch.core.launch.JobLauncher;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class App {
public static void main(String[] args)throws Exception {
// System.out.println("hello");
String[] springConfig = {"a_sample/job_hello_world.xml"};
// Creating the application context object
ApplicationContext context = new ClassPathXmlApplicationContext(springConfig);
// Creating the job launcher
JobLauncher jobLauncher = (JobLauncher) context.getBean("jobLauncher");
// Creating the job
Job job = (Job) context.getBean("helloWorldJob");
// Executing the JOB
JobExecution execution = jobLauncher.run(job, new JobParameters());
System.out.println("Exit Status : " + execution.getStatus());
}
}
निष्पादित करने पर, उपरोक्त स्प्रिंगबैच कार्यक्रम निम्नलिखित आउटपुट का उत्पादन करेगा -
Apr 24, 2017 4:40:54 PM org.springframework.context.support.AbstractApplicationContext prepareRefresh
INFO:Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@2ef1e4fa: startup date [Mon Apr 24 16:40:54 IST 2017]; root of context hierarchy
Apr 24, 2017 4:40:54 PM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions INFO: Loading XML bean definitions
Apr 24, 2017 4:40:54 PM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
INFO: Loading XML bean definitions
Apr 24, 2017 4:40:54 PM org.springframework.beans.factory.support.DefaultListableBeanFactory preInstantiateSingletons
Apr 24, 2017 4:40:55 PM org.springframework.batch.core.launch.support.SimpleJobLauncher afterPropertiesSet
INFO: No TaskExecutor has been set, defaulting to synchronous executor.
Apr 24, 2017 4:40:55 PM org.springframework.batch.core.launch.support.SimpleJobLauncher$1 run INFO: Job: [FlowJob: [name=helloWorldJob]] launched with the following parameters: [{}] Apr 24, 2017 4:40:55 PM org.springframework.batch.core.job.SimpleStepHandler handleStep INFO: Executing step: [step1] Hello This is a sample example of spring batch Apr 24, 2017 4:40:55 PM org.springframework.batch.core.launch.support.SimpleJobLauncher$1 run
INFO: Job: [FlowJob: [name=helloWorldJob]] completed with the following parameters: [{}] and the following status: [COMPLETED]
Exit Status : COMPLETED
इस अध्याय में, हम एक स्प्रिंग बैच एप्लिकेशन बनाएंगे जो XML रीडर और एक MySQL लेखक का उपयोग करता है।
Reader - आवेदन में हम जिस रीडर का उपयोग कर रहे हैं वह है StaxEventItemReader XML दस्तावेज़ों से डेटा पढ़ने के लिए।
इनपुट एक्सएमएल दस्तावेज़ निम्नलिखित है जो हम इस एप्लिकेशन में उपयोग कर रहे हैं। यह दस्तावेज़ डेटा रिकॉर्ड रखता है जो ट्यूटोरियल आईडी, ट्यूटोरियल लेखक, ट्यूटोरियल शीर्षक, जमा करने की तारीख, ट्यूटोरियल आइकन और ट्यूटोरियल विवरण जैसे विवरण निर्दिष्ट करता है।
<?xml version="1.0" encoding="UTF-8"?>
<tutorials>
<tutorial>
<tutorial_id>1001</tutorial_id>
<tutorial_author>Sanjay</tutorial_author>
<tutorial_title>Learn Java</tutorial_title>
<submission_date>06-05-2007</submission_date>
<tutorial_icon>https://www.tutorialspoint.com/java/images/java-minilogo.jpg</tutorial_icon>
<tutorial_description>Java is a high-level programming language originally
developed by Sun Microsystems and released in 1995.
Java runs on a variety of platforms.
This tutorial gives a complete understanding of Java.');</tutorial_description>
</tutorial>
<tutorial>
<tutorial_id>1002</tutorial_id>
<tutorial_author>Abdul S</tutorial_author>
<tutorial_title>Learn MySQL</tutorial_title>
<submission_date>19-04-2007</submission_date>
<tutorial_icon>https://www.tutorialspoint.com/mysql/images/mysql-minilogo.jpg</tutorial_icon>
<tutorial_description>MySQL is the most popular
Open Source Relational SQL database management system.
MySQL is one of the best RDBMS being used for developing web-based software applications.
This tutorial will give you quick start with MySQL
and make you comfortable with MySQL programming.</tutorial_description>
</tutorial>
<tutorial>
<tutorial_id>1003</tutorial_id>
<tutorial_author>Krishna Kasyap</tutorial_author>
<tutorial_title>Learn JavaFX</tutorial_title>
<submission_date>06-07-2017</submission_date>
<tutorial_icon>https://www.tutorialspoint.com/javafx/images/javafx-minilogo.jpg</tutorial_icon>
<tutorial_description>JavaFX is a Java library used to build Rich Internet Applications.
The applications developed using JavaFX can run on various devices
such as Desktop Computers, Mobile Phones, TVs, Tablets, etc.
This tutorial, discusses all the necessary elements of JavaFX that are required
to develop effective Rich Internet Applications</tutorial_description>
</tutorial>
</tutorials>
Writer - writer हम आवेदन में उपयोग कर रहा है JdbcBatchItemWriterMySQL डेटाबेस में डेटा लिखने के लिए। मान लें कि हमने MySQL के अंदर एक डेटाबेस नामक एक तालिका बनाई है"details"।
CREATE TABLE details.TUTORIALS(
tutorial_id int(10) NOT NULL,
tutorial_author VARCHAR(20),
tutorial_title VARCHAR(50),
submission_date VARCHAR(20),
tutorial_icon VARCHAR(200),
tutorial_description VARCHAR(1000)
);
Processor - एप्लिकेशन में हम जिस प्रोसेसर का उपयोग कर रहे हैं, वह एक कस्टम प्रोसेसर है जो पीडीएफ दस्तावेज़ पर प्रत्येक रिकॉर्ड का डेटा लिखता है।
बैच प्रक्रिया में, यदि "n"रिकॉर्ड या डेटा तत्व पढ़े गए थे, फिर प्रत्येक रिकॉर्ड के लिए, यह डेटा को पढ़ेगा, इसे प्रोसेस करेगा और डेटा को राइटर में लिख देगा। डेटा को संसाधित करने के लिए, यह पारित प्रोसेसर पर निर्भर करता है। इस मामले में, कस्टम प्रोसेसर क्लास में, हमने एक विशेष पीडीएफ दस्तावेज़ को लोड करने के लिए कोड लिखा है, एक नया पृष्ठ बनाया है, एक टैबुलर प्रारूप में पीडीएफ पर डेटा आइटम लिखें।
अंत में, यदि आप इस एप्लिकेशन को निष्पादित करते हैं, तो यह XML दस्तावेज़ से सभी डेटा आइटम को पढ़ता है, उन्हें MySQL डेटाबेस में संग्रहीत करता है, और उन्हें दिए गए पीडीएफ दस्तावेज़ में अलग-अलग पृष्ठों में प्रिंट करता है।
jobConfig.xml
निम्नलिखित हमारे नमूना स्प्रिंग बैच एप्लिकेशन की कॉन्फ़िगरेशन फ़ाइल है। इस फ़ाइल में, हम अय्यूब और चरणों को परिभाषित करेंगे। इनके अलावा, हम ItemReader, ItemProcessor और ItemWriter के लिए भी सेम को परिभाषित करते हैं। (यहां, हम उन्हें उनके संबंधित वर्गों के साथ जोड़ते हैं और उन्हें कॉन्फ़िगर करने के लिए आवश्यक गुणों के लिए मानों को पास करते हैं।)
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:batch = "http://www.springframework.org/schema/batch"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xmlns:util = "http://www.springframework.org/schema/util"
xsi:schemaLocation = "http://www.springframework.org/schema/batch
http://www.springframework.org/schema/batch/spring-batch-2.2.xsd
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
http://www.springframework.org/schema/util
http://www.springframework.org/schema/util/spring-util-3.0.xsd ">
<import resource = "../jobs/context.xml" />
<bean id = "itemProcessor" class = "CustomItemProcessor" />
<batch:job id = "helloWorldJob">
<batch:step id = "step1">
<batch:tasklet>
<batch:chunk reader = "xmlItemReader" writer = "mysqlItemWriter" processor = "itemProcessor">
</batch:chunk>
</batch:tasklet>
</batch:step>
</batch:job>
<bean id = "xmlItemReader"
class = "org.springframework.batch.item.xml.StaxEventItemReader">
<property name = "fragmentRootElementName" value = "tutorial" />
<property name = "resource" value = "classpath:resources/tutorial.xml" />
<property name = "unmarshaller" ref = "customUnMarshaller" />
</bean>
<bean id = "customUnMarshaller" class = "org.springframework.oxm.xstream.XStreamMarshaller">
<property name = "aliases">
<util:map id = "aliases">
<entry key = "tutorial" value = "Tutorial" />
</util:map>
</property>
</bean>
<bean id = "mysqlItemWriter" class = "org.springframework.batch.item.database.JdbcBatchItemWriter">
<property name = "dataSource" ref = "dataSource" />
<property name = "sql">
<value>
<![CDATA[insert into details.tutorials (tutorial_id, tutorial_author, tutorial_title,
submission_date, tutorial_icon, tutorial_description)
values (:tutorial_id, :tutorial_author, :tutorial_title, :submission_date,
:tutorial_icon, :tutorial_description);]]>
</value>
</property>
<property name = "itemSqlParameterSourceProvider">
<bean class = "org.springframework.batch.item.database.BeanPropertyItemSqlParameterSourceProvider" />
</property>
</bean>
</beans>
Context.xml
निम्नलिखित है context.xmlहमारे वसंत बैच आवेदन की। इस फाइल में, हम जॉब रिपॉजिटरी, जॉब लॉन्चर और ट्रांजेक्शन मैनेजर जैसे सेम को परिभाषित करेंगे।
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:jdbc = "http://www.springframework.org/schema/jdbc"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
http://www.springframework.org/schema/jdbc
http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd">
<!-- stored job-meta in database -->
<bean id = "jobRepository"
class = "org.springframework.batch.core.repository.support.JobRepositoryFactoryBean">
<property name = "dataSource" ref = "dataSource" />
<property name = "transactionManager" ref = "transactionManager" />
<property name = "databaseType" value = "mysql" />
</bean>
<bean id = "transactionManager"
class = "org.springframework.batch.support.transaction.ResourcelessTransactionMana ger" />
<bean id = "jobLauncher"
class = "org.springframework.batch.core.launch.support.SimpleJobLauncher">
<property name = "jobRepository" ref = "jobRepository" />
</bean>
<!-- connect to MySQL database -->
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver" />
<property name = "url" value = "jdbc:mysql://localhost:3306/details" />
<property name = "username" value = "myuser" />
<property name = "password" value = "password" />
</bean>
<!-- create job-meta tables automatically -->
<jdbc:initialize-database data-source = "dataSource">
<jdbc:script location = "org/springframework/batch/core/schema-drop-mysql.sql"/>
<jdbc:script location = "org/springframework/batch/core/schema-mysql.sql"/>
</jdbc:initialize-database>
</beans>
CustomItemProcessor.java
निम्नलिखित है processorकक्षा। इस वर्ग में, हम एप्लिकेशन में प्रोसेसिंग कोड लिखते हैं। यहां, हम एक पीडीएफ दस्तावेज़ लोड कर रहे हैं, एक नया पेज बना रहे हैं, एक टेबल बना रहे हैं, और प्रत्येक रिकॉर्ड के लिए निम्नलिखित मान डाल रहे हैं: ट्यूटोरियल आईडी, ट्यूटोरियल नाम, लेखक, तालिका में प्रस्तुत करने की तारीख।
import java.io.File;
import java.io.IOException;
import org.apache.pdfbox.pdmodel.PDDocument;
import org.apache.pdfbox.pdmodel.PDPage;
import org.apache.pdfbox.pdmodel.PDPageContentStream;
import org.apache.pdfbox.pdmodel.font.PDType1Font;
import org.springframework.batch.item.ItemProcessor;
public class CustomItemProcessor implements ItemProcessor<Tutorial, Tutorial> {
public static void drawTable(PDPage page, PDPageContentStream contentStream,
float y, float margin, String[][] content) throws IOException {
final int rows = content.length;
final int cols = content[0].length;
final float rowHeight = 50;
final float tableWidth = page.getMediaBox().getWidth()-(2*margin);
final float tableHeight = rowHeight * rows;
final float colWidth = tableWidth/(float)cols;
final float cellMargin=5f;
// draw the rows
float nexty = y ;
for (int i = 0; i <= rows; i++) {
contentStream.drawLine(margin,nexty,margin+tableWidth,nexty);
nexty-= rowHeight;
}
//draw the columns
float nextx = margin;
for (int i = 0; i <= cols; i++) {
contentStream.drawLine(nextx,y,nextx,y-tableHeight);
nextx += colWidth;
}
// now add the text
contentStream.setFont(PDType1Font.HELVETICA_BOLD,12);
float textx = margin+cellMargin;
float texty = y-15;
for(int i = 0; i < content.length; i++){
for(int j = 0 ; j < content[i].length; j++){
String text = content[i][j];
contentStream.beginText();
contentStream.moveTextPositionByAmount(textx,texty);
contentStream.drawString(text);
contentStream.endText();
textx += colWidth;
}
texty-=rowHeight;
textx = margin+cellMargin;
}
}
@Override
public Tutorial process(Tutorial item) throws Exception {
System.out.println("Processing..." + item);
// Creating PDF document object
PDDocument doc = PDDocument.load(new File("C:/Examples/test.pdf"));
// Creating a blank page
PDPage page = new PDPage();
doc.addPage( page );
PDPageContentStream contentStream = new PDPageContentStream(doc, page);
String[][] content = {{"Id",""+item.getTutorial_id()},
{"Title", item.getTutorial_title()},
{"Authour", item.getTutorial_author()},
{"Submission Date", item.getSubmission_date()}} ;
drawTable(page, contentStream, 700, 100, content);
contentStream.close();
doc.save("C:/Examples/test.pdf" );
System.out.println("Hello");
return item;
}
}
TutorialFieldSetMapper.java
निम्नलिखित ReportFieldSetMapper वर्ग है जो डेटा को ट्यूटोरियल वर्ग में सेट करता है।
import org.springframework.batch.item.file.mapping.FieldSetMapper;
import org.springframework.batch.item.file.transform.FieldSet;
import org.springframework.validation.BindException;
public class TutorialFieldSetMapper implements FieldSetMapper<Tutorial> {
@Override
public Tutorial mapFieldSet(FieldSet fieldSet) throws BindException {
// instantiating the Tutorial class
Tutorial tutorial = new Tutorial();
// Setting the fields from XML
tutorial.setTutorial_id(fieldSet.readInt(0));
tutorial.setTutorial_title(fieldSet.readString(1));
tutorial.setTutorial_author(fieldSet.readString(2));
tutorial.setTutorial_icon(fieldSet.readString(3));
tutorial.setTutorial_description(fieldSet.readString(4));
return tutorial;
}
}
Tutorial.java
निम्नलिखित है Tutorialकक्षा। यह एक साधारण वर्ग हैsetter तथा getter तरीकों।
public class Tutorial {
private int tutorial_id;
private String tutorial_author;
private String tutorial_title;
private String submission_date;
private String tutorial_icon;
private String tutorial_description;
@Override
public String toString() {
return " [id=" + tutorial_id + ", author=" + tutorial_author
+ ", title=" + tutorial_title + ", date=" + submission_date + ", icon ="
+tutorial_icon +", description = "+tutorial_description+"]";
}
public int getTutorial_id() {
return tutorial_id;
}
public void setTutorial_id(int tutorial_id) {
this.tutorial_id = tutorial_id;
}
public String getTutorial_author() {
return tutorial_author;
}
public void setTutorial_author(String tutorial_author) {
this.tutorial_author = tutorial_author;
}
public String getTutorial_title() {
return tutorial_title;
}
public void setTutorial_title(String tutorial_title) {
this.tutorial_title = tutorial_title;
}
public String getSubmission_date() {
return submission_date;
}
public void setSubmission_date(String submission_date) {
this.submission_date = submission_date;
}
public String getTutorial_icon() {
return tutorial_icon;
}
public void setTutorial_icon(String tutorial_icon) {
this.tutorial_icon = tutorial_icon;
}
public String getTutorial_description() {
return tutorial_description;
}
public void setTutorial_description(String tutorial_description) {
this.tutorial_description = tutorial_description;
}
}
App.java
निम्नलिखित कोड है जो बैच प्रक्रिया की प्रशंसा करता है। इस श्रेणी में, हम जॉबलाइनर चलाकर बैच एप्लिकेशन लॉन्च करेंगे।
public class App {
public static void main(String[] args) throws Exception {
String[] springConfig = { "jobs/job_hello_world.xml" };
// Creating the application context object
ApplicationContext context = new ClassPathXmlApplicationContext(springConfig);
// Creating the job launcher
JobLauncher jobLauncher = (JobLauncher) context.getBean("jobLauncher");
// Creating the job
Job job = (Job) context.getBean("helloWorldJob");
// Executing the JOB
JobExecution execution = jobLauncher.run(job, new JobParameters());
System.out.println("Exit Status : " + execution.getStatus());
}
}
इस एप्लिकेशन को निष्पादित करने पर, यह निम्नलिखित आउटपुट का उत्पादन करेगा।
May 05, 2017 4:39:22 PM org.springframework.context.support.ClassPathXmlApplicationContext
prepareRefresh
INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@306a30c7:
startup date [Fri May 05 16:39:22 IST 2017]; root of context hierarchy
May 05, 2017 4:39:23 PM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
May 05, 2017 4:39:32 PM org.springframework.batch.core.job.SimpleStepHandler handleStep
INFO: Executing step: [step1]
Processing... [id=1001, author=Sanjay, title=Learn Java, date=06-05-2007,
icon =https://www.tutorialspoint.com/java/images/java-mini-logo.jpg,
description = Java is a high-level programming language originally developed by Sun Microsystems
and released in 1995. Java runs on a variety of platforms.
This tutorial gives a complete understanding of Java.');]
Hello
Processing.. [id=1002, author=Abdul S, title=Learn MySQL, date=19-04-2007,
icon =https://www.tutorialspoint.com/mysql/images/mysql-mini-logo.jpg,
description = MySQL is the most popular Open Source Relational SQL database management system.
MySQL is one of the best RDBMS being used for developing web-based software applications.
This tutorial will give you quick start with MySQL and make you comfortable with MySQL programming.]
Hello
Processing... [id=1003, author=Krishna Kasyap, title=Learn JavaFX, date=06-072017,
icon =https://www.tutorialspoint.com/javafx/images/javafx-mini-logo.jpg,
description = JavaFX is a Java library used to build Rich Internet Applications.
The applications developed using JavaFX can run on various devices
such as Desktop Computers, Mobile Phones, TVs, Tablets, etc.
This tutorial, discusses all the necessary elements of JavaFX
that are required to develop effective Rich Internet Applications]
Hello
May 05, 2017 4:39:36 PM org.springframework.batch.core.launch.support.SimpleJobLauncher run
INFO: Job: [FlowJob: [name=helloWorldJob]] completed with the following parameters: [{}]
and the following status: [COMPLETED]
Exit Status : COMPLETED
यदि आप सत्यापित करते हैं details.tutorial डेटाबेस में तालिका, यह आपको निम्न आउटपुट दिखाएगा -
ट्यूटोरियल _id | ट्यूटोरियल _औथोर | ट्यूटोरियल _title | स करने की तारीख | ट्यूटोरियल _icon | ट्यूटोरियल _description |
---|---|---|---|---|---|
1001 | संजय | जावा सीखें | 2007/06/05 | https: //www.tutorials point.com / java / images / java-mini-logo.jpg | जावा एक उच्च स्तरीय प्रोग्रामिंग भाषा है जिसे मूल रूप से सन माइक्रोसिस्टम्स द्वारा विकसित किया गया है और 1995 में जारी किया गया था। जावा विभिन्न प्लेटफार्मों पर चलता है। यह ट्यूटोरियल जावा की पूरी समझ देता है। |
1002 | अब्दुल एस | MySQL जानें | 19-04-2007 | https: // www। tutorialspoint.com / mysql / images /mysql-minilogo.jpg | MySQL सबसे लोकप्रिय Open Source Relational SQL डेटाबेस मैनेजमेंट सिस्टम है। MySQL वेब-आधारित सॉफ़्टवेयर अनुप्रयोगों को विकसित करने के लिए उपयोग किए जा रहे सबसे अच्छे RDBMS में से एक है। यह ट्यूटोरियल आपको MySQL के साथ त्वरित शुरुआत देगा और आपको MySQL प्रोग्रामिंग के साथ सहज बना देगा। |
1003 | जावाएफ़एक्स सीखें | कृष्ण कश्यप | 2017/06/07 | https: // www। tutorialspoint.com / javafx / images / javafx-minilogo.jpg | MySQL सबसे लोकप्रिय Open Source Relational SQL डेटाबेस मैनेजमेंट सिस्टम है। MySQL वेब-आधारित सॉफ़्टवेयर अनुप्रयोगों को विकसित करने के लिए उपयोग किए जा रहे सबसे अच्छे RDBMS में से एक है। यह ट्यूटोरियल आपको MySQL के साथ त्वरित शुरुआत देगा और आपको MySQL प्रोग्रामिंग के साथ सहज बना देगा। |
यह नीचे दिखाए गए अनुसार प्रत्येक पृष्ठ पर रिकॉर्ड के साथ एक पीडीएफ उत्पन्न करेगा।
इस अध्याय में, हम एक सरल स्प्रिंग बैच एप्लिकेशन बनाएंगे जिसमें CSV रीडर और XML राइटर का उपयोग किया जाएगा।
Reader - reader हम आवेदन में उपयोग कर रहा है FlatFileItemReader CSV फ़ाइलों से डेटा पढ़ने के लिए।
निम्नलिखित इनपुट CSV फ़ाइल है जो हम इस एप्लिकेशन में उपयोग कर रहे हैं। यह दस्तावेज़ डेटा रिकॉर्ड रखता है जो ट्यूटोरियल आईडी, ट्यूटोरियल लेखक, ट्यूटोरियल शीर्षक, जमा करने की तारीख, ट्यूटोरियल आइकन और ट्यूटोरियल विवरण जैसे विवरण निर्दिष्ट करता है।
1001, "Sanjay", "Learn Java", 06/05/2007
1002, "Abdul S", "Learn MySQL", 19/04/2007
1003, "Krishna Kasyap", "Learn JavaFX", 06/07/2017
Writer - आवेदन में हम जिस लेखक का उपयोग कर रहे हैं वह है StaxEventItemWriter XML फ़ाइल में डेटा लिखने के लिए।
Processor - एप्लिकेशन में हम जिस प्रोसेसर का उपयोग कर रहे हैं, वह एक कस्टम प्रोसेसर है जो CSV फ़ाइल से पढ़े गए रिकॉर्ड को प्रिंट करता है।
jobConfig.xml
निम्नलिखित हमारे नमूना स्प्रिंग बैच एप्लिकेशन की कॉन्फ़िगरेशन फ़ाइल है। इस फ़ाइल में, हम अय्यूब और चरणों को परिभाषित करेंगे। इनके अलावा, हम ItemReader, ItemProcessor और ItemWriter के लिए भी सेम को परिभाषित करते हैं। (यहां, हम उन्हें संबंधित कक्षाओं से जोड़ते हैं और उन्हें कॉन्फ़िगर करने के लिए आवश्यक गुणों के लिए मानों को पास करते हैं।)
<beans xmlns = " http://www.springframework.org/schema/beans"
xmlns:batch = "http://www.springframework.org/schema/batch"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/batch
http://www.springframework.org/schema/batch/spring-batch-2.2.xsd
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">
<import resource = "../jobs/context.xml" />
<bean id = "report" class = "Report" scope = "prototype" />
<bean id = "itemProcessor" class = "CustomItemProcessor" />
<batch:job id = "helloWorldJob">
<batch:step id = "step1">
<batch:tasklet>
<batch:chunk reader = "cvsFileItemReader" writer = "xmlItemWriter"
processor = "itemProcessor" commit-interval = "10">
</batch:chunk>
</batch:tasklet>
</batch:step>
</batch:job>
<bean id = "cvsFileItemReader"
class = "org.springframework.batch.item.file.FlatFileItemReader">
<property name = "resource" value = "classpath:resources/report.csv" />
<property name = "lineMapper">
<bean
class = "org.springframework.batch.item.file.mapping.DefaultLineMapper">
<property name = "lineTokenizer">
<bean
class = "org.springframework.batch.item.file.transform.DelimitedLineTokenizer">
<property name = "names" value = "tutorial_id,
tutorial_author, Tutorial_title, submission_date" />
</bean>
</property>
<property name = "fieldSetMapper">
<bean class = "ReportFieldSetMapper" />
</property>
</bean>
</property>
</bean>
<bean id = "xmlItemWriter"
class = "org.springframework.batch.item.xml.StaxEventItemWriter">
<property name = "resource" value = "file:xml/outputs/tutorials.xml" />
<property name = "marshaller" ref = "reportMarshaller" />
<property name = "rootTagName" value = "tutorials" />
</bean>
<bean id = "reportMarshaller"
class = "org.springframework.oxm.jaxb.Jaxb2Marshaller">
<property name = "classesToBeBound">
<list>
<value>Tutorial</value>
</list>
</property>
</bean>
</beans>
Context.xml
निम्नलिखित है context.xmlहमारे वसंत बैच आवेदन की। इस फाइल में, हम जॉब रिपॉजिटरी, जॉब लॉन्चर और ट्रांजेक्शन मैनेजर जैसे सेम को परिभाषित करेंगे।
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:jdbc = "http://www.springframework.org/schema/jdbc"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
http://www.springframework.org/schema/jdbc
http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd">
<!-- stored job-meta in database -->
<bean id = "jobRepository"
class = "org.springframework.batch.core.repository.support.JobRepositoryFactoryBean">
<property name = "dataSource" ref = "dataSource" />
<property name = "transactionManager" ref = "transactionManager" />
<property name = "databaseType" value = "mysql" />
</bean>
<bean id = "transactionManager"
class = "org.springframework.batch.support.transaction.ResourcelessTransactionManager" />
<bean id = "jobLauncher"
class = "org.springframework.batch.core.launch.support.SimpleJobLauncher">
<property name = "jobRepository" ref = "jobRepository" />
</bean>
<bean id = "dataSource" class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver" />
<property name = "url" value = "jdbc:mysql://localhost:3306/details" />
<property name = "username" value = "myuser" />
<property name = "password" value = "password" />
</bean>
<!-- create job-meta tables automatically -->
<jdbc:initialize-database data-source = "dataSource">
<jdbc:script location = "org/springframework/batch/core/schema-drop-mysql.sql" />
<jdbc:script location = "org/springframework/batch/core/schema-mysql.sql" />
</jdbc:initialize-database>
</beans>
CustomItemProcessor.java
निम्नलिखित प्रोसेसर वर्ग है। इस वर्ग में, हम एप्लिकेशन में प्रोसेसिंग कोड लिखते हैं। यहां, हम प्रत्येक रिकॉर्ड की सामग्री को प्रिंट कर रहे हैं।
import org.springframework.batch.item.ItemProcessor;
public class CustomItemProcessor implements ItemProcessor<Tutorial, Tutorial> {
@Override
public Tutorial process(Tutorial item) throws Exception {
System.out.println("Processing..." + item);
return item;
}
}
TutorialFieldSetMapper.java
निम्नलिखित TutorialFieldSetMapper वर्ग है जो डेटा को ट्यूटोरियल वर्ग में सेट करता है।
import org.springframework.batch.item.file.mapping.FieldSetMapper;
import org.springframework.batch.item.file.transform.FieldSet;
import org.springframework.validation.BindException;
public class TutorialFieldSetMapper implements FieldSetMapper<Tutorial> {
@Override
public Tutorial mapFieldSet(FieldSet fieldSet) throws BindException {
//Instantiating the report object
Tutorial tutorial = new Tutorial();
//Setting the fields
tutorial.setTutorial_id(fieldSet.readInt(0));
tutorial.setTutorial_author(fieldSet.readString(1));
tutorial.setTutorial_title(fieldSet.readString(2));
tutorial.setSubmission_date(fieldSet.readString(3));
return tutorial;
}
}
ट्यूटोरियल.जावा वर्ग
निम्नलिखित है Tutorialकक्षा। यह एक सरल जावा वर्ग हैsetter तथा getterतरीकों। इस वर्ग में, हम XML फ़ाइल के टैग के साथ इस वर्ग के तरीकों को जोड़ने के लिए एनोटेशन का उपयोग कर रहे हैं।
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
@XmlRootElement(name = "tutorial")
public class Tutorial {
private int tutorial_id;
private String tutorial_author;
private String tutorial_title;
private String submission_date;
@XmlAttribute(name = "tutorial_id")
public int getTutorial_id() {
return tutorial_id;
}
public void setTutorial_id(int tutorial_id) {
this.tutorial_id = tutorial_id;
}
@XmlElement(name = "tutorial_author")
public String getTutorial_author() {
return tutorial_author;
}
public void setTutorial_author(String tutorial_author) {
this.tutorial_author = tutorial_author;
}
@XmlElement(name = "tutorial_title")
public String getTutorial_title() {
return tutorial_title;
}
public void setTutorial_title(String tutorial_title) {
this.tutorial_title = tutorial_title;
}
@XmlElement(name = "submission_date")
public String getSubmission_date() {
return submission_date;
}
public void setSubmission_date(String submission_date) {
this.submission_date = submission_date;
}
@Override
public String toString() {
return " [Tutorial id=" + tutorial_id + ",
Tutorial Author=" + tutorial_author + ",
Tutorial Title=" + tutorial_title + ",
Submission Date=" + submission_date + "]";
}
}
App.java
निम्नलिखित कोड है जो बैच प्रक्रिया को लॉन्च करता है। इस वर्ग में, हम JobLauncher चलाकर बैच एप्लिकेशन लॉन्च करेंगे।
import org.springframework.batch.core.Job;
import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.JobParameters;
import org.springframework.batch.core.launch.JobLauncher;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class App {
public static void main(String[] args) throws Exception {
String[] springConfig = { "jobs/job_hello_world.xml" };
// Creating the application context object
ApplicationContext context = new ClassPathXmlApplicationContext(springConfig);
// Creating the job launcher
JobLauncher jobLauncher = (JobLauncher) context.getBean("jobLauncher");
// Creating the job
Job job = (Job) context.getBean("helloWorldJob");
// Executing the JOB
JobExecution execution = jobLauncher.run(job, new JobParameters());
System.out.println("Exit Status : " + execution.getStatus());
}
}
इस एप्लिकेशन को निष्पादित करने पर, यह निम्नलिखित आउटपुट का उत्पादन करेगा।
May 08, 2017 10:10:12 AM org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
INFO: Refreshing
org.springframework.context.support.ClassPathXmlApplicationContext@3d646c37: startup date
[Mon May 08 10:10:12 IST 2017]; root of context hierarchy
May 08, 2017 10:10:12 AM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
May 08, 2017 10:10:15 AM org.springframework.jdbc.datasource.init.ScriptUtils executeSqlScript
INFO: Executing step: [step1]
Processing... [Tutorial id=1001, Tutorial Author=Sanjay,
Tutorial Title=Learn Java, Submission Date=06/05/2007]
Processing... [Tutorial id=1002, Tutorial Author=Abdul S,
Tutorial Title=Learn MySQL, Submission Date=19/04/2007]
Processing... [Tutorial id=1003, Tutorial Author=Krishna Kasyap,
Tutorial Title=Learn JavaFX, Submission Date=06/07/2017]
May 08, 2017 10:10:21 AM org.springframework.batch.core.launch.support.SimpleJobLauncher run
INFO: Job: [FlowJob: [name=helloWorldJob]] completed with the following parameters:
[{}] and the following status: [COMPLETED]
Exit Status : COMPLETED
यह निम्नलिखित सामग्री के साथ एक XML फ़ाइल उत्पन्न करेगा।
<?xml version = "1.0" encoding = "UTF-8"?>
<tutorials>
<tutorial tutorial_id = "1001">
<submission_date>06/05/2007</submission_date>
<tutorial_author>Sanjay</tutorial_author>
<tutorial_title>Learn Java</tutorial_title>
</tutorial>
<tutorial tutorial_id = "1002">
<submission_date>19/04/2007</submission_date>
<tutorial_author>Abdul S</tutorial_author>
<tutorial_title>Learn MySQL</tutorial_title>
</tutorial>
<tutorial tutorial_id = "1003">
<submission_date>06/07/2017</submission_date>
<tutorial_author>Krishna Kasyap</tutorial_author>
<tutorial_title>Learn JavaFX</tutorial_title>
</tutorial>
</tutorials>
इस अध्याय में, हम एक स्प्रिंग बैच एप्लिकेशन बनाएंगे जिसमें MySQL रीडर और XML राइटर का उपयोग किया जाएगा।
Reader - आवेदन में हम जिस रीडर का उपयोग कर रहे हैं वह है JdbcCursorItemReader MySQL डेटाबेस से डेटा पढ़ने के लिए।
मान लें कि हमने नीचे दिखाए गए अनुसार MySQL डेटाबेस में एक तालिका बनाई है -
CREATE TABLE details.xml_mysql(
person_id int(10) NOT NULL,
sales VARCHAR(20),
qty int(3),
staffName VARCHAR(20),
date VARCHAR(20)
);
मान लें कि हमने इसमें निम्नलिखित रिकॉर्ड डाले हैं।
mysql> select * from tutorialsdata;
+-------------+-----------------+----------------+-----------------+
| tutorial_id | tutorial_author | tutorial_title | submission_date |
+-------------+-----------------+----------------+-----------------+
| 101 | Sanjay | Learn Java | 06-05-2007 |
| 102 | Abdul S | Learn MySQL | 19-04-2007 |
| 103 | Krishna Kasyap | Learn JavaFX | 06-07-2017 |
+-------------+-----------------+----------------+-----------------+
3 rows in set (0.00 sec)
Writer - आवेदन में हम जिस लेखक का उपयोग कर रहे हैं वह है StaxEventItemWriter XML फ़ाइल में डेटा लिखने के लिए।
Processor - एप्लिकेशन में हम जिस प्रोसेसर का उपयोग कर रहे हैं, वह एक कस्टम प्रोसेसर है जो CSV फ़ाइल से पढ़े गए रिकॉर्ड को प्रिंट करता है।
jobConfig.xml
निम्नलिखित हमारे नमूना स्प्रिंग बैच एप्लिकेशन की कॉन्फ़िगरेशन फ़ाइल है। इस फाइल में, हम जॉब और स्टेप्स को परिभाषित करेंगे। इनके अलावा, हम ItemReader, ItemProcessor और ItemWriter के लिए भी सेम को परिभाषित करते हैं। (यहां, हम उन्हें उनके संबंधित वर्गों के साथ जोड़ते हैं और उन्हें कॉन्फ़िगर करने के लिए आवश्यक गुणों के लिए मानों को पास करते हैं।)
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:batch = "http://www.springframework.org/schema/batch"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xmlns:util = "http://www.springframework.org/schema/util"
xsi:schemaLocation = " http://www.springframework.org/schema/batch
http://www.springframework.org/schema/batch/spring-batch-2.2.xsd
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">
<import resource = "../jobs/context.xml" />
<bean id = "report" class = "Report" scope = "prototype" />
<bean id = "itemProcessor" class = "CustomItemProcessor" />
<batch:job id = "helloWorldJob">
<batch:step id = "step1">
<batch:tasklet>
<batch:chunk reader = "dbItemReader"
writer = "mysqlItemWriter" processor = "itemProcessor" commit-interval = "10">
</batch:chunk>
</batch:tasklet>
</batch:step>
</batch:job>
<bean id = "dbItemReader"
class = "org.springframework.batch.item.database.JdbcCursorItemReader" scope = "step">
<property name = "dataSource" ref = "dataSource" />
<property name = "sql" value = "select * from tutorials_data" />
<property name = "rowMapper">
<bean class = "TutorialRowMapper" />
</property>
</bean>
<bean id = "mysqlItemWriter"
class = "org.springframework.batch.item.xml.StaxEventItemWriter">
<property name = "resource" value = "file:xml/outputs/tutorials.xml" />
<property name = "marshaller" ref = "reportMarshaller" />
<property name = "rootTagName" value = "Tutorial" />
</bean>
<bean id = "reportMarshaller" class = "org.springframework.oxm.jaxb.Jaxb2Marshaller">
<property name = "classesToBeBound">
<list>
<value>Tutorial</value>
</list>
</property>
</bean>
</beans>
Context.xml
निम्नलिखित है context.xmlहमारे वसंत बैच आवेदन की। इस फाइल में, हम जॉब रिपॉजिटरी, जॉब लॉन्चर और ट्रांजेक्शन मैनेजर जैसे सेम को परिभाषित करेंगे।
<beans xmlns = " http://www.springframework.org/schema/beans"
xmlns:jdbc = "http://www.springframework.org/schema/jdbc"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
http://www.springframework.org/schema/jdbc
http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd ">
<!-- stored job-meta in database -->
<bean id = "jobRepository"
class = "org.springframework.batch.core.repository.support.JobRepositoryFactoryBean">
<property name = "dataSource" ref = "dataSource" />
<property name = "transactionManager" ref = "transactionManager" />
<property name = "databaseType" value = "mysql" />
</bean>
<bean id = "transactionManager"
class = "org.springframework.batch.support.transaction.ResourcelessTransactionMana ger" />
<bean id = "jobLauncher"
class = "org.springframework.batch.core.launch.support.SimpleJobLauncher">
<property name = "jobRepository" ref = "jobRepository" />
</bean>
<!-- connect to MySQL database -->
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver" />
<property name = "url" value = "jdbc:mysql://localhost:3306/details" />
<property name = "username" value = "myuser" />
<property name = "password" value = "password" />
</bean>
<!-- create job-meta tables automatically -->
<jdbc:initialize-database data-source = "dataSource">
<jdbc:script location = "org/springframework/batch/core/schema-drop-mysql.sql" />
<jdbc:script location = "org/springframework/batch/core/schema-mysql.sql" />
</jdbc:initialize-database>
</beans>
CustomItemProcessor.java
निम्नलिखित प्रोसेसर वर्ग है। इस वर्ग में, हम एप्लिकेशन में प्रोसेसिंग कोड लिखते हैं। यहां, हम प्रत्येक रिकॉर्ड की सामग्री को प्रिंट कर रहे हैं।
import org.springframework.batch.item.ItemProcessor;
public class CustomItemProcessor implements ItemProcessor<Tutorial, Tutorial> {
@Override
public Tutorial process(Tutorial item) throws Exception {
System.out.println("Processing..." + item);
return item;
}
}
TutorialRowMapper.java
निम्नलिखित है TutorialRowMapper वह वर्ग जो डेटा को सेट करता है Tutorial कक्षा।
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
public class TutorialRowMapper implements RowMapper<Tutorial> {
@Override
public Tutorial mapRow(ResultSet rs, int rowNum) throws SQLException {
Tutorial tutorial = new Tutorial();
tutorial.setTutorial_id(rs.getInt("tutorial_id"));
tutorial.setTutorial_author(rs.getString("tutorial_author"));
tutorial.setTutorial_title(rs.getString("tutorial_title"));
tutorial.setSubmission_date(rs.getString("submission_date"));
return tutorial;
}
}
Tutorial.java
निम्नलिखित है Tutorialकक्षा। यह एक सरल जावा वर्ग हैsetter तथा getterतरीकों। इस वर्ग में, हम XML फ़ाइल के टैग के साथ इस वर्ग के तरीकों को जोड़ने के लिए एनोटेशन का उपयोग कर रहे हैं।
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
@XmlRootElement(name = "details")
public class Tutorial {
int tutorial_id;
String tutorial_author;
String submission_date;
@XmlAttribute(name = "tutorial_id")
public int getTutorial_id() {
return tutorial_id;
}
public void setTutorial_id(int tutorial_id) {
this.tutorial_id = tutorial_id;
}
@XmlElement(name = "tutorial_author")
public String getTutorial_author() {
return tutorial_author;
}
public void setTutorial_author(String tutorial_author) {
this.tutorial_author = tutorial_author;
}
@XmlElement(name = "tutorial_title")
public String getTutorial_title() {
return tutorial_title;
}
public void setTutorial_title(String tutorial_title) {
this.tutorial_title = tutorial_title;
}
@XmlElement(name = "submission_date")
public String getSubmission_date() {
return submission_date;
}
public void setSubmission_date(String submission_date) {
this.submission_date = submission_date;
}
public String toString() {
return " [Tutorial Id=" + tutorial_id + ",
Tutorial Author =" + tutorial_author + ",
Tutorial Title =" + tutorial_title + ",
Submission Date =" + submission_date + "]";
}
}
App.java
निम्नलिखित कोड है जो बैच प्रक्रिया की प्रशंसा करता है। इस श्रेणी में, हम जॉबलाइनर चलाकर बैच एप्लिकेशन लॉन्च करेंगे।
import org.springframework.batch.core.Job;
import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.JobParameters;
import org.springframework.batch.core.launch.JobLauncher;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class App {
public static void main(String[] args) throws Exception {
String[] springConfig = { "jobs/job_hello_world.xml" };
// Creating the application context object
ApplicationContext context = new ClassPathXmlApplicationContext(springConfig);
// Creating the job launcher
JobLauncher jobLauncher = (JobLauncher) context.getBean("jobLauncher");
// Creating the job
Job job = (Job) context.getBean("helloWorldJob");
// Executing the JOB
JobExecution execution = jobLauncher.run(job, new JobParameters());
System.out.println("Exit Status : " + execution.getStatus());
}
}
इस एप्लिकेशन को निष्पादित करने पर, यह निम्नलिखित आउटपुट का उत्पादन करेगा।
May 08, 2017 11:32:06 AM org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@3d646c37:
startup date [Mon May 08 11:32:06 IST 2017]; root of context hierarchy
May 08, 2017 11:32:06 AM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
INFO: Loading XML bean definitions from class path resource [jobs/job_hello_world.xml]
May 08, 2017 11:32:07 AM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
May 08, 2017 11:32:14 AM org.springframework.batch.core.job.SimpleStepHandler handleStep
INFO: Executing step: [step1]
Processing... [Tutorial Id=101, Tutorial Author=Sanjay,
Tutorial Title=Learn Java, Submission Date=06-05-2007]
Processing... [Tutorial Id=102, Tutorial Author=Abdul S,
Tutorial Title=Learn MySQL, Submission Date=19-04-2007]
Processing... [Tutorial Id=103, Tutorial Author=Krishna Kasyap,
Tutorial Title=Learn JavaFX, Submission Date=06-07-2017]
May 08, 2017 11:32:14 AM org.springframework.batch.core.launch.support.SimpleJobLauncher run
INFO: Job: [FlowJob: [name=helloWorldJob]] completed with the following parameters:
[{}] and the following status: [COMPLETED]
Exit Status : COMPLETED
यह निम्नलिखित सामग्री के साथ एक XML फ़ाइल उत्पन्न करेगा।
<?xml version = "1.0" encoding = "UTF-8"?>
<Tutorial>
<details tutorial_id = "101">
<submission_date>06-05-2007</submission_date>
<tutorial_author>Sanjay</tutorial_author>
<tutorial_title>Learn Java</tutorial_title>
</details>
<details tutorial_id = "102">
<submission_date>19-04-2007</submission_date>
<tutorial_author>Abdul S</tutorial_author>
<tutorial_title>Learn MySQL</tutorial_title>
</details>
<details tutorial_id = "103">
<submission_date>06-07-2017</submission_date>
<tutorial_author>Krishna Kasyap</tutorial_author>
<tutorial_title>Learn JavaFX</tutorial_title>
</details>
</Tutorial>
इस अध्याय में, हम एक स्प्रिंग बैच एप्लिकेशन बनाएंगे जिसमें MySQL रीडर और a का उपयोग किया जाता है Flatfile लेखक (.txt)।
Reader - आवेदन में हम जिस रीडर का उपयोग कर रहे हैं वह है JdbcCursorItemReader MySQL डेटाबेस से डेटा पढ़ने के लिए।
मान लें कि हमने नीचे दिखाए गए अनुसार MySQL डेटाबेस में एक तालिका बनाई है।
CREATE TABLE details.xml_mysql(
person_id int(10) NOT NULL,
sales VARCHAR(20),
qty int(3),
staffName VARCHAR(20),
date VARCHAR(20)
);
मान लें कि हमने इसमें निम्नलिखित रिकॉर्ड डाले हैं।
mysql> select * from tutorialsdata;
+-------------+-----------------+----------------+-----------------+
| tutorial_id | tutorial_author | tutorial_title | submission_date |
+-------------+-----------------+----------------+-----------------+
| 101 | Sanjay | Learn Java | 06-05-2007 |
| 102 | Abdul S | Learn MySQL | 19-04-2007 |
| 103 | Krishna Kasyap | Learn JavaFX | 06-07-2017 |
+-------------+-----------------+----------------+-----------------+
3 rows in set (0.00 sec)
Writer - आवेदन में हम जिस लेखक का उपयोग कर रहे हैं वह है FlatFileItemWriter करने के लिए डेटा लिखने के लिए flatfile (।टेक्स्ट)।
Processor - एप्लिकेशन में हम जिस प्रोसेसर का उपयोग कर रहे हैं, वह एक कस्टम प्रोसेसर है जो CSV फ़ाइल से पढ़े गए रिकॉर्ड को प्रिंट करता है।
jobConfig.xml
निम्नलिखित हमारे नमूना स्प्रिंग बैच एप्लिकेशन की कॉन्फ़िगरेशन फ़ाइल है। इस फाइल में, हम जॉब और स्टेप्स को परिभाषित करेंगे। इनके अलावा, हम ItemReader, ItemProcessor और ItemWriter के लिए भी सेम को परिभाषित करते हैं। (यहां, हम उन्हें संबंधित कक्षाओं से जोड़ते हैं और उन्हें कॉन्फ़िगर करने के लिए आवश्यक गुणों के लिए मानों को पास करते हैं।)
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:batch = "http://www.springframework.org/schema/batch"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xmlns:util = "http://www.springframework.org/schema/util"
xsi:schemaLocation = "http://www.springframework.org/schema/batch
http://www.springframework.org/schema/batch/spring-batch-2.2.xsd
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">
<import resource = "../jobs/context.xml" />
<bean id = "tutorial" class = "Tutorial" scope = "prototype" />
<bean id = "itemProcessor" class = "CustomItemProcessor" />
<batch:job id = "helloWorldJob">
<batch:step id = "step1">
<batch:tasklet>
<batch:chunk reader = "mysqlItemReader"
writer = "flatFileItemWriter" processor = "itemProcessor"
commit-interval = "10">
</batch:chunk>
</batch:tasklet>
</batch:step>
</batch:job>
<bean id = "mysqlItemReader"
class = "org.springframework.batch.item.database.JdbcCursorItemReader" >
<property name = "dataSource" ref = "dataSource" />
<property name = "sql" value = "select * from details.tutorialsdata" />
<property name = "rowMapper">
<bean class = "TutorialRowMapper" />
</property>
</bean>
<bean id = "flatFileItemWriter"
class = " org.springframework.batch.item.file.FlatFileItemWriter">
<property name = "resource" value = "file:target/outputfiles/employee_output.txt"/>
<property name = "lineAggregator">
<bean class = " org.springframework.batch.item.file.transform.PassThroughLineAggregator"/>
</property>
</bean>
</beans>
Context.xml
निम्नलिखित है context.xmlहमारे वसंत बैच आवेदन की। इस फाइल में, हम जॉब रिपॉजिटरी, जॉब लॉन्चर और ट्रांजेक्शन मैनेजर जैसे सेम को परिभाषित करेंगे।
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xmlns:jdbc = "http://www.springframework.org/schema/jdbc"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
http://www.springframework.org/schema/jdbc
http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd ">
<!-- stored job-meta in database -->
<bean id = "jobRepository"
class = "org.springframework.batch.core.repository.support.JobRepositoryFactoryBean">
<property name = "dataSource" ref = "dataSource" />
<property name = "transactionManager" ref = "transactionManager" />
<property name = "databaseType" value = "mysql" />
</bean>
<bean id = "transactionManager"
class = "org.springframework.batch.support.transaction.ResourcelessTransactionManager" />
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver" />
<property name = "url" value = "jdbc:mysql://localhost:3306/details" />
<property name = "username" value = "myuser" />
<property name = "password" value = "password" />
</bean>
<bean id = "jobLauncher"
class = "org.springframework.batch.core.launch.support.SimpleJobLauncher">
<property name = "jobRepository" ref = "jobRepository" />
</bean>
<!-- create job-meta tables automatically -->
<jdbc:initialize-database data-source = "dataSource">
<jdbc:script location = "org/springframework/batch/core/schema-drop-mysql.sql" />
<jdbc:script location = "org/springframework/batch/core/schema-mysql.sql" />
</jdbc:initialize-database>
</beans>
CustomItemProcessor.java
निम्नलिखित प्रोसेसर वर्ग है। इस वर्ग में, हम एप्लिकेशन में प्रोसेसिंग कोड लिखते हैं। यहां, हम प्रत्येक रिकॉर्ड की सामग्री को प्रिंट कर रहे हैं।
import org.springframework.batch.item.ItemProcessor;
// Implementing the ItemProcessor interface
public class CustomItemProcessor implements ItemProcessor<Tutorial, Tutorial> {
@Override
public Tutorial process(Tutorial item) throws Exception {
System.out.println("Processing..." + item);
return item;
}
}
TutorialRowMapper.java
निम्नलिखित है TutorialRowMapper वह वर्ग जो डेटा को सेट करता है Tutorial कक्षा।
public class TutorialRowMapper implements RowMapper<Tutorial> {
@Override
public Tutorial mapRow(ResultSet rs, int rowNum) throws SQLException {
Tutorial tutorial = new Tutorial();
tutorial.setTutorial_id(rs.getInt("tutorial_id"));
tutorial.setTutorial_title(rs.getString("tutorial_title"));
tutorial.setTutorial_author(rs.getString("tutorial_author"));
tutorial.setSubmission_date(rs.getString("submission_date"));
return tutorial;
}
}
Tutorial.java
निम्नलिखित है Tutorialकक्षा। यह एक सरल जावा वर्ग हैsetter तथा getterतरीकों। इस वर्ग में, हम XML फ़ाइल के टैग के साथ इस वर्ग के तरीकों को जोड़ने के लिए एनोटेशन का उपयोग कर रहे हैं।
public class Tutorial {
private int tutorial_id;
private String tutorial_title;
private String tutorial_author;
private String submission_date;
public int getTutorial_id() {
return tutorial_id;
}
public void setTutorial_id(int tutorial_id) {
this.tutorial_id = tutorial_id;
}
public String getTutorial_title() {
return tutorial_title;
}
public void setTutorial_title(String tutorial_title) {
this.tutorial_title = tutorial_title;
}
public String getTutorial_author() {
return tutorial_author;
}
public void setTutorial_author(String tutorial_author) {
this.tutorial_author = tutorial_author;
}
public String getSubmission_date() {
return submission_date;
}
public void setSubmission_date(String submission_date) {
this.submission_date = submission_date;
}
@Override
public String toString() {
return " [id=" + tutorial_id + ", title=" +
tutorial_title + ",
author=" + tutorial_author + ", date=" +
submission_date + "]";
}
}
App.java
निम्नलिखित कोड है जो बैच प्रक्रिया की प्रशंसा करता है। इस श्रेणी में, हम जॉबलाइनर चलाकर बैच एप्लिकेशन लॉन्च करेंगे।
import org.springframework.batch.core.Job;
import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.JobParameters;
import org.springframework.batch.core.launch.JobLauncher;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class App {
public static void main(String[] args) throws Exception {
String[] springConfig = { "jobs/job_hello_world.xml" };
// Creating the application context object
ApplicationContext context = new ClassPathXmlApplicationContext(springConfig);
// Creating the job launcher
JobLauncher jobLauncher = (JobLauncher) context.getBean("jobLauncher");
// Creating the job
Job job = (Job) context.getBean("helloWorldJob");
// Executing the JOB
JobExecution execution = jobLauncher.run(job, new JobParameters());
System.out.println("Exit Status : " + execution.getStatus());
}
}
इस एप्लिकेशन को निष्पादित करने पर, यह निम्नलिखित आउटपुट का उत्पादन करेगा।
May 09, 2017 5:44:48 PM org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
INFO: Refreshing org.springframework.context.support.ClassPathXml
ApplicationContext@3d646c37: startup date [Tue May
09 17:44:48 IST 2017]; root of context hierarchy
May 09, 2017 5:44:48 PM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
May 09, 2017 5:44:56 PM org.springframework.batch.core.launch.support.SimpleJobLauncher run
INFO: Job: [FlowJob: [name=helloWorldJob]] launched
with the following parameters: [{}]
May 09, 2017 5:44:56 PM org.springframework.batch.core.job.SimpleStepHandler handleStep
INFO: Executing step: [step1]
Processing...Report [id=101, title=Learn Java, author=Sanjay, date=06-05-2007]
Processing...Report [id=102, title=Learn MySQL, author=Abdul S, date=19-04-2007]
Processing...Report [id=103, title=Learn JavaFX, author=Krishna Kasyap, date=0607-2017]
May 09, 2017 5:44:57 PM org.springframework.batch.core.launch.support.SimpleJobLauncher run
INFO: Job: [FlowJob: [name=helloWorldJob]] completed with the following parameters:
[{}] and the following status: [COMPLETED]
Hello
Exit Status : COMPLETED
यह उत्पन्न करेगा .txt निम्नलिखित सामग्री के साथ फ़ाइल।
Report [id=101, title=Learn Java, author=Sanjay, date=06-05-2007]
Report [id=102, title=Learn MySQL, author=Abdul S, date=19-04-2007]
Report [id=103, title=Learn JavaFX, author=Krishna Kasyap, date=06-07-2017]