<div dir="ltr" style="text-align: justify;">
<div dir="ltr" style="text-align: justify;">
<div dir="ltr" style="text-align: justify;">
<div dir="ltr" style="text-align: justify;">
<div dir="ltr" style="text-align: justify;">
<div class="separator" style="clear: both; text-align: center;"><img src="https://dineshonjava.com/wp-content/uploads/2013/01/spring-batch-reference-model.png" width="640" height="254" border="0" /></div>
<p>The diagram above highlights the key concepts that make up the domain language of batch. A <i><b>Job </b></i>has one to many steps, which has exactly one <i><b>ItemReader</b></i>, <i><b>ItemProcessor</b></i>, and <i><b>ItemWriter</b></i>. A job needs to be launched (<i><b>JobLauncher</b></i>), and meta data about the currently running process needs to be stored (<i><b>JobRepository</b></i>).</p>
<h2><i><b>Job- </b></i></h2>
<p>A Job is an entity that encapsulates an entire batch process. As is common with other Spring projects, a Job will be wired together via an XML configuration file. This file may be referred to as the &#8220;job configuration&#8221;. However, Job is just the top of an overall hierarchy:</p>
<div class="separator" style="clear: both; text-align: center;"><img src="https://dineshonjava.com/wp-content/uploads/2013/01/job-heirarchy.png" border="0" /></div>
<p>In Spring Batch, a Job is simply a container for Steps. It combines multiple steps that belong logically together in a flow and allows for configuration of properties global to all steps, such as restartability. The job configuration contains:</p>
<div class="itemizedlist">
<ul >
<li>The simple name of the job</li>
<li>Definition and ordering of Steps</li>
<li>Whether or not the job is restartable</li>
</ul>
</div>
<p>A default simple implementation of the <i><b>Job </b></i>interface is provided by Spring Batch in the form of the <i><b>SimpleJob </b></i>class which creates some standard functionality on top of Job, however the batch namespace abstracts away the need to instantiate it directly. Instead, the <;<i><b>job</b></i>>; tag can be used:</p>
</div>
</div>
<pre class="highlight"><;job id="myEmpExpireJob">; 
 <;!-- Step bean details ommitted for clarity -->; 
 <;step id="readEmployeeData" next="writeEmployeeData">;<;/step>; 
 <;step id="writeEmployeeData" next="employeeDataProcess">;<;/step>; 
 <;step id="employeeDataProcess">;<;/step>; 
<;/job>; 
</pre>
<div id="ads-id" align="center"></div>
<h2><b>JobInstance- </b></h2>
<p>A JobInstance refers to the concept of a logical job run. Let&#8217;s consider a batch job that should be run once at the end of the day, such as the &#8216;EndOfDay&#8217; job from the diagram above. There is one &#8216;EndOfDay&#8217; Job, but each individual run of the Job must be tracked separately. In the case of this job, there will be one logical JobInstance per day. For example, there will be a January 1st run, and a January 2nd run. If the January 1st run fails the first time and is run again the next day, it is still the January 1st run.</p>
<h2><b>JobParameters- </b></h2>
<p>Having discussed <i><b>JobInstance </b></i>and how it differs from Job, the natural question to ask is: &#8220;<b>how is one JobInstance</b> <b>distinguished from another</b>?&#8221; The answer is: <i><b>JobParameters</b></i>. <i><b>JobParameters </b></i>is a set of parameters used to start a batch job. They can be used for identification or even as reference data during the run:</p>
<div class="separator" style="clear: both; text-align: center;"><img src="https://dineshonjava.com/wp-content/uploads/2013/01/job-stereotypes-parameters.png" border="0" /></div>
<h2><b>JobExecution-</b></h2>
<p>A <i><b>JobExecution </b></i>refers to the technical concept of a single attempt to run a Job. An execution may end in failure or success, but the <i><b>JobInstance </b></i>corresponding to a given execution will not be considered complete unless the execution completes successfully. Using the EndOfDay Job described above as an example, consider a <i><b>JobInstance </b></i>for 01-01-2013 that failed the first time it was run. If it is run again with the same job parameters as the first run (01-01-2013), a new <i><b>JobExecution </b></i>will be created. However, there will still be only one <i><b>JobInstance</b></i>.</p>
<p>A Job defines what a job is and how it is to be executed, and <i><b>JobInstance </b></i>is a purely organizational object to group executions together, primarily to enable correct restart semantics. A <i><b>JobExecution</b></i>, however, is the primary storage mechanism for what actually happened during a run, and as such contains many more properties that must be controlled and persisted:</p>
<table border="1" summary="JobExecution Properties">
<tbody>
<tr>
<td>status</td>
<td>A BatchStatus object that indicates the status of the execution. While running, it&#8217;s BatchStatus.STARTED, if it fails, it&#8217;s BatchStatus.FAILED, and if it finishes successfully, it&#8217;s BatchStatus.COMPLETED</td>
</tr>
<tr>
<td>startTime</td>
<td>A java.util.Date representing the current system time when the execution was started.</td>
</tr>
<tr>
<td>endTime</td>
<td>A java.util.Date representing the current system time when the execution finished, regardless of whether or not it was successful.</td>
</tr>
<tr>
<td>exitStatus</td>
<td>The ExitStatus indicating the result of the run. It is most important because it contains an exit code that will be returned to the caller. See chapter 5 for more details.</td>
</tr>
<tr>
<td>createTime</td>
<td>A java.util.Date representing the current system time when the JobExecution was first persisted. The job may not have been started yet (and thus has no start time), but it will always have a createTime, which is required by the framework for managing job level ExecutionContexts.</td>
</tr>
<tr>
<td>lastUpdated</td>
<td>A java.util.Date representing the last time a JobExecution was persisted.</td>
</tr>
<tr>
<td>executionContext</td>
<td>The &#8216;property bag&#8217; containing any user data that needs to be persisted between executions.</td>
</tr>
<tr>
<td>failureExceptions</td>
<td>The list of exceptions encountered during the execution of a Job. These can be useful if more than one exception is encountered during the failure of a Job.</td>
</tr>
</tbody>
</table>
<h2><b>Step-</b></h2>
<p>A <i><b>Step </b></i>is a domain object that encapsulates an independent, sequential phase of a batch job. Therefore, every Job is composed entirely of one or more steps. A Step contains all of the information necessary to define and control the actual batch processing. This is a necessarily vague description because the contents of any given Step are at the discretion of the developer writing a Job. A Step can be as simple or complex as the developer desires. A simple Step might load data from a file into the database, requiring little or no code. (depending upon the implementations used) A more complex Step may have complicated business rules that are applied as part of the processing. As with Job, a Step has an individual <i><b>StepExecution </b></i>that corresponds with a unique <i><b>JobExecution</b></i>:</p>
<div class="separator" style="clear: both; text-align: center;"><img src="https://dineshonjava.com/wp-content/uploads/2013/01/jobHeirarchyWithSteps.png" border="0" /></div>
</div>
<h2><b>StepExecution-</b></h2>
<p>A <i><b>StepExecution </b></i>represents a single attempt to execute a Step. A new <i><b>StepExecution </b></i>will be created each time a Step is run, similar to <i><b>JobExecution</b></i>. However, if a step fails to execute because the step before it fails, there will be no execution persisted for it. A <i><b>StepExecution </b></i>will only be created when its Step is actually started.</p>
<p>Step executions are represented by objects of the <i><b>StepExecution </b></i>class. Each execution contains a reference to its corresponding step and <b><i>JobExecution</i></b>, and transaction related data such as commit and rollback count and start and end times. Additionally, each step execution will contain an <i><b>ExecutionContext</b></i>, which contains any data a developer needs persisted across batch runs, such as statistics or state information needed to restart. The following is a listing of the properties for <i><b>StepExecution</b></i>:</p>
<h2><b>StepExecution Properties</b></h2>
<div class="table-contents">
<table border="1" summary="StepExecution Properties">
<tbody>
<tr>
<td>status</td>
<td>A BatchStatus object that indicates the status of the execution. While it&#8217;s running, the status is BatchStatus.STARTED, if it fails, the status is BatchStatus.FAILED, and if it finishes successfully, the status is BatchStatus.COMPLETED</td>
</tr>
<tr>
<td>startTime</td>
<td>A java.util.Date representing the current system time when the execution was started.</td>
</tr>
<tr>
<td>endTime</td>
<td>A java.util.Date representing the current system time when the execution finished, regardless of whether or not it was successful.</td>
</tr>
<tr>
<td>exitStatus</td>
<td>The ExitStatus indicating the result of the execution. It is most important because it contains an exit code that will be returned to the caller. See chapter 5 for more details.</td>
</tr>
<tr>
<td>executionContext</td>
<td>The &#8216;property bag&#8217; containing any user data that needs to be persisted between executions.</td>
</tr>
<tr>
<td>readCount</td>
<td>The number of items that have been successfully read</td>
</tr>
<tr>
<td>writeCount</td>
<td>The number of items that have been successfully written</td>
</tr>
<tr>
<td>commitCount</td>
<td>The number transactions that have been committed for this execution</td>
</tr>
<tr>
<td>rollbackCount</td>
<td>The number of times the business transaction controlled by the Step has been rolled back.</td>
</tr>
<tr>
<td>readSkipCount</td>
<td>The number of times read has failed, resulting in a skipped item.</td>
</tr>
<tr>
<td>processSkipCount</td>
<td>The number of times process has failed, resulting in a skipped item.</td>
</tr>
<tr>
<td>filterCount</td>
<td>The number of items that have been &#8216;filtered&#8217; by the ItemProcessor.</td>
</tr>
<tr>
<td>writeSkipCount</td>
<td>The number of times write has failed, resulting in a skipped item.</td>
</tr>
</tbody>
</table>
</div>
<h2><b>JobRepository-</b></h2>
<p><i><b>JobRepository </b></i>is the persistence mechanism for all of the Stereotypes mentioned above. It provides CRUD operations for <i><b>JobLauncher</b></i>, Job, and Step implementations. When a Job is first launched, a JobExecution is obtained from the repository, and during the course of execution <b><i>StepExecution </i></b>and <i><b>JobExecution </b></i>implementations are persisted by passing them to the repository:</p>
<pre class="highlight"><;job-repository id="jobRepository"/>; 
</pre>
</div>
<h2><b>JobLauncher-</b></h2>
<p><b><i>JobLauncher </i></b>represents a simple interface for launching a Job with a given set of JobParameters:</p>
<pre class="highlight">public interface JobLauncher { 
 
 public JobExecution run(Job job, JobParameters jobParameters) 
 throws JobExecutionAlreadyRunningException, JobRestartException; 
} 
</pre>
<h2><b>Item Reader-</b></h2>
<p><i><b>ItemReader </b></i>is an abstraction that represents the retrieval of input for a Step, one item at a time. When the <i><b>ItemReader </b></i>has exhausted the items it can provide, it will indicate this by returning null. More details about the <b><i>ItemReader </i></b>interface and its various implementations can be found in later Chapter , <a href="https://dineshonjava.com/itemreaders-and-itemwriters-in-spring/"><i><b>ItemReaders </b></i>and <i><b>ItemWriters</b></i></a>.</p>
<h2><b>Item Writer-</b></h2>
<p><i><b>ItemWriter </b></i>is an abstraction that represents the output of a Step, one batch or chunk of items at a time. Generally, an item writer has no knowledge of the input it will receive next, only the item that was passed in its current invocation. More details about the <b><i>ItemWriter </i></b>interface and its various implementations can be found in later Chapter, <a href="https://dineshonjava.com/itemreaders-and-itemwriters-in-spring/"><b><i>ItemReaders </i></b>and <i><b>ItemWriters</b></i></a>.</p>
<h2><b>Item Processor-</b></h2>
<p><i><b>ItemProcessor </b></i>is an abstraction that represents the business processing of an item. While the <i><b>ItemReader </b></i>reads one item, and the <i><b>ItemWriter </b></i>writes them, the <i><b>ItemProcessor </b></i>provides access to transform or apply other business processing. If, while processing the item, it is determined that the item is not valid, returning null indicates that the item should not be written out. More details about the <i><b>ItemProcessor </b></i>interface can be found in later Chapter, <a href="https://dineshonjava.com/itemreaders-and-itemwriters-in-spring/"><i><b>ItemReaders </b></i>and <b><i>ItemWriters</i></b></a>.</p>
<h3><b>Batch Namespace-</b></h3>
<p>Many of the domain concepts listed above need to be configured in a Spring <b><i>ApplicationContext</i></b>. While there are implementations of the interfaces above that can be used in a standard bean definition, a namespace has been provided for ease of configuration:</p>
<pre class="highlight"><;beans:beans xmlns:beans="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.springframework.org/schema/batch" xsi:schemalocation=" 
 http://www.springframework.org/schema/beans 
 http://www.springframework.org/schema/beans/spring-beans-2.0.xsd 
 http://www.springframework.org/schema/batch 
 http://www.springframework.org/schema/batch/spring-batch-2.0.xsd">; 
 
 <;job id="ioSampleJob">; 
 <;step id="step1">; 
 <;tasklet>; 
 <;chunk commit-interval="2" reader="itemReader" writer="itemWriter">;<;/chunk>; 
 <;/tasklet>; 
 <;/step>; 
 <;/job>; 
 
<;/beans:beans>; 
</pre>
<div style="text-align: center;">
<p><b style="background-color: white; color: #222222; font-family: Arial,Tahoma,Helvetica,FreeSans,sans-serif; font-style: normal; font-variant: normal; letter-spacing: normal; line-height: 18px; orphans: 2; text-align: center; text-indent: 0px; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px;"><;<;</b><b style="background-color: white; color: #222222; font-family: Arial,Tahoma,Helvetica,FreeSans,sans-serif; font-style: normal; font-variant: normal; letter-spacing: normal; line-height: 18px; orphans: 2; text-align: center; text-indent: 0px; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px;"><a href="https://dineshonjava.com/whats-new-in-spring-batch-2xx/">What is New in spring batch2</a></b><b style="background-color: white; color: #222222; font-family: Arial,Tahoma,Helvetica,FreeSans,sans-serif; font-style: normal; font-variant: normal; letter-spacing: normal; line-height: 18px; orphans: 2; text-align: center; text-indent: 0px; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px;"> <;<;|<a style="color: #888888;" href="https://dineshonjava.com/spring-tutorial/">index</a>| </b><b style="background-color: white; color: #222222; font-family: Arial,Tahoma,Helvetica,FreeSans,sans-serif; font-style: normal; font-variant: normal; letter-spacing: normal; line-height: 18px; orphans: 2; text-align: center; text-indent: 0px; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px;">>;>;</b><b><a class="GLVTYVNPB" href="https://dineshonjava.com/configuring-and-running-job-in-spring/">Configuring and Running a Job in Spring Batch>;>;</a></b></p>
<p> ;</p>
</div>
</div>
<div class="wp-post-navigation"> 
									 <div class="wp-post-navigation-pre"> 
									 <a href="https://dineshonjava.com/whats-new-in-spring-batch-2xx/">Previous</a> 
									 </div> 
									 <div class="wp-post-navigation-next"> 
									 <a href="https://dineshonjava.com/itemreaders-and-itemwriters-in-spring/">Next</a> 
									 </div> 
									</div>
<script type="text/javascript">
jQuery(document).ready(function($) {
 $.post('https://dineshonjava.com/wp-admin/admin-ajax.php', {action: 'mts_view_count', id: '610'});
});
</script>
Strategy Design Patterns We can easily create a strategy design pattern using lambda. To implement…
Decorator Pattern A decorator pattern allows a user to add new functionality to an existing…
Delegating pattern In software engineering, the delegation pattern is an object-oriented design pattern that allows…
Technology has emerged a lot in the last decade, and now we have artificial intelligence;…
Managing a database is becoming increasingly complex now due to the vast amount of data…
Overview In this article, we will explore Spring Scheduler how we could use it by…