Carsten Wiesbaum, esentri AG

Schlüsselworte
Implementierung, Kontinuierliche Integration, SOA (Service-oriented architecture), SOA Suite

Einleitung
Ein primärer Fokus von Version 12c der Oracle SOA Suite war die Steigerung der
Entwicklungsproduktivität. Zwei prominente Neuerungen sind die Einführung von diversen SOA
Templates sowie die Unterstützung von Maven als Build-Tool. Die nun existierenden SOA Templates
können in vielen Ebenen der SOA Suite Entwicklung genutzt werden. Sie unterstützen die
Entwicklung sinnvoll, haben teilweise jedoch Limitierungen hinsichtlich ihrer Flexibilität. An dieser
Stelle wird die Möglichkeit Maven als alternatives Build-Tool in der SCA Entwicklung zu nutzen
interessant. Maven bietet mit Archetypes einen eigenen Templating-Mechanismus. Innerhalb des
Vortrags werden die Funktionsweisen der beiden beschriebenen Funktionen durchleuchtet. Danach
wird gezeigt wie ein eigener SOA Suite Archetype erstellt und genutzt werden kann. Schließlich wird
ein kurzes Fazit gezogen.

SCA Projekte und allgemeine Implementationsmuster
In der Softwareentwicklung findet man häufig wiederkehrende Entwurfsmuster die standardisierte
Lösungen für bestimmte Aufgaben darstellen. Sie werden für Themen wie der Fehlerbehandlung,
Überwachung oder Initialisierung von Datenstrukturen genutzt. Auch während der Entwicklung von
Oracle SOA Suite Applikationen werden solche Entwurfsmuster regelmäßig festgelegt und verwendet.
Die manuelle Umsetzung dieser Entwurfsmuster kann dabei schnell zu einer langweiligen und
fehleranfälligen Aufgabe werden. Aus diesem Grund sind mit der Zeit einige Ansätze entstanden, um
solche Aufgaben zu automatisieren. Ein häufig genutzter Ansatz in der Entwicklercommunity ist die
Erstellung von Templates mit denen neue Artefakte und ganze Projekte generiert werden können.

Durch die Neuerung der SOA Templates sowie der Unterstützung von Maven als Build-Tool in Oracle
SOA Suite 12c enthält das Produkt nun gleich zwei Templating Mechanismen die genutzt werden
können. Im Folgenden werden beide Mechanismen vorgestellt. Dazu wurde ein einfaches SCA Projekt
mit einem Entwurfsmuster entwickelt (siehe Abbildung 1). Das Entwurfsmuster enthält einen
ControllerBPEL der den eigentlichen Prozess umschließt und vor sowie nach dessen Ausführung
Monitoring Events feuert. Die Monitoring Events werden aus einem Stand-Alone Subprocess gefeuert

Abb. 1: SCA Projekt mit Entwurfsmuster

Abb. 1: SCA Projekt mit Entwurfsmuster

 

Oracle SOA Suite Templates
Die seit Version 12c existierenden SOA Templates können in vielen Ebenen der SOA Suite
Entwicklung genutzt werden. Generell werden bei der Erstellung eines Templates für die SOA Suite
ganze oder einzelne Bestandteile von SCA Projekten verpackt und in einer Datei abgelegt. Bei der
Verwendung eines Templates werden diese Bestandteile wieder in das aktuelle Projekt ausgepackt und
erweitern dessen eigenen Code. Es existieren drei Arten dieser Templates:

  • SOA Project Templates
  • Service Component Templates
  • Custom BPEL Scope Activity Templates

SOA Project Templates beinhalten ein komplettes SCA Projekt inklusive aller Komponenten, ihrer
Schnittstellendefinitionen (WSDL, XSD) und weiterer beschreibender Metadaten. Bei der Erstellung
von Service Component Templates werden einzelne SCA Komponenten zur Verfügung gestellt, zum
Beispiel wiederverwendbare BPEL-Prozesse oder Mediatoren. Zuletzt können einzelne BPEL Scopes
als Custom BPEL Scope Activity Template zentral abgelegt und genutzt werden. Mögliche
Anwendungen wären etwa die Initialisierung von Variablen oder die Standardisierung der
Fehlerbehandlung in Catch-Blöcken.
Die Erstellung eines SOA Templates ist dabei relativ einfach, es genügt in einem Projekt auf der
entsprechenden Ebene über das Kontextmenü die Funktion Create X Template… auszuwählen.
Abbildung 2 zeigt den Create SOA Template Dialog in dem die einzelnen Dateien für das zu
erstellende Template ausgewählt werden können. Neben den Dateien müssen lediglich ein
Speicherort, Name und eine Beschreibung angegeben werden. Anschließend kann das Template zur
Erstellung eines neuen SCA Projektes genutzt werden.

 Erstellung eines SOA Project Templates

Abb. 2: Erstellung eines SOA Project Templates

Nach der Erstellung wird im zuvor angegebenen Ordner eine tmpl-Datei angelegt. Bei diesen Dateien
handelt es sich tatsächlich um ein ZIP-Archiv welches die gesamte Projektstruktur und dessen Dateien
enthält (sie Abbildung 3). Zusätzlich beinhaltet das Template eine XML-Datei mit Metadaten zum
Template. Wie in Listing 1 zu sehen ist, beschränken sich diese auf den Namen, die Beschreibung und
die beinhalteten Komponenten.

<?xml version = ‚1.0‘ encoding = ‚UTF-8‘?>
<template name=“Complete_SoaTemplate“ id=“Complete_SoaTemplate“
type=“composite“ scaRoot=“SOA/“ usesORAMDS=“true“>
<description>SOA template including monitoring pattern.</description>
<component componentName=“CustomerService_ep“ componentType=“service“/>
<component componentName=“ControllerBPEL“ componentType=“bpel“/>
<component componentName=“ProcessMonitoring“ componentType=“sbpel“/>
<component componentName=“CustomerServiceBPEL“ componentType=“bpel“/>
</template>

Listing 1: SOA Template Metadaten
Wird das Template nun zur Erstellung eines neuen SCA Projektes genutzt, werden die Inhalte der
tmpl-Datei extrahiert und in das neue Projekt kopiert. Dabei wird von JDeveloper lediglich der
Composite Name im Code ersetzt, es gibt keine Möglichkeit bei der Erstellung des Projektes aktiv
Einfluss auf das Ergebnis zu nehmen. Gerade bei der Anlage neuer Projekte mit SCA-Templates wäre
eine gewisse Flexibilität jedoch wünschenswert.

Struktur einer tmpl-Datei

Abb. 3: Struktur einer tmpl-Datei

Nutzung von Maven Archetypes als SOA Templates
An dieser Stelle wird die Möglichkeit Maven als alternatives Build-Tool in der SCA Entwicklung zu
nutzen interessant. Maven bietet mit Archetypes einen eigenen Templating-Mechanismus. Dieser
bietet, neben der Standardisierung von Projektstrukturen, die Möglichkeit über Apache Velocity
Properties Einfluss auf das Ergebnis der Projekterzeugung zu nehmen. Gerade im Umfeld der Java
Entwicklung sind Archetypes und deren Funktion bekannt und ein alltägliches Arbeitsmittel.

Maven Archetypes werden von JDeveloper im Grunde bei jeder Anlage eines SOA Suite 12c
Projektes genutzt. Im Hintergrund werden zwei Oracle Archetypes verwendet, oracle-soa-application
und oracle-soa-project. Beide Archetypes liegen im JDeveloper Installationsverzeichnis unter
$ORACLE_HOME/soa/plugins/maven/com/oracle/soa/archetype. Es besteht jedoch auch die
Möglichkeit Archetypes von lokalen und entfernten Maven Repositories für die Erstellung von
Applikationen und Projekten zu nutzen. Die Funktion ist über die New Gallery unter General ->
Maven -> Generate from Archetype zu finden. Abbildung 4 zeigt die Nutzung von Maven Archetypes
zur Anlage von Projekten. Hierbei müssen die üblichen Maven Properties angegeben und der
entsprechende Archetype in den bekannten Maven Repositories gesucht sowie ausgewählt werden.
Wenn ein Archetype weitere Properties benötigt, werden diese in einem weiteren Dialog abgefragt.

Nutzung von Maven Archetypes in JDeveloper

Abb. 4: Nutzung von Maven Archetypes in JDeveloper
Zur Erzeugung eines eigenen Archetypes gibt es im Grunde zwei Möglichkeiten, die Entwicklung
eines neuen Archetypes von Grund auf oder die Umwandlung eines bestehenden Maven Projektes in
einen Archetype. Da es sich bei SOA Suite 12c Projekten bereits um Maven Projekte mit der
korrekten Struktur handelt, ist die zweite Methode einfacher durchzuführen und spart Zeit. Zur
Umwandlung eines bestehenden SOA Projektes in einen Archetype müssen drei Schritte durchgeführt
werden:

  • Generierung des Archetype Projektes mit Maven archetype:create-from-project Plugin
  • Anpassung des entstehenden Projektes
  • Bauen und Installation des Archetypes in das lokale Repository

Im ersten Schritt wird ein Archetype Projekt aus dem bestehenden SOA Projekt generiert. Listing 2
zeigt die benötigte Kommandozeile.

[esentri@localhost SoaTemplate]$ ls
deploy pom.xml SOA SoaTemplate.jpr
[esentri@localhost SoaTemplate]$ mvn archetype:create-from-project
[INFO] Scanning for projects…

[INFO] ——————————————————————–
—-
[INFO] BUILD SUCCESS
[INFO] ——————————————————————–
—-
[INFO] Total time: 1.776s
[INFO] Finished at: Wed Sep 30 23:32:05 CEST 2015
[INFO] Final Memory: 11M/152M
[INFO] ——————————————————————–
—-
[INFO] Archetype project created in
<SOME_PATH>/SoaTemplate/target/generated-sources/archetype
Listing 2: Erzeugung des Maven Archetype Projektes

In Abbildung 5 ist das resultierende Archetype Projekt zu sehen. Bei der Generierung des Projektes
werden von Maven bereits Dateien angepasst, um sie auf die Nutzung als Template vorzubereiten. So
werden bestimmte Zeichen und Zeichenketten, die in Velocity Templates mit speziellen Funktionen
belegt sind, durch entsprechende Variablen ersetzt. Des Weiteren werden alle Dateien nach den, zum
Zeitpunkt der Generierung definierten, Werten für die Maven Properties artifactId und groupId
durchsucht und durch deren Variablen Repräsentationen ersetzt (${artifactiId} und ${groupId}). Nach
der Generierung sollte daher in den Projektdateien geprüft werden, ob Strings fälschlicherweise ersetzt
wurden. So können Teile eines Namespaces durch Variablen ersetzt werden.

 

Generiertes Archetype Projekt

Abb. 5: Generiertes Archetype Projekt

Nach der Generierung sind noch einige Anpassungen am Archetype Projekt nötig. Zunächst muss die
vorhandene JPR-Datei entfernt werden, bei der späteren Nutzung des Archetypes in JDeveloper wird
eine passende Version generiert. Auch der deploy-Ordner ist überflüssig und kann gelöscht werden.
Zuletzt müssen der vorhandene Ordner SOA/SCA-INF und die Datei src/main/resources/METAINF/
maven/ archetype-metadata.xml durch die Vorlage aus dem oracle-soa-project Archetype ersetzt
werden. Die Datei archetype-metadata.xml enthält beschreibende Metadaten, die bei der Nutzung des
Archetypes benötigt werden. In ihr werden relevante Dateien für die Erzeugung eines Projektes aus
dem Archetype und zusätzliche Properties definiert. Die von Oracle entwickelte Datei wird zur
Generierung von SCA Projekten genutzt und ist damit die perfekte Grundlage für eigene Archetypes.
Nachdem die Archetype Projektstruktur entsprechend angepasst wurde, kann nun der Code der
Template-Dateien angepasst werden. Um in Maven Archetypes Einfluss auf das resultierende Projekt
zu nehmen, werden Velocity Properties innerhalb der Code-Templates hinzugefügt. Alle Velocity
Properties müssen in der Datei archetype-metadata.xml definiert werden. Sie werden dann bei der
Generierung von Projekten mit den übergebenden Werten ersetzt. Abbildung 6 Zeigt ein Beispiel für
die Verwendung von Velocity Properties. Im Beispiel werden der Service-Namespace und der
Domain-Objekt Name durch variable Werte ersetzt. Somit kann Einfluss auf das Ergebnis des
generierten SCA Projektes genommen werden.

Code mit Velocity Properties

Abb. 6: Code mit Velocity Properties

 

Bei der Nutzung von zusätzlichen Properties ist zu beachten das bei der Generierung des Archetype
Projektes vom Maven Plugin archetype:create-from-project ein Test angelegt wurde. Dieser prüft
unter anderem die Funktionstüchtigkeit der übergebenden Maven Parameter. Damit der Bau und die
Installation des Archetypes im nächsten Schritt funktioniert, muss dieser Test noch um die
zusätzlichen Properties erweitert werden. Dazu müssen die zusätzlichen Properties in der Datei
src/test/resources/projects/basic/archetype.properties hinzugefügt werden (siehe Listing 3).
package=it.pkg
version=0.1-SNAPSHOT
groupId=archetype.it
artifactId=basic
serviceNamespace=CustomerService
domainObjNamespace=http://some.name.space.com
domainObjName=Customer
Listing 3: Angepasste archetype.properties Datei
Nachdem alle Anpassungen wie beschrieben durchgeführt worden sind, muss der Archetype gebaut
und im lokalen Repository installiert werden. Dazu reicht es im Archetype Projekt mvn clean install
auszuführen. Anschließend ist der Archetype in JDeveloper zur Erstellung eines neuen SCA-Projektes
nutzbar. Abbildung 7 zeigt die Erzeugung eines SCA Projektes mit dem erstellten Maven Archetype
und dessen Property Konfiguration. Das nach Abschluss des Wizards entstehende Projekt ist in
Abbildung 8 zu sehen. Bei der Generierung wurden alle zuvor definierten Properties mit den
entsprechenden Werten ersetzt. Das SCA Projekt ist direkt bau- und auslieferbar.

 

Property Konfiguration in JDeveloper

Abb. 7: Property Konfiguration in JDeveloper

 

Entstandenes SCA Projekt

Abb. 8: Entstandenes SCA Projekt

Fazit
Wie gezeigt ist es möglich sowohl mit den SOA Templates als auch mit Maven Archetypes die
Standardisierung von Entwurfsmustern in SCA Projekten zu erreichen. Die in JDeveloper
vorhandenen SOA Templating Funktionen haben einen Vorteil hinsichtlich der einfachen Erzeugung
und Nutzung. Das Entwurfsmuster muss lediglich implementiert werden und kann dann über
Kontextmenüpunkte zu einem SOA Template konvertiert werden. Anschließend ist es relativ einfach
für die Erzeugung neuer SCA Projekte nutzbar. Ein großer Nachteil dieser Funktion ist jedoch der
statische Charakter der Templates. Bei der Entwicklung werden die entwickelten Dateien lediglich in
einem Zip Archive verpackt und bei Bedarf neuen Projekten hinzugefügt. Es gibt keine Unterstützung
durch das Werkzeug um Einfluss auf das resultierende Projekt zu nehmen. In der Praxis ist es daher
häufig schwierig geeignete Anwendungsfälle für diese Templates zu finden. Zumeist unterscheidet
sich die Umsetzung der Entwurfsmuster dann doch in kleinen Details.

Im Gegensatz dazu bieten Maven Archetypes über die Nutzung der Velocity Properties die
Möglichkeit aktiv Einfluss auf das Ergebnis der Projektgenerierung zu nehmen. Hierzu muss der
Entwickler des Entwurfsmusters jedoch mehr Erfahrung mit SCA Applikationen und Maven besitzen.
Es müssen einige manuelle Schritte bei der Erzeugung des Templates durchgeführt werden, um ein
lauffähiges und flexibles Template zu erhalten. Im Grunde bezahlt man die erhöhte Flexibilität mit
dem Verlust von etwas Komfort bei der Entwicklung der Templates.

Nach Meinung des Autors wäre die Nutzung von Maven Archetypes als Template Mechanismus die
richtige und konsequente Umsetzung Seitens Oracle gewesen. Es existieren bereits funktionierende
Archetypes von Oracle die von JDeveloper im Hintergrund genutzt werden. Die Erzeugung neuer
beziehungsweise die Erweiterung existierender Archetypes muss lediglich durch das Tool unterstützt
werden. Damit wären die Templating Mechanismen der Oracle SOA Suite auf einen Schlag flexibler
und viel sinnvoller im Entwickleralltag einzusetzen.