tags | projects | |
---|---|---|
|
This guide walks you through the process of creating a basic batch-driven solution.
You’ll build a service that imports data from a CSV spreadsheet, transforms it with custom code, and stores the final results in a database.
Typically your customer or a business analyst supplies a spreadsheet. In this case, you make it up.
src/main/resources/sample-data.csv
link:initial/src/main/resources/sample-data.csv[role=include]
This spreadsheet contains a first name and a last name on each row, separated by a comma. This is a fairly common pattern that Spring handles out-of-the-box, as you will see.
Next, you write a SQL script to create a table to store the data.
src/main/resources/schema-all.sql
link:initial/src/main/resources/schema-all.sql[role=include]
Note
|
Spring Boot runs schema-@@platform@@.sql automatically during startup. -all is the default for all platforms.
|
Now that you see the format of data inputs and outputs, you write code to represent a row of data.
src/main/java/hello/Person.java
link:complete/src/main/java/hello/Person.java[role=include]
You can instantiate the Person
class either with first and last name through a constructor, or by setting the properties.
A common paradigm in batch processing is to ingest data, transform it, and then pipe it out somewhere else. Here you write a simple transformer that converts the names to uppercase.
src/main/java/hello/PersonItemProcessor.java
link:complete/src/main/java/hello/PersonItemProcessor.java[role=include]
PersonItemProcessor
implements Spring Batch’s ItemProcessor
interface. This makes it easy to wire the code into a batch job that you define further down in this guide. According to the interface, you receive an incoming Person
object, after which you transform it to an upper-cased Person
.
Note
|
There is no requirement that the input and output types be the same. In fact, after one source of data is read, sometimes the application’s data flow needs a different data type. |
Now you put together the actual batch job. Spring Batch provides many utility classes that reduce the need to write custom code. Instead, you can focus on the business logic.
src/main/java/hello/BatchConfiguration.java
link:complete/src/main/java/hello/BatchConfiguration.java[role=include]
For starters, the @EnableBatchProcessing
annotation adds many critical beans that support jobs and saves you a lot of leg work. This example uses a memory-based database (provided by @EnableBatchProcessing
), meaning that when it’s done, the data is gone.
Break it down:
src/main/java/hello/BatchConfiguration.java
link:/complete/src/main/java/hello/BatchConfiguration.java[role=include]
.
The first chunk of code defines the input, processor, and output.
- reader()
creates an ItemReader
. It looks for a file called sample-data.csv
and parses each line item with enough information to turn it into a Person
.
- processor()
creates an instance of our PersonItemProcessor
you defined earlier, meant to uppercase the data.
- write(DataSource)
creates an ItemWriter
. This one is aimed at a JDBC destination and automatically gets a copy of the dataSource created by @EnableBatchProcessing
. It includes the SQL statement needed to insert a single Person
driven by Java bean properties.
The next chunk focuses on the actual job configuration.
src/main/java/hello/BatchConfiguration.java
link:/complete/src/main/java/hello/BatchConfiguration.java[role=include]
. The first method defines the job and the second one defines a single step. Jobs are built from steps, where each step can involve a reader, a processor, and a writer.
In this job definition, you need an incrementer because jobs use a database to maintain execution state. You then list each step, of which this job has only one step. The job ends, and the Java API produces a perfectly configured job.
In the step definition, you define how much data to write at a time. In this case, it writes up to ten records at a time. Next, you configure the reader, processor, and writer using the injected bits from earlier.
Note
|
chunk() is prefixed <Person,Person> because it’s a generic method. This represents the input and output types of each "chunk" of processing, and lines up with ItemReader<Person> and ItemWriter<Person> .
|
Although batch processing can be embedded in web apps and WAR files, the simpler approach demonstrated below creates a standalone application. You package everything in a single, executable JAR file, driven by a good old Java main()
method.
src/main/java/hello/Application.java
link:complete/src/main/java/hello/Application.java[role=include]
The main()
method defers to the SpringApplication
helper class, providing Application.class
as an argument to its run()
method. This tells Spring to read the annotation metadata from Application
and to manage it as a component in the Spring application context.
The @ComponentScan
annotation tells Spring to search recursively through the hello
package and its children for classes marked directly or indirectly with Spring’s @Component
annotation. This directive ensures that Spring finds and registers BatchConfiguration
, because it is marked with @Configuration
, which in turn is a kind of @Component
annotation.
The @EnableAutoConfiguration
annotation switches on reasonable default behaviors based on the content of your classpath. For example, it looks for any class that implements the CommandLineRunner
interface and invokes its run()
method. In this case, it runs the demo code for this guide.
For demonstration purposes, there is code to create a JdbcTemplate
, query the database, and print out the names of people the batch job inserts.
The job prints out a line for each person that gets transformed. After the job runs, you can also see the output from querying the database.
Converting (firstName: Jill, lastName: Doe) into (firstName: JILL, lastName: DOE) Converting (firstName: Joe, lastName: Doe) into (firstName: JOE, lastName: DOE) Converting (firstName: Justin, lastName: Doe) into (firstName: JUSTIN, lastName: DOE) Converting (firstName: Jane, lastName: Doe) into (firstName: JANE, lastName: DOE) Converting (firstName: John, lastName: Doe) into (firstName: JOHN, lastName: DOE) Found <firstName: JILL, lastName: DOE> in the database. Found <firstName: JOE, lastName: DOE> in the database. Found <firstName: JUSTIN, lastName: DOE> in the database. Found <firstName: JANE, lastName: DOE> in the database. Found <firstName: JOHN, lastName: DOE> in the database.