Comment utiliser Java pour développer une application de traitement par lots basée sur Spring Batch

Comment utiliser Java pour développer une application de traitement par lots basée sur Spring Batch, des exemples de code spécifiques sont requis

L'application de traitement par lots est une méthode de traitement de données courante, qui peut s'exécuter en arrière-plan et traiter automatiquement de grandes quantités de données. Le développement d'applications de traitement par lots en Java peut être réalisé via le framework Spring Batch. Spring Batch est un framework de traitement par lots open source qui fournit un ensemble de composants réutilisables pour aider les développeurs à simplifier le développement d'applications de traitement par lots.

Ce qui suit présentera comment utiliser Java pour développer une application de traitement par lots basée sur Spring Batch et fournira des exemples de code détaillés.

Étape 1 : Importer les dépendances

Tout d'abord, nous devons importer les dépendances Spring Batch dans le projet. Vous pouvez ajouter les dépendances suivantes dans le fichier pom.xml du projet :

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

Étape 2 : Configurer la source de données et la configuration de base de Spring Batch

Ensuite, nous devons configurer la source de données et la configuration de base de Spring Batch. Vous pouvez ajouter la configuration suivante dans le fichier application.properties (ou application.yml) :

spring.datasource.url=<数据库URL>
spring.datasource.username=<用户名>
spring.datasource.password=<密码>

spring.batch.job.names=<批处理作业名称>

Ici, vous devez remplacer c6e92402cf9eebbb5beaa6b585ed1b5a, e0b3a91f7c200bb2b489bcce2a53776c, 16398288f261faa759d47caefd275b5c la valeur réelle.

Étape 3 : Créer un modèle de données

Ensuite, nous devons créer une classe de modèle de données pour représenter les données dans le processus par lots. Par exemple, en supposant que notre application batch souhaite traiter une table d'informations utilisateur, nous pouvons créer une classe User pour représenter les informations utilisateur :

public class User {
    private String name;
    private int age;
    // 省略getter和setter方法
}

Étape 4 : Créer un lecteur (ItemReader)

Ensuite, nous devons créer un ItemReader pour lire des données. Spring Batch fournit une variété d'implémentations de lecteurs par défaut, telles que le lecteur JDBC (JdbcCursorItemReader), le lecteur de fichiers (FlatFileItemReader), etc. Ici, nous utilisons le lecteur JDBC pour lire les données de la base de données.

@Bean
public ItemReader<User> userItemReader(DataSource dataSource) {
    JdbcCursorItemReader<User> reader = new JdbcCursorItemReader<>();
    reader.setDataSource(dataSource);
    reader.setSql("SELECT name, age FROM user");
    reader.setRowMapper((resultSet, rowNum) -> {
        User user = new User();
        user.setName(resultSet.getString("name"));
        user.setAge(resultSet.getInt("age"));
        return user;
    });
    return reader;
}

Ici, nous utilisons JdbcCursorItemReader et définissons la source de données via la méthode setDataSource(), définissons l'instruction SQL via la méthode setSql() et définissons le mappage de l'ensemble de résultats via la méthode setRowMapper().

Étape 5 : Créer un processeur (ItemProcessor)

Ensuite, nous devons créer un ItemProcessor pour traiter les données. ItemProcessor est responsable du traitement et de la conversion des données lues. Par exemple, nous pouvons créer un UserItemProcessor pour ajouter 1 à l'âge de l'objet User :

public class UserItemProcessor implements ItemProcessor<User, User> {
    @Override
    public User process(User user) {
        user.setAge(user.getAge() + 1);
        return user;
    }
}

Étape 6 : Créer un écrivain (ItemWriter)

Ensuite, nous devons créer un ItemWriter pour écrire les données traitées. Spring Batch fournit également une variété d'implémentations d'écrivain par défaut, telles que l'écrivain JDBC (JdbcBatchItemWriter), l'écrivain de fichiers (FlatFileItemWriter), etc. Ici, nous utilisons l'écrivain JDBC pour écrire des données dans la base de données.

@Bean
public ItemWriter<User> userItemWriter(DataSource dataSource) {
    JdbcBatchItemWriter<User> writer = new JdbcBatchItemWriter<>();
    writer.setItemSqlParameterSourceProvider(new BeanPropertyItemSqlParameterSourceProvider<>());
    writer.setSql("INSERT INTO user (name, age) VALUES (:name, :age)");
    writer.setDataSource(dataSource);
    return writer;
}

Ici, nous utilisons JdbcBatchItemWriter et définissons le fournisseur de paramètres via la méthode setItemSqlParameterSourceProvider(), définissons l'instruction SQL via la méthode setSql() et définissons la source de données via la méthode setDataSource().

Étape 7 : Créer un travail

Enfin, nous devons créer un travail pour contenir les lecteurs, les processeurs et les écrivains, ainsi que d'autres composants Spring Batch. Les tâches et les étapes peuvent être créées à l'aide de JobBuilderFactory et StepBuilderFactory. Par exemple, nous pouvons créer un userJob qui contient un userStep :

@Bean
public Job userJob(JobBuilderFactory jobBuilderFactory, Step userStep) {
    return jobBuilderFactory.get("userJob")
            .incrementer(new RunIdIncrementer())
            .flow(userStep)
            .end()
            .build();
}

@Bean
public Step userStep(StepBuilderFactory stepBuilderFactory,
                     ItemReader<User> userItemReader,
                     ItemProcessor<User, User> userItemProcessor,
                     ItemWriter<User> userItemWriter) {
    return stepBuilderFactory.get("userStep")
            .<User, User>chunk(10)
            .reader(userItemReader)
            .processor(userItemProcessor)
            .writer(userItemWriter)
            .build();
}

Ici, nous utilisons la méthode get() de StepBuilderFactory pour créer des étapes et définir la taille de la tâche par lots (c'est-à-dire la quantité de données traitées à chaque fois) via la méthode chunk()).

À ce stade, nous avons terminé le développement d'une application de traitement par lots basée sur Spring Batch. Les travaux par lots peuvent être démarrés en exécutant userJob.

Résumé

Cet article présente comment utiliser Java pour développer une application de traitement par lots basée sur Spring Batch. De l'importation de dépendances, la configuration des sources de données et la configuration de base de Spring Batch, à la création de modèles de données, de lecteurs, de processeurs, d'écrivains et de tâches, des exemples de code détaillés sont fournis dans l'article. J'espère que cet article pourra aider les lecteurs à démarrer rapidement le développement d'applications de traitement par lots basées sur Spring Batch en Java.

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!