Pluginbasierte Entwicklung auf Basis einer eigenen JAR

Pluginbasierte Entwicklung auf Basis
einer eigenen JAR Datei
2017-03-07
2017.06
by Paul Rochowski
MyCoRe bietet die Möglichkeit innerhalb des Konfigurationsverzeichnisses
in dem Ordner lib eigene Anwendungserweiterungen (Komponenten) zu
hinterlegen. Der folgende Abschnitt beschreibt die Möglichkeiten die ein
solches Paket durch seine grundlegende Struktur bietet, stellt ein einfaches
Beispiel dar um eine Hello-World Servletkomponente innerhalb von Eclipse zu
entwickeln und zeigt wie diese mit dem MyCoRe-Framework verknüpft wird.
Table of contents
1 Warum pluginbasiert entwickeln?................................................................................ 2
2 „Make JAR not WAR!“............................................................................................... 2
3 Tutorial: Entwicklung eines eigenen JAR Plugins.......................................................2
3.1 Workspace einrichten.............................................................................................. 3
3.2 HelloWorldServlet in Aktion.................................................................................. 9
3.3 Projekt Struktur im Detail.......................................................................................9
4 To do...........................................................................................................................12
5 MyCoRe um Hello World Servletkomponente erweitern.......................................... 12
6 Deployment/Debugging.............................................................................................. 12
Pluginbasierte Entwicklung auf Basis einer eigenen JAR Datei
1 Warum pluginbasiert entwickeln?
Ein stetig wachsender MyCoRe Kern bietet ein solides Framework für die Verwaltung
und Präsentation digitaler Inhalte an. Es ist jedoch zu beachten, dass jede MyCoReAnwendung für sich eigenständig ist. Zwar bietet die Community mit Skeleton und
MIR bereits fertige Anwendungen die schnell an die eigenen Bedürfnisse angepasst
werden können, die Frage nach einem eigenen Plugin ist allerdings berechtigt, wenn
MIR bzw. Skeleton mit den vorgegebenen Werkzeugen nicht ausreichen. Es gibt
teils Anforderungen an eine MyCoRe-Anwendung die ggf. einmalig sind. Hier macht
es keinen Sinn diese in den Kern einfließen zu lassen, da dieses Vorgehen nur eine
Vergrößerung des Kerns ohne Mehrwert für die Community und eine Verkomplizierung
der eigentlichen MyCoRe-Entwicklung zur Folge hätte.
Ebenfalls gibt es Features, die zwar einen Mehrwert für die Community darstellen,
allerdings über die Zeit so mächtig geworden sind, dass die Überlegung nahe steht
diese in losgelöste Komponenten auszulagern um den Kern auf seine Hauptelemente
zu beschränken und die Entwicklung damit zu vereinfachen. Als letzter Punkt ist hier
hervorzuheben, dass eine pluginbasierte Entwicklung dem Entwickler immer eine
geschützte Sandbox Umgebung zur Verfügung stellt, in welcher er Neues ausprobieren
und der Community auf diese Weise vorstellen kann.
2 „Make JAR not WAR!“
Mit der 2011 vorgestellten JSR 315: JavaTM Servlet 3.0 Spezifikation ( https://
jcp.org/en/jsr/detail?id=315) erhielten Modularisierungsmöglichkeiten Einzug in
Web Anwendungen auf Servlet Basis. Statt wie zuvor über den zentralen Deployment
Descriptor web.xml die Konfiguration wie der Webserver Anfragen annehmen und
bedienen soll vorzunehmen, kann man nun vom Web Archive losgelösten Komponenten
eine Eigenverantwortung geben. Diese Eigenverantwortung macht sich der MyCoRe
Kern zunutze und bietet Entwicklern die Möglichkeit mit eigenen JAR Dateien MyCoRe
weiterzuentwickeln als auch die bestehenden Anwendungen MIR/Skeleton auf Java
Grundlage an die eigenen Bedürfnisse anzupassen. Innerhalb der MyCoRe GitHub
Seite ( https://github.com/rochpaul/mycore-custom-module) steht ein minimales Maven
Projekt bereit, welches die Referenzarchitektur für eine eigene pluginbasierte Anwendung
darstellt.
3 Tutorial: Entwicklung eines eigenen JAR Plugins
Um das hier beschriebene Tutorial nacharbeiten zu können, sollten die folgenden
Voraussetzung erfüllt sein:
•
Generelle MyCoRe-Anforderungen (siehe Anforderungen ( http://mycore.de/
documentation/getting_started/requirements.html) ) mit einer aktuellen MIRInstallation (siehe MIR ( http://mycore.de/documentation/getting_started/mir.html) )
Seite 2 von 12
Pluginbasierte Entwicklung auf Basis einer eigenen JAR Datei
•
•
Eclipse Grundinstallation (getestet mit Eclipse Java EE IDE for Web Developers
Mars.2 Release 4.5.2)
Die Eclipse-Erweiterungen m2e sowie EGit
3.1 Workspace einrichten
Erstellen Sie zunächst für das custom-module-Beispielprojekt einen neuen
Workspace und checken Sie dann von der MyCoRe GitHub Seite das Projekt aus.
Hierzu öffnen Sie in Eclipse die Git Perspective (Window -> Perspective ->
Open Perspective -> Other...) und klicken auf die Option Clone Git
Repository. Füllen Sie wie in Abbildung 1 gezeigt die benötigten Eingabefelder aus
(hier reicht es die URL im Browser mit Strg + c zu kopieren und dann Clone Git
Repository zu öffnen, Eclipse füllt die Eingabefelder dann automatisch aus) und
wählen den Master aus. Nach Eingabe eines gewünschten Verzeichnispfades erstellen Sie
mit Finish das lokale custom-module Git Repository.
Seite 3 von 12
Pluginbasierte Entwicklung auf Basis einer eigenen JAR Datei
Seite 4 von 12
Pluginbasierte Entwicklung auf Basis einer eigenen JAR Datei
Abbildung 1: Checkout des custom-module Beispielprojektes
Nachdem Sie nun lokal alle benötigten Sourcen ausgecheckt haben, muss Eclipse
mitgeteilt werden werden, dass es sich um ein Maven Projekt handelt, welches in den
Projekt Explorer importiert werden soll. Wählen Sie hierzu unter File -> Import die
Select-Option "Existing Maven Projects" aus. Als Root Directory wird hier der Root des
zuvor erstellen lokalen Repositories angegeben. Eclipse erkennt nun wie in Abbildung 2
zu sehen ist anhand der im Root liegenden pom.xml, dass es sich um ein Maven Projekt
handelt.
Seite 5 von 12
Pluginbasierte Entwicklung auf Basis einer eigenen JAR Datei
Seite 6 von 12
Pluginbasierte Entwicklung auf Basis einer eigenen JAR Datei
Abbildung 2: Import als Maven Projekt
Das custom-module wurde nun als Maven Projekt importiert und steht ebenso
unter git Versionskontrolle. Um nun ein eigenes Projekt zu erstellen und das custommodule als Basis zu benutzen eignet sich GitHub als öffentliches remote Git Repository.
Von dem custom-module Projekt kann innerhalb von GitHub ein Fork erstellt und
dieser dann wie in Abbildung 3 zusehen ist konfiguriert werden. Für weitere Infos bzgl.
Git/GitHub wird an dieser Stelle auf die interne Git Dokumentation ( http://mycore.de/
documentation/developer/work_with_git.html) verwiesen.
Seite 7 von 12
Pluginbasierte Entwicklung auf Basis einer eigenen JAR Datei
Seite 8 von 12
Pluginbasierte Entwicklung auf Basis einer eigenen JAR Datei
Abbildung 3: Einstellung des remote Repositories für die eigene Anwendung
3.2 HelloWorldServlet in Aktion
Als einfaches Beispiel soll nun auf Grundlage der gegebenen Struktur ein HelloWorld
Servlet erstellt werden. Dieses befindet sich bereits innerhalb des Java Package Ordners
custom.mycore.servlets. Es ist ein mittels Eclipse Wizard erstelltes Servlet,
welches in der doGet Methode um die Hello World Ausgabe erweitert wurde. Innerhalb
der web-fragment.xml wurde konfiguriert wo das Servlet zu finden ist und unter
welcher URL es im Browser angesprochen werden kann. Das Beispielprojekt soll nun
in MyCoRe eingebunden werden um zunächst über einen Webbrowser eine Anfrage
an das HelloWorldServlet zu schicken. Hierzu muss aus der jetzigen Projektstruktur
eine JAR Datei erzeugt und diese innerhalb des MyCoRe Konfigurationsverzeichnisses
im lib Ordner bereitgestellt werden. Für diese Aufgabe ist Maven das passende Build
Werkzeug. Durch die Einbindung des maven jar Plugins innerhalb der pom.xml wird
die Möglichkeit bereitgestellt auf einfache Weise eine JAR Datei zu bauen. Navigieren
Sie mittels Terminal/Kommandozeile ins root Directory des Beispielprojektes und lassen
Sie Maven mittels mvn clean && mvn install Befehl die benötigte Arbeit
machen. Es wurde nun ein target-Verzeichnis erstellt, in welchem die gebaute JAR Datei
abgelagert wurde. Nachdem Sie die Datei ins MyCoRe Konfigurationsverzeichnis kopiert
haben, kann MIR nun auf gewohnte Art und Weise mittels Tomcat gestartet werden.
Nachdem der startup Vorgang des Tomcat Servers abgeschlossen wurde, kann nun eine
Anfrage über einen Webbrowser an das HelloWorldServlet gestellt werden. In Abbildung
4 sieht man das Ergebnis einer Anfrage an das Servlet.
Abbildung 4: HelloWorldServlet in Aktion
3.3 Projekt Struktur im Detail
Im Folgenden soll das vorherige Beispiel genauer betrachtet werden um die
Möglichkeiten die ein solches Java Archiv bietet besser zu verstehen. Hierzu dient die
Projekt Struktur des Beispielprojektes:
| \ src | \ main | \ resources (Alle nicht zu übersetzenden Resourcen) | \ META-INF
(JAR Spezifikation Standard) | \web-fragment.xml (Definition von Servlets, Filtern und
Listener für JAR Ebene) \resources (Statischer Content mit Zugriff vom web-context
root) \ java (Java Resourcen) | \ custom/mycore (Package Struktur) | \servlets (Ordner
Seite 9 von 12
Pluginbasierte Entwicklung auf Basis einer eigenen JAR Datei
für Servlets) | \HelloWorldServlet (Hello World Servlet Beispiel) | \ LICENSE.txt
(Lizenzinformationen) \ pom.xml (Maven Einstellungen bzgl. Abhängigkeiten,
Versionierung und Build Prozess)
Da es sich um ein Maven Projekt handelt, befindet sich innerhalb des root Verzeichnis
die zentrale Konfigurationsdatei pom.xml. Damit der Mechanismus so funktionieren
kann wie im HelloWorldServlet gezeigt wird, benötigt das Projekt eine bestimmte
Grundkonfiguration. Für den MyCoRe Kern sind JAR Dateien in dem lib Verzeichnis
zunächst MCRComponents. Innerhalb von MyCoRe muss es also etwas geben,
das JAR Dateien zunächst in einem separaten Konfigurationsverzeichnis als
MyCoRe Komponenten identifiziert und diese in Zusammenhang mit dem oben
beschriebenen Servlet API Modularisierungsmechanismus bringen kann. Dies erledigt
die MCRAutoDeploy Klasse. Durch den pom.xml Eintrag <MCR-Auto-Deploy>
true </MCR-Auto-Deploy> sagt man der MCRAutoDeploy Klasse, dass dieses
JAR Archiv Komponenten enthält, die an den MyCoRe Servlet Kontext gebunden werden
können. Das folgende Aktivitätsdiagramm verdeutlicht dies:
Seite 10 von 12
Pluginbasierte Entwicklung auf Basis einer eigenen JAR Datei
Seite 11 von 12
Pluginbasierte Entwicklung auf Basis einer eigenen JAR Datei
Aktivitätsdiagramm 1: Registrierung von eigenen Plugins innerhalb von MyCoRe
4 To do
<web-fragment xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://java.sun.com/xml/ns/javaee" xmlns:webfragment="http://java.sun.com/
xml/ns/javaee/web-fragment_3_0.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/
javaee http://java.sun.com/xml/ns/javaee/web-fragment_3_0.xsd" id="WebFragment_ID"
version="3.0"> </web-fragment> ... <display-name>HelloWorldServlet</display-name>
<name>HelloWorldServlet</name> <servlet> <servlet-name>HelloWorldServlet</
servlet-name> <servlet-class>custom.mycore.servlets.HelloWorldServlet</servlet-class>
</servlet> <servlet-mapping> <servlet-name>HelloWorldServlet</servlet-name> <urlpattern>/HelloWorld</url-pattern> </servlet-mapping> ...
5 MyCoRe um Hello World Servletkomponente erweitern
6 Deployment/Debugging
Seite 12 von 12