Here, you can find a clear explanation about its main components and concepts and several working examples. This tutorial is not about the Spring framework in general; it is expected that you are familiar with mechanisms like Inversion of Control and Dependency Injection, that are the main pillars of the Spring framework. It is also assumed that you know how to configure the Spring framework context for basic applications and that you are used to work with both annotations and configuration files based Spring projects.<\/p>\n
If this is not the case, I would really recommend going to the Spring framework official page and learn the basic tutorials before starting to learn what is Spring batch and how it works. In spring docs<\/a> you can find a good one.<\/p>\n At the end of this tutorial, you can find a compressed file with all the examples listed and some extras.<\/p>\n The software used in the elaboration of this tutorial is listed below:<\/p>\n This tutorial will not explain how to use Maven although it is used for solving dependencies, compiling, and executing the examples provided. You can learn more in our Log4j Maven example<\/a>.<\/p>\n The module Spring boot is also heavily used in the examples, for more information about it please refer to the official Spring Boot documentation<\/a>.<\/p>\n Spring Batch is an open source framework for batch processing. It is built as a module within the Spring framework and depends on this framework (among others). Before continuing with Spring Batch we are going to put here the definition of batch processing:<\/p>\n \u201cBatch processing is the execution of a series of programs (“jobs”) on a computer without manual intervention\u201d<\/i> (From the Wikipedia).<\/p>\n So, for our matter, a batch application executes a series of jobs (iterative or in parallel), where input data is read, processed and written without any interaction. We are going to see how Spring Batch can help us with this purpose.<\/p>\n Spring Batch provides mechanisms for processing large amount of data like transaction management, job processing, resource management, logging, tracing, conversion of data, interfaces, etc. These functionalities are available out of the box and can be reused by applications containing the Spring Batch framework. By using these diverse techniques, the framework takes care of the performance and the scalability while processing the records.<\/p>\n Normally a batch application can be divided in three main parts:<\/p>\n Spring Batch contains features and abstractions (as we will explain in this article) for automating these basic steps and allowing the application programmers to configure them, repeat them, retry them, stop them, executing them as a single element or grouped (transaction management), etc.<\/p>\n It also contains classes and interfaces for the main data formats, industry standards and providers like XML, CSV, SQL, Mongo DB, etc.<\/p>\n In the next chapters of this tutorial we are going to explain and provide examples of all these steps and the difference possibilities that Spring Batch offers.<\/p>\n Here are the most important concepts in the Spring Batch framework:<\/p>\n Jobs are abstractions to represent batch processes, that is, sequences of actions or commands that have to be executed within the batch application.<\/p>\n Spring batch contains an interface to represent Jobs<\/a>. Simple Jobs contain a list of steps and these are executed sequentially or in parallel.<\/p>\n In order to configure a Job it is enough to initialize the list of steps, this is an example of an xml based configuration for a dummy Job:<\/p>\n This interface<\/a> represents a Job Launcher. Implementations of its run() method takes care of starting job executions for the given jobs and job parameters.<\/p>\n This is an abstraction representing a single run for a given Job. It is unique and identifiable. The class representing this abstraction is http:\/\/docs.spring.io\/spring-batch\/apidocs\/org\/springframework\/batch\/core\/JobInstance.html<\/a>.<\/p>\n Job instances can be restarted in case they were not completed successfully and if the Job is restart able. Otherwise an error will be raised.<\/p>\n Steps are mainly the parts that compose a Job (and a Job instance). A Steps also contain configuration options for their processing strategy, commit interval, transaction mechanism or job repositories that may be used. Spring Batch uses normally chunk processing, that is reading all data at one time and processing and writing \u201cchunks\u201d of this data on a preconfigured interval, called commit interval.<\/p>\n Here is a very basic example of a xml based step configuration using an interval of 10:<\/p>\n And the following snippet is the annotation based version defining the readers, writers and processors involved, a chunk processing strategy and a commit interval of 10 (this is the one that we are using in the majority of examples in this tutorial):<\/p>\n Job repositories are abstractions responsible for storing and updating metadata information related to Job instance executions and Job contexts. The basic interface that has to be implemented in order to configure a Job Repository can be found here<\/a>.<\/p>\n Spring stores as metadata information about their executions, the results obtained their instances, the parameters used for the Jobs executed, and the context where the processing runs. The table names are very intuitive and similar to their domain classes counterparts, in this link<\/a>, there is an image with a very good summary of these tables.<\/p>\n Please visit the Spring Batch metadata schema<\/a> for more information.<\/p>\n Readers are abstractions responsible of the data retrieval. They provide batch processing applications with the needed input data. We will see in this tutorial how to create custom readers and we will see how to use some of the most important Spring Batch predefined ones. Here is a list of some readers provided by Spring Batch:<\/p>\n We can see that Spring Batch already provides readers for many of the formatting standards and database industry providers. It is recommended to use the abstractions provided by Spring Batch in your applications rather than creating your own ones.<\/p>\n Writers are abstractions responsible of writing the data to the desired output database or system. The same that we explained for Readers is applicable to Writers: Spring Batch already provides classes and interfaces to deal with many of the most used databases, these should be used. Here is a list of some of these provided writers:<\/p>\n In this article we will show how to create custom writers and how to use some of the listed ones.<\/p>\n Processors are in charge of modifying the data records converting them from the input format to the output desired one. The main interfaces used for Item Processors configuration can be found here<\/a>.<\/p>\n In this article we will see how to create our custom item processors.<\/p>\n The following picture (from the Spring batch documentation<\/a>) gives a very good summary of all these concepts and how the basic Spring Batch architecture is designed:<\/p>\n Although it is difficult to categorize the use cases where batch processing can be applied in the real world, I am going to try to list in this chapter the most important ones:<\/p>\n Spring Batch provides mechanisms to support all these scenarios, with the elements and components listed in the previous chapter programmers can implement batch applications for conversion of data, filtering records, validation, extracting information from databases or input files and reporting. Before starting talking about specific Jobs and Steps I am going to show how a Spring Batch configuration class looks like. The next snippet contains a configuration class with all the components needed for batch processing using Spring Batch. It contains readers, writers, processors, job flows, steps and all other needed beans.<\/p>\n During this tutorial we will show how to modify this configuration class in order to use different abstractions for our different purposes. The class bellow is pasted without comments and specific code, for the working class example please go to the download section in this tutorial where you can download all the sources:<\/p>\n In order to launch our spring context and execute the configured batch shown before we are going to use Spring Boot. Here is an example of a program that takes care of launching our application and initializing the Spring context with the proper configuration. This program is used with all the examples shown in this tutorial:<\/p>\n I am using Maven to resolve all the dependencies and launching the application using Spring boot. Here is the used And the goal used is:<\/p>\n Now we are going to go through the configuration file shown above step by step. First of all we are going to explain how In the example application pasted above we can see how a Job and a first step are configured. Here we extract the related piece of code:<\/p>\n We can observe how a Job with the name \u201cjob1\u201d is configured using just one step; in this case an step called \u201cstep1\u201d. The class JobBuilderFactory<\/a> creates a job builder and initializes the job repository. The method The step processes (using the processor) in chunks of 10 units the As we already mentioned in this tutorial, Spring Batch applications consist basically of three steps: reading data, processing data and writing data. We also explained that in order to support these 3 operations Spring Batch provides 3 abstractions in form of interfaces:<\/p>\n Programmers should implement these interfaces in order to read, process and write data in their batch application jobs and steps. In this chapter we are going to explain how to create custom implementations for these abstractions.<\/p>\n The abstraction provided by Spring Batch for reading records of data is the interface The method The custom reader above reads the next element in the internal list of The interface provided by Spring Batch for data processing expects one input item and produces one output item. The type of both of them can be different but does not have to be different. Producing null means that the item is not required for further processing any more in case of concatenation.<\/p>\n In order to implement this interface, it is only necessary to implement the The class above may not be useful in any real life scenario but shows how to override the In order to create a custom writer programmers need to implement the interface Here is an example of a custom writer where the input item is written in the standard console:<\/p>\n Also not very useful in real life, only for learning purposes.<\/p>\n It is also important to mention that for almost all real life scenarios Spring Batch already provides specific abstractions that cope with most of the problems. For example Spring Batch contains classes to read data from MySQL databases, or to write data to a HSQLDB database, or to convert data from XML to CSV using JAXB; and many others. The code is clean, fully tested, standard and adopted by the industry, so I can just recommend to use them.<\/p>\n These classes can also be overridden in our applications in order to fulfil our wishes without the need of re implement the whole logic. Implementing the provided classes by Spring may be also useful for testing, debugging, logging or reporting purposes. So before discovering the wheel again and again, it would be worth to check the Spring Batch documentation and tutorials because probably we will find a better and cleaner way to solve our specific problems.<\/p>\n Using the example above, we are going to modify the readers and writers in order to be able to read from a csv file and write into a flat file as well. The following snippet shows how we should configure the reader in order to provide a reader that extracts the data from a flat file, csv in this case. For this purpose Spring already provides the class FlatFileItemReader<\/a> that needs a resource property where the data should be coming from and a line mapper to be able to parse the data contained in that resource. The code is quite intuitive:<\/p>\n The following piece of code shows the modifications that are needed in the writer. In this case we are going to use a writer of the class FlatFileItemWriter<\/a> that needs an output file to write to and an extractor mechanism. The extractor can be configured as shown in the snippet:<\/p>\n In this chapter we are going to see how to modify our writer and our data source in order to write processed records to a local MySQL DB.<\/p>\n If we want to read data from a MySQL DB we first need to modify the configuration of the data source bean with the needed connection parameters:<\/p>\n Here is how the writer can be modified using an SQL statement and a It is good to mention here, that there are problems with the required Jettison library<\/a>.<\/p>\n [ulp id=’oiCtu6x3AwpaVNPI’]<\/p>\n <\/p>\n As third example we are going to show how to create readers and writers in order to use an in memory database, this is very useful for testing scenarios. By default, if nothing else is specified, Spring Batch choose HSQLDB as data source.<\/p>\n The data source to be used is in this case the same one as for a MySQL DB but with different parameters (containing the HSQLDB configuration):<\/p>\n The writer does not differ (almost) from the MySQL one:<\/p>\n If we want that Spring takes care of the initialization of the DB to be used we can create an script with the name schema-all.sql (for all providers, schema-hsqldb.sql for Hsqldb, schema-mysql.sql for MySQL, etc.) in the resources project of our project:<\/p>\n This script is also provided in the download section at the end of the tutorial.<\/p>\n In this chapter we are going to see briefly how to test Batch applications using the Spring Batch testing capabilities. This chapter does not explain how to test Java applications in general or Spring based ones in particular. It only covers how to test from end to end Spring Batch applications, only Jobs or Steps testing is covered; that is why unit testing of single elements like item processors, readers or writers is excluded, since this does not differ from normal unit testing.<\/p>\n The Spring Batch Test Project contains abstractions that facilitate the unit testing of batch applications.<\/p>\n Two annotations are basic when running unit tests (using Junit in this case) in Spring:<\/p>\n Instances of the class<\/a> can be used for launching jobs and single steps inside the unit test methods (among many other functionalities. Its method You can assert or validate the tests checking the status of the Job execution for complete Jobs unit tests or asserting the results of the writer for single steps tests. In the example shown we do not use any xml configuration file, instead we use the already mentioned configuration class. In order to indicate the unit test to load this configuration, the annotation More information about Spring Batch unit testing can be found in the following tutorial: http:\/\/docs.spring.io\/spring-batch\/trunk\/reference\/html\/testing.html<\/a>.<\/p>\n Spring provides mechanisms for retrying Jobs but since the release 2.2.0 is not anymore part of the Spring Batch framework but included in the Spring Retry<\/a>. A very good tutorial can be found here<\/a>.<\/p>\n Retry policies, callbacks and recovery mechanism are part of the framework.<\/p>\n Spring Batch supports parallel processing in two possible variations (single process and multi process) that we can separate into the following categories. In this chapter we are just going to list these categories and explain briefly how Spring Batch provides solutions to them:<\/p>\n <\/p>\n These are the main options that Spring Batch offers to programmers to allow them to process their batch applications somehow in parallel. But parallelism in general and specifically parallelism in batch processing is a very deep and complicate topic that is out of the scope of this document.<\/p>\n Spring Batch offers the possibility to repeat Jobs and Tasks in a programmatic and configurable way. In other words, it is possible to configure our batch applications to repeat Jobs or Steps until specific conditions are met (or until specific conditions are not yet met). Several abstractions are available for this purpose:<\/p>\n The RepeatCallback<\/a> interface contains the functional logic that has to be repeated in the Batch:<\/p>\n The Spring already provides some basic implementations for the <\/p>\n In this case the batch will terminate after 10 iterations since the iterate() method returns always Since Java 7, batch processing is included in the Java Platform. The JSR 352 (Batch applications for the Java Platform<\/a>) specifies a model for batch applications and a runtime for scheduling and executing jobs. At the moment of writing this tutorial, the Spring Batch implementation (3.0) implements completely the specification of the JSR-352.<\/p>\n The domain model and the vocabulary used is pretty similar to the one used in Spring Batch. This is a good thing for both programmers and the industry; since the industry profits from the fact that a standard has been created in the Java Platform, using as basis a very good library like Spring Batch, which is widely used and well tested. Programmers benefit because in case Spring Batch is discontinued or cannot be used for any reason in their applications (compatibility, company policies, size restrictions\u2026) they can choose the Java standard implementation for Batch processing without much changes in their systems.<\/p>\n You can learn more information about how Spring Batch has been adapter to the JSR 352<\/a>.<\/p>\n So that\u2019s it. I hope you have enjoyed it and you are able now to configure and implement batch applications using Spring Batch. I am going to summarize here the most important points explained in this article:<\/p>\n In this tutorial I used no xml file (apart from some examples) for configuring the spring context, everything was done via annotations. I did it this way for clarity reasons but I do not recommend to do this in real life applications since xml configuration files may be useful in specific scenarios. As I said, this was a tutorial about Spring Batch and not about Spring in general.<\/p>\n The following links contain a lot of information and theoretical examples where you can learn all the features of the Spring Batch module:<\/p>\n Last updated on Apr. 29th, 2021<\/strong><\/p>\n","protected":false},"excerpt":{"rendered":"\n
Table Of Contents<\/h2>\n
\n
1. Introduction<\/h2>\n
\n
2. Concepts<\/h2>\n
Jobs<\/h3>\n
<job id=\"eatJob\" xmlns=\"http:\/\/www.springframework.org\/schema\/batch\">\n\t<step id=\"stepCook\" next=\"stepEntries\">\n\t <tasklet>\n\t\t<chunk reader=\"cookReader\" writer=\"cookProcessor\" \n processor=\"cookWriter\" commit-interval=\"1\" \/>\n\t <\/tasklet>\n\t<\/step>\n\t<step id=\"stepEntries\" next=\"stepMeat\">\n\t <tasklet>\n\t\t<chunk reader=\"entriesReader\" writer=\"entriesProcessor\" \n processor=\"entriesWriter\" commit-interval=\"1\" \/>\n\t <\/tasklet>\n\t<\/step>\n\t<step id=\"stepMeat\" next=\"stepWine\">\n\t <tasklet ref=\"drinkSomeWine\" \/>\n\t<\/step>\n\t<step id=\"stepWine\" next=\"clean\">\n\t <tasklet>\n\t\t<chunk reader=\"wineReader\" writer=\"wineProcessor\" \n processor=\"wineWriter\" commit-interval=\"1\" \/>\n\t <\/tasklet>\n\t<\/step>\n\t<step id=\"clean\">\n\t\t<tasklet ref=\"cleanTheTable\" \/>\n\t<\/step>\n <\/job>\n<\/pre>\n
Job launcher<\/h3>\n
Job instance<\/h3>\n
Steps<\/h3>\n
Step<\/code> is a part of a Job<\/code> and contains all the necessary information to execute the batch processing actions that are expected to be done at that phase of the job. Steps in Spring Batch are composed of ItemReader<\/code>, ItemProcessor<\/code> and ItemWriter<\/code> and can be very simple or extremely complicated depending on the complexity of their members.<\/p>\n<step id=\"step\" next=\"nextStep\">\n <tasklet>\n <chunk reader=\"customItemReader\" writer=\"customItemWriter\" processor=\"customItemProcessor\" commit-interval=\"10\" \/>\n <\/tasklet>\n<\/step>\n<\/pre>\n
@Bean\npublic Step step1(StepBuilderFactory stepBuilderFactory,\n\t\tItemReader reader, ItemWriter writer,\n\t\tItemProcessor processor) {\n\t\/* it handles bunches of 10 units *\/\n\treturn stepBuilderFactory.get(\"step1\")\n\t\t\t. chunk(10).reader(reader)\n\t\t\t.processor(processor).writer(writer).build();\n}\n<\/pre>\nJob Repositories<\/h3>\n
Item Readers<\/h3>\n
\n
Item Writers<\/h3>\n
\n
Item Processors<\/h3>\n
![\"Spring](\"http:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2015\/03\/spring-batch-reference-model.png\")
<\/a>3. Use Cases<\/h2>\n
\n
4. Controlling flow<\/h2>\n
@Configuration\n@EnableBatchProcessing\npublic class SpringBatchTutorialConfiguration {\n\n@Bean\npublic ItemReader reader() {\n\treturn new CustomItemReader();\n}\n\n@Bean\npublic ItemProcessor processor() {\n\treturn new CustomItemProcessor();\n}\n\n@Bean\npublic ItemWriter writer(DataSource dataSource) {\n\treturn new CustomItemItemWriter(dataSource);\n}\n\n@Bean\npublic Job job1(JobBuilderFactory jobs, Step step1) {\n\treturn jobs.get(\"job1\").incrementer(new RunIdIncrementer())\n\t\t\t.flow(step1).end().build();\n}\n\n@Bean\npublic Step step1(StepBuilderFactory stepBuilderFactory,\n\t\tItemReader reader, ItemWriter writer,\n\t\tItemProcessor processor) {\n\t\/* it handles bunches of 10 units *\/\n\treturn stepBuilderFactory.get(\"step1\")\n\t\t\t. chunk(10).reader(reader)\n\t\t\t.processor(processor).writer(writer).build();\n}\n\n@Bean\npublic JdbcTemplate jdbcTemplate(DataSource dataSource) {\n\treturn new JdbcTemplate(dataSource);\n}\n\n\n@Bean\npublic DataSource mysqlDataSource() throws SQLException {\nfinal DriverManagerDataSource dataSource = new DriverManagerDataSource();\n\tdataSource.setDriverClassName(\"com.mysql.jdbc.Driver\");\n\tdataSource.setUrl(\"jdbc:mysql:\/\/localhost\/spring_batch_annotations\");\n\tdataSource.setUsername(\"root\");\n\tdataSource.setPassword(\"root\");\n\treturn dataSource;\n}\n\n...\n<\/pre>\n@SpringBootApplication\npublic class SpringBatchTutorialMain implements CommandLineRunner {\n\n\tpublic static void main(String[] args) {\n\n\t\tSpringApplication.run(SpringBatchTutorialMain.class, args);\n\t}\n\n\t\n\t@Override\n\tpublic void run(String... strings) throws Exception {\n\n\t\tSystem.out.println(\"running...\");\n\t}\n\n}\n<\/pre>\npom.xml<\/code>:<\/p>\n<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<project xmlns=\"http:\/\/maven.apache.org\/POM\/4.0.0\" xmlns:xsi=\"http:\/\/www.w3.org\/2001\/XMLSchema-instance\"\n xsi:schemaLocation=\"http:\/\/maven.apache.org\/POM\/4.0.0 http:\/\/maven.apache.org\/xsd\/maven-4.0.0.xsd\">\n <modelVersion>4.0.0<\/modelVersion>\n\n <groupId>com.danibuiza.javacodegeeks<\/groupId>\n <artifactId>Spring-Batch-Tutorial-Annotations<\/artifactId>\n <version>0.1.0<\/version>\n\n <parent>\n <groupId>org.springframework.boot<\/groupId>\n <artifactId>spring-boot-starter-parent<\/artifactId>\n <version>1.2.1.RELEASE<\/version>\n <\/parent>\n\n <dependencies>\n <dependency>\n <groupId>org.springframework.boot<\/groupId>\n <artifactId>spring-boot-starter-batch<\/artifactId>\n <\/dependency>\n <dependency>\n <groupId>org.hsqldb<\/groupId>\n <artifactId>hsqldb<\/artifactId>\n <\/dependency>\n <dependency>\n\t\t\t<groupId>mysql<\/groupId>\n\t\t\t<artifactId>mysql-connector-java<\/artifactId>\n\t\t<\/dependency>\n <\/dependencies>\n\n\n <build>\n <plugins>\n <plugin>\n <groupId>org.springframework.boot<\/groupId>\n <artifactId>spring-boot-maven-plugin<\/artifactId>\n <\/plugin>\n <\/plugins>\n <\/build>\n<\/project>\n\n<\/pre>\n
mvn spring-boot:run\n<\/pre>\n
Jobs<\/code> and Steps<\/code> are executed and what rules they follow.<\/p>\n\t@Bean\n\tpublic Job job1(JobBuilderFactory jobs, Step step1) {\n\t\treturn jobs.get(\"job1\").incrementer(new RunIdIncrementer())\n\t\t\t\t.flow(step1).end().build();\n\t}\n\n\t@Bean\n\tpublic Step step1(StepBuilderFactory stepBuilderFactory,\n\t\t\tItemReader reader, ItemWriter writer,\n\t\t\tItemProcessor processor) {\n\t\t\/* it handles bunches of 10 units *\/\n\t\treturn stepBuilderFactory.get(\"step1\")\n\t\t\t\t. chunk(10).reader(reader)\n\t\t\t\t.processor(processor).writer(writer).build();\n\t}\n<\/pre>\nflow()<\/code> of the class JobBuilder<\/a> creates an instance of the class JobFlowBuilder<\/a> using the step1 method shown. This way the whole context is initialized and the Job \u201cjob1\u201d is executed.<\/p>\nCustomPojo<\/code> records provided by the reader and writes them using the past writer. All dependencies are injected in runtime, Spring takes care of that since the class where all this happens is marked as a configuration class using the annotation org.springframework.context.annotation.Configuration <\/code>.<\/p>\n5. Custom Writers, Readers and Processors<\/h2>\n
\n
Custom Reader<\/h3>\n
ItemReader<\/code>. It only has one method (read()<\/code>) and it is supposed to be executed several times; it does not need to be thread safe, this fact is very important to know by applications using these methods.<\/p>\nread()<\/code> of the interface ItemReader<\/code> has to be implemented. This method expects no input parameters, is supposed to read one record of the data from the desired queue and returns it. This method is not supposed to do any transformation or data processing. If null is returned, no further data has to be read or analyzed.<\/p>\npublic class CustomItemReader implements ItemReader {\n\n\tprivate List pojos;\n\n\tprivate Iterator iterator;\n\n\t@Override\n\tpublic CustomPojo read() throws Exception, UnexpectedInputException,\n\t\t\tParseException, NonTransientResourceException {\n\n\t\tif (getIterator().hasNext()) {\n\t\t\treturn getIterator().next();\n\t\t}\n\t\treturn null;\n\n\t}\n. . .\n<\/pre>\npojos<\/code>, this is only possible if the iterator is initialized or injected when the custom reader is created, if the iterator is instantiated every time the read()<\/code> method is called, the job using this reader will never end and cause problems.<\/p>\nCustom Processor<\/h3>\n
process()<\/code> method. Here is a dummy example:<\/p>\npublic class CustomItemProcessor implements ItemProcessor {\n\n\t@Override\n\tpublic CustomPojo process(final CustomPojo pojo) throws Exception {\n\t\tfinal String id = encode(pojo.getId());\n\t\tfinal String desc = encode(pojo.getDescription());\n\n\t\tfinal CustomPojo encodedPojo = new CustomPojo(id, desc);\n\n\t\treturn encodedPojo;\n\n\t}\n\n\tprivate String encode(String word) {\n\t\tStringBuffer str = new StringBuffer(word);\n\t\treturn str.reverse().toString();\n\t}\n\n}\n<\/pre>\nItemProcessor<\/code> interface and do whatever actions (in this case reversing the input pojo members) are needed in the process method.<\/p>\nCustom Writer<\/h3>\n
ItemWriter<\/code>. This interface only contains one method write()<\/code> that expects an input item and returns void<\/code>. The write method can do whatever actions are wanted: writing in the database, writing in a csv file, sending an email, creating a formatted document etc. The implementations of this interface are in charge of flushing the data and leave structures in a safe state.<\/p>\npublic class CustomItemWriter implements ItemWriter {\n\n\t@Override\n\tpublic void write(List pojo) throws Exception {\n\t\tSystem.out.println(\"writing Pojo \" + pojo);\n\t}\n\n}\n<\/pre>\n6. Flat file example<\/h2>\n
@Bean\npublic ItemReader reader() {\n\tif (\"flat\".equals(this.mode)) {\n\t\t\/\/ flat file item reader (using an csv extractor)\n\t\tFlatFileItemReader reader = new FlatFileItemReader();\n\t\t\/\/setting resource and line mapper\n\t\treader.setResource(new ClassPathResource(\"input.csv\"));\n\t\treader.setLineMapper(new DefaultLineMapper() {\n\t\t{\n\t\t\t\/\/default line mapper with a line tokenizer and a field mapper\n\t\t\tsetLineTokenizer(new DelimitedLineTokenizer() {\n\t\t\t{\n\t\t\t\tsetNames(new String[] { \"id\", \"description\" });\n\t\t\t}});\n\t\t\tsetFieldSetMapper(new BeanWrapperFieldSetMapper() {\n\t\t\t{\n\t\t\t\tsetTargetType(CustomPojo.class);\n\t\t\t}});\n\t\t}\n\t\t});\n\treturn reader;\n\t} \n\telse {\n\t\t\t. . .\n<\/pre>\n@Bean\npublic ItemWriter writer(DataSource dataSource) {\n\t...\n\telse if (\"flat\".equals(this.mode)) {\n\t\t\/\/ FlatFileItemWriter writer\n\t\tFlatFileItemWriter writer = new FlatFileItemWriter ();\n\t\twriter.setResource(new ClassPathResource(\"output.csv\"));\n\t\tBeanWrapperFieldExtractor fieldExtractor = new CustomFieldExtractor();\n\t\tfieldExtractor.setNames(new String[] { \"id\", \"description\" });\n\t\tDelimitedLineAggregator delLineAgg = new CustomDelimitedAggregator();\n\t\tdelLineAgg.setDelimiter(\",\");\n\t\tdelLineAgg.setFieldExtractor(fieldExtractor);\n\t\twriter.setLineAggregator(delLineAgg);\n\t\treturn writer;\n\t} \n\telse {\n\t. . .\n\t}\n\t\n<\/pre>\n7. MySQL example<\/h2>\n
@Bean\npublic DataSource dataSource() throws SQLException {\n. . .\nelse if (\"mysql\".equals(this.mode)) {\n\t\/\/ mysql data source\n\tfinal DriverManagerDataSource dataSource = new DriverManagerDataSource();\n\tdataSource.setDriverClassName(\"com.mysql.jdbc.Driver\");\n\tdataSource.setUrl(\"jdbc:mysql:\/\/localhost\/spring_batch_annotations\");\n\tdataSource.setUsername(\"root\");\n\tdataSource.setPassword(\"root\");\n\treturn dataSource;\n} else {\n. . .\n<\/pre>\n JdbcBatchItemWriter<\/code> that gets initialized with the data source shown above:<\/p>\n@Bean\npublic ItemWriter writer(DataSource dataSource) {\n...\t\t\nelse if (\"mysql\".equals(this.mode)) {\n\tJdbcBatchItemWriter writer = new JdbcBatchItemWriter();\n\twriter.setSql(\"INSERT INTO pojo (id, description) VALUES (:id, :description)\");\n\twriter.setDataSource(dataSource);\n\twriter.setItemSqlParameterSourceProvider(\n\t\tnew BeanPropertyItemSqlParameterSourceProvider());\n\treturn writer;\n}\n.. .\n<\/pre>\n8. In Memory DB (HSQLDB) example<\/h2>\n
@Bean\npublic DataSource dataSource() throws SQLException {\n\t. . .\n\t} else {\n\t\t\/\/ hsqldb datasource\nfinal DriverManagerDataSource dataSource = new DriverManagerDataSource();\n\t\tdataSource.setDriverClassName(\"org.hsqldb.jdbcDriver\");\n\t\tdataSource.setUrl(\"jdbc:hsqldb:mem:test\");\n\t\tdataSource.setUsername(\"sa\");\n\t\tdataSource.setPassword(\"\");\n\t\treturn dataSource;\n\t\t}\n\t}\n<\/pre>\n@Bean\npublic ItemWriter writer(DataSource dataSource) {\n\tif (\"hsqldb\".equals(this.mode)) {\n\t\t\/\/ hsqldb writer using JdbcBatchItemWriter (the difference is the\n\t\t\/\/ datasource)\n\t\tJdbcBatchItemWriter writer = new JdbcBatchItemWriter();\n\t\twriter.setItemSqlParameterSourceProvider(new BeanPropertyItemSqlParameterSourceProvider());\n\t\twriter.setSql(\"INSERT INTO pojo (id, description) VALUES (:id, :description)\");\n\t\twriter.setDataSource(dataSource);\n\t\treturn writer;\n\t} else\n\t. . .\n<\/pre>\nDROP TABLE IF EXISTS POJO;\n\nCREATE TABLE POJO (\n id VARCHAR(20),\n description VARCHAR(20)\n);\n<\/pre>\n
9. Unit testing<\/h2>\n
\n
SpringJunit4ClassRunner<\/code> class passed as parameter we are indicating that this class can use all spring testing capabilities.<\/li>\nlaunchJob()<\/code> executes a Job and its method launchStep(\"name\")<\/code> executes an step from end to end. In the following example you can see how to use these methods in real jUnit tests:<\/p>\n@RunWith(SpringJUnit4ClassRunner.class)\n@ContextConfiguration(classes=SpringBatchTutorialConfiguration.class, loader=AnnotationConfigContextLoader.class)\npublic class SpringBatchUnitTest {\n\n\t@Autowired\n\tprivate JobLauncherTestUtils jobLauncherTestUtils;\n\t\n\t@Autowired\n\tJdbcTemplate jdbcTemplate;\n\n\t@Test\n\tpublic void testLaunchJob() throws Exception {\n\n\t\t\/\/ test a complete job\n\t\tJobExecution jobExecution = jobLauncherTestUtils.launchJob();\n\t\tassertEquals(BatchStatus.COMPLETED, jobExecution.getStatus());\n\n\t}\n\n\t@Test\n\tpublic void testLaunchStep() {\n\n\t\t\/\/ test a individual step\n\t\tJobExecution jobExecution = jobLauncherTestUtils.launchStep(\"step1\");\n\t\tassertEquals(BatchStatus.COMPLETED, jobExecution.getStatus());\n\t}\n}\n\n<\/pre>\n ContextConfiguration<\/code> with the properties “classes” and “loader” is used:<\/p>\n@ContextConfiguration(classes=SpringBatchTutorialConfiguration.class, \n\tloader=AnnotationConfigContextLoader.class)\n<\/pre>\n
10. Error handling and retrying Jobs<\/h2>\n
11. Parallel Processing<\/h2>\n
\n
ItemWriter<\/code> and ItemReader<\/code> implementations. In their description is stated normally if they are thread safe or not. In case this information is not provided or the implementations clearly state that they are not thread safe, programmers can always synchronize the call to the read()<\/code> method. This way, several records can be processed in parallel.<\/li>\n
Spring Batch supports this scenario with the element split<\/code>.Here is an example configuration that may help to understand it better:\n \n<job id=\"havingLunchJob\">\n<split id=\"split1\" task-executor=\"taskExecutor\" next=\"cleanTableStep\">\n <flow>\n <step id=\"step1\" parent=\"s1\" next=\"eatCakeStep\"\/>\n <step id=\" eatCakeStep \" parent=\"s2\"\/>\n <\/flow>\n <flow>\n <step id=\"drinkWineStep\" parent=\"s3\"\/>\n <\/flow>\n<\/split>\n<step id=\" cleanTableStep\" parent=\"parentStep1\"\/>\n. . .\n<\/pre>\n<\/li>\n
12. Repeating jobs<\/h2>\n
\n
public interface RepeatOperations { RepeatStatus iterate(RepeatCallback callback) throws RepeatException; } <\/pre>\npublic interface RepeatCallback { RepeatStatus doInIteration(RepeatContext context) throws Exception; } <\/pre>\nRepeatStatus<\/code> returned in their iterate()<\/code> and doInIteration()<\/code> respectively should be RepeatStatus.CONTINUABLE<\/code> in case the Batch should continue iterating or RepeatStatus.FINIHSED<\/code> in case the Batch processing should be terminated.<\/p>\nRepeatCallBack<\/code> interface.<\/p>\n<\/li>\nRepeatOperations<\/code> interface that can be used as starting point in our batch applications. It contains basic functionalities and default behavior for error handling and finalization mechanisms. Applications that do not want this default behavior should implement their custom Completion Policies.
Here is an example of how to use a repeat template with a fixed chunk termination policy and a dummy iterate method:\nRepeatTemplate template = new RepeatTemplate(); template.setCompletionPolicy(new FixedChunkSizeCompletionPolicy(10)); template.iterate(new RepeatCallback() { public ExitStatus doInIteration(RepeatContext context) { int x = 10; x *= 10; x \/= 10; return ExitStatus.CONTINUABLE; } }); <\/pre>\nCONTINUABLE<\/code> and leaves the responsibility of the termination to the completion policy.<\/p>\n<\/li>\nRepeatStatus .CONTINUABLE<\/code>RepeatStatus.FINISHED<\/code> Indicating that the processing should continue<\/a> or it is finished can be successful or unsuccessful.<\/li>\ndoInIteration()<\/code> method. Spring Batch provides the abstraction RepeatContext<\/a> for this purpose.
After the iterate()<\/code> method is called, the context no longer exists. The repeat context have a parent context in case iterations are nested, in these cases, it is possible to use the parent context in order to store information that can be shared between different iterations, like counters or decision variables.<\/li>\nRepeatContext<\/code> and pass it to the callback in every iteration. Once an iteration is completed, the template calls the completion policy and updates its state, which will be stored in the repeat context. After that, the template asks the policy to check if the processing is complete.Spring contains several implementations for this interface, one of the most simple ones is the SimpleCompletionPolicy<\/a>; which offers the possibility to execute the Batch just a fixed number of iterations.<\/li>\n<\/ul>\n13. JSR 352 Batch Applications for the Java Platform<\/h2>\n
JSR 352: Batch Applications for the Java Platform: Jobs<\/code>, Steps<\/code>, Chunks<\/code>, Items<\/code>, ItemReaders<\/code>, ItemWriters<\/code>, ItemProcessors<\/code> etc. are present in the Java Platform JSR 352 model as well. The differences are minor between both frameworks and configuration files looks almost the same.<\/p>\n14. Summary<\/h2>\n
\n
Steps<\/code>, where Readers<\/code>, Processors<\/code> and Writers<\/code> and configured and concatenated to execute the desired actions.<\/li>\nJobs<\/code> and Steps<\/code> and retrying Jobs<\/code> and Steps<\/code>.<\/li>\n15. Resources<\/h2>\n
\n
16. Download the Source Code<\/h2>\n
You can download the full source code of this Spring Batch Tutorial here: Spring Batch Tutorial \u2013 The ULTIMATE Guide<\/a><\/strong><\/div>\n