So entwickeln Sie mit Java eine Stapelverarbeitungsanwendung basierend auf Spring Batch

Um mit Java eine auf Spring Batch basierende Stapelverarbeitungsanwendung zu entwickeln, sind spezifische Codebeispiele erforderlich.

Die Stapelverarbeitungsanwendung ist eine gängige Datenverarbeitungsmethode, die im Hintergrund ausgeführt werden und große Datenmengen automatisch verarbeiten kann. Die Entwicklung von Stapelverarbeitungsanwendungen in Java kann über das Spring Batch-Framework erreicht werden. Spring Batch ist ein Open-Source-Stapelverarbeitungs-Framework, das eine Reihe wiederverwendbarer Komponenten bereitstellt, um Entwicklern die Entwicklung von Stapelverarbeitungsanwendungen zu vereinfachen.

Im Folgenden wird die Verwendung von Java zum Entwickeln einer auf Spring Batch basierenden Stapelverarbeitungsanwendung vorgestellt und detaillierte Codebeispiele bereitgestellt.

Schritt 1: Abhängigkeiten importieren

Zuerst müssen wir Spring Batch-Abhängigkeiten in das Projekt importieren. Sie können der pom.xml-Datei des Projekts die folgenden Abhängigkeiten hinzufügen:

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

Schritt 2: Konfigurieren Sie die Datenquelle und die Grundkonfiguration von Spring Batch

Als nächstes müssen wir die Datenquelle und die Grundkonfiguration von Spring Batch konfigurieren. Sie können die folgende Konfiguration in der Datei application.properties (oder application.yml) hinzufügen:

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

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

Hier müssen Sie , und ersetzen der tatsächliche Wert.

Schritt 3: Erstellen Sie ein Datenmodell

Dann müssen wir eine Datenmodellklasse erstellen, um die Daten im Batch-Prozess darzustellen. Angenommen, unsere Batch-Anwendung möchte beispielsweise eine Benutzerinformationstabelle verarbeiten, können wir eine Benutzerklasse erstellen, um Benutzerinformationen darzustellen:

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

Schritt 4: Erstellen Sie einen Reader (ItemReader)

Als nächstes müssen wir einen ItemReader erstellen Daten lesen. Spring Batch bietet eine Vielzahl von Standard-Reader-Implementierungen, z. B. JDBC-Reader (JdbcCursorItemReader), Dateireader (FlatFileItemReader) usw. Hier verwenden wir den JDBC-Reader, um Daten aus der Datenbank zu lesen.

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

Hier verwenden wir JdbcCursorItemReader und legen die Datenquelle über die Methode setDataSource() fest, legen die SQL-Anweisung über die Methode setSql() fest und legen die Ergebnismengenzuordnung über die Methode setRowMapper() fest.

Schritt 5: Erstellen Sie einen Prozessor (ItemProcessor)

Dann müssen wir einen ItemProcessor erstellen, um die Daten zu verarbeiten. ItemProcessor ist für die Verarbeitung und Konvertierung der gelesenen Daten verantwortlich. Beispielsweise können wir einen UserItemProcessor erstellen, um 1 zum Alter des Benutzerobjekts hinzuzufügen:

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

Schritt 6: Erstellen Sie einen Writer (ItemWriter)

Als nächstes müssen wir einen ItemWriter erstellen, um die verarbeiteten Daten zu schreiben. Spring Batch bietet auch eine Vielzahl von Standard-Writer-Implementierungen, z. B. JDBC-Writer (JdbcBatchItemWriter), Datei-Writer (FlatFileItemWriter) usw. Hier verwenden wir den JDBC-Writer, um Daten in die Datenbank zu schreiben.

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

Hier verwenden wir JdbcBatchItemWriter und legen den Parameteranbieter über die Methode setItemSqlParameterSourceProvider() fest, legen die SQL-Anweisung über die Methode setSql() fest und legen die Datenquelle über die Methode setDataSource() fest.

Schritt 7: Job erstellen

Abschließend müssen wir einen Job erstellen, der Leser, Prozessoren und Autoren sowie andere Spring Batch-Komponenten einschließt. Jobs und Schritte können mit JobBuilderFactory und StepBuilderFactory erstellt werden. Zum Beispiel können wir einen userJob erstellen, der einen userStep enthält:

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

Hier verwenden wir die get()-Methode von StepBuilderFactory, um Schritte zu erstellen, und legen die Größe der Batch-Aufgabe fest (d. h. die Menge der jedes Mal verarbeiteten Daten). durch die chunk()-Methode).

Zu diesem Zeitpunkt haben wir die Entwicklung einer auf Spring Batch basierenden Stapelverarbeitungsanwendung abgeschlossen. Batch-Jobs können durch Ausführen von userJob gestartet werden.

Zusammenfassung

In diesem Artikel wird erläutert, wie Sie mit Java eine auf Spring Batch basierende Stapelverarbeitungsanwendung entwickeln. Vom Importieren von Abhängigkeiten über das Konfigurieren von Datenquellen und der Grundkonfiguration von Spring Batch bis hin zum Erstellen von Datenmodellen, Readern, Prozessoren, Writern und Jobs werden im Artikel detaillierte Codebeispiele bereitgestellt. Ich hoffe, dieser Artikel kann den Lesern helfen, schnell mit der Entwicklung von Stapelverarbeitungsanwendungen auf Basis von Spring Batch in Java zu beginnen.

Das obige ist der detaillierte Inhalt vonSo entwickeln Sie mit Java eine Stapelverarbeitungsanwendung basierend auf Spring Batch. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!