We have talked about how to get up and running with Spring Batch in a few of previous articles. Now, we\u2019re going to start discussing some of the strategies available for scaling Spring Batch.<\/p>\n
This article will focus on partitioning a step so that the step has several threads that are each processing a chunk of data in parallel. This is beneficial if you have a large chunk of data that can be logically split up into smaller chunks that can be processed in parallel. The way this works is that you will define a master step that is responsible for determining the basis of the chunks, and then farming all of those chunks out to a set of slave steps to process each chunk.<\/p>\n
If I could go back in time to a previous experience, a perfect example of this would be processing all of the daily invoices for each company within a large procurement system. Our data that would be processed could be split up logically by each company being processed. Let\u2019s say that there are 250 companies that participate in this procurement system and our partitioned step has been defined to have 15 threads. Our Partitioner<\/strong> would likely run a query to find all of the companies that have invoices waiting to be processed for that day. The Partitioner\u2019s responsibility at that point would be to create an ExecutionContext<\/strong> for each of those companies and add that to a map with a unique key. That ExecutionContext should contain any information required to process invoices for that company, such as the company ID and any other relevant information. When the Partitioner returns the map of ExecutionContexts, Spring Batch will then create a new Step<\/strong> for each entry in the map and use the key value as part of the step name. Based upon the configuration, such as 15 threads, it will then create a pool of 15 threads and start executing the steps in parallel 15 at a time. For example, if you had 85 steps, Spring Batch would start executing 15 steps and as each step completed, the thread that had completed the step would pick up the next step and begin execution until all steps have been completed.<\/p>\n So now that we have a basic understanding of how partitioning works, let\u2019s take a look at a simple example. For our use case, we\u2019re going to be inspecting an inbound directory where incoming vendor catalog files will be dumped. So to create a spring batch partitioner, we\u2019ll need to create a class that implements the Spring Batch\u2019s Partitioner interface. Since this is something generic and can be made reusable, we\u2019re going to call this class MultiFileResourcePartitioner<\/strong>, which is a simple POJO and has only one field name \u201cinboundDir\u201d<\/strong> representing the path to the directory that contains the files to be processed. The Partitioner interfaces specifies that the class should implement a method named \u201cpartition\u201d<\/strong> that takes an int parameter representing the grid size and returns a Map that holds the ExecutionContext.<\/p>\n Here\u2019s the class listing for MultiFileResourcePartitioner:<\/p>\n The configuration for this bean in our application context will look like this: Looking at the partition method that is implemented, we\u2019re simply going to list all of the files that are found in the specified inbound directory and create an ExecutionContext for each file that is found add it to the map that is returned. The unique key that is used to place each ExecutionContext into the map will also become part of the step name that is created for each entry in the map. Spring Batch will use that partition map to create a slave step from each of the keys that are found in the map.<\/p>\n To partition a step, you need to first create the step that will be referenced by the partition configuration. This step should configured just like any other step within a Spring Batch and for this example we\u2019ll define a FlatFileItemReader<\/strong> and a simple ItemWriter<\/strong> that will just call the toString()<\/strong> method and log it to the console.<\/p>\n Here are the configuration details for the step and its associated spring beans. The important thing to note here is that we have the ItemReader scoped at the step level so that we don\u2019t run into any issues with multiple threads using the same beans to process the data. We also need them scoped that way so that we can use the Spring late binding to specify the value holding the file resource in the Step\u2019s ExecutionContext.<\/p>\n Since we are reading and processing comma delimited text files in this example, we have very little code to write for this step configuration. The only code we\u2019ll need to implement is the FieldSetMapper<\/strong> required to map the contents of the line to the object representing the file record. Each line in the file will contain the fields \u201ccategory\u201d,\u201dsub category\u201d,\u201ddescription\u201d,\u201dcatalog num\u201d,\u201dcolor\u201d,\u201dsize\u201d,\u201dprice\u201d and \u201cqty.\u201d So our object will contain those fields and our FieldSetMapper code listing will look like this.<\/p>\n Now that we have the Partitioner and Step created and configured, all that remains left to do is configure the partitioned step itself! And it\u2019s as easy as this:<\/p>\n When configuring the partitioned step, you define a step just as you would any other step by giving it an ID and if required a next step value. Instead of defining the contents of a step as a normal chunk or tasklet, Spring Batch provides a partition tag that requires you to specify the job step to be partitioned and the Partitioner that will be used to determine the chunks of data. You will also need to define the partition handler that will be processing those steps, in this case we\u2019ll be using a ThreadPoolTaskExecutor<\/strong> which will have a thread pool size of 10 and allow them to timeout if they aren\u2019t being used.<\/p>\n So, if you have a Spring Batch process that has a step processing a large amount of records and you\u2019re interested in improving the performance, consider giving step partitioning a try. It should be easy to implement and provide you with some additional performance to help speed up processing times.<\/p>\n For the example code associated with this article, I have uploaded the source code to a github repository at\u00a0https:\/\/github.com\/jonny-hackett\/batch-example<\/a>. To execute the example code related to this article, there is a JUnit test name\u00a0InventoryLoadTest<\/strong>. The data files are located under src\/test\/resources\/data\/inbound and need to be placed into a local directory that matches the Partitioner inbound directory. Also, check out\u00a0http:\/\/docs.spring.io\/spring-batch\/reference\/html\/scalability.html<\/a>. We have talked about how to get up and running with Spring Batch in a few of previous articles. Now, we\u2019re going to start discussing some of the strategies available for scaling Spring Batch. This article will focus on partitioning a step so that the step has several threads that are each processing a chunk …<\/p>\n","protected":false},"author":471,"featured_media":240,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[8],"tags":[30,691],"class_list":["post-19522","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-enterprise-java","tag-spring","tag-spring-batch"],"yoast_head":"\nAn Example<\/h2>\n
package com.keyhole.example.partition;\r\n\r\nimport java.io.File;\r\nimport java.util.HashMap;\r\nimport java.util.Map;\r\n\r\nimport org.springframework.batch.core.partition.support.Partitioner;\r\nimport org.springframework.batch.item.ExecutionContext;\r\nimport org.springframework.core.io.FileSystemResource;\r\n\r\npublic class MultiFileResourcePartitioner implements Partitioner {\r\n\r\n\tprivate String inboundDir;\r\n\r\n\t@Override\r\n\tpublic Map<String, ExecutionContext> partition(int gridSize) {\r\n\r\n\t\tMap<String, ExecutionContext> partitionMap = new HashMap<String, ExecutionContext>();\r\n\t\tFile dir = new File(inboundDir);\r\n\t\tif (dir.isDirectory()) {\r\n\t\t\tFile[] files = dir.listFiles();\r\n\t\t\tfor (File file : files) {\r\n\t\t\t\tExecutionContext context = new ExecutionContext();\r\n\t\t\t\tcontext.put(\"fileResource\", file.toURI().toString());\r\n\t\t\t\tpartitionMap.put(file.getName(), context);\r\n\t\t\t}\r\n\t\t}\r\n\t\treturn partitionMap;\r\n\t}\r\n\r\n\tpublic String getInboundDir() {\r\n\t\treturn inboundDir;\r\n\t}\r\n\r\n\tpublic void setInboundDir(String inboundDir) {\r\n\t\tthis.inboundDir = inboundDir;\r\n\t}\r\n\r\n}<\/pre>\n<bean id=\"inventoryFilePartitioner\"\r\n\t\tclass=\"com.keyhole.example.partition.MultiFileResourcePartitioner\"\r\n\t\tscope=\"step\">\r\n\t\t<property name=\"inboundDir\" value=\"\/data\/inbound\" \/>\r\n<\/bean><\/pre>\n
<batch:step id=\"inventoryLoadStep\"\r\n\txmlns=\"http:\/\/www.springframework.org\/schema\/batch\">\r\n\t<batch:tasklet transaction-manager=\"transactionManager\">\r\n\t\t<batch:chunk reader=\"inventoryLoadReader\" writer=\"logItemWriter\"\r\n\t\t\tcommit-interval=\"5000\" \/>\r\n\t<\/batch:tasklet>\r\n<\/batch:step>\r\n<bean name=\"inventoryLoadReader\" scope=\"step\"\r\n\tclass=\"org.springframework.batch.item.file.FlatFileItemReader\">\r\n\t<property name=\"resource\"\r\n\t\tvalue=\"#{stepExecutionContext['fileResource']}\" \/>\r\n\t<property name=\"lineMapper\" ref=\"inventoryLineMapper\" \/>\r\n<property name=\"linesToSkip\" value=\"1\" \/>\r\n<\/bean>\r\n\r\n<bean name=\"inventoryLineMapper\"\r\n\tclass=\"org.springframework.batch.item.file.mapping.DefaultLineMapper\">\r\n\t<property name=\"fieldSetMapper\" ref=\"inventoryFieldMapper\" \/>\r\n\t<property name=\"lineTokenizer\" ref=\"inventoryLineTokenizer\" \/>\r\n<\/bean>\r\n\r\n<bean name=\"inventoryLineTokenizer\" \t\tclass=\"org.springframework.batch.item.file.transform.DelimitedLineTokenizer\" \/><\/pre>\npackage com.keyhole.example.partition;\r\n\r\nimport org.springframework.batch.item.file.mapping.FieldSetMapper;\r\nimport org.springframework.batch.item.file.transform.FieldSet;\r\nimport org.springframework.stereotype.Component;\r\nimport org.springframework.validation.BindException;\r\n\r\n@Component(\"inventoryFieldMapper\")\r\npublic class InventoryItemFieldSetMapper implements FieldSetMapper<InventoryItem> {\r\n\r\n\t@Override\r\n\tpublic InventoryItem mapFieldSet(FieldSet fieldSet) throws BindException {\r\n\t\tInventoryItem item = new InventoryItem();\r\n\t\titem.setCategory(fieldSet.readString(0));\r\n\t\titem.setSubCategory(fieldSet.readString(1));\r\n\t\titem.setDescription(fieldSet.readString(2));\r\n\t\titem.setCatalogNum(fieldSet.readString(3));\r\n\t\titem.setColor(fieldSet.readString(4));\r\n\t\titem.setSize(fieldSet.readString(5));\r\n\t\titem.setPrice(fieldSet.readDouble(6));\r\n\t\titem.setQty(fieldSet.readInt(7));\r\n\t\treturn item;\r\n\t}\r\n\r\n}<\/pre>\n<batch:job id=\"InventoryLoader\">\r\n\t<batch:step id=\"partitionedInventoryLoadStep\">\r\n\t\t<batch:partition step=\"inventoryLoadStep\" partitioner=\"inventoryFilePartitioner\">\r\n\t\t\t<batch:handler grid-size=\"10\" task-executor=\"inventoryLoadTaskExecutor\" \/>\r\n\t\t<\/batch:partition>\r\n\t<\/batch:step>\r\n<\/batch:job><\/pre>\n
<bean id=\"inventoryLoadTaskExecutor\"\r\n\tclass=\"org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor\">\r\n\t<property name=\"corePoolSize\" value=\"10\" \/>\r\n\t<property name=\"maxPoolSize\" value=\"10\" \/>\r\n\t<property name=\"allowCoreThreadTimeOut\" value=\"true\" \/>\r\n<\/bean><\/pre>\n
Additional Resources<\/h2>\n
\n <\/p>\n