X4 Benutzerhandbuch - SoftProject GmbH

X4 Benutzerhandbuch
X4 Enterprise Service Bus Version 4.0
Copyright © 2002 – 2009, SoftProject, Alle Rechte vorbehalten

X4 Benutzerhandbuch: X4 Enterprise Service Bus Version 4.0
Die in dieser Dokumentation enthaltenen Informationen und die zugehörigen Programme können ohne
besondere Ankündigung geändert werden.
© SoftProject GmbH 2002–2009. Alle Rechte vorbehalten.
Diese Dokumentation und die zugehörigen Programme dürfen ohne schriftliche Zustimmung der SoftProject
GmbH weder ganz noch teilweise kopiert, reproduziert, verändert oder in irgendeine elektronische oder
maschinenlesbare Form umgewandelt werden.
Alle Warenzeichen sind Warenzeichen der jeweiligen Eigentümer.
SoftProject GmbH
Am Erlengraben 3
D-76275 Ettlingen
Telefon: +49 (0)7243 / 56 175-0
Fax: +49 (0)7243 / 56 175-199
E-Mail: info@softproject.de
Website: http://www.softproject.de

Inhaltsverzeichnis
Über diese Dokumentation ............................................................................................................. vii
1. Zweck dieser Dokumentation .............................................................................................. vii
2. Zielgruppe ............................................................................................................................. vii
3. Darstellungs-Konventionen ................................................................................................... vii
4. Weiterführende Quellen ....................................................................................................... viii
1. Einführung .................................................................................................................................... 1
1.1. Enterprise Application Integration ...................................................................................... 1
1.2. Business Process Management ........................................................................................... 1
1.3. Application Server .............................................................................................................. 1
1.4. X4 Enterprise Service Bus .................................................................................................. 1
1.5. Prozesse in X4 .................................................................................................................... 3
1.6. Adapter in X4 ..................................................................................................................... 4
1.7. X4 und XML ....................................................................................................................... 4
2. X4 Front-End .............................................................................................................................. 5
2.1. Mit dem X4 Server verbinden ............................................................................................ 5
2.2. Rundgang durch das X4 Front-End ...................................................................................... 6
2.2.1. Sichten im X4 Front-End ......................................................................................... 6
2.2.2. Menüs ..................................................................................................................... 7
2.2.3. Symbolleiste ............................................................................................................ 7
2.2.4. Repository Navigator ............................................................................................... 9
2.3. X4 Front-End konfigurieren .............................................................................................. 10
2.3.1. Adapter-Editor konfigurieren ................................................................................. 10
2.3.2. Verbindung zum X4 Server konfigurieren ............................................................... 11
2.3.3. Prozess-Designer konfigurieren .............................................................................. 12
2.3.4. Run-Modus konfigurieren ...................................................................................... 13
2.3.5. Debug-Modus konfigurieren .................................................................................. 13
2.3.6. XSL-Transformations-Vorschau konfigurieren ......................................................... 14
2.4. X4 Front-End aktualisieren ............................................................................................... 16
2.4.1. Eclipse-Plugin aktualisieren ................................................................................... 16
2.4.2. Standalone-Version aktualisieren ........................................................................... 17
3. Werkzeuge im X4 Front-End ................................................................................................... 19
3.1. Prozess-Designer ................................................................................................................ 19
3.1.1. Übersicht über den Prozess-Designer ..................................................................... 19
3.1.2. Zeichnungsfläche ................................................................................................... 20
3.1.3. Properties-Sicht ..................................................................................................... 21
3.1.4. Palette ................................................................................................................... 21
3.1.5. Debug-Symbolleiste ............................................................................................... 23
3.1.6. Run/Debug Console-Sicht ...................................................................................... 23
3.2. Adapter-Editor .................................................................................................................. 24
3.3. SQL-Editor ........................................................................................................................ 26
3.4. Datenbankverbindungs-Editor ........................................................................................... 27
3.5. Condition Editor ............................................................................................................... 28
3.6. XSL-Editor .......................................................................................................................... 30

X4 Benutzerhandbuch
iv
3.6.1. Überblick über den XSL-Editor ............................................................................... 31
3.6.2. Quelldokumentbereich ........................................................................................... 31
3.6.3. Verknüpfungsbereich .............................................................................................. 32
3.6.4. Stylesheet-Bereich ................................................................................................. 33
3.6.5. Kontextmenü im Stylesheet-Bereich ...................................................................... 34
3.7. XML-Editor ........................................................................................................................ 35
3.7.1. Übersicht über den XML-Editor ............................................................................. 35
3.7.2. Design-Ansicht des XML-Editors ............................................................................ 35
3.7.3. Source-Ansicht des XML-Editors ............................................................................ 36
3.8. Text-Editor ....................................................................................................................... 37
3.9. BPM-Designer .................................................................................................................. 37
3.9.1. BPM-Designer ......................................................................................................... 37
3.9.2. Prozess-Bausteine und Symbole ............................................................................ 38
3.10. X4 Business Activity Monitoring (BAM) .......................................................................... 39
4. Prozesse modellieren .................................................................................................................. 41
4.1. Prozess-Bausteine ............................................................................................................ 41
4.1.1. Prozessfluss-Bausteine ............................................................................................ 41
4.1.2. Daten-Bausteine ..................................................................................................... 41
4.1.3. Modul-Bausteine ..................................................................................................... 42
4.1.4. Zeichnungselemente ............................................................................................... 42
4.2. Elemente im Repository verwalten ................................................................................... 42
4.2.1. Projekte in X4 ........................................................................................................ 43
4.2.2. Projekt öffnen und schließen ................................................................................. 43
4.2.3. Neues Projekt anlegen ........................................................................................... 43
4.2.4. Neuen Prozess oder Prozess-Baustein anlegen ....................................................... 43
4.2.5. Prozesse und Bausteine in verschiedenen Ansichten öffnen ................................... 44
4.2.6. Prozesse und Bausteine importieren und exportieren .............................................. 44
4.3. Prozess-Bausteine verwenden ............................................................................................ 45
4.3.1. Start, Stop und Übergang (Transition) einfügen ..................................................... 45
4.3.2. Transfer-Adapter anlegen und verwenden ............................................................. 46
4.3.3. Funktions-Adapter-Baustein anlegen und verwenden ............................................ 47
4.3.4. XML-Dokument erstellen ....................................................................................... 48
4.3.5. XSL-Mapping anlegen und verwenden ................................................................... 49
4.3.6. Variable verwenden ............................................................................................... 51
4.3.7. Subprozess anlegen ............................................................................................... 52
4.3.8. Gabelung (Fork) und Zusammenführung (Join) einfügen ........................................ 52
4.3.9. Daten mit Merge zusammenführen ....................................................................... 53
4.3.10. Bedingungen und Verzweigungen mit Condition erstellen .................................... 54
4.3.11. Datenbank-Verbindung herstellen ........................................................................ 56
4.4. Prozess-Bausteine parametrieren ..................................................................................... 58
4.4.1. Parametrierungs-Möglichkeiten ............................................................................. 58
4.4.2. Benutzerdefinierte Parameter setzen ..................................................................... 59
4.4.3. Dynamische Parameter erzeugen ........................................................................... 60
4.4.4. Statusinformationen mit ConditionState erzeugen ................................................ 62
4.5. Prozesse debuggen und ausführen ..................................................................................... 63
4.5.1. Prozess debuggen (Debug-Modus) ......................................................................... 63

X4 Benutzerhandbuch
v
4.5.2. Prozess ausführen (Run-Modus) ............................................................................ 64
4.5.3. Prozess mit Scheduler zeitgesteuert ausführen ...................................................... 65
5. Neu in X4 Version 4.0 ............................................................................................................. 67
5.1. X4 Server ......................................................................................................................... 67
5.1.1. Neue Funktionen ..................................................................................................... 67
5.1.2. Behobene Fehler ..................................................................................................... 69
5.1.3. Bekannte Probleme ................................................................................................. 69
5.1.4. Änderungen ............................................................................................................. 69
5.2. X4 Front-End .................................................................................................................... 69
5.2.1. X4 Front-End auf Eclipse-Basis ............................................................................. 70
5.2.2. Refactoring: Elemente im Repository dynamisch bearbeiten ................................... 70
5.2.3. Prozess-Dokumentation automatisch erzeugen ...................................................... 74
5.2.4. Vorlagen für Prozesse und Prozess-Bausteine verwenden ...................................... 76
5.2.5. Weitere Verbessungen im X4 Front-End .................................................................. 77
A. Tastenkombinationen ................................................................................................................ 79
Prozess-Designer ..................................................................................................................... 79
XSL-Editor ............................................................................................................................... 80
Index ................................................................................................................................................ 83

Über diese Dokumentation
In diesem Abschnitt erfahren Sie, an wen sich diese Dokumentation richtet, welchen
Zweck sie hat und welche Konventionen und Symbole verwendet werden. Außerdem wird
auf weiterführende Quellen verwiesen.
Zweck dieser Dokumentation
Zielgruppe
Diese Dokumentation macht Sie mit den grundlegenden Prinzipien der Modellierung von
Geschäftsprozessen mit X4 vertraut und erläutert die Bedienung des X4 Front-Ends. Eine
Adapter-Referenz für Entwickler finden Sie im englischsprachigen X4 Reference Manual.
Diese Dokumentation richtet sich an Anwender von X4, die mithilfe des X4 Front-Ends
in ihrer Eclipse-Entwicklungsumgebung Geschäftsprozesse grafisch modellieren und
X4-Adapter konfigurieren sowie Datenstrukturen mittels XSL-Mappings transformieren
möchten.
Dazu werden neben detailliertem fachlichem Wissen der Daten und Arbeitsbläufe auch
grundsätzliches Wissen über XML sowie Kenntnisse in XSLT und XPath benötigt.
Darstellungs-Konventionen
Kennzeichnungen
Folgende Kennzeichnungen werden in dieser Dokumentation verwendet:
• kursiv: für neue Begriffe und Hervorhebungen
• Fett: für Oberflächen-Elemente wie Schaltflächen, Menüs oder Beschriftungen von
Elementen
• Feste Breite: für Code-Beispiele, Dateinamen etc.
Symbole
Folgende Symbole werden in dieser Dokumentation verwendet:
ACHTUNG: Warnung oder (Daten-) Sicherheitshinweis
Hinweis, Erinnerung, Verweis oder allgemeine Anmerkung
Tipp oder Hilfestellung

Über diese Dokumentation
viii
Weiterführende Quellen
Weitere Dokumentation zu X4 finden Sie im Internet unter http://www.softproject.de/
download:
• X4 Reference Manual: Englischsprachiges Referenzhandbuch zu den X4-Adaptern,
Reports, X4-URL-Protokollen, XSLT-Strukturen sowie XPath-Operatoren und -
Funktionen
• X4 Adapter Development Kit: Englischsprachiges Handbuch zum Entwickeln von
individuellen X4-Adaptern.
• X4 BAM User Manual: Englischsprachige Dokumentation zum webbasierten X4-Modul
Business Activity Monitoring (X4 BAM).

1. Einführung
1
1 Einführung
In diesem Abschnitt erhalten Sie einen Überblick über die Grundbegriffe des Business
Process Managements mit X4.
1.1 Enterprise Application Integration
Unter Enterprise Application Integration (EAI), zu Deutsch: unternehmensweite
Integration von Geschäftsfunktionen, versteht man ein Konzept zum Zusammenführen
von verschiedenen Software-Anwendungen, die innerhalb eines Unternehmens auf
unterschiedlichen Plattformen verteilt sind.
1.2 Business Process Management
Unter Business Process Management (BPM), zu Deutsch: Verwaltung von
Geschäftsprozessen, versteht man u. a. die Analyse, Modellierung, Umsetzung und
Dokumentation von Aufgaben, die sich innerhalb eines Unternehmens wiederholen. Das
kann beispielsweise die Abwicklung einer Bestellung sein.
Das Ziel von BPM ist, wiederkehrende Prozesse effizient zu gestalten und sie – wenn
möglich – zu automatisieren. So laufen Prozesse schneller, mit weniger Fehlern und damit
kosteneffektiver ab.
1.3 Application Server
Heutzutage werden Geschäftsprozesse elektronisch abgebildet und auf sogenannten
Application Servern (Anwendungs-Servern) ausgeführt. Der Application Server bietet eine
standardisierte Plattform, auf der Prozesse ausgeführt werden. Häufig wird dazu die Java-
Plattform J2EE verwendet. Für Application Server gibt es verschiedene Produkte, etwa
die weit verbreitete Open-Source-Lösung JBoss Application Server oder kommerzielle
Lösungen wie IBM Websphere und BEA Weblogic.
Applikationen bestehen bei J2EE aus einer Reihe von Klassenbibliotheken in Form von
Java-Archiven mit der Dateinamensendung .jar und aus Enterprise-Application-Archiven
(Dateinamensendung .ear), die vollständige Java-Anwendungen enthalten können.
1.4 X4 Enterprise Service Bus
Der X4 Enterprise Service Bus (kurz: X4) ist eine integrierte Plattform zur Enterprise
Application Integration und dient als Kommunikationsschnittstelle zwischen
unterschiedlichen Technologien, Standards, Datenformen und Protokollen in Unternehmen.
Geschäftsabläufe und Datenoperationen werden dabei in sogenannten Prozessen
abgewickelt. X4 bietet zudem die Möglichkeit, Aktivitäten in Logs zu speichern und
automatisch generierte Reports zu erzeugen.
Vereinfacht betrachtet ist X4 ist eine Sammlung von Datenanbindungen bzw. Adaptern,
beispielsweise an den Datenaustausch-Standard EDIFACT. X4 kann als Middleware
fungieren, bietet jedoch deutlich mehr Möglichkeiten.

1. Einführung
2
Abbildung 1.1: X4 Enterprise Service Bus
Server und Clients
Unterschieden werden muss zwischen dem X4 Server und dem X4 Front-End:
• X4 Server: Technisch gesehen ist der X4 Server eine Anwendung, die auf einem
Application Server wie beispielsweise JBoss läuft. Der X4 Server führt die Prozesse aus.
Der X4 Server enthält das X4 Repository, in welchem sämtliche Projekte, Prozesse und
Konfigurationen gespeichert sind.
• X4 Front-End: Mit dem X4 Front-End lassen sich Geschäftsprozesse entwickeln,
grafisch darstellen und steuern. Das X4 Front-End enthält neben einer Prozess-Design-
Komponente u.a. ein Werkzeug zum Mapping von Datenstrukturen mittels XSLT. Das
X4 Front-End basiert ab Version 4.0 auf der freien Entwicklungsumgebung Eclipse.
Zusätzlich können über verschiedene Web-Oberflächen auf Prozesse und Daten
zugegriffen werden. Dazu zählen zum einen Komponenten wie X4 BAM (Business Activity
Monitoring) zum Überwachen von X4-Prozessen, zum anderen aber auch anwendungsund
branchenspezifische Oberflächen wie der X4 Geolocator.
Entwurfs-Modus
Mit dem X4 Front-End können Sie sowohl mit als auch ohne Verbindung zum Repository
arbeiten. Normalerweise besteht eine Verbindung zum X4 Server und Sie arbeiten auf dem
Server-Repository.
Mit dem Entwurfs-Modus können Sie jedoch auch ohne Verbindung zum X4 Server mit
dem Prozesse modellieren und XSLT-Mappings entwerfen.

1. Einführung
3
1.5 Prozesse in X4
Als zentraler Bestandteil zur EAI dienen in X4 die Prozesse. Sie enthalten die für die
jeweilige Integrationsaufgabe notwendigen Adapter, Struktur-Umwandlungen (XSLT-
Mappings) und bilden die erforderliche Logik ab, etwa in Form vom Bedingungen und
Schleifen. So ist es möglich, aus wiederverwendbaren Bausteinen individuelle XMLbasierte
Integrationslösungen zu entwickeln.
Technische Prozesse
Jeder Schritt eines Prozesses wird durch einen Prozess-Baustein (beispielsweise ein
Adapter oder ein XSLT-Mapping) repräsentiert. Diese Prozess-Bausteine werden im X4
Front-End als Symbole in einem Prozessdiagramm dargestellt und grafisch bearbeitet. Bei
einem fertigen Prozess handelt es sich um eine voll funktionsfähige Integrationslösung,
die auf dem X4 Server bei entsprechenden Ereignissen (beispielsweise bei einer Bestellung)
oder zeitgesteuert ausgeführt wird.
Abbildung 1.2: Beispiel eines Prozesses in X4
Spricht man von X4-Prozessen, so handelt es sich zumeist um rein technische Prozesse,
beispielsweise dem Datenaustausch zwischen einer Web-Anwendung und einer MSSQL-
Datenbank mit anschließender Fakturierung in einem PDF-Dokument.
Fachliche Prozesse (Business Process Modeling)
Die sogenannten BPM-Prozesse bilden die Arbeitsabläufe im Unternehmen ab. In dieser
übergeordneten Perspektive können technische Prozesse mit fachlichen Arbeitsabläufen
im Unternehmen verbunden werden. Mit dem BPM-Designer (BPM) lassen sich im X4
Front-End auch fachliche Prozesse modellieren und gleichzeitig Prozessdiagramme gemäß
der BPMN-Spezifikation erstellen.
BPM-Prozesse können technische Prozesse in Form von Subprozessen einbinden.
Außerdem können im BPM-Designer verschiedene Arten von Gateways (logische
Verzweigungen), Datenobjekte (z.B. XML-Dokumente), Timer und Counter in BPM-
Prozessen angeordnet werden.

1. Einführung
4
Umsetzung in X4
Ein Prozess besteht aus einer XML-Datei, die mit der Dateinamensendung .wrf
(technischer Prozess) oder .bpm (fachlicher Prozess) im X4 Repository abgelegt wird.
Sämtliche Datenelemente werden lediglich referenziert. Der X4 Server interpretiert
die ausgeführten X4-Prozesse gemäß den in der Server-Engine hinterlegten
Verarbeitungsregeln und führt die Prozesse aus.
1.6 Adapter in X4
Einen modularen Ansatz verfolgt X4 mit den sogenannten Adaptern, die als Bausteine in
X4-Prozesse integriert werden. Diese stellen Datenanbindungen her, beispielsweise mit
Oracle-Datenbanken, übertragen Daten über verschiedene Protokolle wie HTTP und JMS,
oder transformieren und konvertieren verschiedene Daten und Datenformate.
Hierbei wird unterschieden zwischen folgenden Arten von Adaptern:
• Transfer-Adapter: Stellen Datenverbindungen über verschiedene Protokolle
(beispielsweise FTP) her.
• Funktions-Adapter: Bieten Zusatzfunktionen u.a. zur Datenmanipulation,
beispielsweise zum Einlesen von Daten im CSV-Format oder zur
Zeichensatzumwandlung.
• Prozess-Vorlagen: Bei diesen häufig ebenfalls als "Adapter" bezeichneten
Komponenten handelt es sich um Prozesse, um Daten auszulesen und zu manipulieren,
die in genormten Formaten und Systemarchitekturen gespeichert sind, beispielsweise
eine EDIFACT-Anbindung. Diese Prozess-Vorlagen müssen lediglich an die
Gegebenheiten angepasst werden.
X4 stellt bereits zahlreiche einsatzbereite Adapter zur Verfügung, die im Prozess-Designer
nur noch ausgewählt und konfiguriert werden müssen.
1.7 X4 und XML
Mithilfe des X4 Adapter Development Kit (ADK) lassen sich zusätzlich
benötigte Adapter entwickeln. Das ADK finden Sie im Internet unter http://
www.softproject.de/download.
Die X4-Plattform arbeitet auf Basis von XML-Technologie (eXtensible Markup Language).
Dieser W3C-Standard ist ideal zum Austausch von strukturierten Daten geeignet.
Daten werden in X4 daher in XML abgebildet und mittels XSLT (Extensible Stylesheet
Language Transformation) verarbeitet. Damit unterscheidet sich X4 von anderen EAI-
Lösungen, die lediglich zwischen Formaten konvertieren; X4 hingegen kann über XML mit
angebundenen Systemen in Echtzeit und transaktionssicher kommunzieren.
Eine Einführung in die XML-Technologie finden Sie im Internet beispielsweise unter http://
de.selfhtml.org/xml/.

2. X4 Front-End
5
2 X4 Front-End
In diesem Abschnitt erhalten Sie einen Überblick über das Eclipse-Front-End von X4. Mit
dem X4 Front-End können Sie komplexe Geschäftsprozesse modellieren und verwalten.
2.1 Mit dem X4 Server verbinden
Um Prozesse mit X4 modellieren und verwalten zu können, muss sich das X4 Front-End
zunächst mit dem X4 Server und dem Repository verbinden. Das Front-End muss sich nicht
notwendigerweise auf demselben Computer wie der Server befinden.
Benutzernamen und Passwörter werden im X4 Server-Ordner in X4DB/0/
tblAccess.xml verwaltet.
1. Folgende Voraussetzungen sicherstellen:
• X4 Server ist installiert und gestartet (siehe X4 Installation Guide).
• Eclipse und das X4 Front-End sind installiert und gestartet (siehe X4 Installation
Guide).
2.
Im Repository Navigator auf Connect to remote repository klicken, um den
Connection Manager zu öffnen.
3. Verbindungsdaten eingeben:
• In Server die Adresse des X4 Servers eingeben.
• In Instance die Bezeichnung der zu startenden X4-Instanz eingeben.
• In Protocol je nach Verbindungsart HTTP oder HTTPS wählen.
• Wenn Sie einen anderen Port als die Standard-Ports für HTTP oder HTTPS verwenden:
in Port die gewünschte Port-Nummer eingeben.

2. X4 Front-End
6
Über Proxy Settings können Sie die Eclipse-Standardeinstellungen zu Proxy-
Servern und Internet-Verbindung bearbeiten.
4. Anmeldedaten einstellen:
• In User den Benutzernamen eingeben.
• In Password das zugehörige Passwort eingeben.
• Wenn Sie dieses Passwort speichern möchten: Remember Password: wählen.
Über Add können Sie die soeben konfigurierte Verbindung in Connection
Profiles speichern. Dort können Sie verschiedene Verbindungen zu
unterschiedlichen X4 Servern und Instanzen speichern (siehe Abschnitt 2.3.2,
„Verbindung zum X4 Server konfigurieren “).
5. Connect klicken, um mit dem X4 Server zu verbinden.
Das Repository zum angegebenen Benutzer mit allen verfügbaren Projekten wird nun
geladen. Im Repository Navigator werden unter dem Projektbaum die aktuellen
Anmelde- und Verbindungsdaten angezeigt.
2.2 Rundgang durch das X4 Front-End
Wie das Eclipse-Front-End von X4 aussieht, wenn eine Verbindung zum Repository
aufgebaut ist, zeigt (siehe Abbildung 2.1, „Das X4 Front-End in Eclipse“).
Abbildung 2.1: Das X4 Front-End in Eclipse
2.2.1 Sichten im X4 Front-End

2. X4 Front-End
7
2.2.2 Menüs
Das Front-End ist in mehrere Bereiche aufgeteilt, die in Eclipse Sichten genannt werden.
• Repository Navigator: Diese Sicht enthält eine Baumstruktur des verbundenen
Repositorys mit verschiedenen Elementen wie X4-Projekten, Ordnern und Dateien
(siehe Abschnitt 2.2.4, „Repository Navigator “).
• Editor-Bereich in der Mitte: Hier werden Prozesse, Adapter etc. zum Anzeigen und
Bearbeiten in Editoren geöffnet.
Die einzelnen Editoren werden in Tabs (Registerkarten) geöffnet. Im Tab wird der
Dateiname des geöffneten Bausteins angezeigt. Ungespeicherte Bausteine sind mit
einem * markiert.
• Properties: Hier können Sie die Eigenschaften von Prozessen und von Prozess-
Bausteinen anzeigen und bearbeiten, die gerade im Prozess-Designer geöffnet und
markiert sind.
• Palette: Dient als Werkzeugleiste. Per Drag&Drop können Sie Prozess-Bausteine und
Zeichnungselemente in geöffnete Prozesse eingefügen.
• Outline: Zeigt eine Baumstruktur des geöffneten Prozesses, geordnet nach Elementtyp
(Prozesse, Adapter, Mappings, Dokumente etc.).
• Run/Debug Console: Hier werden Log-Meldungen ausgeben und Debug-
Informationen angezeigt, wenn ein Prozess auf Fehler überprüft wird.
Am oberen Fensterrand befindet sich die Eclipse-Menüleiste, die folgende Menüs enthält.
• File: Prozess- und Baustein-Dateien speichern, exportieren, kürzlich geöffnete
Elemente öffnen.
• Edit: Bearbeitungsfunktionen wie rückgängig machen/wiederherstellen, Auswahl
ausschneiden/kopieren/einfügen, Markieren, Suchen und Ersetzen
• View (wenn ein Prozess geöffnet ist): Raster ein- oder ausblenden
• Navigate, Search und Project: Nicht für das X4 Front-End relevant
• X4 Wizards: verschiedene Assistenten (X4 Wizards) aufrufen, etwa zum Einrichten
von Webservices oder Erstellen von Prozessdokumentation
• Run: Nicht für das X4 Front-End relevant
• Window: Fenster und Perspektiven und Sichten der Eclipse-Oberfläche verwalten,
Eclipse-Einstellungen bearbeiten
• Help: Eclipse-Hilfe aufrufen, Plugins installieren und Software aktualisieren
2.2.3 Symbolleiste
Über die Symbolleiste, die sich direkt unter der Eclipse-Menüleiste befindet, können Sie
verschiedene Funktionen und Anzeigeoptionen aufrufen. Nicht alle sind für das X4 Front-
End relevant. Einige Symbole werden zudem nur angezeigt, wenn ein Prozess im Prozess-
Designer geöffnet ist.
X4-Komponenten aufrufen
Webservice Management: Webservice-Verwaltung aufrufen

2. X4 Front-End
8
Bausteine anlegen und bearbeiten
New: Neuen Baustein (Prozess, Adapter etc.) anlegen
Save: Aktuell bearbeiteten Baustein speichern
Undo: Letzten Bearbeitungsschritt rückgängig machen
Redo: Rückgängig gemachten Schritt wiederherstellen
Copy: Auswahl kopieren
Cut: Auswahl ausschneiden
Paste: Auswahl einfügen
Ansicht verändern
Zoom Out, Zoom In: Vergrößern, Zoom wählen, Verkleinern
Back: Zuvor bearbeiteten Baustein öffnen
Forward: Nächsten bearbeiteten Baustein öffnen
Component Icon Size: Größe der Bausteinsymbole verändern
Snap to grid: Raster einblenden und Bausteinsymbole am Raster ausrichten
Prozess ausführen und debuggen
Run X4 Process: X4-Prozess ausführen
Start Debug: X4-Prozess debuggen (Fehler anzeigen und beseitigen)
Step Into: Einzelschritt ausführen und anzeigen (auch in Subprozessen)
Step Over: Prozess-Schritt ausführen (ohne Schritte des Subprozess anzuzeigen)
Step Return: aus Subprozess herausspringen
Suspend: Debugging-Vorgang anhalten
Resume: Debugging fortsetzen
Terminate: Debugging beenden
Toggle Breakpoint: Breakpoint (Debug-Haltepunkt) zu markiertem Baustein setzen
Clear all Breakpoints: Alle Breakpoints in diesem Prozess löschen

2. X4 Front-End
9
2.2.4 Repository Navigator
Die Repository Navigator-Sicht auf der linken Seite des Front-Ends enthält eine
Baumstruktur des verbundenen Repositorys mit verschiedenen Elementen wie X4-
Projekten, Ordnern und Dateien.
Über das Textfeld über dem Projektbaum können Sie nach Dateien im Repository suchen.
Kontextmenü im Repository Navigator
Das Kontextmenü können Sie aufrufen, indem Sie im Repository Navigator auf das
gewünschte Element im Projektbaum rechtsklicken.
Abbildung 2.2: Kontextmenü im Repository Navigator
Über dieses Kontextmenü können Sie im Repository Navigator zahlreiche
Dateioperationen ausführen:
• New: Neue Elemente (Prozesse, Ordner, Adapter etc.) im Repository anlegen
• Open und Open with: Elemente (Prozesse, Ordner, Adapter etc.) öffnen
• Preview: Vorschau des markierten Elements anzeigen
• Copy full path to Clipboard und Copy XStore URL to Clipboard: Pfad zur
markierten Datei in die Zwischenablage kopieren (als Ordnerpfad oder als XStore-URL)
• Refresh: Elemente neu aus dem Repository laden
• Cut, Copy und Paste: Markiertes Element im Repository Navigator ausschneiden,
kopieren und einfügen
• Delete: Markiertes Element aus dem Repository löschen

2. X4 Front-End
10
• Refactor/Rename: Element umbenennen (siehe Abschnitt 5.2.2.1, „Elemente
umbenennen und Referenzen automatisch aktualisieren “)
• Run X4 Process (nur bei Prozessen): Prozess ausführen
• Export as Webservice (nur bei Prozessen): Prozess als Webservice exportieren
• Validate Process: (nur bei Prozessen): Prozess auf Gültigkeit prüfen
• View Call Hierarchy: Anzeigen, in welchen Prozessen dieses Element verwendet wird
• Import: Element aus dem Dateisystem ins Repository importieren
• Export: Markiertes Element aus dem Repository ins Dateisystem exportieren
2.3 X4 Front-End konfigurieren
Die Darstellung und das Verhalten einiger Komponenten des X4 Front-Ends lassen sich wie
folgt nach Ihrem Bedarf anpassen.
2.3.1 Adapter-Editor konfigurieren
Sie können jeweils für Funktions-Adapter und Transfer-Adapter einstellen, wie sich diese
im normalen Online- und im Entwurfs-Modus verhalten.
1. Menü Window > Preferences aufrufen.
2. Auf der linken Seite X4 Front-End doppelklicken, Adapter Editor wählen.
3. Jeweils für Funktions-Adapter und Transfer-Adapter einstellen:
• Make adapter definition cache: Im Online-Modus die Adapter-Definitionen auf
den Client kopieren, wenn eine Verbindung zum X4 Server aufgebaut wird (Standard-
Einstellung: aktiviert)
• Always use default adapter definition: Im Entwurfs-Modus immer auf
standardmäßig hinterlegte Adapter-Definitionen zugreifen (Standard-Einstellung:
gewählt)
• Use adapter definition from last connection: Im Entwurfs-Modus die Adapter-
Definitionen verwenden, die bei der letzten Verbindung zum X4 Server auf den Client
kopiert wurden. Diese Definitionen sind möglicherweise aktueller.

2. X4 Front-End
11
4. OK klicken, um die Einstellungen zu speichern und das Fenster zu schließen.
2.3.2 Verbindung zum X4 Server konfigurieren
Sie können einstellen, wie und zu welchem X4 Server über das Front-End eine Verbindung
aufgebaut wird.
1. Menü Window > Preferences aufrufen.
2. Auf der linken Seite X4 Front-End doppelklicken, Connection wählen, um die
Verbindungseinstellungen aufzrufen.
3. Verbindungsdaten einstellen:
• Server: Name des Servers (Beispiel: localhost)
• Instance: Bezeichnung der X4-Instanz, mit der verbunden werden soll
• Protocol: Verbindungsprotokoll wählen: HTTP oder HTTPS (SSL-verschlüsselt)
• Wenn Sie einen anderen Port als die Standard-Ports für HTTP oder HTTPS verwenden:
in Port die gewünschte Port-Nummer eingeben.
Über Proxy Settings können Sie die Eclipse-Standardeinstellungen zu Proxy-
Servern und Internet-Verbindung bearbeiten.
4. Anmeldedaten einstellen:
• In User den Benutzernamen eingeben.
• In Password das zugehörige Passwort eingeben.
• Wenn Sie dieses Passwort speichern möchten: Remember Password: wählen.
5. Test Connection klicken, um zu prüfen, ob die Verbindung korrekt aufgebaut wird.
6. Wenn Sie mehrere Verbindung verwalten möchten:

2. X4 Front-End
12
• In Profile einen eindeutigen Namen für die Verbindung eingeben; dieser wird nach
dem Klicken auf Apply in Connection Profiles angezeigt.
• Add klicken, um neue Verbindungen zu Connection Profiles hinzuzufügen.
• Remove klicken, um eine gewählte Verbindung zu löschen.
7. OK klicken, um die Einstellungen zu speichern und das Fenster zu schließen.
2.3.3 Prozess-Designer konfigurieren
Sie können die Standard-Eigenschaften von Prozessen und die Standard-Darstellung der
Prozesse im Prozess-Designer einstellen.
1. Menü Window > Preferences aufrufen.
2. Auf der linken Seite X4 Front-End doppelklicken, Process Designer wählen.
3. Standard-Verhalten und -Eigenschaften von Prozessen einstellen:
• Can Stop: Zulassen, dass der Prozess abgebrochen werden kann
• Stop on error: Prozess-Ausführung automatisch abbrechen, wenn ein Fehler auftritt
• In Service: Prozess ausführbar machen (wenn die Option nicht aktiviert ist, kann der
Prozess nicht ausgeführt werden)
• Limit process instances: Anzahl der Prozessinstanzen begrenzen. Wenn diese Option
aktiviert ist, können Sie in Maximum eine ganzzahlige Anzahl festlegen.
• Limit execution time: Prozess-Ausführzeit begrenzen. Wenn diese Option aktiviert
ist, können Sie in Maximum eine Zeit festlegen.
4. Standard-Darstellung der Prozesse im Zeichnungsbereich einstellen:
• Show Grid / Snap to grid: Raster im Prozess-Designer anzeigen und die Symbole am
Raster ausrichten
• Use following icon size: Größe der Prozessbaustein-Symbole festlegen:

2. X4 Front-End
13
• Small (24 pixels): Kleine Darstellung
• Normal (32 pixels): Normale Darstellung
• Large (48 pixels): Große Darstellung
5. OK klicken, um die Einstellungen zu speichern und das Fenster zu schließen.
2.3.4 Run-Modus konfigurieren
Sie können festlegen, ob Prozesse im Front-End mit einer gleichbleibenden Input-Datei
ausgeführt werden sollen. Dies ist beispielsweise beim Entwickeln von Prozessen sinnvoll,
wenn Ihnen nicht sämtliche Daten und übergeordnete Prozesse zur Verfügung stehen.
1. Mit dem Repository verbinden.
2. Menü Window > Preferences aufrufen.
3. Auf der linken Seite X4 Front-End doppelklicken, Run wählen.
Sie können diese Einstellungen auch aufrufen, indem Sie in der Symbolleiste in
auf den kleinen Pfeil klicken, und Configure Run wählen.
4. Input-Datei bestimmen, die für alle Prozesse im Front-End verwendet werden soll:
• Use input file for the runned process aktivieren, um die Schaltfläche Browse
verwenden zu können.
• Browse klicken, um das Fenster Browse X4 Repository zu öffnen. Hier können Sie
eine beliebige Datei aus dem Repository wählen.
5. OK klicken, um die Einstellungen zu speichern und das Fenster zu schließen.
2.3.5 Debug-Modus konfigurieren
Sie können festlegen, wie sich Prozesse verhalten, wenn Sie im Front-End auf Fehler
überprüft werden (Debugging). Einmal gesetzt gelten diese Einstellungen für alle Prozesse,
die im Front-End auf Fehler geprüft werden.
1. Mit dem Repository verbinden.
2. Menü Window > Preferences aufrufen.
3. Auf der linken Seite X4 Front-End doppelklicken, Debug wählen.

2. X4 Front-End
14
Sie können diese Einstellungen auch aufrufen, indem Sie in der Symbolleiste in
auf den kleinen Pfeil klicken, und Configure Debug wählen.
4. Verhalten im Debug-Modus einstellen:
• Use input file for the debugged process: Input-Datei bestimmen, die für alle
Prozesse im Front-End verwendet werden soll.
Wenn aktiviert, lässt sich die Schaltfläche Browse verwenden.
Browse klicken, um das Fenster Browse X4 Repository zu öffnen. Hier können Sie
eine beliebige Datei aus dem Repository wählen.
• Enable debug steps delay: Verzögerung zwischen zwei Prozess-Schritten einfügen.
Wenn aktiviert, können Sie im Textfeld darunter eine Verzögerungszeit (in
Millisekunden) eingeben.
• In Debug Stepping Mode wählen, wie das Prozess-Debugging angezeigt werden soll:
• Step Over mode: Schritte ausführen (ohne Details der einzelnen Schritte im
Subprozess anzuzeigen)
• Step Into mode: Schritte ausführen und anzeigen (auch von Subprozessen)
• Break on Entry: Nach dem ersten Prozess-Schritt das Debugging anhalten
5. OK klicken, um die Einstellungen zu speichern und das Fenster zu schließen.
2.3.6 XSL-Transformations-Vorschau konfigurieren
Für den XSL-Editor im X4 Front-End können Sie für dessen Vorschau festlegen, ob XSL-
Stylesheets auf dem X4 Server oder im X4 Front-End transformiert werden sollen. In
letzterem Fall haben Sie die Wahl zwischen dem standardmäßig verwendeten Prozessor
und Saxon.
Diese Einstellungen gelten ausschließlich für den XSL-Editor! XSL-Mappings in
Prozessen werden immer auf dem X4 Server ausgeführt!

2. X4 Front-End
15
1. Menü Window > Preferences aufrufen.
2. Auf der linken Seite X4 Front-End doppelklicken, XSL Preview wählen.
3. In Working Online können Sie das Verhalten von XSL-Transformationen (Ausführen von
XSL-Mappings) einstellen, wenn eine Verbindung zum X4 Server aufgebaut wurde:
• Always transform locally: Immer den XSLT-Prozessor des X4 Front-Ends verwenden
(XSL-Skripte lokal ausführen)
In XSL Processor können Sie dann einstellen, welcher lokale XSLT-Prozessor
verwendet wird:
• Default processor: Standard-XSLT-Prozessor des X4 Front-Ends mit der gezeigten
Klasse verwenden
• Saxon: alternativen XSLT-Prozessor Saxon mit der gezeigten Klasse verwenden
• Wenn Sie zum Debuggen eine bestimmte Input-Datei für XSL-Mappings verwenden
möchten: Use Input File aktivieren und über Browse ein entsprechendes XML-
Dokument im Repository wählen.
4. In Working Locally können Sie einstellen, welcher XSLT-Prozessor im Entwurfs-Modus
des X4 Front-Ends verwendet wird, wenn Sie also ohne Verbindung zum X4 Server
arbeiten:
• Default processor: Standard-XSLT-Prozessor des X4 Front-Ends mit der gezeigten
Klasse verwenden
• Saxon: alternativen XSLT-Prozessor Saxon mit der gezeigten Klasse verwenden
• Wenn Sie zum Debuggen eine bestimmte Input-Datei für XSL-Mappings verwenden
möchten: Use Input File aktivieren und über Browse ein entsprechendes XML-
Dokument aus Ihrem lokalen Eclipse-Projekt wählen.
5. OK klicken, um die Einstellungen zu speichern und das Fenster zu schließen.

2. X4 Front-End
16
2.4 X4 Front-End aktualisieren
Das X4 Front-End lässt sich sowohl in der Eclipse-Plugin-Version als auch in der
Standalone-Version mithilfe einer integrierten Update-Funktion schnell und unkompliziert
über das Internet aktualisieren.
2.4.1 Eclipse-Plugin aktualisieren
Sie können direkt aus Ihrer Eclipse-Umgebung heraus das Plugin für das X4 Front-End
aktualisieren. Hierfür ist eine Internet-Verbindung erforderlich.
1. Menü Help > Software Updates aufrufen.
Das Fenster Software Updates and Add-ons mit der Registerkarte Installed Software
wird geöffnet, die eine Liste der in Eclipse installierten Plugins zeigt.
2. Das Plugin X4 Front-End for Eclipse wählen.
3. Update klicken.
Verfügbare Updates für das X4 Front-End werden nun, sofern vorhanden, angezeigt.

2. X4 Front-End
17
4. Finish klicken, um den Update-Vorgang zu starten.
Die notwendigen Pakete werden heruntergeladen.
Nach Abschluss des Installationsvorgangs wird das Fenster Software Update geöffnet,
in dem Sie gefragt werden, ob Sie Eclipse neustarten möchten, um die Änderungen
anzuzeigen.
5. Yes klicken, um das Front-End neuzustarten.
Das X4 Front-End wird nach einigen Sekunden automatisch wieder geöffnet und ist nun
aktualisiert.
2.4.2 Standalone-Version aktualisieren
Sie können die Standalone-Version des X4 Front-Ends direkt aus der Anwendung heraus
aktualisieren. Hierfür ist eine Internet-Verbindung erforderlich.
Ein Update über das Internet ist nicht möglich Dann kontaktieren Sie Ihren
X4-Administrator oder wenden Sie sich an den SoftProject-Support (E-Mail:
support@softproject.de), um ein aktuelles Installationspaket der Standalone-
Version zu erhalten. Diese ist direkt nach dem Entpacken lauffähig und ersetzt
die bisherige Installation des X4 Front-Ends.
1. Menü Help > Check Updates aufrufen.
Es wird geprüft, ob neue Updates verfügbar sind. Wenn ja, wird das Fenster Updates
geöffnet.

2. X4 Front-End
18
2. Zu installierendes Update auswählen und Lizenbestimmungen akzeptieren.
• X4 Front-End standalone Update Site aktivieren.
• Next klicken, um die nächste Seite aufzurufen.
• Wenn Sie den Lizenzbestimmung zustimmen: I accept ... wählen (erforderlich).
• Next klicken, um die nächste Seite mit einer Liste der zu installierenden Features
aufzurufen.
3. Finish klicken, um das Herunterladen der Updates zu starten.
Dieser Vorgang kann einige Augenblicke dauern. Anschließend wird das Fenster
Verification geöffnet.
4. Im Fenster Verification auf Install all klicken, um die Updates auf Ihrem Computer zu
installieren.
Anschließend wird das Fenster Install/Update geöffnet.
5. Yes klicken, um das Front-End neuzustarten.
Das X4 Front-End wird nach einigen Sekunden automatisch wieder geöffnet und ist nun
aktualisiert.

3. Werkzeuge im X4 Front-End
19
3 Werkzeuge im X4 Front-End
Das X4 Front-End stellt eine Reihe von Werkzeuge zur Modellierung von X4-Prozessen zur
Verfügung, die im Folgenden vorgestellt werden.
3.1 Prozess-Designer
In diesem Abschnitt wird der Prozess-Designer beschrieben, mit dem Sie technische
Geschäftsprozesse in Form von Diagrammen grafisch modellieren können.
3.1.1 Übersicht über den Prozess-Designer
Der Prozess-Designer ist die zentrale Komponente im X4 Front-End, mit dem Sie
technische Geschäftsprozesse in Form von Diagrammen modellieren können. Zum
jedem Prozess und zu den einzelnen Prozess-Bausteinen können Sie festlegen, wie diese
ausgeführt werden sollen. Mit dem Prozess-Designer können Sie:
• Verbindungen zwischen verschiedenen Back-End-Systemen herstellen,
• Daten in Echtzeit transformieren,
• Geschäftsregeln im modellierten Prozess implementieren und
• modellierte Prozesse debuggen und auf dem X4 Server ausführen.
Um den Prozess-Designer zu starten, öffnen Sie im Repository Navigator einen
bestehenen Prozess durch Doppelklick oder legen einen neuen Prozess an (siehe
Abschnitt 4.2.4, „Neuen Prozess oder Prozess-Baustein anlegen “).
Abbildung 3.1: Der Prozess-Designer im X4 Front-End

3. Werkzeuge im X4 Front-End
20
3.1.2 Zeichnungsfläche
In der Mitte des Fensters im Editor-Bereich befindet sich die Zeichnungsfläche. Hier
fügen Sie Prozess-Bausteine zu Prozess-Diagrammen zusammen und erstellen Übergänge
zwischen den einzelnen Prozess-Schritten. Ein Raster hilft Ihnen beim Platzieren und
Ausrichten der Baustein-Symbole. Jeder geöffnete Prozess oder Baustein wird in einem
Tab angezeigt, der den jeweiligen Dateinamen trägt.
Kontextmenü im Prozess-Designer
Wenn Sie im Editor-Bereich des Prozess-Designers auf einen Prozess-Baustein
rechtsklicken, stehen Ihnen je nach Bausteinart verschiedene Funktionen zur Verfügung:
Abbildung 3.2: Kontextmenü im Prozess-Designer (markiert: Subprozess)
• Undo und Redo: Rückgängig machen und Wiederherstellen des letzten Schritts
• Copy und Cut: markierten Prozess-Baustein kopieren oder ausschneiden
• Set ... document: markierten Baustein durch ein anderes Element im Repository
austauschen
• Edit: markierten Baustein-Datei bearbeiten (nur Modul-Bausteine und Dokumente)
• Toggle Breakpoint: Debug-Haltepunkt setzen
• Rename: Beschriftung des gewählten Prozess-Bausteins im Prozess-Diagramm ändern
• Delete: Prozess-Baustein aus dem Prozess-Diagramm entfernen
• Validate ... (nur bei Subprozessen): Subprozess auf Gültigkeit prüfen

3. Werkzeuge im X4 Front-End
21
• Preview ... (nur bei Modul-Bausteinen und Dokumenten): Prozess-Baustein in
separatem Editor öffnen
• Select in Repository Navigator: den Prozess-Baustein im Repository Navigator
zeigen
• View Call Hierarchy: Verwendungsnachweis für den markierten Prozess-Baustein
anzeigen
• View Documentation (nur bei Subprozessen): Prozess-Dokumentation temporär im
Editor-Bereich anzeigen
• Bring to Front: Prozess-Baustein in den Vordergrund des Diagramms setzen
• Bring forward: Prozess-Baustein im Diagramm eine Ebene nach vorne setzen
• Bring backward: Prozess-Baustein im Diagramm eine Ebene nach hinten bringen
• Send to Back: Prozess-Baustein in den Hintergrund des Diagramms setzen
• Refresh (nur bei Modul-Bausteinen und Dokumenten): Prozess-Baustein neu aus dem
Repository laden
• Properties: Eigenschaften des Prozess-Bausteins in der Properties-Sicht anzeigen
3.1.3 Properties-Sicht
In der Properties-Sicht bearbeiten Sie die Eigenschaften von markierten Prozess-
Bausteinen und von geöffneten Prozessen. In der linken Spalte befinden sich die
Eigenschaften, in der rechten Spalte die zugehörigen Werte.
Um die Eigenschaften eines geöffneten Prozesses zu bearbeiten, klicken Sie auf die
Zeichnungsfläche, um eventuell ausgewählte Bausteine zu deselektieren.
3.1.4 Palette
Abbildung 3.3: Properties-Sicht bei einem Prozess
Am rechten Rand der Zeichnungsfläche befindet sich eine Werkzeugleiste, die Palette.
Sie enhält Symbole, die Sie per Drag&Drop in den Editor-Bereich ziehen können. Ohne
weitere Konfiguration können Sie so Prozessfluss-Bausteine (Verzweigung, Stop etc.) und
Zeichnungselemente (Rechteck, Textfeld etc.) einfügen.
Zudem können Sie Adapter, Variablen etc. einfügen, die bei der Prozess-Modellierung
zunächst lediglich als Platzhalter dienen. Hierbei handelt es sich also um Baustein-

3. Werkzeuge im X4 Front-End
22
Prototypen, die nicht durch eine Datei im Repository repräsentiert werden, sondern direkt
im Prozess gespeichert werden.
Die Palette wird nicht angezeigt Dann klappen Sie die Palette aus, indem Sie am
rechten Rand der Zeichnungsfläche anklicken.
Die Symbole in der Palette sind in vier Ausklappbereiche ("Flyouts") gegliedert.
Control-Ausklappbereich
Start: Start-Baustein einfügen
Stop: Stop-Baustein als Prozess-Ende einfügen
Fork: Gabelung in den Prozess einfügen
Join: Zusammenführung einer Gabelung einfügen
Condition: Bedingung einfügen
Transaction: Transaktions-Baustein einfügen
Pause: Pausen-Element einfügen
Counter: Zähler einfügen
Data-Ausklappbereich
XML: Platzhalter für ein XML-Dokument einfügen
Document: Platzhalter für ein Dokument im Binärformat einfügen
Merge: Merge-Baustein einfügen
Variable: Variable einfügen
Modules-Ausklappbereich
Database: Platzhalter für eine Datenbank-Verbindung einfügen
Transfer: Platzhalter für einen Transfer-Adapter einfügen
Adapter: Platzhalter für einenen Funktions-Adapter einfügen
Nested Process: Platzhalter für Subprozess ("nested process") einfügen
Mapping: Platzhalter für ein XSL-Mapping einfügen

3. Werkzeuge im X4 Front-End
23
Report: Platzhalter für ein XSL-FO-Skript einfügen
Drawing-Ausklappbereich
Rectangle: Rechteck-Zeichnungselement einfügen
Textbox: Textfeld zum Beschriften und Dokumentieren einfügen
Ellipse: Ellipsen-Zeichnungselement einfügen
Polygon: Vieleck-Zeichnungselement einfügen
Polyline: freies Linien-Zeichnungselement einfügen
Curve: Kurvenlinie einfügen
Line: Gerade Linie einfügen
Image: Externe Grafikdatei in das Prozessdiagramm einfügen
3.1.5 Debug-Symbolleiste
In der Sicht Properties können Sie markierte Zeichnungselemente u.a.
hinsichtlich der Füllfarbe (Fill Color), der Linienfarbe (Line Color) und der
Liniendicke (Line Width) formatieren.
Über die Debug-Symbolleiste können Sie den Prozess auf Fehler überprüfen und testen.
Run X4 Process: X4-Prozess starten
Start Debug: X4-Prozess debuggen (Fehler anzeigen und beseitigen)
Step Into: Einzelschritt ausführen und anzeigen (auch in Subprozessen)
Step Over: Subprozess ausführen und Status anzeigen
Step Return: Auf nächsthöhere Prozess-Ebene springen
Suspend: Debugging-Vorgang anhalten
Resume: Debugging fortsetzen
Terminate: Debugging beenden
Toggle Breakpoint: Debug-Haltepunkt zu diesem Baustein setzen
Clear all Breakpoints: Alle Debug-Haltepunkte in diesem Prozess löschen
3.1.6 Run/Debug Console-Sicht

3. Werkzeuge im X4 Front-End
24
Wenn Sie einen Prozess auf Fehler überprüfen, werden in der Run/Debug Console-Sicht
zu jedem ausgeführten Prozess-Schritt Debug-Informationen angezeigt. Fehlermeldungen
werden rot hervorgehoben, erfolgreiche Statusmeldungen sind grün.
Zu jedem Prozess-Schritt wird eine Ausgabe-Datei angelegt, die Sie über den
entsprechenden Verweis ansehen können (beispielsweise file://1244017505671).
Abbildung 3.4: Run/Debug Console-Sicht
3.2 Adapter-Editor
Über diesen Editor konfigurieren Sie Adapter des X4 Repositorys. Unterschieden wird
hierbei zwischen Transfer-Adaptern und Funktions-Adaptern.
Je nach ausgewähltem Adapter sind unterschiedliche Parameter erforderlich. Eine
Parameter-Referenz zu jedem Adaptertyp finden Sie im X4 Reference Manual
(englischsprachig) in Kapitel 2 Adapters.
Um den Adapter-Editor aufzurufen, doppelklicken Sie im Repository Navigator oder in
einem geöffneten Prozess auf einen Transfer- oder Funktions-Adapter, oder Sie erstellen
einen neuen Transfer- oder Funktions-Adapter.
Die Adapter-Editoren bieten folgende Funktionen:
• Adapter Type: Adapter wählen
• Reset To Default: Sämtliche Parameterwerte auf Standard zurücksetzen (löscht
sämtliche Eingaben)
• Filter: Anfangsbuchstaben eines Parameters eingeben, um angezeigte Parameter zu
filtern.
• Show All: Filter zurücksetzen, um wieder alle Parameter anzeigen.
• Parameter: Bezeichnung des Parameters
Notwendige Parameter erhalten das Symbol .
• Value: den zum Parameter gehörigen Wert können Sie hier eingeben.
• Parameter Description: Zeigt eine Beschreibung des gewählten Parameters an.
Transfer-Adapter-Editor
Über diesen Editor konfigurieren Sie Prozess-Bausteine vom Typ Transfer-Adapter. Mit
Transfer-Adaptern können Sie über verschiedene Protokolle wie FTP oder E-Mail Daten
austauschen.

3. Werkzeuge im X4 Front-End
25
Abbildung 3.5: Transfer-Adapter-Editor (Beispiel: Filesystem-Transfer-Adapter)
Funktions-Adapter-Editor
Über diesen Editor konfigurieren Sie Prozess-Bausteine vom Typ Funktions-Adapter.
Funktions-Adapter stellen grundlegende Funktionen bereit, etwa Zeichensatz-
Konvertierungen oder ermöglichen Zugriff auf ein SAP-System.
Da das X4 Front-End hauptsächlich mit XML-Daten arbeitet, werden mit Funktions-
Adapter meist XML-Dokumente erzeugt oder verändert. Als Ausgabe erzeugen Funktions-
Adapter meist XML-Daten, die in einem nächsten Prozess-Schritt weiterverarbeitet
werden.
Abbildung 3.6: Funktions-Adapter-Editor

3. Werkzeuge im X4 Front-End
26
3.3 SQL-Editor
Über diesen Editor können Sie SQL-Anweisungen definieren, um mit einer Datenbank zu
interagieren. Durch die logische Trennung der Prozess-Bausteine SQL-Anweisung und
Datenbank-Verbindung können Sie im X4 Front-End diese Prozess-Bausteine flexibel
einsetzen und mehrfach verwenden.
Um den SQL-Editor aufzurufen, doppelklicken Sie im Repository Navigator oder in einem
geöffneten Prozess auf einen SQL-Anweisungsbaustein, oder Sie erstellen eine neue SQL-
Anweisung.
Abbildung 3.7: SQL-Editor
Für die SQL-Anweisungen in diesem Prozess-Baustein eine Datenbank-Verbindung
definieren:
• Connection: Datenbankverbindungs-Baustein aus dem Repository wählen
Diese können Sie auch per Drag&Drop aus dem Repository einfügen. Bereits
verwendete Datenbankverbindungen können Sie aus dieser Liste auswählen.
• Browse: Datenbankverbindungs-Baustein aus dem Repository wählen.
Query-Bereich
Im Query-Bereich des SQL-Editors können Sie in ein Textfeld SQL-Anweisungen eingeben
und eine oder mehrere SQL-Anweisungen in einer Liste speichern. Zum Verwalten der Liste
der gespeicherten SQL-Anweisungen verwenden Sie folgende Schaltflächen:

3. Werkzeuge im X4 Front-End
27
• Add: SQL-Anweisung zur Liste der gespeicherten Anweisungen hinzufügen
• Remove: Gespeicherte SQL-Anweisung aus der Liste löschen
Options-Bereich
Im Options-Bereich des SQL-Editors können Sie die Ausgabe-Optionen für die SQL-
Anweisungen festlegen:
• Result Element: Name des XML-Elements verändern, das jeden ausgegebenen
Datensatz umschließt (Standard: )
• Use Cursor: Datenbank-Cursor für die SQL-Anweisung verwenden (aktiviert Textfeld
Fetch Size)
• Fetch Size: Anzahl der ausgebenen Ergebnisse beschränken
• Execute Query: SQL-Anweisung innerhalb des SQL-Editors ausführen
Result-Bereich
Im Result-Bereich des SQL-Editors können Sie das Ergebnis der SQL-Anweisung anzeigen.
• Data: Diese Registerkarte zeigt die ausgegebenen Ergebnisse der Anweisung
tabellarisch an
• XML: Diese Registerkarte zeigt die ausgegebenen Ergebnisse der SQL-Anweisung als
XML-Struktur an, so wie sie der SQL-Anweisungs-Baustein ausgeben wird
• Save Result XML: Ergebnisse der SQL-Anweisung als XML-Dokument im Repository
speichern
• Außerdem können Sie für bereits ausgeführte SQL-Anweisungen spezielle Datenbank-
Vorlagen im XML-Format erzeugen und im Repository abspeichern. Diese enthalten
eine Tabellendefinition der ausgeführten Anweisungen und können für Datenbank-
Mappings verwendet werden. Folgende Vorlagen sind möglich:
• Generate INSERT Template: Datenbank-Vorlage für ein INSERT-Statement
erstellen und im Repository speichern
• Generate UPDATE Template: Datenbank-Vorlage für ein UPDATE-Statement
erstellen und im Repository speichern
• Generate DELETE Template: Datenbank-Vorlage für ein DELETE-Statement
erstellen und im Repository speichern
3.4 Datenbankverbindungs-Editor
Über diesen Editor konfigurieren Sie Datenbankverbindungen entweder über DataSource
Connections oder über JDBC Connections. Auf die Datenbank-Verbindungen greifen Sie
mithilfe eines im Prozess vorgelagerten SQL-Anweisungs-Baustein zu.
Je nachdem, ob Sie DataSource Connection oder JDBC Connection wählen,
sind unterschiedliche Parameter erforderlich. Eine Parameter-Referenz zu jedem
Verbindungstyp finden Sie im X4 Reference Manual (englischsprachig) im Abschnitt 2.3
Connection Configuration.

3. Werkzeuge im X4 Front-End
28
Um den Datenbankverbindungs-Editor aufzurufen, doppelklicken Sie im Repository
Navigator oder in einem geöffneten Prozess auf einen Datenbankverbindungs-Baustein,
oder Sie erstellen eine neue Datenbankverbindung.
Abbildung 3.8: Datenbankverbindungs-Editor
Der Datenbankverbindungs-Editor bietet folgende Funktionen:
• Database Type: Datenbankverbindungs-Typ wählen
• Reset To Default: Sämtliche Parameterwerte auf Standard zurücksetzen (löscht
sämtliche Eingaben)
• Filter: Anfangsbuchstaben eines Parameters eingeben, um angezeigte Parameter zu
filtern.
• Show All: Filter zurücksetzen, um wieder alle Parameter anzeigen.
• Parameter: Bezeichnung des Parameters
Notwendige Parameter erhalten das Symbol .
• Value: Den zum Parameter gehörigen Wert können Sie hier eingeben.
• Parameter Description: Zeigt eine Beschreibung des gewählten Parameters an.
• Test Connection: Datenbankverbindung testen
3.5 Condition Editor
Mit dem Condition Editor können Sie für Condition-Bausteine innerhalb eines Prozesses
festlegen, unter welchen Bedingungen verschiedene Verzweigungen ausgeführt werden
sollen. Für jede Verzweigung lässt sich daher festlegen, bei welchen Werten oder
Eigenschaften sie gültig ist und aufgerufen wird.
Um den Condition Editor aufzurufen, öffnen Sie einen Prozess und doppelklicken auf ein
Condition-Symbol .

3. Werkzeuge im X4 Front-End
29
Abbildung 3.9: Condition Editor
Das Fenster des Condition Editors enthält folgende Bereiche und Symbole:
Branch-Bereich
In der Auswahlliste Branch wählen Sie den Zweig, für den Sie eine Bedingung festlegen
möchten. Alternativ können Sie auch in der grafischen Darstellung den gewünschten
Übergang anklicken, um für diesen Zweig eine Bedingung zu definieren.
Zoom in: Ansicht vergrößern
Original zoom: Ursprüngliche Größe anzeigen
Zoom out: Ansicht verkleinern
Zoom to page: Alles anzeigen
Zoom to width: Ansicht auf voller Breite
Condition-Bereich
Im Bereich Condition werden die Bedingungen für den ausgewählten Zweig angezeigt
und bearbeitet. Um eine Bedingung zu erstellen oder zu bearbeiten, klicken Sie im
Listenfeld auf Insert ....
Das Auswahlfeld Condition zeigt die Bedingung des ausgewählten Übergangs an.
Undo: Rückgängig machen

3. Werkzeuge im X4 Front-End
30
Redo: Rückgängig gemachten Schritt wiederherstellen
Cut: Auswahl ausschneiden
Copy: Auswahl kopieren
Paste: Auswahl einfügen
Logical AND: Logische UND-Verknüpfung einfügen
Logical OR: Logische ODER-Verknüpfung einfügen
Logical NOT: Logische NICHT-Verknüpfung einfügen
Delete: Bedingung löschen
Edit Condition-Bereich
Im Bereich Edit Condition können Sie die gewählte Bedingung bearbeiten.
If result of: In dieser Auswahlliste wählen Sie den Prozess-Baustein, für dessen Ergebnis
Sie eine Bedingung festlegen möchten.
Browse: Prozess-Ansicht in voller Größe einblenden
Vergleichsoperator auswählen
• : größer als ...
• : ungleich zu ...
Vergleichswert angeben
• (no result): Wenn kein Ergebnis vorhanden ist
• error: Wenn ein Fehler auftritt
• ok: Wenn kein Fehler auftritt
• empty: Wenn das Ergebnis eine leere Menge ist
• (Beliebiger Wert)
3.6 XSL-Editor
In diesem Abschnitt wird der XSL-Editor beschrieben, mit dem Sie XSL-Mappings in einer
grafischen Ansicht erstellen und bearbeiten können.

3. Werkzeuge im X4 Front-End
31
3.6.1 Überblick über den XSL-Editor
Mit dem XSL-Editor können Sie XSL-Mappings und XSL-FO-Reports zwischen XML-
Dokumenten erstellen, d.h. eine XML-Datenstruktur mithilfe der Sprache XSLT 1.1 in eine
andere XML-Datenstruktur oder in ein XSL-FO-Skript transformieren. Der XSL-Editor
unterstützt Sie beim Erstellen eines XSL-Mappings durch eine grafische Oberfläche und
durch eine automatische Gültigkeitsprüfung des Stylesheets sowie der XPath-Ausdrücke.
Um ein Mapping zu erstellen, benötigen Sie drei Dateien:
• XML-Quelldokument (oder ein XML-Schema)
• XSLT-Stylesheet (dieses wird im XSL-Editor erstellt)
• XML-Ausgabedokument
Um den XSL-Editor zu starten, doppelklicken Sie im Repository Navigator oder auf der
Zeichnungsfläche auf ein XSLT-Mapping.
Abbildung 3.10: Der XSL-Editor
Der XSL-Editor verfügt über zwei Ansichten, zwischen denen Sie über zwei Registerkarten
am unteren Rand des XSL-Editors wechseln können:
• Design: In der dreispaltigen Design-Ansicht stellt der XSL-Editor das XSLT-Stylesheet
als Baum dar. Hier können Sie die Knoten des Quelldokuments den Knoten im XSLT-
Stylesheet grafisch über Verbindungslinien zuordnen.
• Source: In dieser Quellcode-Ansicht können Sie das XSLT-Stylesheet direkt im XML-
Editor bearbeiten (siehe Abschnitt 3.7.1, „Übersicht über den XML-Editor “).
3.6.2 Quelldokumentbereich
Auf der linken Seite des XSL-Editors befindet sich in der Design-Ansicht der
Quelldokumentbereich, in dem Sie das zu transformierende Quelldokument oder eine
Schema-Datei (.xsd) anzeigen können.

3. Werkzeuge im X4 Front-End
32
Abbildung 3.11: Quelldokumentbereich im XSL-Editor
Um ein Quelldokument oder ein Schema einzufügen, ziehen Sie eine entsprechende Datei
aus dem Repository Navigator per Drag&Drop in den Quelldokumentbereich. Alternativ
rechtsklicken Sie auf den Quelldokumentbereich, um das Kontextmenü aufzurufen und
wählen Assign Schema.
3.6.3 Verknüpfungsbereich
In der mittleren Spalte des XSL-Editors befindet sich der Verknüpfungsbereich. Hier
werden die Verknüpfungen zwischen Knoten im Quelldokument und XSL-Stylesheet als
verschiedenfarbige Linien visualisiert.
Abbildung 3.12: Verknüpfungsbereich im XSL-Editor
Verknüpfungs-Kategorien
Farbe/Stil Bedeutung Verwendung
Grün
Wert-Übernahme, mit oder ohne
Kindknoten-Elemente
xsl:value-of, xsl:copy-of
Orange Anlegen eines Kontextes xsl:for-each

3. Werkzeuge im X4 Front-End
33
Farbe/Stil Bedeutung Verwendung
Gelb
Gestrichelt
Grau
3.6.4 Stylesheet-Bereich
Wert-Überprüfung mit
Bedingungen
XPath-Ausdruck mit Filter-
Ausdruck (Prädikat)
Mehrere Verknüpfungspfade zu
einem Knoten
xsl:if, xsl:choose
bei Filter-Ausdrücken
(Prädikaten)
bei zugeklappten Knoten
Auf der rechten Seite des XSL-Editors befindet sich der Stylesheet-Bereich. Hier
bearbeiten Sie den Hauptbestandteil eines Mappings, das XSL-Stylesheet. Das Stylesheet
wird in einer Baumstruktur angezeigt und bietet über das Kontextmenü Zusatzfunktionen
für die XSL-Bearbeitung.
Abbildung 3.13: Stylesheet-Bereich im XSL-Editor
Die verschiedenen Bestandteile des XSL-Stylesheets werden in der Baumansicht mit
Symbolen und farblichen Hervorhebungen dargestellt:
• Knoten mit XSL-Anweisungen besitzen eine braune Schriftfarbe und ein
entsprechendes Symbol, z.B. .
• Knoten mit einem XPath-Ausdruck besitzen ein entsprechendesXPath-Symbol ( ). Um
den XPath-Ausdruck zu bearbeiten, klicken Sie auf dieses Symbol.
• Virtuelle Knoten (aus der Quellstruktur übernommene, aber noch nicht im Stylesheet
explizit vorhandene Knoten) werden grau dargestellt.
Symbole der Knotentypen
Symbol Knotentyp Symbol Knotentyp
Element
xsl:attribute

3. Werkzeuge im X4 Front-End
34
Symbol Knotentyp Symbol Knotentyp
Attribut
Virtuelles Element
Virtuelles Attribut
Element aus dem Schema
Attribute aus dem Schema
Namespace
Processing Instruction
Kommentar
Text
Variable
Rekursives virtuelles
Element
xsl:choose
xsl:copy
xsl:copy-of
xsl:element
xsl:for-each
xsl:if
xsl:otherwise
xsl:stylesheet
xsl:template
xsl:value-of
xsl:variable
xsl:when
Andere XSLT-Anweisung
3.6.5 Kontextmenü im Stylesheet-Bereich
Um das Kontextmenü im Stylesheet-Bereich des XSL-Editors aufzurufen, rechtsklicken Sie
auf den gewünschten Knoten im XSL-Stylesheet.
Über das Kontextmenü können Sie im Stylesheet-Bereich den gewählten Knoten
folgendermaßen bearbeiten:
• Edit XPath (nur wenn XPath-Ausdruck hinterlegt ist): XPath-Ausdruck bearbeiten
• Edit (bei Processing Instructions, Namespace-Deklarationen): Knoteninhalt bearbeiten
• Add here (nur bei virtuellen Knoten): Virtuellen Knoten in tatsächlichen Knoten
umwandeln
• Rename: Knoten umbenennen
• Add Child: Kind-Knoten (Element, Attribut, xsl-Anweisung etc.) an dieser Stelle im
Stylesheet hinzufügen
• Add Before: Knoten (Element, Attribut, xsl-Anweisung etc.) vor dem markierten
Knoten einfügen
• Add After: Knoten (Element, Attribut, xsl-Anweisung etc.) hinter dem markierten
Knoten einfügen
• Add Parent: Eltern-Element (übergeordnetes Element) einfügen

3. Werkzeuge im X4 Front-End
35
• Cut, Copy und Paste: Auswahl ausschneiden, kopieren und einfügen
• Delete: Knoten löschen
• Expand: Unterelemente des Knotens aufklappen
• Collapse: Knoten mit aufgeklappten Unterelementen zuklappen
• Assign Schema: Virtuellen Knoten aus einem XML-Dokument einfügen
• Remove Schema: Eingefügten virtuellen Knoten entfernen
3.7 XML-Editor
In diesem Abschnitt wird der XML-Editor beschrieben, mit dem Sie wohlgeformte XML-
Dokumente erstellen und bearbeiten können.
3.7.1 Übersicht über den XML-Editor
Um den XML-Editor zu starten, doppelklicken Sie im Repository Navigator oder auf der
Zeichnungsfläche auf ein XML-Dokument.
Zum Bearbeiten von XML-Dokumenten stehen Ihnen zwei Ansichten zur Verfügung, die
Design-Ansicht und die Source-Ansicht, zwischen denen Sie über die Registerkarten am
unteren Rand des Editors wechseln können.
Um XSL-Stylesheets, HTML-Dateien etc. mit dem XML-Editor zu öffnen,
rechtsklicken Sie im Repository Navigator auf das gewünschte Stylesheet und
wählen im Kontextmenü Open with > XML-Editor.
3.7.2 Design-Ansicht des XML-Editors
In der Design-Ansicht wird die Baumstruktur des geöffneten XML-Dokuments tabellarisch
dargestellt. In der linken Spalte befinden sich die verschiedenen Knoten des Elements,
die Sie auf- und zuklappen können, sofern Kindknoten existieren. In der rechten Spalte
werden die Inhalte der Knoten angezeigt.
Abbildung 3.14: XML-Editor in der Design-Ansicht
Kontextmenü in der Design-Ansicht
Die Baumstruktur des XML-Dokuments können Sie über das Kontextmenü bearbeiten,
indem Sie auf das gewünschte Element rechtsklicken.

3. Werkzeuge im X4 Front-End
36
Abbildung 3.15: Kontextmenü in der Design-Ansicht des XML-Editors
Funktionen im Kontextmenü sind:
• Remove: Markierten Knoten entfernen
• Add DTD Information: Strukturdefinition in Form einer DTD (Document Type
Definition) hinzufügen
• Edit Namespaces: Namensräume bearbeiten
• Add Attribute: Neues Attribut hinzufügen
• Add Child: Neuen Kindknoten (Element, Processing Instruction etc.) hinzufügen
• Add Before: Neuen Knoten vor dem markierten Knoten einfügen
• Add After: Neuen Knoten hinter dem markierten Knoten einfügen
In der Outline-Sicht können Sie ebenfalls das geöffnete XML-Dokument in einer
grafisch dargestellten Baumstruktur bearbeiten. Auch dort steht Ihnen dieses
Kontextmenü zur Verfügung.
3.7.3 Source-Ansicht des XML-Editors
In der Source-Ansicht des XML-Editors können Sie den Quelltext von XML-Dokumenten
bearbeiten. Dabei unterstützt Sie der Editor durch folgende Funktionen:
• Syntax-Highlighting: Farbliche Hervorhebung der verschiedenen Knotentypen
• Validierung: Eine Überprüfung, ob das XML-Dokument wohlgeformt ist, erfolgt beim
Speichern oder indem Sie auf das Symbol
in der Symbolleiste klicken.
• Eingabehilfen: Der Editor macht Vorschläge, wenn Sie neue Elemente einfügen
möchten (siehe Abbildung 3.16, „XML-Editor in der Source-Ansicht mit Eingabe-
Unterstützung“).
• Pretty-Print: XML-Dokument mit Einrückungen und Zeilenumbrüchen lesbarer
formatieren. Rechtsklicken Sie dazu im Editor-Bereich, um das Kontextmenü
aufzurufen und rufen Source > Format auf.

3. Werkzeuge im X4 Front-End
37
Abbildung 3.16: XML-Editor in der Source-Ansicht mit Eingabe-Unterstützung
3.8 Text-Editor
Mit dem Text-Editor können Sie unformatierte Textdateien (.txt, .csv etc.) anzeigen und
bearbeiten. Strukturierte Daten (.xml, .html etc.) können Sie ebenfalls bearbeiten, jedoch
stehen hier die erweiterten Bearbeitungsfunktionen des XML-Editors nicht zur Verfügung.
Abbildung 3.17: Text-Editor in Eclipse
3.9 BPM-Designer
Die Darstellung des Text-Editors in Eclipse können Sie anpassen, indem Sie im
Editor-Bereich rechtsklicken, um das Kontextmenü aufzurufen und Preferences
wählen.
In diesem Abschnitt wird der BPM-Designer beschrieben, mit dem Sie fachliche Prozesse
gemäß dem BPMN-Standard im X4 Front-End erstellen können.
3.9.1 BPM-Designer
Mit dem BPM-Designer können Sie fachliche Prozesse gemäß dem Notationsstandard der
BPMN modellieren (BPM steht hier für Business Process Modeling). Da in BPM-Prozesse
theoretisch auch nicht-automatisierbare Aktionen, etwa Arbeitsabläufe von Menschen,
eingebunden werden können, sind BPM-Prozesse nicht notwendigerweise vom X4 Server

3. Werkzeuge im X4 Front-End
38
ausführbar. X4-Prozesse können jedoch als Subprozesse in BPM-Prozesse eingefügt und
ausgeführt werden.
Abbildung 3.18: BPM-Designer im X4 Front-End
Der BPM-Designer ist eine spezielle (fachliche) Sicht auf Prozesse. Er entspricht in Aufbau
und Bedienweise dem Prozess-Designer (siehe Abschnitt 3.1.1, „Übersicht über den
Prozess-Designer “), unterscheidet sich jedoch hinsichtlich der Prozess-Bausteine bzw.
Symbole im Prozess-Diagramm.
3.9.2 Prozess-Bausteine und Symbole
Folgende Prozess-Bausteine und Symbole gemäß BPMN stehen im BPM-Designer in der
Palette am rechten Rand des Zeichnungsbereichs zur Verfügung:
Start Event
End Event
OR Gateway
AND Gateway
XOR Gateway
Sub-Process
Data Object
Start-Event-Baustein einfügen
End-Event-Baustein als Prozess-Ende einfügen (entspricht Stop
in X4-Prozessen)
Exklusiv-ODER-Prozessfluss-Baustein (entspricht einer
Gabelung/Fork in X4-Prozessen) einfügen
UND-Prozessfluss-Baustein (entspricht einer
Zusammenführung/Join in X4-Prozessen) einfügen
Exklusiv-ODER-Prozessfluss-Baustein (entspricht einem
Bedingungs-/Condition-Baustein in X4-Prozessen) einfügen
Subprozess-Baustein (X4-Prozess) einfügen
Datenobjekt (entspricht einer Text-/Binärdatei in X4-Prozessen)
einfügen

3. Werkzeuge im X4 Front-End
39
Timer Event Timer-Prozessfluss-Baustein (entspricht einer Pause in X4-
Prozessen) einfügen
Counter
Zähler einfügen
3.10 X4 Business Activity Monitoring (BAM)
X4 BAM ist ein browser-basiertes Werkzeug mit dem Sie bestehende X4-Prozesse
überwachen und steuern können. X4 BAM unterstützt Sie bei der Fehlerbehebung, indem
Sie Probleme wie Datenüberlastung, lange Antwortzeiten und Verletzungen der Service-
Level-Bestimmungen identifizieren können. X4 BAM ersetzt das bisher mitgelieferte X4
Command Center.
Um X4 BAM aufzurufen, geben Sie in der Adressleiste Ihres Browsers http://
localhost:8080/X4-bam-jsp ein und drücken Sie Enter.
Abbildung 3.19: X4 Business Activity Monitoring (BAM)
Die wichtigsten Funktionen von X4 BAM sind:
• Übersichtliche Darstellung der Prozesse
• Bestimmung von Parametern wie Prozesslaufzeit, PID oder der Fehlerrate
• Komfortables Reporting und Excel-Export (als .csv-Datei)
• Aufrufen der Prozessdokumentation
• Technisches Logging und Content Logging
Nähere Informationen zu X4 BAM finden Sie im Handbuch X4 4.0 BAM User Manual
(englischsprachig).

3. Werkzeuge im X4 Front-End
40

4. Prozesse modellieren
41
4 Prozesse modellieren
In diesem Abschnitt wird beschrieben, aus welchen Bestandteilen sich ein X4-Prozess
zusammensetzt und wie Sie mit dem X4 Front-End Geschäftsprozesse organisieren,
entwickeln, grafisch darstellen und ausführen können.
4.1 Prozess-Bausteine
X4-Prozesse werden aus verschiedenen Prozess-Bausteinen aufgebaut. In welche
grundlegenden Bausteinarten sich Prozess-Bausteine unterteilen lassen, wird im
Folgenden dargestellt.
Detaillierte Informationen zu Prozessen, den einzelnen Bausteinarten und
Adaptern finden Sie im X4 4.0 Reference Manual (englischsprachig) im Abschnitt
1 Process Components.
4.1.1 Prozessfluss-Bausteine
Die Prozessfluss-Bausteinen stellen die Basisfunktionen für den Ablauf des Prozesses und
entsprechende Kontrollstrukturen bereit:
Start: Beginn des Prozesses
Stop: Ende des Prozesses
Fork: Gabelungen
Join: Zusammenführungen von Gabelungen
Condition: Bedingte Verzweigungen
Transaction: Transaktionen
Pause: Wartezeiten
Counter: Zähler
4.1.2 Daten-Bausteine
Hierbei handelt es sich um Prozess-Bausteine, die Daten temporär oder permanent
speichern und innerhalb eines Prozesses zusammenführen:
XML: XML-Dokumente
Document: Text- oder Binärdateien
Merge: Daten-Zusammenführungen

4. Prozesse modellieren
42
Variable: Variablen
4.1.3 Modul-Bausteine
Mit Modulen wird der Prozess mit der Außenwelt und anderen Prozessen verbunden,
beispielsweise in Form von Datenbank-Verbindungen, Funktions-Adapter und
Subprozessen. Modul-Bausteine liegen als wiederverwendbare Dateien im Repository vor.
Deren Konfiguration erfolgt entweder in der jeweiligen Adapter-Konfiguration oder direkt
in einem XSL-Stylesheet (bei Mappings und Reports).
Database: Datenbank-Anbindung
Transfer: Transfer-Adapter zur Nutzung verschiedener Protokolle
Adapter: Funktions-Adapter für weitere Daten-Operationen
Nested Process: Subprozesse
Mapping: XSL-Stylesheets
Report: XSL-FO-Stylesheets
4.1.4 Zeichnungselemente
Diese Bausteine besitzen keine eigene Funktion, sondern dienen dazu, das
Prozessdiagramm zu dokumentieren und übersichtlich zu gestalten:
Rectangle: Rechteck-Zeichnungselemente
Textbox: Textfelder
Ellipse: Ellipsen-Zeichnungselemente
Polygon: Vieleck-Zeichnungselemente
Polyline: Freie Linien-Zeichnungselemente
Curve: Kurvenlinien-Zeichnungselemente
Line: Linien-Zeichnungselemente
Image: Externe Grafikdateien
4.2 Elemente im Repository verwalten
In diesem Abschnitt wird beschrieben, wie Sie Projekte, Prozesse und Projekt-Bausteine im
Repository verwalten können.

4. Prozesse modellieren
43
4.2.1 Projekte in X4
Ein Projekt ist in X4 die höchste Ebene im Repository. Projekte besitzen eine Dateisystem-
Struktur. Ein Projekt kann Ordner, Prozesse, Prozess-Bausteine und andere Dateien
enthalten.
Jeder Benutzer kann nur Projekte im Repository Navigator sehen und bearbeiten,
die in der benutzerspezifischen sogenannten user collection des X4 Servers in /X4DB liegen. Nur ein X4-Administrator kann sämtliche
Projekte aller Benutzer sehen und bearbeiten.
4.2.2 Projekt öffnen und schließen
Im Repository Navigator muss zunächst ein Projekt geöffnet werden, um die darin
liegenden Dateien bearbeiten zu können.
• Projekt öffnen: Auf das Projekt-Symbol doppeklicken.
• Projekt schließen: Rechtsklicken und Close Project wählen.
4.2.3 Neues Projekt anlegen
1. Im Repository Navigator rechtsklicken, um das Kontextmenü aufzurufen.
2. New > Project aufrufen, um ein neues Projekt-Ordner anzulegen.
3. In Project name den Namen des Projekts eingeben und OK klicken.
Empfohlene Ordnerstruktur
SoftProject empfiehlt, zu jedem Projekt folgende Ordnerstruktur anzulegen:
• Adapter: enthält sämtliche Transfer- und Funktionsadapter-Dateien der Prozesse im
Projekt (.tra, .fa, .cs)
• Data: enthält alle Daten in Form von XML-Dokumenten, Text- und Binärdateien (.xml,
.csv, .sql)
• Mappings: enthält sämtliche XSL-Stylesheets (Mappings; .xsl)
• Processes: enthält sämtliche Prozess-Dateien (Hauptprozess und Subprozesse; .wrf)
• Reports: (falls notwendig) enthält sämtliche Reports (XSL-FO-Stylesheets) des
Projekts (.rep)
4.2.4 Neuen Prozess oder Prozess-Baustein anlegen
Um zu einem Projekt im Repository einen neuen Prozess, Ordner oder Prozess-Baustein
hinzuzufügen, gehen Sie wie folgt vor:
1. Auf den gewünschten Zielordner rechtsklicken, um das Kontextmenü zu öffnen.

4. Prozesse modellieren
44
2. New aufrufen und gewünschtes Element (Project, Folder, Process, Adapter etc.)
auswählen, um den File creation wizard zu öffnen.
3. Im File Creation Wizard den Zielordner wählen und in File Name den Dateinamen
eingeben.
4. Finish klicken.
Das neu angelegte Element ist nun im Repository Navigator im markierten Ordner
verfügbar und kann bearbeitet und konfiguriert werden.
Mit der Funktion From Template im Kontextmenü des Repository Navigators
können Sie Prozesse und Prozess-Bausteine anhand von Vorlagen erstellen.
So können Sie schnell auf häufig wiederkehrende Muster zugreifen (siehe
Abschnitt 5.2.4, „Vorlagen für Prozesse und Prozess-Bausteine verwenden “).
4.2.5 Prozesse und Bausteine in verschiedenen Ansichten öffnen
Um einen Prozess oder einen Prozess-Baustein im Repository Navigator zum Anzeigen
oder Bearbeiten zu öffnen, haben Sie folgende Möglichkeiten:
• Standard-Ansicht: Datei im Repository Navigator doppelklicken.
• Vorschau: Rechtsklicken auf die Datei und Preview aufrufen.
• Text Editor: Rechtsklicken auf die Datei und Open with > Text editor aufrufen.
• XML Editor: Rechtsklicken auf die Datei und Open with > XML Editor aufrufen.
Über die Registerkarten am unteren Rand des Editors können Sie zwischen folgenden
Ansichten wählen (siehe Abschnitt 3.7.1, „Übersicht über den XML-Editor “):
• Design: Tabellarische Baum-Darstellung von XML-Dokumenten
• Source: XML-Quelltext anzeigen und bearbeiten
4.2.6 Prozesse und Bausteine importieren und exportieren

4. Prozesse modellieren
45
Sie können Dateien aus dem Dateisystem ins Repository importieren oder umgekehrt
Elemente aus dem Repository ins Dateisystem exportieren.
Datei importieren
• Menü File > Import aufrufen, um den Import Wizard zu starten.
• Eine oder mehrere Dateien und Ordner aus dem Dateisystem auswählen.
• In Target directory den gewünschten Zielordner im Repository angeben und ggf. mit
Browse auswählen.
• Finish klicken.
Datei exportieren
• Menü File > Export aufrufen, um den Export Wizard zu starten.
• Eine oder mehrere Dateien und Ordner aus dem Repository auswählen.
• In Target directory das gewünschte Zielverzeichnis im Dateisystem angeben und ggf.
mit Browse auswählen.
• Finish klicken.
4.3 Prozess-Bausteine verwenden
In diesem Abschnitt erfahren Sie, wie Sie die verschiedenen Bestandteile eines X4-
Prozesses in einen Prozess einbinden können. Diese erfolgt soweit möglich anhand von
Beispieldaten.
4.3.1 Start, Stop und Übergang (Transition) einfügen
Die Grundelemente jedes X4-Prozesses sind der Prozess-Beginn (Start-Baustein),
mindestens ein Prozess-Ende (Stop-Baustein) und jeweils ein Übergang (Transition), der
die einzelnen Prozess-Schritte verbindet und durch die Pfeilrichtung die Reihenfolge
definiert.
1. Neuen Prozess anlegen (siehe Abschnitt 4.2.4, „Neuen Prozess oder Prozess-Baustein
anlegen “).
Der Start-Baustein und ein Stop-Baustein sind in neu angelegten Prozessen bereits
vorhanden.
Zusätzliche Stop-Bausteine können Sie per Drag&Drop aus der Palette einfügen.
2. Übergang herstellen, um Start und Stop zu verbinden.
• Mit dem Mauszeiger über den Start-Baustein fahren, um ein kleines gelbes Dreieck (tslot)
anzuzeigen.
• Dreieck anklicken und zum Stop-Baustein ziehen, um einen Übergang herzustellen.

4. Prozesse modellieren
46
Übergänge mit Label beschriften
Sie können Übergänge (Transitions) und Prozess-Bausteine beschriften, um die Lesbarkeit
des Prozessdiagramms zu verbessern.
Klicken Sie dazu auf das Element und geben in der Properties-Sicht in Label einen
Beschriftungstext ein, beispielsweise nächster Datensatz.
4.3.2 Transfer-Adapter anlegen und verwenden
Um Daten verarbeiten zu können, müssen diese im Prozess verfügbar gemacht werden.
Transfer-Adapter ermöglichen, über verschiedene Protokolle auf Daten zuzugreifen. Eine
entsprechende Instanz des Transfer-Adapters muss nur noch für das Projekt angelegt und
konfiguriert werden.
Beispiel: Es soll ein Dateisystem-Transfer eingerichtet werden, der auf die Datei
Camera.csv zugreift.
1. Im Repository Navigator einen neuen Transfer-Adapter anlegen.
• Auf den Projektordner rechtsklicken, um das Kontextmenü aufzurufen.
• Im Kontextmenü New > Transfer aufrufen, um den File Creation Wizard zu öffnen
• Im File Creation Wizard den Zielordner wählen und in File Name den Dateinamen
eingeben, Finish klicken.
Der Adapter-Baustein wurde angelegt und wird zum Konfigurieren im Adapter-Editor
geöffnet.
2. Protokoll des Transfer-Adapters auswählen und konfigurieren.
• In der Auswahlliste Adapter Type das gewünschte Protokoll auswählen.
Im Beispiel: File System.
Eine Parameter-Beschreibung weiterer Transfer-Adapter finden Sie
im X4 Reference Manual (englischsprachig), im Abschnitt 2.2 Transfer
Configuration.
• Wenn notwendig, weitere Felder ausfüllen.
Pflichtfelder erkennen Sie am Symbol .
• STRG+S drücken, um den Adapter zu speichern.
3. Adapter-Baustein in den Prozess einfügen.
• Den neu angelegten Adapter-Baustein aus dem Repository Navigator per Drag&Drop
in den geöffneten Prozess ziehen.
• Transfer-Adapter-Baustein auf der Übergangslinie zwischen Start und Stop fallen
lassen, wenn die Linie dick wird.
Der Adapter-Baustein ist nun Teil des Prozesses.
4. Eigenschaften des gewählten Adapter-Bausteins in der Properties-Sicht festlegen.
• Operation wählen, um festzulegen, was mit den Daten geschehen soll.
Im Beispiel: Receive wählen, um Daten in den Prozess hineinzubekommen.

4. Prozesse modellieren
47
• Input source wählen, um festzulegen, ob eine einzelne Datei (Actions) oder ein
Ordner (Directory) gelesen werden soll.
Beispiel: Actions wählen, um nur eine Datei zu lesen.
• In File Name den Namen der zu lesenden Datei eingeben.
Im Beispiel: Cameras.csv
Der Adapter ist nun einsatzbereit.
4.3.3 Funktions-Adapter-Baustein anlegen und verwenden
Funktions-Adapter sind Prozess-Bausteine, die grundlegende Funktionen bereitstellen,
etwa Zeichensatz-Konvertierungen oder Zugriff auf ein SAP-System ermöglichen. Da das
X4 Front-End hauptsächlich mit XML-Daten arbeitet, werden mit Funktions-Adapter meist
XML-Dokumente erzeugt oder verändert.
Als Ausgabe erzeugen Funktions-Adapter meist XML-Daten, die in einem nächsten
Prozess-Schritt weiterverarbeitet werden.
Beispiel: Es soll ein ein Adapter eingerichtet werden, der eine CSV-Text-Datei in XML
konvertiert. Die Datei Camera.csv hat folgenden Inhalt:
"Nummer","Name","Marke","Description","Preis","Waehrung"
"1","xvc","Minolta","3x","400","Euro"
"2","Powershot","Canon","5x","100","Euro"
"3","Tp","Yashika","3x","300","Euro"
"4","C10","Leika","15x","500","Euro"
1. Im Repository Navigator einen neuen Funktions-Adapter anlegen.
• Auf den Projektordner rechtsklicken, um das Kontextmenü aufzurufen.
• Im Kontextmenü New > Adapter aufrufen, um den File Creation Wizard zu öffnen.
• Im File Creation Wizard den Zielordner wählen und in File Name den Dateinamen
eingeben, Finish klicken.
Der Adapter-Baustein wurde angelegt und wird zum Konfigurieren im Editor-Bereich
geöffnet.
2. Protokoll des Transfer-Adapters auswählen und konfigurieren.
• In der Auswahlliste Adapter Type den gewünschten Adapter-Typ auswählen.
Im Beispiel: CSVReader.
Eine Parameter-Beschreibung weiterer Funktions-Adapter finden Sie im X4
Reference Manual (englischsprachig), im Abschnitt 2.4 Adapter Configuration.
• Wenn notwendig, weitere Felder ausfüllen.
Pflichtfelder erkennen Sie am Symbol .
Im Beispiel CSVReader:
• In DELIMITER: , (Komma) angeben, um das Trennzeichen in der CSV-Datei zu
definieren.

4. Prozesse modellieren
48
• In QUOTE: " (Anführungszeichen) angeben, mit dem Textinhalte eingeschlossen
werden.
• In ROW_NAME: camera angeben, um das umschließende Element jedes Datensatzes
im XML-Output zu benennen.
• In ROOT_NAME: products angeben, um das Wurzel-Element im XML-Output zu
benennen.
• STRG+S drücken, um den Adapter zu speichern.
3. Adapter-Baustein in den Prozess einfügen.
• Den neu angelegten Adapter-Baustein aus dem Repository Navigator per Drag&Drop
in den geöffneten Prozess ziehen.
Im Beispiel: zwischen Transfer-Adapter und Stop-Baustein einfügen.
4. Eigenschaften des gewählten Adapter-Bausteins in der Properties-Sicht festlegen.
• In Operation festlegen, was mit den Daten geschehen soll.
Im Beispiel: Receive angeben, um Daten in den Prozess hineinzubekommen.
• In Input source festzulegen, ob eine einzelne Datei (Actions) oder ein Ordner
(Directory) gelesen werden soll.
Im Beispiel Actions wählen, um nur eine Datei zu lesen.
• In File Name den Pfad und Namen der zu lesenden Datei eingeben.
Im Beispiel Camera.csv angeben.
Der Adapter ist nun einsatzbereit.
4.3.4 XML-Dokument erstellen
Eine einfache Möglichkeit, strukturierte Daten abzulegen ist, diese in XML-Dokumenten zu
speichern. Daten werden zwischen den einzelnen Prozess-Bausteinen in der Regel in XML
ausgetauscht.
Beispiel: Die Inhalte der CSV-Datei Camera.csv wurden ausgelesen und sollen nun in das
XML-Dokument Camera.xml gespeichert werden.
1. Im Repository Navigator ein neues XML-Dokument anlegen.
• Auf den Projektordner rechtsklicken, um das Kontextmenü aufzurufen.
• Im Kontextmenü New > XML Document aufrufen, um den File Creation Wizard zu
öffnen.
• Im File Creation Wizard den Zielordner wählen und in File Name den Dateinamen
eingeben, Finish klicken.
Das XML-Dokument wurde angelegt und wird im XML-Editor geöffnet (siehe
Abschnitt 3.7.1, „Übersicht über den XML-Editor “).
2. XML-Dokument per Drag&Drop aus dem Repository Navigator in den Prozess einfügen.
Im Beispiel: Zwischen Funktions-Adapter und Stop-Baustein einfügen.

4. Prozesse modellieren
49
3. In der Properties-Sicht in Operation für das XML-Dokument festlegen, ob die Datei
gelesen (Read) oder geschrieben (Write) werden soll.
Im Beispiel: Read wählen, da die Daten aus dem Funktions-Adapter in das XML-Dokument
geschrieben werden sollen.
Die Daten aus der CSV-Datei werden nun im Beispiel im XML-Dokument gespeichert,
wenn der Prozess ausgeführt wird.
4.3.5 XSL-Mapping anlegen und verwenden
Häufig müssen Datenstrukturen umgewandelt werden, das heißt von der Struktur des
Quelldokuments in eine andere Struktur transformiert werden. Hierfür gibt es in X4 die
sogenannten XSL-Mappings. Die technische Umsetzung eines Mappings erfolgt mithilfe
der XML-Technologien XSLT und XPath in einem XSL-Stylesheet.
Beispiel: Die Daten aus der CSV-Datei, die mittlerweile in XML vorliegen, sollen in eine
HTML-Tabelle umgewandelt werden.
1. Im Repository Navigator ein neues XSL-Mapping (XSL-Stylesheet) anlegen.
• Auf den Projektordner rechtsklicken, um das Kontextmenü aufzurufen.
• Im Kontextmenü New > XSLT Stylesheet aufrufen, um den File Creation Wizard zu
öffnen.
• Im File Creation Wizard den Zielordner wählen und in File Name den Dateinamen
eingeben, Finish klicken.
Das XSL-Mapping wurde angelegt und wird im XSL-Editor geöffnet (siehe
Abschnitt 3.6.1, „Überblick über den XSL-Editor “). Hier können Sie in der dreispaltigen
Design-Ansicht das Mapping grafisch erstellen oder in der Quelltext-Ansicht
bearbeiten (Source-Ansicht).
2. Grundstruktur des Zieldokuments im XSL-Mapping anlegen.
• Im Stylesheet-Bereich auf das Root-Template (template match="/") rechtsklicken,
um das Kontextmenü zu öffnen.
• Im Kontextmenü Add Child > Element wählen, um sämtliche benötigten Elemente
mit der entsprechenden Hierarchie einfügen.
Add Child > Text wählen, um die Kopfzeilen-Beschriftung im Tabellenkopf
einzufügen.
Im Beispiel: Die Struktur des Zieldokuments ist das HTML-Grundgerüst mit einer
Tabellenkopfzeile und lautet:

4. Prozesse modellieren
50
KameraBeschreibungPreis
Mit virtuellen Knoten
Dateien übernehmen.
können Sie auch Strukturen aus XML- und Schema-
Rechtsklicken Sie dazu im Stylesheet-Bereich auf das Element, das
Unterelemente aus einer externen Datei erhalten soll, und wählen über das
Kontextmenü Assign Schema eine XML-Quelldatei aus. Deren Elemente werden
nun als virtuelle Knoten unterhalb des gewählten Elements eingefügt. Durch
Doppelklicken übernehmen Sie diese als Knoten ins XSL-Mapping.
3. XML-Quelldokument in den XSL-Editor einfügen, um das Mapping grafisch zu erstellen.
• XML-Quelldokument (XML-Dokument oder XML-Schema) aus dem Repository
Navigator per Drag&Drop in die linke Spalte des XSL-Editors, den Quelldokument-
Bereich, ziehen.
Das XML-Quelldokument wird in einer Baumansicht dargestellt.
• Alle Unterelemente ausklappen, um vollständige Struktur anzuzeigen.
4. For-each-Baustein einfügen, um eine Zielstruktur aufzubauen, die sich pro Datensatz
wiederholen soll.
• Auf das übergeordnete Element rechtsklicken, um das Kontextmenü aufzurufen.
• Im Kontextmenü Add Child > xsl:for-each aufrufen, um ein xsl:for-each-
Schleifenelement einzufügen.
Im Beispiel: xsl:for-each innerhalb des table-Elements einfügen, um HTML-
Tabellenzeilen dynamisch zu erzeugen.
• Unterhalb des xsl:for-each-Elements die sich wiederholenden Strukturelemente
einfügen.
Im Beispiel: Innerhalb des xsl:for-each-Elements über das Kontextmenü und Add
Child > Element folgende Struktur anlegen, die eine (noch) leere HTML-Tabellenzeile
darstellt:
• Quellknoten anklicken und per Drag&Drop auf das xsl:for-each-Element ziehen, um
einen XPath-Ausdruck zu erzeugen.
Im Beispiel: Camera-Element und xsl:for-each-Element verbinden, um jeden
Kamera-Datensatz in einer eigenen Zeile abzubilden.
5. Mit xsl:value-of Knoteninhalte vom Quelldokument ins Zieldokument übernehmen.
• Quellknoten anklicken und per Drag&Drop auf den Zielknoten ziehen.

4. Prozesse modellieren
51
Im Beispiel: Name-Element und erstes td-Element, Description mit dem zweiten td-
Element und Preis mit dem dritten td-Element verbinden.
Für jede Verbindung wird eine Linie im Verknüpfungsbereich angezeigt.
6. In die Source-Ansicht wechseln, um weitere XSLT-Funktionen einzusetzen.
Im Beispiel: Die Elementinhalte von Preis und Währung sollen über die Funktion concat
zusammengeführt werden.
• Registerkarte Source wählen, um das XSL-Mapping im Quelltext anzuzeigen.
• XSLT-Syntax bearbeiten, im Beispiel die Zeile ersetzen durch: .
• STRG+S drücken, um das XSL-Mapping zu speichern.
•
In der Symbolleiste
7. XSL-Mapping in den Prozess einfügen.
klicken, um das XSL-Mapping testweise auszuführen.
• Das XML-Quelldokument aus dem Repository Navigator per Drag&Drop in den
geöffneten Prozess ziehen.
Im Beispiel: zwischen XML-Dokument und Stop-Baustein einfügen.
Ein einfaches Mapping von XML nach HTML wurde erstellt. Wenn der Prozess ausgeführt
wird, werden nun im Beispiel die XML-Daten in eine HTML-Seite transformiert.
4.3.6 Variable verwenden
In Variablen lassen sich temporär Daten speichern, während ein Prozess ausgeführt wird.
Jede Variable muss zunächst initialisiert werden, also einen eindeutigen Namen erhalten
und mit einem Wert belegt werden (Put-Operation). In späteren Prozess-Schritten kann
dann per Get-Operation auf die Variable zugeriffen werden. Schließlich können Variablen-
Inhalte über die Remove-Operation aus dem Speicher gelöscht werden.
Variable einfügen
1. Aus der Palette eine Variable per Drag&Drop in den Prozess ziehen.

4. Prozesse modellieren
52
Im Beispiel: Variablen-Symbol
Baustein einfügen.
per Drag&Drop zwischen dem Mapping und den Stop-
2. In der Properties-Sicht die Eigenschaften festlegen, um die Variable zu initialisieren.
• In Name einen eindeutigen Variablennamen eingeben (z.B. Put E-Mail).
• In Operation den Wert Put wählen, um die Daten aus dem vorangegangenen Prozess-
Schritt in die Variable zu laden.
Die Variable wurde nun angelegt und kann verwendet werden.
Weitere Operationen mit Variablen
• Variablen-Inhalt in späteren Prozess-Schritten auslesen: Die Variable mit demselben
Namen erneut einfügen und die Eigenschaft Operation auf Get setzen.
• Variablen-Inhalt aus dem Speicher löschen: Die Variable mit demselben Namen erneut
einfügen und die Eigenschaft Operation auf Remove setzen.
• Innerhalb von XSL-Mappings auf Variablen mittels context://-Protokoll (siehe X4
Reference Manual in Abschnitt 3.2 Context Protocol).
4.3.7 Subprozess anlegen
Bei umfangreicheren Prozessen ist es sinnvoll, einzelne Segmente in Subprozesse zu
modularisieren. So wird der Prozess übersichtlicher und die Subprozesse lassen sich
mehrfach verwenden. Prozesse lassen sich nahezu beliebig tief ineinander verschachteln.
Subprozesse werden als separate .wrf-Dateien gespeichert.
Prozesse lassen sich wie andere Prozess-Bausteine per Drag&Drop aus dem Repository
Navigator in die Zeichnungsfläche des Prozess-Designers ziehen.
Prozess-Bausteine als Subprozess auslagern
1. Prozess-Bausteine (mindestens 2) markieren, die ausgelagert werden sollen.
Im Beispiel: Den Transfer-Adapter, den Funktions-Adapter und das XML-Dokument
gleichzeitig auswählen.
2. Funktion Pack as nested process aufrufen.
• Auf der Zeichnungsfläche rechtsklicken, um das Kontextmenü aufzurufen.
• Im Kontextmenü Pack as nested process wählen, um den Wizard aufzurufen.
• Im Fenster Process File Naming den Zielordner wählen und in File Name den
Dateinamen des Subprozesses eingeben.
• Finish klicken.
Der Subprozess mit den markierten Bausteinen wird als separater Prozess-Baustein
angelegt. Im Hauptprozess werden die gewählten Bausteine automatisch durch den neu
angelegten Prozess-Baustein ersetzt.
4.3.8 Gabelung (Fork) und Zusammenführung (Join) einfügen

4. Prozesse modellieren
53
Um zwei oder mehrere voneinander unabhängige Anweisungen zu starten, können Sie
eine Gabelung (Fork-Baustein) verwenden. Die Anweisungen können dann auf denselben
Input, etwa die Daten eines vorherigen Prozess-Bausteins, zugreifen.
Wieder zusammenführen können Sie die separaten Anweisungen mit einem Join-
Baustein. Eine Anweisung innerhalb einer Gabelung kann aus beliebig vielen Prozess-
Schritten bzw. Bausteinen bestehen.
Abbildung 4.1: Gabelung (Fork) und Zusammenführung (Join)
Die Anweisungen innerhalb einer Gabelung werden nicht parallel abgearbeitet, sondern
anhand einer Priorität gesteuert, die an den Übergängen durch eine Zahl dargestellt wird.
Die Priorität der Anweisungen können Sie in den Eigenschaften des Übergangs festlegen:
1. Fork-Baustein einfügen, um mehrere voneinander unabhängige Anweisungen zu
definieren.
• Aus der Palette einen Fork-Baustein per Drag&Drop in den Prozess ziehen.
• Übergang vom vorherigen Prozess-Baustein zum Fork-Baustein herstellen.
• Übergänge vom Fork-Baustein zu mindestens 2 dahinter liegenden Anweisungen
herstellen.
2. Prioriäten der einzelnen Anweisungen festlegen, um die Ausführ-Reihenfolge festzulegen.
• Übergang anklicken und in der Properties-Sicht in Priority den gewünschten Rang
auswählen. 1 entspricht dabei der höchsten Priorität, die gewählte Anweisung wird
also zuerst ausgeführt.
• Wenn Sie Übergänge beschriften möchten, um das Prozess-Diagramm lesbarer zu
gestalten: Einen Übergang anklicken und in der Properties-Sicht in Label einen
Beschriftungstext eingeben.
3. Join-Baustein per Drag&Drop auf die Zeichnungsfläche ziehen und Übergänge
hinzufügen.
Die Anweisungen innerhalb der Gabelung werden nun in der angegebenen Reihenfolge
ausgeführt.
4.3.9 Daten mit Merge zusammenführen

4. Prozesse modellieren
54
In vielen Fällen ist es sinnvoll, dass Daten, die aus unterschiedlichen Quellen stammen,
in einem einzigen XML-Dokument zur Verfügung stehen. Der Merge-Baustein wird meist
hinter der Zusammenführung einer Gabelung (Join) verwendet, um die dort verarbeiteten
Daten zu vereinen. Die durch einen Merge-Baustein erzeugte XML-Struktur enthält
ein Root-Element , das die verschiedenen XML-Daten der Quellen enthält,
beispielsweise:
...
Um Daten in einem XML-Dokument zusammenzuführen, ziehen Sie aus der Palette einen
Merge-Baustein per Drag&Drop hinter einen Join-Baustein. Weitere Einstellungen sind
nicht notwendig.
4.3.10 Bedingungen und Verzweigungen mit Condition erstellen
Mit dem Condition-Baustein können Sie Verzweigungen im Prozess abbilden, wobei
jeder Zweig eine Bedingung enthält. Wird der Prozess ausgeführt, werden die Daten aus
dem vorangegangenen Prozess-Schritt ausgewertet und es wird eine Fallunterscheidung
getroffen.
So kann beispielsweise überprüft werden, ob eine Adapter-Datenquelle noch Daten liefert,
andernfalls wird der Prozess auf einen Stop-Baustein umgeleitet und damit beendet. Auch
Schleifen können so implementiert werden.
1. Condition-Baustein einfügen, um Verzweigungen definieren zu können.
• Aus der Palette einen Condition-Baustein per Drag&Drop in den Prozess ziehen.
• Übergang vom vorherigen Prozess-Baustein zum Condition-Baustein herstellen.
• Übergänge vom Condition-Baustein zu mindestens 2 verschiedenen dahinter
liegenden Anweisungen herstellen.
2. Condition-Baustein doppelklicken, um den Condition Editor aufzrufen.

4. Prozesse modellieren
55
3. Bedingungen für jede Verzweigung festlegen.
Wenn Sie für eine Verzweigung keine Bedingung festgelegt haben, dann wird
diese immer ausgeführt. Dies wird durch ein verändertes Symbol des Condition-
Bausteins dargestellt.
• Auf einen Übergang hinter dem Condition-Baustein klicken, um eine Verzweigung zu
wählen.
Der gewählte Übergang wird nun mit einer dicken, rot gestrichtelten Linie dargestellt.
• Auf Insert logical operations ... klicken, um die Bedingung bearbeiten zu können.
Jede Bedingung kann aus mehreren Bedingungselementen bestehen, die
Sie über logische Operatoren (AND, OR und NOT) verknüpfen können.
Bedingungselemente können Sie über die entsprechenden Schaltflächen links
im Condition-Bereich einfügen.
• In If result of den Prozess-Baustein auswählen, dessen Daten bedingt verarbeitet
werden sollen.
Hier stehen sämtliche Bausteine des Prozesses zur Auswahl. Verwenden Sie
denjenigen, der unmittelbar vor dem Condition-Baustein steht.
• Vergleichsoperator wählen (

4. Prozesse modellieren
56
mit put eine Variable vor der Schleife, die sie innerhalb der Schleife mit get
auslesen und am Ende der Schleife wieder mit put überschreiben.
4.3.11 Datenbank-Verbindung herstellen
Um innerhalb eines X4-Prozesses eine Verbindung zu relationalen Datenbanken (z.B.
Oracle, MSSQL) aufzubauen, sind zwei Prozess-Bausteine notwendig:
• Im SQL-Anweisungs-Baustein (SQL Query) definieren Sie die Operation, die auf der
Datenbank ausgeführt werden soll, beispielsweise eine SELECT-Abfrage oder eine
UPDATE-Anweisung. Diese SQL-Anweisungen werden in einer spezifischen XML-
Struktur im Prozess-Baustein gespeichert und an den darauffolgenden Prozess-
Baustein weitergegeben.
• Im Datenbank-Verbindungs-Baustein (Database Connection) wird nun eine
Verbindung zur Datenbank aufgebaut. Dies erfolgt entweder direkt per JDBC oder über
eine DataSource-Verbindung innerhalb der J2EE-Plattform. Dieser Prozess-Baustein
gibt Daten im XML-Format aus.
Beispiel: Es soll eine Verbindung zu einer HSQL-Datenbank, die zum Installationsumfang
des X4 Servers gehört, über eine DataSource hergestellt werden.
1. Im Repository Navigator eine Datenbank-Verbindung anlegen.
• Auf den Projektordner rechtsklicken, um das Kontextmenü aufzurufen.
• Im Kontextmenü New > Database Connection aufrufen, um den File Creation
Wizard zu öffnen.
• Im File Creation Wizard den Zielordner wählen und in File Name den Dateinamen
eingeben, Finish klicken.
Die Datenbank-Verbindung wurde angelegt und wird zum Konfigurieren geöffnet.
2. Datenbank-Verbindungstyp wählen und Verbindungs-Parameter definieren.

4. Prozesse modellieren
57
• In Database Access Interface zwischen JDBC oder DataSource (J2EE) wählen, um
den Datenbank-Verbindungstyp festzulegen.
Im Beispiel: DataSource (J2EE) wählen, um auf eine in X4 integrierte HSQL-
Datenbank zuzugreifen.
Eine Parameter-Beschreibung für JDBC-Verbindungen finden Sie im X4
Reference Manual (englischsprachig), im Abschnitt 2.3.1 JDBC Connection.
• In DataSource ID den Namen der gewünschten DataSource eingeben.
Im Beispiel: java:DefaultDS eingeben.
• Test Connection klicken, um den korrekten Verbindungsaufbau zu prüfen.
• STRG+S drücken, um die Datenbank-Verbindung speichern.
3. SQL-Anweisung erstellen und testen.
• Auf den Projektordner rechtsklicken, um das Kontextmenü aufzurufen.
• Im Kontextmenü New > SQL Query aufrufen, um den File Creation Wizard zu
öffnen.
• Im File Creation Wizard den Zielordner wählen und in File Name den Dateinamen
eingeben, Finish klicken.
Eine leere SQL-Anweisung wurde angelegt und wird zum Konfigurieren geöffnet.
• In Connection die Datenbank-Verbindung auswählen, um die SQL-Anweisung in
dieser Ansicht testen zu können.
• Im mittleren Textfeld die eigentliche SQL-Anweisung eingeben.

4. Prozesse modellieren
58
Im Beispiel: SELECT * FROM JMS_ROLES eingeben.
• Mehrere SQL-Anweisungen speichern: Auf Add klicken. Die verschiedenen
SQL-Anweisungen werden dann beim Ausführen dieses Prozess-Bausteins
hintereinander abgearbeitet und in einem einzigen XML-Dokument als
Ergebnis ausgegeben.
• Alle umschließenden XML-Elemente umbenennen: In Result Element
den gewünschten Element-Namen eingeben. Im ausgegebenen XML-
Dokument wird dann das Elternelement aller Datenzeilen ersetzt.
• Zahl der Datensätze beschränken: Use Cursor aktivieren und in Fetch
Size die Anzahl der gewünschten Datensätze angeben, die bei der SQL-
Anweisung ausgegeben werden sollen.
• Execute Query klicken, um die SQL-Anweisung zu testen.
Die Ergebnisse der SQL-Anweisung werden in der Registerkarte Data tabellarisch, in
der Registerkarte XML in der generierten XML-Struktur angezeigt.
• STRG+S drücken, um die Datenbank-Verbindung speichern.
Vorlagen für Datenbank-Mappings erstellen: Execute Query klicken, dann auf
Generate INSERT Template, Generate UPDATE Template oder Generate
DELETE Template klicken. Dann werden XML-Dokumente angelegt, die
Strukturinformationen einer SQL-Anweisung enthalten.
Ergebnis der SQL-Anweisung als XML-Dokument speichern: Save Result XML
klicken.
4. Im Prozess den Datenbank-Verbindungsbaustein hinter den SQL-Anweisungs-Baustein
anordnen.
• Den SQL-Anweisungs-Baustein aus dem Repository Navigator per Drag&Drop in den
Prozess ziehen.
• In der Properties-Sicht in Operation Read wählen.
• Den Datenbank-Verbindungs-Baustein hinter dem SQL-Anweisungs-Baustein in den
Prozess einfügen.
Die SQL-Anweisung kann nun mit der darauf folgenen Datenbank-Verbindung
ausgeführt werden.
4.4 Prozess-Bausteine parametrieren
In diesem Abschnitt erfahren Sie, wie Prozess-Bausteine parametriert bzw. konfiguriert
werden können, um in Prozessen verwendet zu werden. Außerdem wird die Möglichkeit
beschrieben, innerhalb eines Prozesses Platzhalter zu verwenden und Parameter
dynamisch zu setzen, um den Prozess weiter zu automatisieren.
4.4.1 Parametrierungs-Möglichkeiten

4. Prozesse modellieren
59
Es gibt folgende Möglichkeiten, je nach Anwendungszweck Prozess-Bausteine zu
parametrieren:
• Repository-Dateien konfigurieren: Prozess-Baustein-Dateien aus dem Repository per
Doppelklick im jeweiligen Editor öffnen (z. B. Funktions-Adapter im Adapter-Editor,
XML-Dokumente im XML-Editor).
Bearbeitungen werden in der entsprechenden Datei im Repository gespeichert.
• Eigenschaften bearbeiten: Die Prozess-Bausteine eines geöffneten Prozesses in der
Properties-Sicht anpassen (z. B. die Eigenschaft Operation setzen).
Diese Konfiguration wird im geöffneten Prozess gespeichert.
• Benutzerdefinierte Parameter mit Platzhaltern verwenden: Für einige Bausteine eines
Prozesses lassen sich benutzerdefinierte Parameter (Custom Parameters) definieren
(siehe Abschnitt 4.4.2, „Benutzerdefinierte Parameter setzen “).
Diese Konfiguration wird im geöffneten Prozess gespeichert.
Als benutzerdefinierte Parameterwerte können Sie eine Reihe von in X4 vordefinierten
Platzhalter verwenden, die zur Laufzeit des Prozesses gesetzt werden. Platzhalter sind
z. B. %PID% (aktuelle Prozess-ID) oder %NOW% (aktuelles Datum und Uhrzeit).
• Dynamische Parameter erzeugen: Innerhalb eines Prozesses können Sie in
Abhängigkeit von verarbeiteten Daten mit dynamischen Parametern verschiedene
Prozess-Bausteine ansteuern und mit ConditionState Statusinformationen erzeugen,
die von Bedingungen (Condition-Bausteinen) ausgewertet werden. Dynamische
Parameter werden in XSL-Mappings als Processing Instruction erzeugt und vom
darauf folgenden Prozess-Baustein (z.B. einem Transfer-Adapter) verarbeitet (siehe
Abschnitt 4.4.3, „Dynamische Parameter erzeugen “).
Die Konfiguration wird zur Laufzeit des Prozesses dynamisch erzeugt.
• Dynamische Parameter über iXmap-Datei erzeugen (veraltet): Sie können statt der
ProcessingInstructions-Implementierung auch mit einem XSL-Mapping ein XML-
Dokument erzeugen, das DynamicParameter, ConditionState etc. enthält. Mehr
Informationen finden Sie im X4 Reference Manual (englischsprachig) im Abschnitt
5.1.3 Legacy Process Control Mappings with iXmap.
Priorisierung der Parameter
Beachten Sie folgende Priorisierung bei der Parametrierung:
• Benutzerdefinierte Parameter (Custom Parameters) überschreiben die Konfiguration
von Prozess-Bausteinen im Repository (beispielsweise Funktions-Adapter).
• Dynamische Parameter überschreiben gesetzte benutzerdefinierte Parameter und
die Konfiguration von Prozess-Bausteinen im Repository (beispielsweise Funktions-
Adapter).
4.4.2 Benutzerdefinierte Parameter setzen
Für bestimmte Prozess-Bausteine eines geöffneten Prozesses (für XSL-Mappings, Reports,
Datenbank-Verbindungen, Transfer- und Funktions-Adapter) lassen sich benutzerdefinierte
Parameter (Custom Parameters) definieren.

4. Prozesse modellieren
60
Als benutzerdefinierte Parameterwerte können Sie eine Reihe von in X4 vordefinierten
Platzhalter verwenden, die zur Laufzeit des Prozesses gesetzt werden. Platzhalter sind z. B.
%PID% (aktuelle Prozess-ID) oder %NOW% (aktuelles Datum und Uhrzeit).
1. Fenster Custom Parameters aufrufen, um benutzerdefinierte Parameter zum Prozess-
Baustein bearbeiten zu können.
• Prozess-Baustein im Prozess-Designer markieren.
• In der Properties-Sicht bei Custom Parameters auf [ ] klicken, um anzuzeigen.
• klicken, um das Fenster Custom Parameters aufzurufen.
2. In Name den Namen des benutzerdefinierten Parameters eingeben.
• XSL-Mappings und Reports: Im Stylesheet können Sie den hier gesetzten Namen
als Parameter ansprechen und den zugehörigen Wert übergeben, z. B. einen
benutzerdefinierten Parameter PDFPath mit .
• Adapter und Datenbank-Verbindungen: Die Bezeichnung des zu überschreibenden
Parameters verwenden, z. B. bei einem XPath-Adapter-Baustein den Parameter-Namen
XPath.
3. In Value den zu überschreibenden Parameter-Wert eingeben.
Hier können Sie Platzhalter einfügen, die beim Ausführen des Prozesses von X4 durch die
jeweils aktuellen Werte ersetzt werden, z. B. %PID% durch die aktuelle Prozess-ID.
Eine vollständige List der verfügbaren Platzhalter finden Sie im X4 Reference
Manual (englischsprachig) im Abschnitt 2.1 Parameter Placeholders.
4. Wenn notwendig weitere benutzerdefinierte Parameter verwalten:
• Add klicken, um weitere benutzerdefinierte Parameter hinzuzufügen.
• Remove klicken, um benutzerdefinierte Parameter aus der Liste zu löschen.
• Mit Up und Down können Sie die Reihenfolge der Parameter in der Liste verändern.
5. OK klicken, um die benutzerdefinierten Parameter anzulegen.
4.4.3 Dynamische Parameter erzeugen

4. Prozesse modellieren
61
Innerhalb eines Prozesses können Sie in Abhängigkeit von verarbeiteten Daten mit
sogenannten dynamischen Parametern Prozess-Bausteine ansteuern und bereits gesetzte
Parameter überschreiben. Dynamische Parameter werden in XSL-Mappings als Processing
Instruction erzeugt und vom darauf folgenden Prozess-Baustein (beispielsweise einem
Transfer-Adapter) verarbeitet.
1. XSL-Mapping im Prozess vor dem zu parametrierenden Adapter oder Datenbank-
Verbindung positionieren.
Hierbei haben Sie mehrere Möglichkeiten:
• Ein einzelnes XSL-Daten-Mapping einsetzen, das XML-Daten transformiert und
gleichzeitig dynamisch Processing-Instruction-Definitionen enthält.
• Ein separates XSL-Mapping, das nur die Process-Instructions generiert, beispielsweise
wenn eine Datei untransformiert an einen Transfer-Adapter übergeben werden soll.
In diesem Fall ist es erforderlich, eine Gabelung (mithilfe von Fork- und Join-
Bausteinen) zu verwenden; in eine Anweisung der Gabelung setzen Sie das XSL-
Mapping, in eine zweite Anweisung den zu übergebenden Prozess-Baustein.
2. Processing Instruction im XSL-Mapping nach folgendem Muster definieren:
ParameterName="ParameterValue"
3. ParameterName durch den gewünschten Parameter-Namen ersetzen.
Eine Beschreibung der Parameter für Transfer- und Funktions-Adapter sowie
für Datenbankverbindungs-Bausteine finden Sie im X4 Reference Manual
(englischsprachig) in den Abschnitten 2.2 Transfer Configuration bis 2.4 Adapter
Configuration.
4. ParameterValue durch den gewünschten Wert ersetzen, meist in Form eines XSL-Befehls.
5. Wenn das XSL-Mapping ausschließlich dynamische Parameter erzeugen soll: Zusätzlich
mit festlegen, dass das XSL-
Mapping kein Ergebnis-Dokument erzeugt.
Beachten Sie zudem, dass das XSL-Mapping ein Wurzel-Element generieren muss, damit
das XSL-Mapping ausgeführt und ein gültiges XML-Dokument erzeugt werden kann.
Beispiel
Ein aus einer XML-Datei ausgelesener Dateiname soll als dynamischer Parameter an einen
Filesystem-Transfer-Adapter übergeben werden.

4. Prozesse modellieren
62
Abbildung 4.2: Filesystem-Transfer-Adapter per XSL-Mapping ansteuern
Im Beispiel besteht das XSL-Mapping aus folgendem Quelltext:
Abbildung 4.3: Dynamisch gesetzter Dateiname für den FileSystem-Transfer-Adapter
Weitere Processing Instructions
Analog zu den oben beschriebenen dynamischen Parametern können Sie in XSL-Mappings
weitere Processing Instructions definieren, die von X4 ausgewertet werden.
• ConditionState: dynamisch generierte Statusinformationen, die von
Bedingungen (Condition-Bausteinen) ausgewertet werden (siehe Abschnitt 4.4.4,
„Statusinformationen mit ConditionState erzeugen “).
• LogInfo: benutzerdefinierte Ausgaben ins Log erzeugen
• NoResult: die Ausgabe eines Ergebnis-Dokuments mit unterdrücken.
Eine ausführliche Beschreibung dieser Processing Instructions finden Sie im X4
Reference Manual (englischsprachig) im Abschnitt 5.1.2.1 Processing Instructions
Implementation.
4.4.4 Statusinformationen mit ConditionState erzeugen
Mit einem XSL-Mapping können Sie abhängig von verarbeiteten Daten
Statusinformationen als Processing Instruction erzeugen, die von einem Condition-
Baustein ausgewertet werden. Je nach Status können Sie so entsprechend definierte
Verzweigungen ausführen lassen.
1. Leeres XSL-Mapping im Prozess vor einem Condition-Baustein positionieren.
2. Processing Instruction(s) im XSL-Mapping nach folgendem Muster definieren:

4. Prozesse modellieren
63
value
3. value durch einen Wert aus dem verarbeiteten XML-Dokument ersetzen.
Beispiel:
Zulässige Werte für value sind ganze Zahlen (Integer) sowie -1 für einen
Fehlerstatus.
Nicht zulässig sind folgende Status-Nummern, da diese systemintern reserviert
sind:
• -999 (Status-ID für Stop-Baustein)
• -2 (systemintern reserviert)
• 999 (Status-ID für noch nicht ausgeführte Prozess-Bausteine)
4. Beachten Sie zudem, dass das XSL-Mapping ein Wurzel-Element generieren muss, damit
das XSL-Mapping ausgeführt und ein gültiges XML-Dokument erzeugt werden kann.
Das XSL-Mapping gibt nun Processing Instructions nach dem Muster aus, z.B. aus.
5. Im nachfolgenden Condition-Baustein für jede Verzweigung einen erzeugten Status
auswerten (siehe Abschnitt 4.3.10, „Bedingungen und Verzweigungen mit Condition
erstellen “).
• Auf einen Übergang hinter dem Condition-Baustein doppelklicken, um den Condition
Editor zu öffnen.
• Auf Insert logical operation ... klicken, um eine Bedingung zu definieren.
• In If result of das XSL-Mapping wählen.
• In is einen Vergleichsoperator wählen und rechts den zu prüfenden Wert eingeben.
Das XSL-Mapping lässt sich nicht ausführen Möglicherweise hat dies folgende
Ursachen:
• Der verarbeitete Wert ist -999, -2, 999 oder eine Zeichenkette (String).
• Das vom XSL-Mapping erzeugte XML-Dokument enthält kein Wurzel-
Element; Fügen Sie z.B. hinter die ConditionState-Definitionen ein.
4.5 Prozesse debuggen und ausführen
In diesem Abschnitt erfahren Sie, wie Sie erstellte Prozesse auf Fehler überprüfen
(debuggen) und auf dem X4 Server ausführen können. Hierfür gibt es zwei Modi:
• Im Run-Modus wird der Prozess direkt ausgeführt; in der Run/Debug Console-Sicht
werden Log-Mitteilungen des X4 Servers angezeigt.
• Im Debug-Modus werden zu jedem ausgeführten Prozess-Schritt detaillierte
Statusinformationen in der Run/Debug Console-Sicht ausgegeben.
4.5.1 Prozess debuggen (Debug-Modus)

4. Prozesse modellieren
64
Während der Prozess-Entwicklung können Sie direkt im Prozess-Designer Ihre Prozesse
auf syntaktische Fehler der einzelnen Prozess-Bausteine überprüfen.
1. Falls gewünscht, Debug-Haltepunkte (Breakpoints) setzen, um bei kritischen Prozess-
Schritten das Debugging automatisch anzuhalten.
2.
• Im Prozess-Designer den gewünschten Prozess-Baustein anklicken.
•
In der Symbolleiste
(Toggle Breakpoint) klicken.
(Start Debug) klicken, um den Prozess im Debug-Modus zu starten.
Wenn ein Parameter (meist der Operation-Parameter) nicht gesetzt wird, kommt sofort
eine Fehlermeldung. Der betroffene Prozess-Baustein erhält ein Warndreieck.
3.
(Step Into) klicken, um den nächsten Einzelschritt auszuführen und anzuzeigen (auch
in Subprozessen).
Zu jedem ausgeführten Prozess-Schritt wird ein Eintrag in der Debug-Sicht angezeigt.
Fehlermeldungen werden rot hervorgehoben, erfolgreiche Statusmeldungen sind grün.
Außerdem wird jeweils eine temporäre Ausgabe-Datei angelegt, die Sie über den
entsprechenden Verweis ansehen können (beispielsweise file://1244017505671).
4.
Wenn ein Fehler auftritt, wird der Debug-Modus abgebrochen.
Mit
(Terminate) können Sie den Debug-Modus bei Bedarf manuell beenden.
4.5.2 Prozess ausführen (Run-Modus)
Sie können Prozesse direkt aus dem X4 Front-End heraus aufrufen. Dabei wird der Prozess
auf dem X4 Server ausgeführt und es werden keine Debug-Informationen erzeugt.
Um Prozesse auszuführen, gibt es mehrere Möglichkeiten:
•
Geöffnete Prozesse starten: In der Symbolleiste auf
(Run X4 Process) klicken.
• Im Repository Navigator: Den Prozess rechtsklicken, im Kontextmenü Run X4 Process
wählen.
• Als Subprozess: Dieser wird automatisch vom übergeordneten Prozess aufgerufen
• Zeitgesteuert ausführen: Mithilfe des Schedule-Eigenschaft des Prozesses zu
festgelegten Zeiten starten (siehe Abschnitt 4.5.3, „Prozess mit Scheduler zeitgesteuert
ausführen “)

4. Prozesse modellieren
65
4.5.3 Prozess mit Scheduler zeitgesteuert ausführen
Für jeden Prozess können Sie über den Scheduler festlegen, ob er zeitgesteuert aufgerufen
werden soll. Dies ist bei Routine-Aufgaben wie dem täglichen Datenabgleich mit einem
Datenlieferanten zu einer bestimmten Uhrzeit sinnvoll.
Sie können die automatische Ausführung auf ein bestimmtes Zeitfenster begrenzen, den
Prozess in frei definierbaren Zeitabständen unendlich oft wiederholen lassen oder eine
maximale Anzahl von Durchläufen definieren.
Die Zeitpläne werden zentral auf dem X4 Server in /X4DB/0/
schedule.xml gespeichert. Ein geöffnetes X4 Front-End ist also nicht erforderlich, um
Prozesse zeitgesteuert auszuführen.
1. Gewünschten Prozess im Prozess-Designer öffnen und auf einen leeren Bereich auf der
Zeichnungsfläche klicken.
2. In Properties auf Schedule not set klicken.
Wenn bereits ein Zeitplan für diesen Prozess festgelegt wurde, wird stattdessen Schedule
set angezeigt.
Das Fenster Process Run Schedule wird geöffnet.
3. Startzeitpunkt festlegen:
• Start process aktivieren.
• Rechts daneben das Datum und die Uhrzeit festlegen.
4. Wenn der Prozess periodisch ausgeführt werden soll, Ausführintervall festlegen:
• Start next on every aktivieren.
• Rechts daneben einen Zahl eingeben.
• Im Auswahlmenü die gewünschte Zeiteinheit auswählen (Sekunden, Minuten,
Stunden, Tage, Wochen, Monate oder Jahre).
Der Prozess wird nun im angegebenen Zeitabstand endlos wiederholt ausgeführt.
5. Wenn Sie eine maximale Anzahl von Durchläufen definieren möchten, die Zahl der
Durchläufe festlegen:
• End after wählen.
• Rechts daneben die maximale Anzahl von Durchläufen eingeben.

4. Prozesse modellieren
66
6. Wenn Sie einen Endzeitpunkt für das zeitgesteuerte Ausführen definieren möchten:
• End by wählen.
• Rechts daneben das Datum und die Uhrzeit festlegen.
7. OK klicken, um den Zeitplan zu speichern.
Der Zeitplan ist nun im Prozess hinterlegt und wird auf dem Server gespeichert. Zur
festgelegten Zeit wird der Prozess nun automatisch ausgeführt.
Der Parameter In Service des Prozesses muss aktiviert sein, damit der Prozess
zeitgesteuert gestartet werden kann!

5. Neu in X4 Version 4.0
67
5 Neu in X4 Version 4.0
In diesem Abschnitt wird beschrieben, welche neuen Funktionen und Eigenschaften der X4
Enterprise Service Bus in Version 4.0 besitzt und wie Sie diese nutzen können.
5.1 X4 Server
In diesem Abschnitt lernen Sie die wichtigsten Neuerungen und Änderungen des X4
Servers kennen.
5.1.1 Neue Funktionen
• EDIFACT-Adapter: Mit dem neuen EDIFACT-Adapter können zusätzliche
Nachrichtentypen DIN ISO 9735-konform erstellt und verarbeitet werden. Er
ermöglicht eine generische Konvertierung zwischen dem EDIFACT-Datenformat und
XML.
• BIPRO-Adapter: Der neue BiPRO-Adapter ermöglicht die automatisierte Anbindung
von Versicherungsunternehmen und Maklern. Via WebServices können so Angebote,
Anträge und Tarifierung sicher abgewickelt werden. Der BiPRO-Adapter besteht aus X4
Prozess-Vorlagen, die leicht an unternehmensspezifische Workflows angepasst werden
können.
• Datenbank-Adapter wurde wie folgt verbessert:
• Performance-Verbesserungen um bis zu Faktor 10 durch die Funktionen Batch
Insert, Batch Update und Batch Delete.
• Der Umgang mit Datumsformaten wurde verbessert.
• ImageToImage-Adapter zum Konvertieren von Bilddateien wurde hinzugefügt.
• Word2PDF-Adapter wurde wie folgt verbessert:
• Adapter kann nun ohne Zugriff auf das Dateisystem komplett im Arbeitsspeicher
ausgeführt werden.
• Der Word2PDF-Adapter kann nun mehrere Input-Dokumente verarbeiten.
• PDFToTiff-Adapter (PDF Tiff Image) wurde hinzugefügt und besitzt nun folgende
Funktionen:
• Umwandlung von PDF-Dateien in TIFF-Bilddateien.
• TIFF-Dateien mit mehreren Seiten können erzeugt werden.
• TiffToPDF-Adapter wurde hinzugefügt.
• TCPStarter wurde hinzugefügt, der an einem Port horcht und Prozesse mit den
übergebenen Daten startet.
• E-Mail-Transferadapter erhält folgende neue Funktionen:
• Base64-Kodierung beim Empfang von E-Mails ist nun über einen Parameter immer
möglich.
• Priorität von E-Mails kann gesetzt werden.
• Direkter Versand von EML-Nachrichten ist nun möglich.
• IMAP-Adapter wurde folgendermaßen verbessert:

5. Neu in X4 Version 4.0
68
• Neuer Parameter zur Base64-Kodierung beim Empfang von E-Mails wurde
hinzugefügt.
• Ineinander verschachtelte E-Mails können nun verarbeitet werden.
• FTP- und SFTP-Adapter: eine Operation Rename wurde hinzugefügt.
• Weitere Adapter wurden hinzugefügt:
• BAM-Adapter (Verbindung zu X4 Business Activity Monitoring) wurde hinzugefügt.
• XMLSignatureValidator-Adapter wurde zu den bereits bestehenden
Sicherheitsfunktionen hinzugefügt.
• TIFFProperties-Adapter zum Lesen von TIFF-Eigenschaften wurde hinzugefügt.
• X4 SAP-Adapter erhält nun folgende Funktionen:
• Konfiguration der Verschlüsselung für den SAP-Adapter ist nun über X4config
möglich.
• Ein Fehlerstatus wird erzeugt, wenn kein BAPI aufgerufen werden kann.
• Die Parameter ConnectionPoolTimeout und ConnectionPoolTimeoutCheck sind
nun verfügbar.
• Der Adapter gibt nun -1 aus, wenn IDoc nicht korrekt gesetzt ist.
• Transaction Handling für JCoServer wird nun unterstützt.
• Syntax-Prüfung ist für IDocs nun abschaltbar.
• Ungültige Zeichen in XML werden nun korrekt behandelt.
• Zentrale Verschlüsselungs-Konfiguration über die X4config ist nun möglich.
• JMS Transfer-Adapter wurde wie folgt erweitert:
• Eine List-Methode wurde hinzugefügt.
• Beim Empfangen liefert der Parameter toXML nun immer Base64-kodierte Daten.
• XPath-Adapter lässt sich nun zurücksetzen.
• COBOL Copy Book Reader-Adapter verwendet nun reguläre Ausdrücke.
• Message Queue-Adapter (Websphere MQ) wurde wie folgt verbessert:
• Wenn die Operation Receive gewählt wird, die Parameter toXML auf true und
MessageFormat auf NONE gesetzt werden, dann wird die Nachricht immer Base64-
kodiert.
• Alias-Konfiguration der Verschlüsselung ist nun über X4config möglich.
• Timehelper: Neue XSLT-Hilfsklasse zur Zeitberechnung wurde hinzugefügt.
• Transaktionen: Das Timeout-Verhalten lässt sich nun kontrollieren.
• HTTPStarter: Daten können einfacher im Body an den Prozess übergeben werden.
• Neue Platzhalter wurden hinzugefügt:
• %CURRENT_PROJECT%: Aktuelles Projekt
• %ACTION_ID%: ID des aktuellen Prozess-Bausteins
• Kompatibilität mit alternativen VMs: HTTPS-Verbindungen werden von verschiedenen
Java Virtual Machines, die nicht von Sun stammen, unterstützt, wenn kein Keystore
übergeben wird.

5. Neu in X4 Version 4.0
69
• Folgende weitere Starter wurden hinzugefügt:
• HTTPForm: X4-Prozesse aus HTTPForms starten
• WSStarter: X4-Prozesse als WebService starten
• Weitere Neuerungen im X4 Server:
5.1.2 Behobene Fehler
• Debugging-Ausgaben wurden verbessert.
• Thread-Namen wurden zur besseren Übersicht beim Debugging vereinheitlicht.
• Sämtliche Adapter sind nun mittels externer URL konfigurierbar und
verschlüsselbar.
Im Folgenden werden die wichtigsten bekannten Fehler dargestellt, die mit X4 in der
Version 4.0 behoben wurden. Fehler können Sie unter http://bugzilla.softproject.de melden.
• Im PDFSplitter-Adapter wurden verschiedene Fehler beseitigt.
• File System-Transferadapter gibt 0 zurück, wenn eine Datei nicht gelöscht werden
konnte.
• Im Excel-Adapter wurde der Umgang mit Formeln verbessert.
5.1.3 Bekannte Probleme
Im Folgenden werden Probleme genannt, die den Entwicklern bereits bekannt sind, jedoch
zum jetzigen Zeitpunkt noch nicht behoben werden konnten.
• XSL-Editor: Wird von der Ansicht Source in Design gewechselt, dann können
Bearbeitungschritte, die in der Source-Ansicht durchgeführt wurden, nicht mehr
rückgängig gemacht werden.
5.1.4 Änderungen
Im Folgenden werden die wichtigsten Unterschiede zwischen X4 Version 3.9 und X4
Version 4.0 dargestellt.
• X4 SAP-Adapter: Struktur von gesendeten IDocs entspricht nun der Struktur von
empfangenen IDocs.
• FOP 0.95: XSL-FO-Prozessor wurde auf Version 0.95 aktualisiert. Eventuell ist es
erforderlich, Ihre Reports anzupassen.
• Verhaltensänderung von Prozessen über RMI: Prozesse, die über RMI aufgerufen
werden (z. B. Prozess-Starter-Adapter) verhalten sich nun korrekt, wenn der
Rückgabewert nicht UTF8-kodiert ist. Entfernen Sie daher die Workarounds aus Ihren
bestehenden Prozessen.
• WebServices mit Axis: AxisURL aus der X4config wird nun verwendet.
• Benutzer-ID (in X4DB) ist nun eine Zeichenkette, keine Zahl mehr.
5.2 X4 Front-End
In diesem Abschnitt lernen Sie das X4 Front-End und dessen neue Funktionen kennen.

5. Neu in X4 Version 4.0
70
5.2.1 X4 Front-End auf Eclipse-Basis
Das X4 Front-End basiert ab Version 4.0 komplett auf der flexiblen und leistungsfähigen
Entwicklungsumgebung (IDE) Eclipse. Das neue X4 Front-End greift auf zahlreiche
bekannte und bewährte Eclipse-Funktionen zurück, etwa zur XML-Darstellung.
Das X4 Front-End steht in folgenden Varianten zur Verfügung (benötigen Java Runtime
Environment 1.6):
• Eclipse-Plugin: Direkt in Ihrer gewohnten Eclipse-Umgebung X4-Prozesse modellieren,
Mappings erstellen usw.
• Standalone-Version: Das X4 Front-End als eigenständige Anwendung
Abbildung 5.1: X4 Front-End als Eclipse-Plugin
5.2.2 Refactoring: Elemente im Repository dynamisch bearbeiten
Mit den im Folgenden vorgestellten neuen Refactoring-Funktionen können Sie beim
Umbenennen und Verschieben von Dateien im X4 Repository viel Zeit sparen und Fehler
vermeiden.
5.2.2.1 Elemente umbenennen und Referenzen automatisch aktualisieren
Wenn Sie Dateien im Repository umbenennen möchten, können Sie nun die Referenzen in
den Prozessen automatisch aktualisieren lassen.
1. Auf das gewünschte Element im Repository Navigator rechtsklicken, um das
Kontextmenü zu öffnen.
2. Refactor/Rename wählen, um das Fenster Rename repository file aufzurufen.

5. Neu in X4 Version 4.0
71
3. In Rename repository resource einen neuen Dateinamen eingeben.
4. Wenn sämtliche Referenzen auf die Datei geändert werden sollen:
• Update references wählen.
• Next klicken, um anzuzeigen, in welchen Referenzen auf die umbenannte Datei
angepasst werden.
5. Finish klicken, um die gewünschten Änderungen durchzuführen.

5. Neu in X4 Version 4.0
72
5.2.2.2 Elemente verschieben und automatisch Referenzen aktualisieren
Sie können nun Elemente beliebig innerhalb von Projekten des X4 Repositorys verschieben.
Dabei können die Referenzen auf die verschobene Datei in anderen Prozessen auf Wunsch
automatisch angepasst werden.
1. Datei per Drag&Drop an die gewünschte Stelle im Repository verschieben.
Das Fenster Update references wird geöffnet.
2. Wenn sämtliche Referenzen auf die verschobene Datei geändert werden sollen:
• Yes klicken.
Das Fenster Move File Confirm wird geöffnet. Hier wird angezeigt, von welchen
Elementen im Repository die verschobene Datei verwendet wird.
• OK klicken, um die gewünschten Änderungen durchzuführen.
3. Wenn die Referenzen nicht aktualisiert werden sollen: No klicken.
5.2.2.3 Call Hierarchy: Verwendungsnachweis für Prozess-Bausteine
Zu jedem Prozess und Prozess-Baustein im X4 Repository können Sie mit der Call
Hierarchy-Funktion anzeigen, von welchen Prozessen diese verwendet werden. So
können Sie auf einen Blick sehen, welche Abhängigkeiten bestehen.
1. Im Repository Navigator das gewünschte Element rechtsklicken, um das Kontextmenü
aufzurufen.
2. Im Kontextmenü View Call Hierarchy wählen.
Als Verwendungsnachweis wird in der Call Hierarchy Viewer-Sicht eine hierarchische
Auflistung der betroffenen Prozesse angezeigt.

5. Neu in X4 Version 4.0
73
5.2.2.4 Pack as Nested Process: Subprozess anlegen
Bei umfangreicheren Prozessen ist es sinnvoll, einzelne Segmente in Subprozesse
auszulagern und den Prozess damit zu modularisieren. Mithilfe der Funktion Pack as
Nested Process erfolgt dies über das Kontextmenü im Prozess-Designer. Die so erstellten
Subprozesse lassen sich mehrfach verwenden und nahezu beliebig tief ineinander
verschachteln.
1. Im Prozess-Designer mehrere Prozess-Bausteine (mindestens 2) markieren, die ausgelagert
werden sollen.
2. Auf der Zeichnungsfläche rechtsklicken, um das Kontextmenü aufzurufen.
3. Pack as nested process wählen.
Das Fenster Process File Naming wird geöffnet.
4. Den Zielordner wählen und in File Name den Dateinamen des Subprozesses eingeben.

5. Neu in X4 Version 4.0
74
5. Finish klicken.
Der Subprozess wird mit den gewählten Bausteinen angelegt. Im Hauptprozess werden die
gewählten Bausteine durch den neu angelegten Subprozess ersetzt.
5.2.3 Prozess-Dokumentation automatisch erzeugen
Mit den im Folgenden vorgestellten Prozess-Dokumentations-Funktionen können Sie
für jeden Prozess im Repository während des Entwicklungsprozesses automatisch eine
Dokumentation im HTML-Format erzeugen.
5.2.3.1 Prozess-Dokumentation in X4
Diese Prozess-Dokumentation enthält zu jedem Prozess-Baustein (nun auch zu XSL-
Mappings) sämtliche Parameter und stellt das Prozess-Diagramm in Form einer SVG-Datei
dar.
Möglichkeiten um Prozess-Dokumentation zu erzeugen:
• Export: Prozess-Dokumentation zu Projekten oder einzelnen Ordnern im X4 Repository
mit dem Generate Process Documentation Wizard ins Dateisystem exportieren
(siehe Abschnitt 5.2.3.2, „Prozess-Dokumentation ins Dateisystem exportieren “)
• Vorschau: Dokumentation zu einem Subprozess direkt aus dem Prozess-Designer
temporär im X4 Front-End anzeigen (siehe Abschnitt 5.2.3.3, „Prozess-Dokumentation
temporär erzeugen “)
• Mit X4 BAM: Aus der X4 BAM-Oberfläche heraus die Prozess-Dokumentation zu jedem
Prozess anzeigen

5. Neu in X4 Version 4.0
75
Abbildung 5.2: Prozess-Dokumentation im HTML-Format mit SVG-Diagramm
5.2.3.2 Prozess-Dokumentation ins Dateisystem exportieren
1. Menü X4 Wizards > Generate Process Documentation Wizard aufrufen.

5. Neu in X4 Version 4.0
76
2. In Process Source Folder auf Browse klicken, um den gewünschten Ordner im Repository
auszuwählen.
3. In Documentation Destination Folder auf Browse klicken, um den Zielordner im
Dateisystem auszuwählen.
4. Finish klicken, um die Prozess-Dokumentation im Zielordner zu erzeugen.
5.2.3.3 Prozess-Dokumentation temporär erzeugen
Sie können Prozess-Dokumentation zu einem Subprozess direkt aus dem Prozess-Designer
temporär im X4 Front-End anzeigen.
1. Im Prozess-Designer auf gewünschten Subprozess rechtsklicken und View Process
Documentation aufrufen.
Die temporär erzeugte Prozess-Dokumenation wird im Editor-Bereich in der View Process
Documentation-Sicht angezeigt.
Prozess-Diagramm-Grafik wird nicht angezeigt
Um das Prozess-Diagramm in der Sicht View Process Documentation-Sicht
darzustellen, wird ein SVG-Viewer benötigt, wenn in Eclipse der Internet Explorer
als Standard-Browser verwendet wird.
Den kostenfreien SVG-Viewer können Sie von http://www.ieaddons.com/de/
Details.aspxId=444 herunterladen und installieren.
5.2.4 Vorlagen für Prozesse und Prozess-Bausteine verwenden
Die Vorlagen-Funktion ermöglicht es Ihnen, ausgearbeitete Prozesse als Vorlagen
wiederzuverwenden und damit die Prozess-Entwicklung erheblich zu beschleunigen. Die
so erstellten Prozesse müssen nur noch an die Gegebenheiten angepasst werden. Die

5. Neu in X4 Version 4.0
77
Vorlagen-Funktion beschränkt sich jedoch nicht auf Prozesse – Sie können für sämtliche
Prozess-Bausteine im X4 Repository eigene Vorlagen anlegen und verwenden. Die
Vorlagen-Funktion beschränkt sich jedoch nicht auf Prozesse; Sie können für sämtliche
Prozess-Bausteine im X4 Repository eigene Vorlagen anlegen und verwenden.
Die Vorlagen-Dateien werden auf dem X4 Server im Ordner /X4DB/0 in der Datei Templates.xml verwaltet.
Die Vorlagen-Dateien selbst befinden sich im Unterordner /Templates.
1. Im Repository Navigator rechtsklicken, um das Kontexmenü aufzurufen.
2. In From Template den gewünschten Elementtyp wählen, um den File Creation Wizard
aufzurufen.
Für ausgegraute Elemente sind keine Vorlagen definiert.
Beispiel: Process wählen, um einen Prozess auf Basis einer Prozess-Vorlage zu erstellen.
3. Einen Eintrag aus der Liste der verfügbaren Vorlagen wählen und Next klicken.
4. Den Zielordner wählen und in File Name den Dateinamen des Subprozesses eingeben.
5. Finish klicken.
Das Element wird gemäß der Vorlage mit allen dazugehörigen Dateien und ggf. auch
Ordnern im Repository angelegt.
5.2.5 Weitere Verbessungen im X4 Front-End

5. Neu in X4 Version 4.0
78
Die Entwickler von X4 haben zahlreiche weitere Verbesserungen implementiert, unter
anderem:
• Update-Site: Front-End-Aktualisierungen direkt aus dem X4 Front-End heraus
installieren
• Entwurfs-Modus: auch ohne Verbindung zum X4 Repository Prozesse modellieren und
XSL-Mappings entwerfen
• Debugging: vereinheitlichte Thread-Namen und verbesserte Debug-Ausgaben
erleichtern es, Fehler zu identifizieren
• Hilfe: Deutschsprachige Dokumentation und Online-Hilfe (über die F1-Taste aufrufbar)
zum X4 Front-End

A. Tastenkombinationen
Das X4 Front-End bietet eine Reihe von Möglichkeiten, mit Tastenkombinationen und per
Drag&Drop Prozesse, Prozess-Bausteine und XSL-Mappings schneller zu bearbeiten.
Prozess-Designer
Sie können die im Folgenden genannten Standard-Tastenkombinationen individuell
bearbeiten. Wählen Sie dazu im Menü Window > Preferences > Keys.
Prozess ausführen und debuggen
Run: Prozess ausführen:
Debug: Prozess auf Fehler prüfen:
Step Into: Beim Debuggen Einzelschritt
ausführen und anzeigen (auch in
Subprozessen):
Step Over: Beim Debuggen Prozess-Schritt
ausführen (ohne Schritte des Subprozess
anzuzeigen):
Step Return: Beim Debuggen aus
Subprozess herausspringen
Suspend: Debugging-Vorgang anhalten
Resume: Debugging fortsetzen
Terminate: Debugging abbrechen
F9-Taste drücken.
F11-Taste drücken.
F5-Taste drücken.
F6-Taste drücken.
F7-Taste drücken.
Strg+F8 drücken.
F8-Taste drücken.
Strg+F2 drücken.
Prozess-Bausteine und Übergänge einfügen
Prozess-Baustein zwischen zwei
verbundenen Bausteinen aus dem
Repository einfügen:
Prozess-Baustein entfernen und Übergang
behalten:
Prozess-Baustein durch eine Datei aus dem
Repository ersetzen:
Prozess-Baustein hinter einem
unverbundenen Baustein einfügen und
dabei automatisch einen Übergang
herstellen:
Datei per Drag&Drop aus dem Repository
auf den Übergang ziehen; Wenn die Linie
des Übergangs dick wird, loslassen.
Alt-Taste drücken und Prozess-Baustein auf
der Zeichnungsfläche verschieben.
Datei per Drag&Drop aus dem Repository
auf den zu ersetzenden Prozess-Baustein
ziehen.
Unverbundenen Prozess-Baustein
markieren, Shift-Taste drücken und die
Datei aus dem Repository hinter den
markierten Prozess-Baustein ziehen.
Elemente bearbeiten
Alles auf der Zeichnungsfläche auswählen:
Strg+A drücken.

A. Tastenkombinationen
Elemente bearbeiten
Prozess-Baustein ausschneiden:
Prozess-Baustein kopieren:
Prozess-Baustein einfügen:
Prozess-Baustein entfernen:
Bearbeitungsschritt rückgängig machen:
Bearbeitungsschritt wiederherstellen:
Prozess-Baustein bearbeiten:
Editor schließen:
Bearbeitetes Element speichern:
Datei im Repository umbenennen:
Datei im Repository verschieben:
Neu laden:
Ansicht bearbeiten
Prozessdiagramm vergrößern (zoomen):
Prozessdiagramm verkleinern:
Strg+X drücken.
Strg+C drücken.
Strg+V drücken.
Entf-Taste drücken.
Strg+Z drücken.
Strg+Y drücken.
Auf Symbol doppelklicken.
Strg+W drücken.
Strg+S drücken.
F2-Taste drücken.
Datei per Drag&Drop in den Ordner ziehen.
F5-Taste drücken.
Strg+- drücken.
Strg++ drücken.
XSL-Editor
Basis-Funktionen
XSL-Transformation ausführen:
Kind-Element einfügen:
Geschwister-Element einfügen:
Attribut einfügen:
Text einfügen:
Umschließendes Eltern-Element einfügen:
Element umbenennen:
Markierten Knoten entfernen:
Code formatieren/einrücken:
Knoten kopieren
Markierten Knoten als vorangehenden
Knoten einfügen:
Markierten Knoten als nachfolgenden
Knoten einfügen:
F9-Taste drücken.
Einfg -Taste drücken.
Shift+Einfg drücken.
Alt+Einfg drücken.
Strg+Einfg drücken.
Strg+Shift+Einfg drücken.
Alt+Shift+R drücken.
Entf-Taste drücken.
Strg+Shift+F drücken.
Strg+Alt+Nach oben drücken.
Strg+Alt+Nach unten drücken.

A. Tastenkombinationen
81
Knoten kopieren
Markierten Knoten als vorangehenden
Eltern-Knoten einfügen:
Knoten verschieben
Markierten Knoten als vorangehenden
Knoten verschieben:
Markierten Knoten als nächsten Knoten
verschieben:
Markierten Knoten als vorangehenden
Eltern-Knoten verschieben:
Im Stylesheet-Baum navigieren
Zum Eltern-Element wechseln:
Zum nächsten Geschwister-Knoten
wechseln:
Zum vorangehenden Element wechseln:
Verbundene Knoten in Quelldokument-
Bereich und Stylesheet-Bereich markieren:
Letzte Markierung wiederherstellen:
XSL-T-Elemente einfügen
xsl:value-of einfügen:
xsl:if einfügen:
xsl:when einfügen:
xsl:otherwise einfügen:
xsl:copy-of einfügen:
xsl:element einfügen:
xsl:choose einfügen:
xsl:for-each einfügen:
xsl:attribute einfügen:
Strg+Alt+Nach links drücken.
Alt+Nach oben drücken.
Alt+Nach unten drücken.
Alt+Shift+Nach links drücken.
Strg+Shift+Nach links drücken.
Strg+Shift+Nach unten drücken.
Strg+Shift+Nach oben drücken.
Shift+Einfg drücken.
Alt+Shift+Nach unten drücken.
Alt+Shift+S , dann V drücken.
Alt+Shift+S , dann I drücken
Alt+Shift+S , dann W drücken
Alt+Shift+S , dann O drücken
Alt+Shift+S , dann P drücken
Alt+Shift+S , dann E drücken
Alt+Shift+S , dann C drücken
Alt+Shift+S , dann F drücken
Alt+Shift+S , dann A drücken

Index
A
Adapter, 4
Adapter-Editor, 24, 25
konfigurieren, 10
Anmelden am X4 Server, 5
Application Server, 1
Arbeitsfläche (Siehe Zeichnungsfläche)
Ausklappbereich
Control, 22
Ausklappbereich ("Flyout")
Data, 22
Drawing, 23
Modules, 22
Ausklappbereich (Flyout), 22
B
BAM (Siehe X4 BAM)
Bedingung (Condition) einfügen, 54
Bedingungen setzen (Condition Editor), 28
BPM
BPM-Designer, 37
BPM-Prozess in X4, 3
Business Process Management, 1
Notation (BPMN), 37
Symbole, 38
Branch (Siehe Verzweigung)
Breakpoint (Siehe Debug-Haltepunkt)
Business Activity Monitoring (Siehe X4 BAM)
C
Call Hierarchy (Verwendungsnachweis), 72
Condition (Bedingung) einfügen, 54
Condition Editor, 28
Branch-Bereich, 29
Condition-Bereich, 29
Edit Condition-Bereich, 30
ConditionState, 62
Connection (Datenbank) herstellen, 56
Custom Parameters, 59
D
DataSource-Verbindung herstellen, 56
Daten mit Merge zusammenfügen, 53
Datenbank-Anweisung anlegen, 56
Datenbank-Mapping: Vorlage erstellen, 56
Datenbank-Verbindung herstellen, 56
Datenbankverbindungs-Editor, 27
Debug-Modus konfigurieren (Front-End), 13
Debugging
Debug-Haltepunkt (Breakpoint) setzen, 63
Funktionen in der Symbolleiste, 23
Run/Debug Console-Sicht, 23
Dynamische Parameter erzeugen, 60
E
EAI, 1
Eclipse-Plugin (X4 Front-End) aktualisieren, 16
Editor
Adapter-Editor , 24, 25
Datenbankverbindungs-Editor , 27
SQL-Editor , 26
Transfer-Adapter-Editor , 24
Entwurfs-Modus, 2
konfigurieren, 10
F
fachlicher Prozess (BPM-Prozess), 3
Fork-Baustein (Gabelung)
einfügen, 52
Front-End, 1, 5
aktualisieren, 16
Condition Editor, 28
Funktionen in der Symbolleiste, 7
Funktions-Adapter konfigurieren, 10
konfigurieren, 10
Menüs, 7
Neuerungen, 69
Prozess-Designer, 19
Repository Navigator, 9
Server-Verbindung konfigurieren, 11
Text-Editor, 37
Transfer-Adapter konfigurieren, 10
updaten, 16
Werkzeuge, 19
XML-Editor, 35
XSL-Editor, 31
Funktions-Adapter
anlegen und verwenden, 47
G
Gabelung (Fork)

Index
84
einfügen, 52
H
Haltepunkt (Siehe Debug-Haltepunkt)
I
Input-Datei festlegen (gesamtes Front-End), 13
J
J2EE, 1
JBoss Application Server, 1
JDBC-Verbindung herstellen, 56
Join-Baustein (Zusammenführung) einfügen, 52
K
Konfiguration
Adapter Editor, 10
Debug-Modus (Front-End), 13
Prozess-Designer, 12
Run-Modus (gesamtes Front-End), 13
Verbindung zum X4 Server, 11
XSL-Transformation konfigurieren (Front-End),
14
Kontextmenü
Repository Navigator, 9
XML-Editor (Design-Ansicht), 35
XSL-Editor (Stylesheet-Bereich), 34
L
Label vergeben, 45
Login, 5
LogInfo, 62
M
Mapping Editor (Siehe XSL-Editor)
Menüs im Front-End, 7
Merge-Baustein einfügen, 53
N
Nested Process (Siehe Subprozess)
Neu in X4 Version 4.0, 67
NoResult, 62
O
Ordnerstruktur (empfohlene), 43
P
Palette , 21
Control-Ausklappbereich, 22
Data-Ausklappbereich, 22
Drawing-Flyout, 23
Modules-Ausklappbereich, 22
Parameter
dynamisch erzeugen, 60
setzen, 58
Parametrierung, 58
Benutzerdefinierte Parameter, 59
Custom Parameters, 59
Plugin (X4 Front-End) aktualisieren, 16
Process Designer (Siehe Prozess-Designer)
Processing Instruction
ConditionState, 62
DynamicParameter, 60
LogInfo, 62
NoResult, 62
Projekt, 43
anlegen, 43
im Repository verwalten, 42
öffnen, 43
schließen, 43
von Vorlage erstellen, 76
Properties-Sicht, 21
Prozess, 3
anlegen, 43
auf Fehler prüfen, 63
ausführen (Run), 64
Ausführen konfigurieren (Front-End), 13
Debug-Modus konfigurieren (Front-End), 13
debuggen, 63
Eigenschaften bearbeiten, 21
exportieren, 45
im Repository verwalten, 42
importieren, 45
Input-Datei festlegen (gesamtes Front-End), 13
öffnen, 44
von Vorlage erstellen, 76
zeitgesteuert ausführen, 65
Prozess-Baustein, 41
als Subprozess speichern, 73
Arten von Bausteinen, 41
Baustein anlegen, 43
Baustein exportieren, 45

Index
85
Baustein importieren, 45
Baustein öffnen, 44
Bedingung (Condition) einfügen, 54
beschriften (mit Label), 45
Call Hierarchy (Verwendungsnachweis), 72
Condition (Bedingung) einfügen, 54
Datenbank-Verbindung einfügen, 56
Fork (Gabelung einfügen, 52
Funktions-Adapter anlegen, 47
Gabelung (Fork) einfügen, 52
im Repository verwalten, 42
Join (Zusammenführung) einfügen, 52
Label vergeben, 45
Mapping anlegen, 49
Merge einfügen, 53
parametrieren, 58, 59
Start-Baustein einfügen, 45
Stop-Baustein einfügen, 45
Subprozess anlegen, 52
Transfer-Adapter anlegen, 46
Übergang (Transition)einfügen, 45
Variable verwenden, 51
Verwendungsnachweis (Call Hierarchy), 72
Verzweigung (Condition) einfügen, 54
von Vorlage erstellen, 76
XML-Dokument erstellen, 48
XSL-Mapping anlegen, 49
Zusammenführung (Join) einfügen, 52
Prozess-Designer, 19
Ansicht verändern, 8
Debug-Funktionen, 8
konfigurieren, 12
Prozess ausführen, 64
Prozess debuggen, 63
Tastenkombinationen, 79
Zeichnungsfläche, 20
Prozess-Dokumentation, 74
ins Dateisystem exportieren, 74, 75
zu Subprozess erzeugen, 74
zu Subprozess temporär erzeugen, 76
Q
Query (Datenbank-Anweisung) anlegen, 56
R
Refactoring
Elemente umbenennen, 70
Elemente verschieben, 72
Repository Navigator, 9
Elemente verschieben, 72
Kontextmenü, 9
Run (Prozess ausführen), 64
Run-Modus konfigurieren (gesamtes Front-End),
13
S
Scheduler (zeitgesteuerte Prozesse), 65
Schleifen einfügen, 54
Shortcuts (Tastenkombinationen), 79
Sicht
Palette , 21
Properties , 21
Repository Navigator, 9
Run/Debug Console , 23
Übersicht, 6
SQL-Anweisung anlegen, 56
SQL-Editor, 26
Standalone-Version (X4 Front-End) aktualisieren,
17
Subprozess anlegen, 52, 73
Symbolleiste, 7
T
t-slot, 45
Tastenkombinationen, 79
technischer Prozess, 3
Template
für Projekte, Prozesse und Prozessbausteine
verwenden, 76
Text-Editor, 37
Transfer-Adapter
anlegen und einfügen, 46
Transfer-Adapter-Editor, 24
Transformation konfigurieren (Front-End), 14
Transition (Siehe Übergang)
U
Uebergang (Transition)
beschriften (mit Label), 45
einfügen, 45
Update für X4 Front-End, 16

Index
86
V
Variable erstellen, 51
Verbindung zum X4 Server
aufbauen, 5
konfigurieren, 11
Verbindungspfeil (Siehe Übergang (Transition))
Verschachtelter Prozess (Siehe Subprozess)
Verwendungsnachweis für Prozess-Bausteine, 72
Verzeichnisstruktur (Siehe Ordnerstruktur)
Verzweigung (Condition) einfügen, 54
View (Eclipse) (Siehe Sicht)
Virtueller Knoten, 49
Vorlage
für Projekte, Prozesse und Prozessbausteine
verwenden, 76
Vorlage für Datenbank-Mapping erstellen, 56
anlegen und einfügen, 49
dynamische Parameter erzeugen, 60
xsl:easy (Siehe XSL-Editor)
Z
Zeichnungsfläche, 20
Zeitgesteuerten Prozess ausführen, 65
W
Webservice Management aufrufen, 7
Workplace (Siehe Zeichnungsfläche)
X
X4 BAM, 39
Funktionen, 39
im Browser aufrufen, 39
X4 Front-End (Siehe Front-End)
X4 Server, 1
Neuerungen, 67
verbinden mit, 5
XML, 4
XML-Dokument erstellen, 48
XML-Editor, 35
Design-Ansicht, 35
Kontextmenü, 35
Source-Ansicht, 36
XSL-Editor, 31
Knotentypen und Symbole, 33
Kontextmenü, 34
Quelldokumentbereich, 31
Stylesheet erstellen, 49
Stylesheet-Bereich, 33
Tastenkombinationen, 80
Transformation konfigurieren (Front-End), 14
Verknüpfungsbereich, 32
XSL-Mapping erstellen, 49
XSL-Mapping