Beispiel für eine Frühlingscharge

Einführung

Spring Batch ist ein Batch-Verarbeitungs-Framework, das vom Spring-Framework-Team entwickelt und verwaltet wird. Es ist eines der führenden und beliebtesten Batch-Verarbeitungs-Frameworks auf dem Markt. Spring Batch verwendet die Chunk-orientierte Verarbeitung zur Durchführung der Stapelverarbeitung, die bei der Verarbeitung großer Datenmengen effizienter ist. Spring Batch ist kein Planer zum Starten des Jobs, sondern ein Job für die Stapelverarbeitung. Dies kann durch externe Ereignisse wie System-Timer, Scheduler usw. aufgerufen/ausgelöst werden, um den Job zu starten. Dieses Tutorial hilft Ihnen, die grundlegenden Konzepte zu verstehen, die zum Schreiben eines einfachen Spring-Batch-Programms erforderlich sind.

  • Die Spring Batch-Infrastruktur
  • Konfigurieren Sie die Spring-Batch-Wiederholung bei Fehler
  • Kugelsichere Jobplanung in Spring Batch

Spring Batch-Terminologien

Das folgende Bild zeigt die wichtigen Terminologien, die bei der Spring-Batch-Programmierung verwendet werden.

Spring Batch-Terminologien

Beispiel für eine Frühlingscharge

Im Folgenden finden Sie die einfachen Schritte zum Schreiben eines Spring Batch-Jobs. Beachten Sie, dass diese Schritte spezifisch für dieses Beispiel sind und je nach Anforderung des Batch-Prozesses unterschiedlich sein können.

In diesem Beispiel werden die Eingabedaten aus einer CSV-Datei übernommen FlatFileItemReader API und dann ohne weitere Verarbeitung (Spring Batch bietet ItemProcessor zum Verarbeiten der gelesenen Daten vor dem Schreiben in die Datenbank) schreibt es direkt in die Datenbanktabelle mit OrderItemWriter, einer Implementierungsklasse für ItemWriter. Befolgen Sie die folgenden Schritte, um dieses Beispiel zu verstehen.

  • Schritt 1: Erstellen Sie ein Domänenobjekt mit der erforderlichen Datenstruktur.
  • Schritt 2: Ein … kreieren FieldSetMapper Implementierungsklasse, die für die Zuordnung der Domänenobjekteigenschaften zur in diesem Beispiel verwendeten CSV-Datei erforderlich ist.
  • Schritt 3: Erstellen Sie in der Datenbank eine Tabelle zum Speichern der Daten
  • Schritt 4: Erstellen Sie eine Datenquellenkonfigurationsdatei mit Datenbankanmeldeinformationen.
  • Schritt 5: Erstellen Sie eine Jobkontextkonfigurationsdatei
  • Schritt 6: Erstellen ItemWriter Implementierungsklasse, die zum Einfügen der verarbeiteten Daten in die Datenbank verwendet wird.
  • Schritt 7: Erstellen Sie eine Job Launcher-Klasse zum Aufrufen des Jobs und zum Ausführen des Batch-Prozesses.
  • Schritt 8: Führen Sie den Job Launcher aus, der in Schritt 7 erstellt wurde.

Struktur des Spring Batch-Projekts

Struktur des Spring Batch-Projekts

Employee.java

package javabeat.net;
import java.io.Serializable;

import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement(name="employee")

public class Employee implements Serializable {

	private String empId;
	private String city;
	private String country;

	@XmlElement(name="EMP_ID")
	public String getEmpId() {
		return empId;
	}
	public void setEmpId(String empId) {
		this.empId = empId;
	}
	@XmlElement(name="CITY")
	public String getCity() {
		return city;
	}
	public void setCity(String city) {
		this.city = city;
	}
	@XmlElement(name="COUNTRY")
	public String getCountry() {
		return country;
	}
	public void setCountry(String country) {
		this.country = country;
	}

}

EmployeeDataMapper.java

package javabeat.net;

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

public class EmployeeDataMapper implements FieldSetMapper<Employee> {

	public Employee mapFieldSet(FieldSet fieldSet) throws BindException {

		Employee order = new Employee();
		order.setEmpId(fieldSet.readString(0));
		order.setCity(fieldSet.readString(1));
		order.setCountry(fieldSet.readString(2));
		return order;

	}

}

OrderItemWriter.java

package javabeat.net;

import java.util.List;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.batch.item.ItemWriter;
public class OrderItemWriter implements ItemWriter<Employee> {
	private static final String INSERT_EMPLOYEE = "insert into batch.employee "
			+ "( empid, city, country ) values(?,?,?)";
	private JdbcTemplate jdbcTemplate;
	public void write(List<? extends Employee> employees) throws Exception {
		for (Employee order : employees) {
			jdbcTemplate.update(INSERT_EMPLOYEE, order.getCity(),
					order.getCountry(), order.getCountry());
		}
	}
	public OrderItemWriter(DataSource ds) {
		this.jdbcTemplate = new JdbcTemplate(ds);
	}
}

datasource-config.xml

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:jdbc="http://www.springframework.org/schema/jdbc" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
http://www.springframework.org/schema/jdbc
http://www.springframework.org/schema/jdbc/spring-jdbc-4.0.xsd">

	<!-- connect to MySQL database -->
	<bean id="dataSource"
		 >
		<property name="driverClassName" value="com.mysql.jdbc.Driver" />
		<property name="url" value="jdbc:mysql://localhost:3306/batch" />
		<property name="username" value="root" />
		<property name="password" value="admin" />
	</bean>

	<bean id="transactionManager"
		  />

	<!-- create job-meta tables automatically In production you don't need to
		create this every time. Just create once in production. -->
	<jdbc:initialize-database data-source="dataSource">
		<jdbc:script location="org/springframework/batch/core/schema-drop-mysql.sql" />
		<jdbc:script location="org/springframework/batch/core/schema-mysql.sql" />
	</jdbc:initialize-database>

</beans>

job-config.xml

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:batch="http://www.springframework.org/schema/batch"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
http://www.springframework.org/schema/batch
http://www.springframework.org/schema/batch/spring-batch-3.0.xsd">

	<import resource="datasource-config.xml" />
	<import resource="job-context.xml" />

	<job id="employeeJob" xmlns="http://www.springframework.org/schema/batch">
		<step id="employeeprocessor">
			<tasklet>
				<chunk reader="reader" writer="writer" commit-interval="3"
					skip-limit="2">
					<skippable-exception-classes>
						<include
							  />
					</skippable-exception-classes>
				</chunk>
			</tasklet>
		</step>
	</job>

	<bean id="reader"  
		scope="step">
		<property name="resource" value="classpath:input/employees.csv" />
		<property name="linesToSkip" value="1" />
		<property name="lineMapper">
			<bean  >
				<property name="lineTokenizer">
					<bean
						 >
						<property name="names" value="EMP_ID,CITY,COUNTRY" />
						<property name="delimiter" value="," />
					</bean>
				</property>
				<property name="fieldSetMapper">
					<bean   />
				</property>
			</bean>
		</property>
	</bean>

	<bean id="writer"  >
		<constructor-arg ref="dataSource" />
	</bean>

</beans>

job-context.xml

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.0.xsd">

	<!-- stored job-meta in memory
	<bean id="jobRepository"  >
		<property name="transactionManager" ref="transactionManager" /> </bean>-->

	<!-- stored job-meta in database -->
	 <bean id="jobRepository"
		 >
		<property name="dataSource" ref="dataSource" />
		<property name="transactionManager" ref="transactionManager" />
		<property name="databaseType" value="mysql" />
	</bean>

	<bean id="transactionManager"
		  />

	<bean id="jobLauncher"
		 >
		<property name="jobRepository" ref="jobRepository" />
	</bean>

</beans>

Main.java

package javabeat.net;
import org.springframework.batch.core.Job;
import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.JobParameters;
import org.springframework.batch.core.launch.JobLauncher;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Main {
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		String[] config = { "job-config.xml" };
		ApplicationContext context = new ClassPathXmlApplicationContext(config);
		JobLauncher jobLauncher = (JobLauncher) context.getBean("jobLauncher");
		Job job = (Job) context.getBean("employeeJob");
		try {
			JobExecution execution = jobLauncher.run(job, new JobParameters());
			System.out.println("Exit Status : " + execution.getStatus());
		} catch (Exception e) {
			e.printStackTrace();
		}
		System.out.println("Finished Execution of Batch Job");
	}
}

[wpdm_file id=117]

Kommentar verfassen

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert

Nach oben scrollen