Spring Boot - Dịch vụ hàng loạt

Bạn có thể tạo tệp JAR có thể thực thi và chạy ứng dụng Spring Boot bằng cách sử dụng lệnh Maven hoặc Gradle như được hiển thị bên dưới:

Đối với Maven, bạn có thể sử dụng lệnh dưới đây:

mvn clean install

Sau khi “XÂY DỰNG THÀNH CÔNG”, bạn có thể tìm thấy tệp JAR trong thư mục đích.

Đối với Gradle, bạn có thể sử dụng lệnh như sau:

gradle clean build

Sau khi “XÂY DỰNG THÀNH CÔNG”, bạn có thể tìm thấy tệp JAR trong thư mục build / libs.

Chạy tệp JAR bằng cách sử dụng lệnh ở đây -

java –jar <JARFILE>

Bây giờ, ứng dụng đã khởi động trên cổng Tomcat 8080 như hình.

Bây giờ, hãy nhấn vào URL http://localhost:8080/ trong trình duyệt web của bạn và kết nối ổ cắm web và gửi lời chào và nhận tin nhắn.

Dịch vụ hàng loạt là một quá trình thực thi nhiều hơn một lệnh trong một tác vụ duy nhất. Trong chương này, bạn sẽ học cách tạo dịch vụ hàng loạt trong ứng dụng Spring Boot.

Chúng ta hãy xem xét một ví dụ mà chúng ta sẽ lưu nội dung tệp CSV vào HSQLDB.

Để tạo một chương trình Batch Service, chúng ta cần thêm phần phụ thuộc Spring Boot Starter Batch và phần phụ thuộc HSQLDB vào tệp cấu hình bản dựng của chúng tôi.

Người dùng Maven có thể thêm các phần phụ thuộc sau vào tệp pom.xml.

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

Người dùng Gradle có thể thêm các phần phụ thuộc sau vào tệp build.gradle.

compile("org.springframework.boot:spring-boot-starter-batch")
compile("org.hsqldb:hsqldb")

Bây giờ, thêm tệp dữ liệu CSV đơn giản bên dưới tài nguyên classpath - src / main / resources và đặt tên tệp là file.csv như hình minh họa -

William,John
Mike, Sebastian
Lawarance, Lime

Tiếp theo, viết một tập lệnh SQL cho HSQLDB - trong thư mục tài nguyên classpath - request_fail_hystrix_timeout

DROP TABLE USERS IF EXISTS;
CREATE TABLE USERS  (
   user_id BIGINT IDENTITY NOT NULL PRIMARY KEY,
   first_name VARCHAR(20),
   last_name VARCHAR(20)
);

Tạo một lớp POJO cho mô hình USERS như minh họa -

package com.tutorialspoint.batchservicedemo;
public class User {
   private String lastName;
   private String firstName;

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

Bây giờ, hãy tạo một bộ xử lý trung gian để thực hiện các thao tác sau khi đọc dữ liệu từ tệp CSV và trước khi ghi dữ liệu vào SQL.

package com.tutorialspoint.batchservicedemo;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.batch.item.ItemProcessor;

public class UserItemProcessor implements ItemProcessor<User, User> {
   private static final Logger log = LoggerFactory.getLogger(UserItemProcessor.class);

   @Override
   public User process(final User user) throws Exception {
      final String firstName = user.getFirstName().toUpperCase();
      final String lastName = user.getLastName().toUpperCase();
      final User transformedPerson = new User(firstName, lastName);

      log.info("Converting (" + user + ") into (" + transformedPerson + ")");
      return transformedPerson;
   }
}

Hãy để chúng tôi tạo tệp cấu hình hàng loạt, để đọc dữ liệu từ CSV và ghi vào tệp SQL như hình dưới đây. Chúng ta cần thêm chú thích @EnableBatchProcessing trong tệp lớp cấu hình. Chú thích @EnableBatchProcessing được sử dụng để kích hoạt các hoạt động hàng loạt cho ứng dụng Spring Boot của bạn.

package com.tutorialspoint.batchservicedemo;

import javax.sql.DataSource;
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.core.launch.support.RunIdIncrementer;
import org.springframework.batch.item.database.BeanPropertyItemSqlParameterSourceProvider;
import org.springframework.batch.item.database.JdbcBatchItemWriter;
import org.springframework.batch.item.file.FlatFileItemReader;
import org.springframework.batch.item.file.mapping.BeanWrapperFieldSetMapper;
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.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;

@Configuration
@EnableBatchProcessing
public class BatchConfiguration {
   @Autowired
   public JobBuilderFactory jobBuilderFactory;

   @Autowired
   public StepBuilderFactory stepBuilderFactory;

   @Autowired
   public DataSource dataSource;

   @Bean
   public FlatFileItemReader<User> reader() {
      FlatFileItemReader<User> reader = new FlatFileItemReader<User>();
      reader.setResource(new ClassPathResource("file.csv"));
      reader.setLineMapper(new DefaultLineMapper<User>() {
         {
            setLineTokenizer(new DelimitedLineTokenizer() {
               {
                  setNames(new String[] { "firstName", "lastName" });
               }
            });
            setFieldSetMapper(new BeanWrapperFieldSetMapper<User>() {
               {
                  setTargetType(User.class);
               }
            });
         }
      });
      return reader;
   }
   @Bean
   public UserItemProcessor processor() {
      return new UserItemProcessor();
   }
   @Bean
   public JdbcBatchItemWriter<User> writer() {
      JdbcBatchItemWriter<User> writer = new JdbcBatchItemWriter<User>();
      writer.setItemSqlParameterSourceProvider(new BeanPropertyItemSqlParameterSourceProvider<User>());
      writer.setSql("INSERT INTO USERS (first_name, last_name) VALUES (:firstName, :lastName)");
      writer.setDataSource(dataSource);
      return writer;
   }
   @Bean
   public Job importUserJob(JobCompletionNotificationListener listener) {
      return jobBuilderFactory.get("importUserJob").incrementer(
         new RunIdIncrementer()).listener(listener).flow(step1()).end().build();
   }
   @Bean
   public Step step1() {
      return stepBuilderFactory.get("step1").<User, User>chunk(10).reader(reader()).processor(processor()).writer(writer()).build();
   }
}

Các reader() phương thức được sử dụng để đọc dữ liệu từ tệp CSV và phương thức writer () được sử dụng để ghi dữ liệu vào SQL.

Tiếp theo, chúng ta sẽ phải viết một lớp Trình nghe Thông báo Hoàn thành Công việc - được sử dụng để thông báo sau khi Hoàn thành Công việc.

package com.tutorialspoint.batchservicedemo;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.springframework.batch.core.BatchStatus;
import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.listener.JobExecutionListenerSupport;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Component;

@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 !! It's time to verify the results!!");

         List<User> results = jdbcTemplate.query(
            "SELECT first_name, last_name FROM USERS", new RowMapper<User>() {
            
            @Override
            public User mapRow(ResultSet rs, int row) throws SQLException {
               return new User(rs.getString(1), rs.getString(2));
            }
         });

         for (User person : results) {
            log.info("Found <" + person + "> in the database.");
         }
      }
   }
}

Bây giờ, tạo một tệp JAR thực thi và chạy ứng dụng Spring Boot bằng cách sử dụng các lệnh Maven hoặc Gradle sau.

Đối với Maven, sử dụng lệnh như minh họa -