Eine gängige Anforderung in Projekten ist der Datenaustausch mit Fremdsystemen und externen Partnern. IT-Systeme arbeiten schon lange nicht mehr isoliert vom Rest der Welt sondern sind oft hochintegriert, genau wie die Geschäftsprozesse, die sie unterstützen. Obwohl die Technologie der Wahl für den Austausch momentan eher Webservices oder REST-Services sein dürften, ist man als Entwickler nicht immer frei in der Wahl der Kommunikationsmittel. Für manche Zwecke haben eher althergebrachte Technologien wie FTP/SFTP oder auch E-Mail (siehe Versand von E-Mails mit Spring Batch ) durchaus ihre Daseinsberechtigung.
In diesem Artikel wird gezeigt, wie sich mit Hilfe von Spring Batch und Spring Integration ein SFTP-Upload realisieren lässt.
Wie in Spring Batch üblich, benötigt man einen Marshaller mit Reader und Writer. Die Zuständigkeit des Readers ist es, die zu transferierenden Daten aus der Datenbank auszulesen. Dazu bedient er sich eines RowMappers, der die Daten, die die Datenbank-Abfrage als Resultat liefert, in ein Domänen-Objekt transferiert.
Der Reader:
1<bean id="sftpFileReader"> 2 <property name="dataSource" ref="dataSource" /> 3 <property name="sql" value="SELECT * FROM table" /> 4 <property name="rowMapper"> 5 <bean class="de.package.rowmapper.SftpFileRowMapper" /> 6 </property> 7</bean>
Der RowMapper, welcher vom Reader verwendet wird:
1package de.package.rowmapper;
2
3import java.sql.ResultSet;
4import java.sql.SQLException;
5
6import org.apache.commons.logging.Log;
7import org.apache.commons.logging.LogFactory;
8import org.springframework.jdbc.core.RowMapper;
9
10import de.package.domainObjects.SftpFileObject;
11
12public class SftpFileRowMapper implements RowMapper {
13
14 public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
15 SftpFileObject fileLine = new SftpFileObject();
16 try {
17 fileLine.setDbField1(rs.getString("dbField1"));
18 fileLine.setDbField2(rs.getString("dbField2"));
19 ...
20 } catch (SQLException e) {
21 System.out.println("Can't create data row for export File.");
22 }
23 return fileLine;
24 }
25}
Das Domänen-Objekt, welches vom Reader verwendet wird:
1package de.package.domainObjects;
2
3public class SftpFileObject implements java.io.Serializable {
4
5 private static final long serialVersionUID = 1L;
6
7 public String dbField1;
8 public String dbField2;
9 ...
10
11 public String getDbField1() {
12 return dbField1;
13 }
14
15 public void setDbField1(String dbField1) {
16 this.dbField1= dbField1;
17 }
18
19 public String getDbField2() {
20 return dbField2;
21 }
22
23 public void setDbField2(String dbField2) {
24 this.dbField2= dbField2;
25 }
26
27 ...
28}
Der Writer schreibt die Daten der Domänen-Objekte in eine CSV-Datei (hier sind natürlich auch beliebige andere Formate denkbar). Hierzu benutzt er den DelimitedLineAggregator aus dem Spring Batch Framework. Damit die CSV-Datei auch eine Kopfzeile bekommt, benutzen wir zusätzlich das Property headerCallback.
Der Writer:
1<bean id="sftpFileWriter" scope="step"> 2 <property name="resource" value="file:path/to/file/filename.csv" /> 3 <property name="encoding" value="ISO-8859-1" /> 4 <property name="headerCallback"> 5 <bean class="de.package.helper.HeaderCallback" /> 6 </property> 7 <property name="lineAggregator"> 8 <bean class="org.springframework.batch.item.file.transform.DelimitedLineAggregator"> 9 <property name="delimiter" value=";" /> 10 <property name="fieldExtractor"> 11 <bean class="org.springframework.batch.item.file.transform.BeanWrapperFieldExtractor"> 12 <property name="names" value="dbField1, dbField2, ..." /> 13 </bean> 14 </property> 15 </bean> 16 </property> 17</bean>
Für die Erzeugung der Kopfzeile (s. o.) benutzen wir folgenden, denkbar einfachen Code:
1package de.package.helper;
2
3import java.io.IOException;
4import java.io.Writer;
5import org.springframework.batch.item.file.FlatFileHeaderCallback;
6
7public class HeaderCallback implements FlatFileHeaderCallback {
8
9 @Override
10 public void writeHeader(Writer writer) throws IOException {
11 writer.write("Header1;Header2; ...");
12 }
13}
Der eigentliche Versand per SFTP schließlich wird durch die SftpSessionFactory geregelt, welche auch die Zugangsdaten für den SFTP-Server als Properties bekommt.
1<bean id="sftpSessionFactory" class="org.springframework.integration.sftp.session.DefaultSftpSessionFactory"> 2 <property name="host" value="host.of.receiver"/> 3 <property name="user" value="username"/> 4 <property name="password" value="secureSftpPassword"/> 5 <property name="port" value="22"/> 6</bean>
Des Weiteren benötigt man einen Channel, welcher für den Versand der Daten verwendet wird. Das channel-Tag kommt aus dem Spring Integration Namensraum, der im XML-Header der applicationContext.xml deklariert werden muss (s. u.).
1<int:channel id="outputChannel" />
Damit Spring Batch auch weiß, auf welchem Weg der Versand erfolgen soll, muss man dies Spring Batch mitteilen. Hierfür verwendet man einen „outbound-channel-adapter“, welcher den Versandweg, die Referenz zur SftpSessionFactory und den Dateinamen für den Zielserver (remote-filename-generator) beinhaltet.
1<int-sftp:outbound-channel-adapter id="sftpOutboundAdapter" 2 session-factory="sftpSessionFactory" 3 channel="outputChannel" 4 charset="UTF-8" 5 remote-directory="/target" 6 remote-filename-generator="fileNameGenerator" />
Wenn man es einfach halten möchte, speichert man die Datei auf dem Zielserver mit dem gleichen Namen wie auf dem sendenden Server. Hierfür benötigt man nur den DefaultFileNameGenerator von Spring Integration.
1<bean id="fileNameGenerator" class="org.springframework.integration.file.DefaultFileNameGenerator" />
Um die Datei nun wirklich zu versenden, benötigt man noch ein Tasklet und den eigentlichen Batch Job. Für das Tasklet kann man eine kleine Java Klasse verwenden, welcher man den Dateinamen und den Channel als Parameter mitgibt.
Deklaration des Tasklets:
1<bean id="sftpJobTasklet" class="de.package.tasklets.SftpTasklet"> 2 <property name="fileName" value="path/to/file/filename.csv" /> 3 <property name="sftpChannel" ref="outputChannel" /> 4</bean>
Der Javacode des Tasklets:
1package de.package.tasklets;
2
3import java.io.File;
4import org.springframework.batch.core.StepContribution;
5import org.springframework.batch.core.scope.context.ChunkContext;
6import org.springframework.batch.core.step.tasklet.Tasklet;
7import org.springframework.batch.repeat.RepeatStatus;
8import org.springframework.integration.Message;
9import org.springframework.integration.MessageChannel;
10import org.springframework.integration.support.MessageBuilder;
11
12public class SftpTasklet implements Tasklet {
13
14 private String fileName;
15 private MessageChannel sftpChannel;
16
17 @Override
18 public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {
19
20 File file = new File(fileName);
21
22 if (file.exists()) {
23 Message<File> message = MessageBuilder.withPayload(file).build();
24 try {
25 sftpChannel.send(message);
26 } catch (Exception e) {
27 System.out.println("Could not send file per SFTP: " + e);
28 }
29 } else {
30 System.out.println("File does not exist.");
31 }
32
33 return RepeatStatus.FINISHED;
34
35 }
36
37 public String getFileName() {
38 return fileName;
39 }
40
41 public void setFileName(String fileName) {
42 this.fileName = fileName;
43 }
44
45 public MessageChannel getSftpChannel() {
46 return sftpChannel;
47 }
48
49 public void setSftpChannel(MessageChannel sftpChannel) {
50 this.sftpChannel = sftpChannel;
51 }
52}
Und zu guter Letzt der XML-Code des Batch-Jobs:
1<batch:job id="sftpJob" restartable="false"> 2 <batch:step id="sftpFileGenerateStep" next="sftpFileSendStep"> 3 <batch:tasklet> 4 <batch:chunk reader="sftpFileCreator" writer="sftpFileWriter" commit-interval="100" /> 5 <batch:listeners> 6 <batch:listener ref="fileNameListener" /> 7 </batch:listeners> 8 </batch:tasklet> 9 </batch:step> 10 <batch:step id="sftpFileSendStep"> 11 <batch:tasklet ref="sftpJobTasklet" /> 12 </batch:step> 13</batch:job>
Diesen Batch Job kann man nun wie gewohnt von der Kommandozeile (also z. B. auch als cronjob) starten.
Zur Vollständigkeit hier noch der Header-Teil der applicationContext.xml mit allen benötigten Namespace-Deklarationen:
1<xml version="1.0" encoding="UTF-8"?> 2<beans xmlns="http://www.springframework.org/schema/beans" 3xmlns:batch="http://www.springframework.org/schema/batch" 4xmlns:int="http://www.springframework.org/schema/integration" 5xmlns:int-file="http://www.springframework.org/schema/integration/file" 6xmlns:int-sftp="http://www.springframework.org/schema/integration/sftp" 7xmlns:int-stream="http://www.springframework.org/schema/integration/stream" 8xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 9http://www.springframework.org/schema/batch http://www.springframework.org/schema/batch/spring-batch-2.1.xsd 10http://www.springframework.org/schema/integration http://www.springframework.org/schema/integration/spring-integration.xsd 11http://www.springframework.org/schema/integration/file http://www.springframework.org/schema/integration/file/spring-integration-file-2.0.xsd 12http://www.springframework.org/schema/integration/sftp http://www.springframework.org/schema/integration/sftp/spring-integration-sftp-2.0.xsd 13http://www.springframework.org/schema/integration/stream http://www.springframework.org/schema/integration/stream/spring-integration-stream-2.0.xsd">
War dieser Beitrag hilfreich?
Weitere Beiträge
von Carsten Fröhlich
6.9.2011 Dein Job bei codecentric?
Jobs
Agile Developer und Consultant (w/d/m)
Alle Standorte
Gemeinsam bessere Projekte umsetzen.
Wir helfen deinem Unternehmen.
Du stehst vor einer großen IT-Herausforderung? Wir sorgen für eine maßgeschneiderte Unterstützung. Informiere dich jetzt.
Hilf uns, noch besser zu werden.
Wir sind immer auf der Suche nach neuen Talenten. Auch für dich ist die passende Stelle dabei.
Blog-Autor*in
Carsten Fröhlich
Du hast noch Fragen zu diesem Thema? Dann sprich mich einfach an.
Du hast noch Fragen zu diesem Thema? Dann sprich mich einfach an.