Partager l'introduction de Spring Batch

Cet article vous présente principalement les informations pertinentes pour démarrer avec Spring Batch. L'introduction dans l'article est très détaillée et a une certaine valeur de référence et d'apprentissage pour tous les amis qui en ont besoin, veuillez suivre l'éditeur pour apprendre ensemble. .

Introduction à SpringBatch :

SpringBatch est un framework de traitement parallèle de données volumineuses. Il est généralement utilisé pour la migration hors ligne des données et du traitement des données. Il prend en charge les transactions, la concurrence, les processus, la surveillance, l'expansion verticale et horizontale, et fournit une gestion unifiée des interfaces et des tâches. SpringBatch est une application développée par SpringSource et Accenture pour unifier le parallèle de l'industrie ; normes de traitement. Fournir aux développeurs un ensemble de cadres qui facilitent le développement.

Adresse officielle : github.com/spring-projects/spring-batch

• SpringBatch lui-même fournit une nouvelle tentative, Gestion des exceptions, sauter, redémarrer, statistiques de traitement des tâches, gestion des ressources et autres fonctionnalités, telles sont les principales raisons pour lesquelles les développeurs l'apprécient ;

• SpringBatch est un framework léger de traitement par lots ;

• La structure SpringBatch est en couches, les stratégies et structures commerciales et de traitement sont séparées ;

• L'instance en cours d'exécution de la tâchestatut, les données d'exécution et les paramètres seront tous Implémenté dans la base de données ;
  

Démarrage rapide

pom.xml ajouté

 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-batch</artifactId>
</dependency>

Créer BatchConfig (peut être un autre nom de classe)

@Configuration
@EnableBatchProcessing
public class BatchConfig {
 // tag::readerwriterprocessor[]
 @Bean
 public FlatFileItemReader<Person> flatFileItemReader() {
  FlatFileItemReader<Person> reader = new FlatFileItemReader<>();
  reader.setResource(new ClassPathResource("sample-data.csv"));
  FixedLengthTokenizer fixedLengthTokenizer = new FixedLengthTokenizer();
  reader.setLineMapper(new DefaultLineMapper<Person>() {{
   setLineTokenizer(new DelimitedLineTokenizer() {{
    setNames(new String[]{"firstName", "lastName"});
   }});
   setFieldSetMapper(new BeanWrapperFieldSetMapper<Person>() {{
    setTargetType(Person.class);
   }});
  }});
  return reader;
 }
 @Bean
 public JdbcPagingItemReader<Person> jdbcPagingItemReader(DataSource dataSource) {
  JdbcPagingItemReader<Person> reader = new JdbcPagingItemReader<>();
  reader.setDataSource(dataSource);
  reader.setFetchSize(100);
  reader.setQueryProvider(new MySqlPagingQueryProvider() {{
   setSelectClause("SELECT person_id,first_name,last_name");
   setFromClause("from people");
   setWhereClause("last_name=:lastName");
   setSortKeys(new HashMap<String, Order>() {{
    put("person_id", Order.ASCENDING);
   }});
  }});
  reader.setParameterValues(new HashMap<String, Object>() {{
   put("lastName", "DOE");
  }});
  reader.setRowMapper(new BeanPropertyRowMapper<>(Person.class));
  return reader;
 }
 @Bean
 public JdbcBatchItemWriter<Person> jdbcBatchItemWriter(DataSource dataSource) {
  JdbcBatchItemWriter<Person> writer = new JdbcBatchItemWriter<>();
  writer.setItemSqlParameterSourceProvider(new BeanPropertyItemSqlParameterSourceProvider<>());
  writer.setSql("INSERT INTO people (first_name, last_name) VALUES (:firstName, :lastName)");
  writer.setDataSource(dataSource);
  return writer;
 }
 /*@Bean
 public FlatFileItemWriter<Person> flatFileItemWriter(DataSource dataSource) {
  FlatFileItemWriter<Person> writer = new FlatFileItemWriter<>();
  writer.setAppendAllowed(true);
  writer.setEncoding("UTF-8");
//  writer.set(dataSource);
  return writer;
 }*/
 // end::readerwriterprocessor[]
 // tag::jobstep[]
 @Bean
 public Job importUserJob(JobBuilderFactory jobBuilderFactory, JobCompletionNotificationListener listener, Step step) {
  return jobBuilderFactory.get("importUserJob")
    .incrementer(new RunIdIncrementer())
    .listener(listener)
    .start(step)
    .build();
 }
 @Bean
 public Step step1(StepBuilderFactory stepBuilderFactory, PersonItemProcessor processor, ItemWriter jdbcBatchItemWriter, ItemReader flatFileItemReader) {
  /*CompositeItemProcessor compositeItemProcessor = new CompositeItemProcessor();
  compositeItemProcessor.setDelegates(Lists.newArrayList(processor, processor));*/
  return stepBuilderFactory.get("step1")
    .<Person, Person>chunk(10)
    .reader(flatFileItemReader)
    .processor(processor)
    .writer(jdbcBatchItemWriter)
    .build();
 }
 // end::jobstep[]
}

Architecture en couches de Spring Batch

• Gestion des politiques d'infrastructure : y compris les nouvelles tentatives d'échec des tâches, la gestion des exceptions, les transactions, les sauts et les entrées et sorties de données (fichiers texte, base de données, Message)

• Core : Le cœur de springBatch, y compris JobLauch, job, step, etc.

• Application : Traitement métier, création de tâches, déterminer la méthode d'exécution de la tâche (tâches planifiées, déclenchement manuel, etc.)

Processus d'exécution Spring Batch

Résumé

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!