[JAVA] [Spring Batch] Überprüfung der Implementierung von Chunk Step und Tasklet Step von Spring Batch

Einführung

Wir werden die Implementierungsmethode für die zweistufigen Arten von Spring Batch überprüfen. Dieses Mal wird es durch Java-Annotation realisiert.

Schrittart

Es gibt zwei Haupttypen von Schritten. "Nur Tasklet-Schritte" und "Chunk-Schritte". Werfen wir einen kurzen Blick auf jeden einzelnen unten.

1. Tasklet nur Schritte

   

2. Chunk-Schritte

   

Umgebung

Windows 10 JDK 1.8.0_251 STS 4.6.2

Ein Projekt erstellen

Erstellen Sie ein "Spring Starter Project". Wählen Sie beim Erstellen eines Projekts, wenn es sich um eine Abhängigkeit handelt, nur "Spring Batch" aus.

• Fügen Sie nach dem Erstellen des Projekts die Abhängigkeit von "hsqldb" manuell zu pom.xml hinzu. Fügen Sie dem Abhängigkeitsblock die folgende Quelle hinzu.

pom.xml

        <dependency>
			<groupId>org.hsqldb</groupId>
			<artifactId>hsqldb</artifactId>
			<scope>runtime</scope>
        </dependency>

Chunk-Schritt Beschreibung der Beispielquelle

■ Starten Sie die Hauptmethode

BatchTestAppApplication.java

@SpringBootApplication
public class BatchTestAppApplication {

	public static void main(String[] args) {
		SpringApplication.run(BatchTestAppApplication.class, args);
	}

}

■ SQL für die Tabellenerstellung

schema-all.sql

DROP TABLE people IF EXISTS;

CREATE TABLE people  (
    person_id BIGINT IDENTITY NOT NULL PRIMARY KEY,
    first_name VARCHAR(20),
    last_name VARCHAR(20)
);

■ CSV-Datei eingeben

sample-data.csv

Jill,Doe
Joe,Doe
Justin,Doe
Jane,Doe
John,Doe

■ DTO-Klasse

Person.java

public class Person {

	private String lastName;
	private String firstName;

	public Person() {
	}

	public Person(String firstName, String lastName) {
		this.firstName = firstName;
		this.lastName = lastName;
	}

	public void setFirstName(String firstName) {
		this.firstName = firstName;
	}

	public String getFirstName() {
		return firstName;
	}

	public String getLastName() {
		return lastName;
	}

	public void setLastName(String lastName) {
		this.lastName = lastName;
	}

	@Override
	public String toString() {
		return "firstName: " + firstName + ", lastName: " + lastName;
	}

}

■ Implementierungsklasse der ItemProcessor-Schnittstelle

PersonItemProcessor.java

public class PersonItemProcessor implements ItemProcessor<Person, Person> {

	private static final Logger log = LoggerFactory.getLogger(PersonItemProcessor.class);

	@Override
	public Person process(final Person person) throws Exception {
		final String firstName = person.getFirstName().toUpperCase();
		final String lastName = person.getLastName().toUpperCase();

		final Person transformedPerson = new Person(firstName, lastName);

		log.info("Converting (" + person + ") into (" + transformedPerson + ")");

		return transformedPerson;
	}

}

Erläuterung:

Implementieren Sie die Prozessmethode. Ändern Sie den einfachen Namen in Großbuchstaben. Ein Info-Protokoll wird ausgegeben, um den Ausführungsverlauf zu überprüfen.

■ Hörerklasse

Implementieren Sie die afterJob-Methode von JobExecutionListenerSupport, um das Ergebnis der Jobausführung zu überprüfen.

JobCompletionNotificationListener.java

@Component
public class JobCompletionNotificationListener extends JobExecutionListenerSupport {

	private static final Logger log = LoggerFactory.getLogger(JobCompletionNotificationListener.class);

	private final JdbcTemplate jdbcTemplate;

	@Autowired
	public JobCompletionNotificationListener(JdbcTemplate jdbcTemplate) {
		this.jdbcTemplate = jdbcTemplate;
	}

	@Override
	public void afterJob(JobExecution jobExecution) {
		if (jobExecution.getStatus() == BatchStatus.COMPLETED) {
			log.info("!!! JOB FINISHED! Time to verify the results");

			jdbcTemplate
					.query("SELECT first_name, last_name FROM people",
							(rs, row) -> new Person(rs.getString(1), rs.getString(2)))
					.forEach(person -> log.info("Found <" + person + "> in the database."));
		}
	}
}

■ Jede Bean-Definitionsklasse von Batch

BatchConfiguration.java

@Configuration
@EnableBatchProcessing
public class BatchConfiguration {

	private static final Logger log = LoggerFactory.getLogger(BatchConfiguration.class);

	@Autowired
	public JobBuilderFactory jobBuilderFactory;

	@Autowired
	public StepBuilderFactory stepBuilderFactory;
	
	@Bean
	public FlatFileItemReader<Person> reader() {
		return new FlatFileItemReaderBuilder<Person>().name("personItemReader")
				.resource(new ClassPathResource("sample-data.csv")).delimited()
				.names(new String[] { "firstName", "lastName" })
				.fieldSetMapper(new BeanWrapperFieldSetMapper<Person>() {
					{
						setTargetType(Person.class);
					}
				}).build();
	}

	@Bean
	public PersonItemProcessor processor() {
		return new PersonItemProcessor();
	}

	@Bean
	public JdbcBatchItemWriter<Person> writer(DataSource dataSource) {
		return new JdbcBatchItemWriterBuilder<Person>()
				.itemSqlParameterSourceProvider(new BeanPropertyItemSqlParameterSourceProvider<>())
				.sql("INSERT INTO people (first_name, last_name) VALUES (:firstName, :lastName)").dataSource(dataSource)
				.build();
	}

	@Bean
	public Job importUserJob(JobCompletionNotificationListener listener, Step step1) {
		return jobBuilderFactory.get("importUserJob").incrementer(new RunIdIncrementer()).listener(listener).flow(step1)
				.end()
				.build();
	}
	
	@Bean
	public Step step1(JdbcBatchItemWriter<Person> writer) {
		return stepBuilderFactory.get("step1").<Person, Person>chunk(10).reader(reader()).processor(processor())
				.writer(writer).build();
	}
}

Erläuterung:

1. reader

Gibt FlatFileItemReader als ItemReader zurück. Liest die Daten in der CSV-Eingabedatei und speichert sie in der Person DTO Bean. 2. processor

Geben Sie PersonItemProcessor als ItemProcessor zurück. 3. writer

Gibt JdbcBatchItemWriter als ItemWriter zurück. Speichert das Verarbeitungsergebnis des Artikelprozessors in der Datenbank. 4. step1

Verknüpfen Sie FlatFileItemReader, PersonItemProcessor und JdbcBatchItemWriter mit StepBuilderFactory, um eine Chunk-Step-Bean für Spring Batch zu generieren. 5. importUserJob

Generieren Sie einen Spring Batch-Job mit der angepassten JobCompletionNotificationListener-Bean und der in Schritt 1 generierten Blockschritt-Bean. Wenn Sie den entsprechenden Stapel starten, können Sie den mit dieser Methode generierten Job ausführen.

Tasklet-Schritt Beschreibung der Beispielquelle

Nutzen Sie das obige Projekt, um BatchConfiguration zu ändern und das Tasklet-Schrittbeispiel zu implementieren. Der entsprechende Tasklet-Schritt führt den Betriebssystembefehl aus.

■ Reparatur der Stapelkonfiguration

• Generieren Sie Tasklet Bean

python

	@Bean
	public Tasklet copyFile() {
		log.info("Start FileCopy");
		SystemCommandTasklet tasklet = new SystemCommandTasklet();
		tasklet.setCommand("cmd /C copy C:\\data\\test.txt C:\\data\\test2.txt");
		tasklet.setTimeout(3000);
		return tasklet;
	}

• Überprüfen Sie Javadoc auf die Erläuterung der einzelnen Attribute von SystemCommandTasklet.

--step Bean Generation

python

	@Bean
	public Step step2() {
		return stepBuilderFactory.get("step2").tasklet(copyFile()).build();
	}

• Job erstellen

python

	@Bean
	public Job cmdJob(JobCompletionNotificationListener listener, Step step1, Step step2, Step step3) {
		return jobBuilderFactory.get("cmdJob").incrementer(new RunIdIncrementer()).listener(listener).
				flow(step2)
				.end()
				.build();
	}

Referenz

Creating a Batch Service [Java] [Spring Boot] Versuchen Sie, Tasklet mit Spring Batch zu verwenden