[JAVA] [Spring Batch] Vérification de la mise en œuvre de l'étape de bloc et de l'étape de tâche de Spring Batch

introduction

Nous vérifierons la méthode de mise en œuvre pour les types en deux étapes de Spring Batch. Cette fois, il sera réalisé par annotation Java.

Type d'étape

Il existe deux principaux types d'étapes. «Étapes réservées aux tâches» et «étapes de bloc». Jetons un bref coup d'œil à chacun d'entre eux ci-dessous.

1. Tasklet seulement étapes

   

2. Chunk étapes

   

environnement

Windows 10 JDK 1.8.0_251 STS 4.6.2

Créer un projet

Créez un «projet Spring Starter». Lors de la création d'un projet, lorsqu'il s'agit d'une dépendance, sélectionnez uniquement "Spring Batch".

• Après avoir créé le projet, ajoutez manuellement la dépendance de "hsqldb" à pom.xml. Ajoutez la source suivante au bloc de dépendances.

pom.xml

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

étape de bloc Exemple de description de la source

■ Démarrer la méthode principale

BatchTestAppApplication.java

@SpringBootApplication
public class BatchTestAppApplication {

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

}

■ SQL pour la création de table

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)
);

■ Fichier CSV d'entrée

sample-data.csv

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

■ Classe DTO

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;
	}

}

■ Classe d'implémentation de l'interface ItemProcessor

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;
	}

}

La description:

Implémentez la méthode de processus. Modifiez le nom simple en majuscules. Un journal d'informations est généré pour vérifier l'historique d'exécution.

■ Classe d'auditeur

Implémentez la méthode afterJob de JobExecutionListenerSupport pour vérifier le résultat de l'exécution du travail.

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."));
		}
	}
}

■ Chaque classe de définition Bean de 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();
	}
}

La description:

1. reader

Renvoie FlatFileItemReader comme ItemReader. Lit les données dans le fichier CSV d'entrée et les stocke dans le Bean DTO Person. 2. processor

Renvoyez PersonItemProcessor comme ItemProcessor. 3. writer

Renvoie JdbcBatchItemWriter comme ItemWriter. Stocke le résultat du traitement de Item Processor dans DB. 4. step1

Liez FlatFileItemReader, PersonItemProcessor et JdbcBatchItemWriter avec StepBuilderFactory pour générer un bean step chunk pour Spring Batch. 5. importUserJob

Générez un Job Spring Batch à l'aide du JobCompletionNotificationListener Bean personnalisé et du Bean étape de bloc généré à l'étape 1. Lorsque vous démarrez le lot correspondant, vous pouvez exécuter le Job généré par cette méthode.

tasklet étape Exemple de description de la source

Tirez parti du projet ci-dessus pour modifier BatchConfiguration afin d'implémenter l'exemple d'étape de tasklet. L'étape de tasklet correspondante exécute la commande du système d'exploitation.

■ Réparation de la configuration par lots

--Générer le bean tasklet

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;
	}

• Vérifiez Javadoc pour l'explication de chaque attribut de SystemCommandTasklet.

--step Bean génération

python

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

--Créer un emploi

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();
	}

référence

Creating a Batch Service [Java] [Spring Boot] Essayez d'utiliser Tasklet avec Spring Batch