Java >> Java Tutorial >  >> Tag >> Spring

Spring Batch Tutorial:Lesen von Informationen aus einer REST-API

Spring

Spring Batch bietet eine gute Unterstützung zum Lesen von Daten aus verschiedenen Datenquellen wie Dateien (CSV oder XML) oder Datenbanken. Es verfügt jedoch nicht über eine integrierte Unterstützung zum Lesen von Eingabedaten aus einer REST-API. Wenn Sie eine REST-API als Datenquelle für Ihren Spring Batch-Job verwenden möchten, müssen Sie einen benutzerdefinierten ItemReader implementieren die die Eingabedaten aus der REST-API liest.

Dieser Blogbeitrag beschreibt, wie Sie Ihren benutzerdefinierten ItemReader implementieren können . Nachdem Sie diesen Blogbeitrag gelesen haben, werden Sie:

  • Verstehen Sie, wie Sie einen ItemReader implementieren können der die Eingabedaten Ihres Batch-Jobs liest, indem er den RestTemplate verwendet Klasse.
  • Wissen Sie, wie Sie ItemReader konfigurieren können Bean, die die Eingabedaten für Ihren Batch-Job bereitstellt.

Fangen wir an.

Einführung in die Beispielanwendung

Während dieses Blogbeitrags implementieren Sie einen ItemReader der die Eingabedaten Ihres Spring Batch-Jobs von einem REST-API-Endpunkt liest, der GET verarbeitet Anfragen werden an den Pfad gesendet:'/api/student/'. Dieser API-Endpunkt gibt die Informationen aller Studenten zurück, die für einen Online-Kurs eingeschrieben sind. Genauer gesagt gibt Ihr API-Endpunkt das folgende JSON-Dokument zurück:

[
    {
        "emailAddress": "[email protected]",
        "name": "Tony Tester",
        "purchasedPackage": "master"
    },
    {
        "emailAddress": "[email protected]",
        "name": "Nick Newbie",
        "purchasedPackage": "starter"
    },
    {
        "emailAddress": "[email protected]",
        "name": "Ian Intermediate",
        "purchasedPackage": "intermediate"
    }
]

Sie müssen das zurückgegebene JSON-Dokument in StudentDTO umwandeln Objekte, die von Ihrem Batch-Job verarbeitet werden. Die StudentDTO class enthält die Informationen eines einzelnen Schülers und ihr Quellcode sieht wie folgt aus:

public class StudentDTO {

    private String emailAddress;
    private String name;
    private String purchasedPackage;

    public StudentDTO() {}

    public String getEmailAddress() {
        return emailAddress;
    }

    public String getName() {
        return name;
    }

    public String getPurchasedPackage() {
        return purchasedPackage;
    }

    public void setEmailAddress(String emailAddress) {
        this.emailAddress = emailAddress;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setPurchasedPackage(String purchasedPackage) {
        this.purchasedPackage = purchasedPackage;
    }
}

Als Nächstes implementieren Sie einen benutzerdefinierten ItemReader der die Eingabedaten Ihres Batch-Jobs vom beschriebenen API-Endpunkt liest.

Implementieren Ihres benutzerdefinierten ItemReader

Sie können Ihren benutzerdefinierten ItemReader implementieren indem Sie diesen Schritten folgen:

Zuerst , müssen Sie eine neue Klasse erstellen (RESTStudentReader ) und implementieren Sie den ItemReader Schnittstelle. Wenn Sie den ItemReader implementieren -Schnittstelle müssen Sie den Typ des zurückgegebenen Objekts auf StudentDTO setzen .

Nachdem Sie Ihren ItemReader erstellt haben Klasse sieht der Quellcode wie folgt aus:

import org.springframework.batch.item.ItemReader;

class RESTStudentReader implements ItemReader<StudentDTO> {

}

Zweiter , müssen Sie den folgenden private hinzufügen Felder zu RESTStudentReader Klasse:

  • Der final apiUrl enthält die URL der aufgerufenen REST-API.
  • Der final RestTemplate enthält einen Verweis auf den RestTemplate Objekt, das Sie verwenden, wenn Sie die Studenteninformationen lesen.
  • Der nextStudentIndex enthält den Index des nächsten StudentDTO Objekt.
  • Der studentData enthält den gefundenen StudentDTO Objekte.

Nachdem Sie diese Felder zum RESTStudentReader hinzugefügt haben Klasse sieht der Quellcode wie folgt aus:

import org.springframework.batch.item.ItemReader;
import org.springframework.web.client.RestTemplate;

import java.util.List;

class RESTStudentReader implements ItemReader<StudentDTO> {

    private final String apiUrl;
    private final RestTemplate restTemplate;

    private int nextStudentIndex;
    private List<StudentDTO> studentData;
}

Dritter müssen Sie dem RESTStudentReader einen Konstruktor hinzufügen Klasse und implementieren Sie sie, indem Sie diesen Schritten folgen:

  1. Stellen Sie sicher, dass der Konstruktor die URL der aufgerufenen REST-API und einen RestTemplate akzeptiert Objekt als Konstruktorargumente.
  2. Implementieren Sie den Konstruktor, indem Sie seine Konstruktorargumente in den Feldern des erstellten Objekts speichern. Legen Sie den Wert von nextStudentIndex fest Feld auf 0.

Nachdem Sie den Konstruktor implementiert haben, wird der Quellcode der RESTStudentReader Klasse sieht wie folgt aus:

import org.springframework.batch.item.ItemReader;
import org.springframework.web.client.RestTemplate;

import java.util.List;

class RESTStudentReader implements ItemReader<StudentDTO> {
    
    private final String apiUrl;
    private final RestTemplate restTemplate;

    private int nextStudentIndex;
    private List<StudentDTO> studentData;

    RESTStudentReader(String apiUrl, RestTemplate restTemplate) {
        this.apiUrl = apiUrl;
        this.restTemplate = restTemplate;
        nextStudentIndex = 0;
    }
}

Vierter , müssen Sie einen public read() hinzufügen Methode zum RESTStudentReader Klasse und geben Sie an, dass die Methode einen StudentDTO zurückgibt Objekt. Außerdem müssen Sie sicherstellen, dass diese Methode einen Exception auslösen kann . Nachdem Sie diese Methode zum RESTStudentReader hinzugefügt haben Klasse, müssen Sie sie implementieren, indem Sie diese Regeln befolgen:

  • Wenn die Schülerinformationen nicht gelesen wurden, lesen Sie die Schülerinformationen, indem Sie die REST-API aufrufen.
  • Wenn der nächste Schüler gefunden wird, geben Sie den gefundenen StudentDTO zurück Objekt und erhöhen Sie den Wert von nextStudentIndex Feld (der Index des nächsten Schülers) um 1.
  • Wenn der nächste Schüler nicht gefunden wird, geben Sie null zurück . Stellen Sie sicher, dass Ihr ItemReader liest die Eingabedaten von der REST-API, wenn es read() ist Methode wird das nächste Mal aufgerufen (setzen Sie den Wert der nextStudentIndex auf 0 und setzen Sie den Wert von studentData Feld auf null ).

Nachdem Sie den RESTStudentReader implementiert haben Klasse sieht der Quellcode wie folgt aus:

import org.springframework.batch.item.ItemReader;
import org.springframework.http.ResponseEntity;
import org.springframework.web.client.RestTemplate;

import java.util.Arrays;
import java.util.List;

class RESTStudentReader implements ItemReader<StudentDTO> {

    private final String apiUrl;
    private final RestTemplate restTemplate;

    private int nextStudentIndex;
    private List<StudentDTO> studentData;

    RESTStudentReader(String apiUrl, RestTemplate restTemplate) {
        this.apiUrl = apiUrl;
        this.restTemplate = restTemplate;
        nextStudentIndex = 0;
    }

    @Override
    public StudentDTO read() throws Exception {
        if (studentDataIsNotInitialized()) {
            studentData = fetchStudentDataFromAPI();
        }

        StudentDTO nextStudent = null;

        if (nextStudentIndex < studentData.size()) {
            nextStudent = studentData.get(nextStudentIndex);
            nextStudentIndex++;
        }
        else {
            nextStudentIndex = 0;
            studentData = null;
        }

        return nextStudent;
    }

    private boolean studentDataIsNotInitialized() {
        return this.studentData == null;
    }

    private List<StudentDTO> fetchStudentDataFromAPI() {
        ResponseEntity<StudentDTO[]> response = restTemplate.getForEntity(apiUrl,
                StudentDTO[].class
        );
        StudentDTO[] studentData = response.getBody();
        return Arrays.asList(studentData);
    }
}

Bevor Sie Ihren neuen ItemReader verwenden können müssen Sie den RestTemplate konfigurieren Bohne. Lassen Sie uns weitermachen und herausfinden, wie Sie diese Bean konfigurieren können.

RestTemplate-Bean konfigurieren

Sie können den RestTemplate konfigurieren Bean, indem Sie diesen Schritten folgen:

  1. Fügen Sie einen public restTemplate() hinzu -Methode zu Ihrer Anwendungskontext-Konfigurationsklasse. Stellen Sie sicher, dass restTemplate() -Methode gibt ein RestTemplate zurück Objekt und kommentieren Sie es mit dem @Bean Anmerkung.
  2. Implementieren Sie den restTemplate() Methode durch Rückgabe eines neuen RestTemplate Objekt.

Wenn Sie Spring Framework verwenden, sieht der Quellcode Ihrer Anwendungskontext-Konfigurationsklasse wie folgt aus:

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;
 
@Configuration
public class SpringBatchExampleContext {
 
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

Wenn Sie Spring Boot verwenden, können Sie auch den restTemplate() hinzufügen -Methode zu Ihrer Anwendungsklasse, die mit @SpringBootApplication annotiert ist Anmerkung. Der Quellcode dieser Klasse sieht wie folgt aus:

import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
@EnableBatchProcessing
@EnableScheduling
public class SpringBatchExampleApplication {

    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }

    public static void main(String[] args) {
        SpringApplication.run(SpringBatchExampleApplication.class, args);
    }
}

Nachdem Sie den RestTemplate konfiguriert haben Bean können Sie endlich Ihren ItemReader konfigurieren Bohne.

Konfiguration der ItemReader Bean

Sie können den ItemReader konfigurieren Bean, indem Sie diesen Schritten folgen:

Zuerst , müssen Sie eine neue Konfigurationsklasse erstellen. Nachdem Sie diese Klasse erstellt haben, sieht ihr Quellcode wie folgt aus:

import org.springframework.context.annotation.Configuration;

@Configuration
public class SpringBatchExampleJobConfig {

}

Zweiter müssen Sie eine neue Methode erstellen, die Ihren ItemReader konfiguriert Bohne. Diese Methode gibt einen ItemReader<StudentDTO> zurück Objekt, und es nimmt einen Environment Objekt und ein RestTemplate Objekt als Methodenparameter.

Nachdem Sie diese Methode zu Ihrer Konfigurationsklasse hinzugefügt haben, sieht ihr Quellcode wie folgt aus:

import org.springframework.batch.item.ItemReader;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;
import org.springframework.web.client.RestTemplate;

@Configuration
public class SpringBatchExampleJobConfig {

    @Bean
    public ItemReader<StudentDTO> itemReader(Environment environment,
                                             RestTemplate restTemplate) {

    }
}

Vierter , müssen Sie den itemReader() implementieren Methode durch Rückgabe eines neuen RESTStudentReader Objekt. Wenn Sie einen neuen RESTStudentReader erstellen -Objekt müssen Sie die folgenden Objekte als Konstruktorargumente übergeben:

  • Die URL der aufgerufenen REST-API. Sie können diese Informationen aus einer Eigenschaftendatei lesen, indem Sie den Environment verwenden Objekt als Methodenparameter angegeben.
  • Der RestTemplate Objekt, das verwendet wird, um die Schülerinformationen von der aufgerufenen REST-API abzufragen.

Nachdem Sie den itemReader() implementiert haben -Methode sieht der Quellcode Ihrer Konfigurationsklasse wie folgt aus:

import org.springframework.batch.item.ItemReader;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;
import org.springframework.web.client.RestTemplate;

@Configuration
public class SpringBatchExampleJobConfig {

    @Bean
    public ItemReader<StudentDTO> itemReader(Environment environment,
                                             RestTemplate restTemplate) {
        return new RESTStudentReader(environment.getRequiredProperty("rest.api.url"),
                restTemplate
        );
    }
}

Sie können jetzt einen benutzerdefinierten ItemReader schreiben die die Eingabedaten Ihres Batch-Jobs von einer REST-API liest. Fassen wir zusammen, was Sie aus diesem Blogbeitrag gelernt haben.

Zusammenfassung

Dieser Blogbeitrag hat Ihnen zwei Dinge beigebracht:

  • Spring Batch hat keinen ItemReader die Informationen aus einer REST-API lesen kann.
  • Wenn Sie die Eingabedaten Ihres Batch-Jobs von einer REST-API lesen möchten, können Sie diese Informationen mit dem RestTemplate lesen Klasse.

Der nächste Teil dieses Tutorials beschreibt, wie Sie die Eingabedaten Ihres Batch-Jobs aus einer Excel-Tabelle lesen können.


Java-Tag