Mulakan pengaturcaraan dengan SPRING BATCH-javaTutorial-php.cn

pengenalan

Dalam projek peribadi atau profesional anda, kadangkala anda memproses volum data yang besar. Pemprosesan kelompok data ialah cara yang cekap untuk memproses jumlah data yang besar di mana data dikumpul, diproses dan kemudian hasil kelompok dihasilkan. Pemprosesan kelompok boleh digunakan dalam banyak kes penggunaan. Kes penggunaan biasa untuk pemprosesan kelompok ialah menukar set besar fail CSV atau JSON kepada format berstruktur sedia untuk pemprosesan selanjutnya.

Dalam tutorial ini, kami akan cuba melihat cara melaksanakan seni bina ini dengan Spring Boot yang merupakan rangka kerja yang memudahkan pembangunan aplikasi berdasarkan Spring.

Apakah Spring-Batch?

Spring Batch ialah rangka kerja sumber terbuka untuk pemprosesan kelompok. Ia adalah penyelesaian yang ringan dan komprehensif yang direka untuk membolehkan pembangunan aplikasi kelompok yang mantap, yang sering dijumpai dalam sistem perusahaan moden. Perkembangannya adalah hasil kerjasama antara SpringSource dan Accenture.

Ia memungkinkan untuk mengatasi masalah berulang semasa pembangunan kelompok:

produktiviti
pengurusan volum data yang besar
kebolehpercayaan
penciptaan semula roda.

NB: Dalam IT, kumpulan ialah program yang beroperasi dalam StandAlone, menjalankan satu set operasi pemprosesan pada volum data.

Senibina Asas Spring Batch

Commencer la programmation avec SPRING BATCH

Untuk mengurus data kelompok, kami menggunakan tiga alatan berikut terutamanya:

JobLauncher: Ini ialah komponen yang bertanggungjawab untuk melancarkan/memulakan program kelompok. Ia boleh dikonfigurasikan untuk mencetuskan secara automatik atau untuk dicetuskan oleh peristiwa luaran (pelancaran manual). Dalam aliran kerja Spring Batch, JobLauncher bertanggungjawab untuk melaksanakan Kerja.

Pekerjaan: Ini adalah komponen yang mewakili tugas yang mana tanggungjawab untuk keperluan perniagaan yang ditangani dalam program diwakilkan. Ia bertanggungjawab untuk melancarkan satu atau lebih Langkah secara berurutan.

Langkah: inilah komponen yang menyelubungi nadi perniagaan yang perlu ditangani. Ia bertanggungjawab untuk mentakrifkan tiga subkomponen berstruktur seperti berikut:

ItemReader: Ini ialah komponen yang bertanggungjawab untuk membaca data input yang akan diproses. Ia boleh datang daripada pelbagai sumber (pangkalan data, fail rata (csv, xml, xls, dll.), baris gilir);

ItemProcessor: Ini ialah komponen yang bertanggungjawab untuk mengubah data yang dibaca. Di dalamnya semua peraturan pengurusan dilaksanakan.

ItemWriter: komponen ini menyimpan data yang diubah oleh pemproses dalam satu atau lebih bekas yang diingini (pangkalan data, fail rata (csv, xml, xls, dll.), awan).

JobRepository: ini ialah komponen yang bertanggungjawab untuk merekodkan statistik daripada pemantauan pada JobLauncher, Job dan Step(s) pada setiap pelaksanaan. Ia menawarkan dua teknik yang mungkin untuk menyimpan statistik ini: menggunakan pangkalan data atau menggunakan Peta. Apabila statistik disimpan dalam pangkalan data, dan oleh itu berterusan dalam cara yang berkekalan, ini membolehkan pemantauan berterusan Kumpulan dari semasa ke semasa untuk menganalisis kemungkinan masalah sekiranya berlaku kegagalan. Sebaliknya, apabila ia berada dalam Peta, statistik yang berterusan akan hilang pada penghujung setiap contoh pelaksanaan Kelompok. Dalam semua kes, satu atau yang lain mesti dikonfigurasikan.

Untuk maklumat lanjut, saya menasihati anda untuk merujuk tapak web Spring.

Selepas penjelasan ringkas tentang seni bina kumpulan musim bunga ini, mari kita cuba tunjukkan cara menyediakan kerja kumpulan musim bunga yang akan membaca data daripada fail CSV yang kemudiannya akan kami masukkan ke dalam pangkalan data." Mari kita masuk ke dalam pengekodan".

Commencer la programmation avec SPRING BATCH

Persediaan projek

Cara paling mudah untuk menjana projek Spring Boot ialah menggunakan Spring Boot Tool dengan langkah-langkah di bawah:

Pergi ke tapak web Spring Initializr
Pilih Projek Maven dan bahasa Java
Tambahkan Spring Batch, JPA, Lombok, Pangkalan Data H2
Masukkan nama kumpulan sebagai "com.example" dan artifak sebagai "SpringBatch"
Klik butang jana

Commencer la programmation avec SPRING BATCH

Setelah projek dijana, anda mesti nyahzipnya kemudian mengimportnya ke dalam IDE anda.

Teknologi yang digunakan:

JDK 1.8
Maven
IntelliJ
Lombok
Data musim bunga JPA
Pangkalan Data H2

Kebergantungan projek

Semua kebergantungan projek terdapat dalam fail pom.xml. Tiga huruf POM ialah akronim untuk Model Objek Projek. Perwakilan XMLnya diterjemahkan oleh Maven ke dalam struktur data yang mewakili model projek.

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.3.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.pathus</groupId>
    <artifactId>SpringBatchExample</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>SpringBatchExample</name>
    <description>Demo of spring batch project </description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

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

        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework.batch</groupId>
            <artifactId>spring-batch-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

Salin selepas log masuk

Struktur Projek

Struktur projek adalah seperti berikut:

Commencer la programmation avec SPRING BATCH

Konfigurasi Kerja

Untuk mendayakan pemprosesan kelompok, kami perlu menganotasi kelas konfigurasi dengan @EnableBatchProcessing. Kami kemudiannya mesti mencipta pembaca untuk membaca fail CSV kami, mencipta pemproses untuk memproses data input sebelum menulis, mencipta penulis untuk menulis ke pangkalan data.

import org.springframework.batch.core.Job;
import org.springframework.batch.core.Step;
import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;
import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
import org.springframework.batch.item.ItemProcessor;
import org.springframework.batch.item.ItemReader;
import org.springframework.batch.item.ItemWriter;
import org.springframework.batch.item.file.FlatFileItemReader;
import org.springframework.batch.item.file.LineMapper;
import org.springframework.batch.item.file.mapping.DefaultLineMapper;
import org.springframework.batch.item.file.transform.DelimitedLineTokenizer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;

import com.pathus90.springbatchexample.batch.StudentProcessor;
import com.pathus90.springbatchexample.batch.StudentWriter;
import com.pathus90.springbatchexample.model.Student;
import com.pathus90.springbatchexample.model.StudentFieldSetMapper;

@Configuration
@EnableBatchProcessing
@EnableScheduling
public class BatchConfig {

    private static final String FILE_NAME = "results.csv";
    private static final String JOB_NAME = "listStudentsJob";
    private static final String STEP_NAME = "processingStep";
    private static final String READER_NAME = "studentItemReader";

    @Value("${header.names}")
    private String names;

    @Value("${line.delimiter}")
    private String delimiter;

    @Autowired
    private JobBuilderFactory jobBuilderFactory;

    @Autowired
    private StepBuilderFactory stepBuilderFactory;

    @Bean
    public Step studentStep() {
        return stepBuilderFactory.get(STEP_NAME)
                .<Student, Student>chunk(5)
                .reader(studentItemReader())
                .processor(studentItemProcessor())
                .writer(studentItemWriter())
                .build();
    }

    @Bean
    public Job listStudentsJob(Step step1) {
        return jobBuilderFactory.get(JOB_NAME)
                .start(step1)
                .build();
    }

    @Bean
    public ItemReader<Student> studentItemReader() {
        FlatFileItemReader<Student> reader = new FlatFileItemReader<>();
        reader.setResource(new ClassPathResource(FILE_NAME));
        reader.setName(READER_NAME);
        reader.setLinesToSkip(1);
        reader.setLineMapper(lineMapper());
        return reader;

    }

    @Bean
    public LineMapper<Student> lineMapper() {

        final DefaultLineMapper<Student> defaultLineMapper = new DefaultLineMapper<>();
        final DelimitedLineTokenizer lineTokenizer = new DelimitedLineTokenizer();
        lineTokenizer.setDelimiter(delimiter);
        lineTokenizer.setStrict(false);
        lineTokenizer.setNames(names.split(delimiter));

        final StudentFieldSetMapper fieldSetMapper = new StudentFieldSetMapper();
        defaultLineMapper.setLineTokenizer(lineTokenizer);
        defaultLineMapper.setFieldSetMapper(fieldSetMapper);

        return defaultLineMapper;
    }

    @Bean
    public ItemProcessor<Student, Student> studentItemProcessor() {
        return new StudentProcessor();
    }

    @Bean
    public ItemWriter<Student> studentItemWriter() {
        return new StudentWriter();
    }
}

Salin selepas log masuk

Konfigurasi kerja dan Langkah

Kaedah pertama mentakrifkan kerja dan yang kedua mentakrifkan satu _langkah tunggal. Pekerjaan dicipta daripada langkah, di mana setiap langkah boleh melibatkan pembaca, pemproses dan penulis. Dalam definisi langkah, kami mentakrifkan jumlah data untuk ditulis pada satu masa dan dalam kes kami, ia menulis sehingga 5 rekod pada satu masa. Kemudian, kami mengkonfigurasi pembaca, pemproses dan penulis menggunakan kacang yang disuntik sebelum ini. Apabila mentakrifkan tugas kita, ia akan dapat menentukan langkah yang berbeza dalam pelaksanaan kita melalui susunan yang tepat. step studentStep akan dilaksanakan oleh job listStudentsJob.

@Bean
    public Step studentStep() {
        return stepBuilderFactory.get(STEP_NAME)
                .<Student, Student>chunk(5)
                .reader(studentItemReader())
                .processor(studentItemProcessor())
                .writer(studentItemWriter())
                .build();
    }

    @Bean
    public Job listStudentsJob(Step step1) {
        return jobBuilderFactory.get(JOB_NAME)
                .start(step1)
                .build();
    }

Salin selepas log masuk

Definisi Pembaca

Dalam konfigurasi kelompok kami, Pembaca membaca sumber data dan dipanggil berturut-turut dalam satu langkah dan mengembalikan objek yang ditakrifkan (Pelajar dalam kes kami).

 @Bean
    public ItemReader<Student> studentItemReader() {
        FlatFileItemReader<Student> reader = new FlatFileItemReader<>();
        reader.setResource(new ClassPathResource(FILE_NAME));
        reader.setName(READER_NAME);
        reader.setLinesToSkip(1);
        reader.setLineMapper(lineMapper());
        return reader;
    }

Salin selepas log masuk

Kelas FlatFileItemReader menggunakan kelas DefaultLineMapper yang seterusnya menggunakan kelas DelimitedLineTokenizer. Peranan DelimitedLineTokenizer adalah untuk menguraikan setiap baris menjadi objek FieldSet dan nama sifat memberikan format pengepala fail dan membolehkan data setiap baris dikenal pasti. Sifat nama ini digunakan oleh kelas pelaksanaan transformasi data menjadi objek perniagaan melalui objek FieldSet. Ini ialah kelas yang ditunjukkan oleh sifat fieldSetMapper (StudentFieldSetMapper).

import org.springframework.batch.item.file.mapping.FieldSetMapper;
import org.springframework.batch.item.file.transform.FieldSet;

public class StudentFieldSetMapper implements FieldSetMapper<Student> {
    @Override
    public Student mapFieldSet(FieldSet fieldSet) {
        return Student.builder()
                .rank(fieldSet.readString(0))
                .firstName(fieldSet.readString(1))
                .lastName(fieldSet.readString(2))
                .center(fieldSet.readString(3))
                .pv(fieldSet.readString(4))
                .origin(fieldSet.readString(5))
                .mention(fieldSet.readString(6))
                .build();
    }
}

Salin selepas log masuk

Antara muka LineMapper digunakan untuk memetakan garisan (rentetan) kepada objek yang biasanya digunakan untuk memetakan garisan yang dibaca daripada fail

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.3.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.pathus</groupId>
    <artifactId>SpringBatchExample</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>SpringBatchExample</name>
    <description>Demo of spring batch project </description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

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

        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework.batch</groupId>
            <artifactId>spring-batch-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

Salin selepas log masuk

Definisi Pemproses

Tidak seperti Pembaca, pelaksanaan Pemproses lebih kepada keperluan berfungsi. Ia tidak wajib dan kita boleh melakukannya tanpanya jika tiada keperluan berfungsi dijangka dalam pemprosesan kita Dalam contoh kita, kita telah menulis pemproses mudah yang hanya menukar beberapa atribut objek pelajar kita kepada huruf besar dan kita boleh melampaui contoh ini dengan. kes berfungsi yang lebih konkrit.

import org.springframework.batch.core.Job;
import org.springframework.batch.core.Step;
import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;
import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
import org.springframework.batch.item.ItemProcessor;
import org.springframework.batch.item.ItemReader;
import org.springframework.batch.item.ItemWriter;
import org.springframework.batch.item.file.FlatFileItemReader;
import org.springframework.batch.item.file.LineMapper;
import org.springframework.batch.item.file.mapping.DefaultLineMapper;
import org.springframework.batch.item.file.transform.DelimitedLineTokenizer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;

import com.pathus90.springbatchexample.batch.StudentProcessor;
import com.pathus90.springbatchexample.batch.StudentWriter;
import com.pathus90.springbatchexample.model.Student;
import com.pathus90.springbatchexample.model.StudentFieldSetMapper;

@Configuration
@EnableBatchProcessing
@EnableScheduling
public class BatchConfig {

    private static final String FILE_NAME = "results.csv";
    private static final String JOB_NAME = "listStudentsJob";
    private static final String STEP_NAME = "processingStep";
    private static final String READER_NAME = "studentItemReader";

    @Value("${header.names}")
    private String names;

    @Value("${line.delimiter}")
    private String delimiter;

    @Autowired
    private JobBuilderFactory jobBuilderFactory;

    @Autowired
    private StepBuilderFactory stepBuilderFactory;

    @Bean
    public Step studentStep() {
        return stepBuilderFactory.get(STEP_NAME)
                .<Student, Student>chunk(5)
                .reader(studentItemReader())
                .processor(studentItemProcessor())
                .writer(studentItemWriter())
                .build();
    }

    @Bean
    public Job listStudentsJob(Step step1) {
        return jobBuilderFactory.get(JOB_NAME)
                .start(step1)
                .build();
    }

    @Bean
    public ItemReader<Student> studentItemReader() {
        FlatFileItemReader<Student> reader = new FlatFileItemReader<>();
        reader.setResource(new ClassPathResource(FILE_NAME));
        reader.setName(READER_NAME);
        reader.setLinesToSkip(1);
        reader.setLineMapper(lineMapper());
        return reader;

    }

    @Bean
    public LineMapper<Student> lineMapper() {

        final DefaultLineMapper<Student> defaultLineMapper = new DefaultLineMapper<>();
        final DelimitedLineTokenizer lineTokenizer = new DelimitedLineTokenizer();
        lineTokenizer.setDelimiter(delimiter);
        lineTokenizer.setStrict(false);
        lineTokenizer.setNames(names.split(delimiter));

        final StudentFieldSetMapper fieldSetMapper = new StudentFieldSetMapper();
        defaultLineMapper.setLineTokenizer(lineTokenizer);
        defaultLineMapper.setFieldSetMapper(fieldSetMapper);

        return defaultLineMapper;
    }

    @Bean
    public ItemProcessor<Student, Student> studentItemProcessor() {
        return new StudentProcessor();
    }

    @Bean
    public ItemWriter<Student> studentItemWriter() {
        return new StudentWriter();
    }
}

Salin selepas log masuk

Definisi Penulis

Penulis menulis data yang datang daripada pemproses (atau dibaca terus oleh Pembaca). Dalam kes kami, ia menerima objek yang diubah daripada pemproses dan setiap objek kemudiannya akan dikekalkan dalam pangkalan data kami dan transaksi akan disahkan.

@Bean
    public Step studentStep() {
        return stepBuilderFactory.get(STEP_NAME)
                .<Student, Student>chunk(5)
                .reader(studentItemReader())
                .processor(studentItemProcessor())
                .writer(studentItemWriter())
                .build();
    }

    @Bean
    public Job listStudentsJob(Step step1) {
        return jobBuilderFactory.get(JOB_NAME)
                .start(step1)
                .build();
    }

Salin selepas log masuk

Fail konfigurasi kelompok (application.properties)

 @Bean
    public ItemReader<Student> studentItemReader() {
        FlatFileItemReader<Student> reader = new FlatFileItemReader<>();
        reader.setResource(new ClassPathResource(FILE_NAME));
        reader.setName(READER_NAME);
        reader.setLinesToSkip(1);
        reader.setLineMapper(lineMapper());
        return reader;
    }

Salin selepas log masuk

Fail CSV untuk menulis ke pangkalan data

import org.springframework.batch.item.file.mapping.FieldSetMapper;
import org.springframework.batch.item.file.transform.FieldSet;

public class StudentFieldSetMapper implements FieldSetMapper<Student> {
    @Override
    public Student mapFieldSet(FieldSet fieldSet) {
        return Student.builder()
                .rank(fieldSet.readString(0))
                .firstName(fieldSet.readString(1))
                .lastName(fieldSet.readString(2))
                .center(fieldSet.readString(3))
                .pv(fieldSet.readString(4))
                .origin(fieldSet.readString(5))
                .mention(fieldSet.readString(6))
                .build();
    }
}

Salin selepas log masuk

Melancarkan aplikasi

Setelah kami selesai menyediakan konfigurasi kelompok, mari kita lihat sama ada semua yang dinyatakan di atas berfungsi

Untuk menjalankan aplikasi, anda perlu mencari fail yang mengandungi anotasi @SpringBootApplication yang merupakan bahagian utama aplikasi kami.

  @Bean
    public LineMapper<Student> lineMapper() {

        final DefaultLineMapper<Student> defaultLineMapper = new DefaultLineMapper<>();
        final DelimitedLineTokenizer lineTokenizer = new DelimitedLineTokenizer();
        lineTokenizer.setDelimiter(delimiter);
        lineTokenizer.setStrict(false);
        lineTokenizer.setNames(names.split(delimiter));

        final StudentFieldSetMapper fieldSetMapper = new StudentFieldSetMapper();
        defaultLineMapper.setLineTokenizer(lineTokenizer);
        defaultLineMapper.setFieldSetMapper(fieldSetMapper);

        return defaultLineMapper;
    }

Salin selepas log masuk

Melancarkan utama di atas akan memulakan tugas kami dan pelancar kelompok kelihatan seperti ini:

import org.springframework.batch.item.ItemProcessor;

import com.pathus90.springbatchexample.model.Student;

public class StudentProcessor implements ItemProcessor<Student, Student> {

    @Override
    public Student process(Student student) {
        student.setFirstName(student.getFirstName().toUpperCase());
        student.setLastName(student.getLastName().toUpperCase());
        student.setCenter(student.getCenter().toUpperCase());
        student.setOrigin(student.getOrigin().toUpperCase());
        student.setMention(student.getMention().toUpperCase());
        return student;
    }
}

Salin selepas log masuk

Penjadual telah disediakan untuk membolehkan kumpulan dicetuskan secara automatik. Dalam contoh ini, kumpulan setelah dilancarkan akan dijalankan setiap 8 saat. Anda boleh bermain dengannya dengan menukar nilai fixedDelaydalam milisaat.

import java.util.List;

import org.springframework.batch.item.ItemWriter;
import org.springframework.beans.factory.annotation.Autowired;

import com.pathus90.springbatchexample.model.Student;
import com.pathus90.springbatchexample.service.IStudentService;

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class StudentWriter implements ItemWriter<Student> {

    @Autowired
    private IStudentService studentService;

    @Override
    public void write(List<? extends Student> students) {
        students.stream().forEach(student -> {
            log.info("Enregistrement en base de l'objet {}", student);
            studentService.insertStudent(student);
        });
    }
}

Salin selepas log masuk

Selain menjalankan fail utama di atas untuk memulakan kumpulan, anda juga boleh menjalankan perintah mvn spring-boot:run semasa menggunakan command prompt.

Anda juga boleh melancarkan aplikasi dengan fail arkib JAR dan dalam kes ini anda mesti:

Pergi ke folder induk projek menggunakan command prompt dan laksanakan arahan mvn clean package yang akan membungkus projek kami.
Dalam folder sasaran, fail jar akan dibuat.
Untuk menjalankan aplikasi, gunakan arahan java -jar target/generated_file_name-0.0.1-SNAPSHOT.jar

Juga pastikan bahawa H2konsol telah pun dimulakan semasa melancarkan aplikasi kumpulan musim bunga kami dan pangkalan data dijana secara automatik serta penciptaan jadual Pelajar .

Commencer la programmation avec SPRING BATCH

Kami dapat melihat dengan jelas bahawa fail kami telah disepadukan dengan baik ke dalam pangkalan data kami.

N.B:Jika kita juga mahu memulakan kelompok secara manual tanpa menghantar penjadualyang akan dicetuskan bergantung pada tetapan kami, saya telah mendedahkan API menggunakan pengawal untuk memanggil Kumpulan Spring Kerja.

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.3.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.pathus</groupId>
    <artifactId>SpringBatchExample</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>SpringBatchExample</name>
    <description>Demo of spring batch project </description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

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

        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework.batch</groupId>
            <artifactId>spring-batch-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

Salin selepas log masuk

hanya lancarkan URL: http://localhost:8080/load dan kumpulan akan dilancarkan

Commencer la programmation avec SPRING BATCH

Kami telah mencapai penghujung pembelajaran pertama kami tentang pengaturcaraan kelompok menggunakan rangka kerja Spring. Tinggalkan komen atau soalan jika ada!

Selamat belajar semua dan saya harap tutorial pertama ini akan memberi manfaat kepada anda.

Anda akan mendapati kod sumber tersedia di sini

Rujukan

https://spring.io/guides/gs/batch-processing/
https://jeremy-jeanne.developpez.com/tutoriels/spring/spring-batch/#LIII-B-3
https://www.baeldung.com/introduction-to-spring-batch

Atas ialah kandungan terperinci Mulakan pengaturcaraan dengan SPRING BATCH. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!