Spring – das Framework für komplexe Java-Ap­pli­ka­tio­nen

2002 stellte der aus­tra­li­sche Ent­wick­ler Rod Johnson in seinem Werk „Expert One-on-One J2EE Design and De­ve­lo­p­ment“ den Code des Java-Frame­works Interface21 vor, den er speziell für die Ver­wen­dung in seinen eigenen Projekten ge­schrie­ben hatte. Auf Basis dieses Codes ent­wi­ckel­te er später gemeinsam mit anderen Pro­gram­mie­rern das Spring-Framework, das im Juni 2003 erstmals unter der freien Lizenz Apache 2.0 auf SourceF­or­ge ver­öf­fent­licht wurde und bis heute zu den be­lieb­tes­ten Lösungen für die Ent­wick­lung von En­ter­pri­se-An­wen­dun­gen in Java zählt. Das Open-Source-Framework räumt seitdem mit den Schwächen und Li­mi­tie­run­gen der stan­dard­mä­ßi­gen Ent­wick­lungs­um­ge­bung J2EE (heute auch als „Java Plattform“ bekannt) und des Kom­po­nen­ten­mo­dells En­ter­pri­se JavaBeans (EJB) auf, indem es deren Kom­ple­xi­tät erheblich reduziert.

Spring ver­ein­facht die Ent­wick­lung von Java-Ap­pli­ka­tio­nen – wobei es keinerlei Rolle spielt, ob es sich dabei um ge­wöhn­li­che Offline- oder um Web­an­wen­dun­gen handelt. Die größten Vorteile des Frame­works sind dabei sein schlanker Quellcode und der geringe Aufwand für An­pas­sun­gen. Um dem Pro­gram­mie­rer diesen Komfort bieten zu können, basiert es auf folgenden Grund­sät­zen, die Rod Johnson bereits seinem Buch erläutert hat:

• De­pen­den­cy Injection (DI): Als De­pen­den­cy Injection be­zeich­net man in der ob­jekt­ori­en­tier­ten Pro­gram­mie­rung eine externe Instanz, die die Ab­hän­gig­kei­ten von Objekten im Vorhinein regelt. Spring bedient sich zu diesem Zweck der Java-Kom­po­nen­ten JavaBeans. Diese fungieren in Java unter anderem als Container zur Da­ten­über­tra­gung, weshalb sie im Spring-Framework als Vorlage für alle ver­wal­te­ten Res­sour­cen („beans“) dienen. Auf diese Weise kann Spring als Container agieren, der dem je­wei­li­gen Java-Projekt vor­kon­fi­gu­rier­te Klassen inklusive ihrer Ab­hän­gig­kei­ten zur Verfügung stellt.

• Aspekt­ori­en­tier­te Pro­gram­mie­rung (AOP): Um die Mo­du­la­ri­tät ob­jekt­ori­en­tier­ter Ap­pli­ka­tio­nen zu­sätz­lich zu erhöhen, bietet Spring optional auch einen aspekt­ori­en­tier­ten Pro­gram­mie­rungs­an­satz mit der Sprache AspectJ. Somit lassen sich Aspekte, also kom­po­nen­ten­über­grei­fen­de Zu­sam­men­hän­ge, die in komplexen Systemen un­ver­meid­bar sind, syn­tak­tisch struk­tu­rie­ren. Das hat den Vorteil, dass der ei­gent­li­che Pro­gramm­code von tech­ni­schen Abläufen wie Feh­ler­be­hand­lung, Va­li­die­rung oder Si­cher­heit getrennt wird.

• Templates: Als Templates werden in Spring Klassen für ver­schie­de­ne Pro­gramm­schnitt­stel­len be­zeich­net, die die Arbeit mit APIs ver­ein­fa­chen, indem sie au­to­ma­ti­sches Res­sour­cen­ma­nage­ment, ein­heit­li­che Feh­ler­be­hand­lun­gen und andere Hil­fe­stel­lun­gen bieten.

Dadurch, dass die oben genannten Grund­sät­ze befolgt werden, erlaubt es das Spring-Framework, bei der Ent­wick­lung von En­ter­pri­se-Java-An­wen­dun­gen auf Plain Old Java Objects (frei übersetzt: ganz ge­wöhn­li­che Java Objekte), kurz POJOs, zu­rück­zu­grei­fen. Diese sind anders als ihr Ge­gen­ent­wurf En­ter­pri­se JavaBeans (EJBs) in nahezu jeder Umgebung lauffähig und benötigen daher auch keinen spe­zi­fi­schen Ap­pli­ka­ti­ons­ser­ver, der die EJB-Container un­ter­stützt – Stan­dard­lö­sun­gen wie Tomcat sind voll­kom­men aus­rei­chend. Um Spring nutzen zu können, benötigen Sie zudem das Java SE De­ve­lo­p­ment Kit (SDK).

Für die ver­schie­dens­ten Ap­pli­ka­tio­nen in Java ist Spring die perfekte Wahl, was in erster Linie auf den modularen Aufbau des Frame­works zu­rück­zu­füh­ren ist. Rund 20 Module stehen Ihnen bei der Ent­wick­lung mit Spring zur Verfügung, wobei Sie frei wählen können, welche dieser Kom­po­nen­ten Sie für Ihre Ap­pli­ka­ti­on nutzen und welche nicht. In der Stan­dard­ar­chi­tek­tur sind die un­ter­schied­li­chen Module in folgende sechs Ober­ka­te­go­rien ein­ge­teilt:

• Core Container: Der Core Container enthält die ele­men­ta­ren Module spring-core, spring-beans, spring-context, spring-context-support und spring-ex­pres­si­on. Core und Beans bilden dabei das Grund­ge­rüst des Frame­works und enthalten bei­spiels­wei­se die De­pen­den­cy-Injection-Funktion sowie den POJO-Support. Das Context-Modul erbt seine Features vom Beans-Modul und fügt der Ap­pli­ka­ti­on zum Beispiel Funk­tio­nen zur In­ter­na­tio­na­li­sie­rung oder zum Laden von Res­sour­cen hinzu. Zu­sätz­lich un­ter­stützt es Java-En­ter­pri­se-Features wie EJB und JMX (Java Ma­nage­ment Ex­ten­si­ons). Mithilfe von Context-Support können Bi­blio­the­ken von Dritt­an­bie­tern in Spring ein­ge­bun­den werden. spring-ex­pres­si­on enthält die Spring Ex­pres­si­on Language (SPeL), eine Er­wei­te­rung der Unified Ex­pres­si­on Language der JSP-2.1-Spe­zi­fi­ka­ti­on (Ja­va­Ser­ver Pages).

• AOP und In­stru­men­ta­ti­on: Um die aspekt­ori­en­tier­te Pro­gram­mie­rung zu er­mög­li­chen, enthält das Spring-Framework das Modul spring-aop sowie das Modul spring-aspects zur In­te­gra­ti­on der bereits erwähnten Sprache AspectJ. Die spring-in­stru­ment-Kom­po­nen­te erlaubt es, Java-Klassen zu in­stru­men­ta­li­sie­ren – also Bytecode zur Laufzeit zu verändern – und fügt außerdem Class­Loa­der-Im­ple­men­tie­run­gen für ver­schie­de­ne Ap­pli­ka­ti­ons­ser­ver hinzu.

• Messaging: Um als Basis für nach­rich­ten­ba­sier­te An­wen­dun­gen fungieren zu können, verfügt Spring über einige Schlüs­sel­funk­tio­nen des Spring-In­te­gra­ti­on-Projekts – wie zum Beispiel „Message“, „Mes­sa­ge­Chan­nel“ oder „Mes­sa­ge­Hand­ler“. Das ent­spre­chen­de Modul trägt den Namen spring-messaging.

• Data Access/In­te­gra­ti­on: Die Module dieser Kategorie dienen dazu, Java-Ap­pli­ka­tio­nen die not­wen­di­gen Fä­hig­kei­ten zur In­ter­ak­ti­on mit anderen An­wen­dun­gen zu verleihen und den Da­ten­zu­griff zu regeln. Das Modul spring-jdbc stellt bei­spiels­wei­se eine Abs­trak­ti­ons­schicht zur Verfügung, die definiert, wie ein Client auf die Datenbank zugreift, und das um­ständ­li­che JDBC-typische Codieren erübrigt. spring-orm wartet hingegen mit In­te­gra­ti­ons­schich­ten für populäre ORM-Schnitt­stel­len auf, mit denen man auf re­la­tio­na­le Da­ten­ban­ken zugreifen kann. Die weiteren Kom­po­nen­ten sind spring-tx (un­ter­stützt pro­gram­ma­ti­sches Trans­ak­ti­ons­ma­nage­ment für alle Klassen und POJOs), spring-oxm (Abs­trak­ti­ons­schicht für Object-/XML-Mapping) und spring-jms, ein Modul mit Features zum Pro­du­zie­ren und Ver­ar­bei­ten von Nach­rich­ten.

• Web: In dieser Kategorie finden sich die spe­zi­fi­schen Module für Web­an­wen­dun­gen spring-web, spring-webmvc und spring-websocket. Ersteres fügt der Java-Ap­pli­ka­ti­on die typischen web­ori­en­tier­ten In­te­gra­ti­ons-Features wie eine Upload-Funktion für mehr­tei­li­ge Daten (multipart) oder einen HTTP-Client hinzu. Das Modul spring-webmvc wird auch als Web-Servlet be­zeich­net und erhält die Spring-Im­ple­men­ta­tio­nen zur Rea­li­sie­rung der stan­dard­mä­ßi­gen Model-View-Con­trol­ler-Ar­chi­tek­tur und der REST-Web­ser­vices. spring-websocket er­mög­licht Da­ten­über­tra­gung zwischen Client und Server auf Grundlage von Web­So­ckets.

• Test: Das spring-test-Modul er­mög­licht es, die Funk­tio­na­li­tät der Kom­po­nen­ten Ihrer Java-Anwendung zu über­prü­fen. So können Sie diese mit ent­spre­chen­den Zusatz-Frame­works wie JUnit oder TestNG um­fang­rei­chen Unit-Tests (mit Fokus auf einer einzelnen Kom­po­nen­te) sowie In­te­gra­ti­ons-Tests (mit Fokus auf das Zu­sam­men­spiel mehrerer Kom­po­nen­ten) un­ter­zie­hen.

Von Beginn an war Java inklusive der damit zu­sam­men­hän­gen­den Tech­no­lo­gien für den Einsatz in der Web­ent­wick­lung geplant. Nach Start­schwie­rig­kei­ten aufgrund der geringen Un­ter­stüt­zung früherer Browser, der noch geringen Band­brei­te privater In­ter­net­an­schlüs­se und un­zu­rei­chen­der Re­chen­leis­tung damaliger PCs erlebte die Pro­gram­mier­spra­che Ende der 90er-Jahre ihren Durch­bruch. In den Anfängen des World Wide Webs waren Java-Applets noch beliebt – das sind in Java ge­schrie­be­ne An­wen­dun­gen, die mithilfe ent­spre­chen­der Lauf­zeit­um­ge­bun­gen im Browser aus­ge­führt werden und mit dem Benutzer in­ter­agie­ren können, ohne Daten zum Server senden zu müssen. Aufgrund ihrer Res­sour­cen­las­tig­keit waren sie aber nicht sehr pra­xis­taug­lich. Mit dem Aufstieg mobiler Geräte, deren Browser Applets nicht un­ter­stüt­zen, sind die in­ter­ak­ti­ven We­b­ele­men­te komplett von der Bild­flä­che ver­schwun­den.

Während sich Java im Frontend also relativ schnell als Flop erwiesen hat, ist die Pro­gram­mier­spra­che ser­ver­sei­tig zu einer festen Größe geworden, wobei die An­wen­dungs­sze­na­ri­os ganz un­ter­schied­lich sind: Von Servlets, den auf Servern aus­ge­führ­ten Applet-Pendants, bis hin zu komplexen En­ter­pri­se-Lösungen wie Midd­le­wa­re, Banken-Software oder großen Content-Ma­nage­ment-Systemen sind ver­schie­dens­te Java-Tech­no­lo­gien heute gefragter denn je, insofern es das Budget zulässt. Aufgrund seiner Vorzüge in punkto Kosten und Zeit­auf­wand wird nämlich bei rund drei Viertel aller Websites die Skript­spra­che PHP ein­ge­setzt. Für Web­ent­wick­ler, die dennoch mit Java arbeiten, bietet Spring jedoch sowohl die not­wen­di­gen Struk­tu­ren als auch eine er­heb­li­che Ver­ein­fa­chung des Ar­beits­pro­zes­ses. Die Vorzüge von Java-Web­an­wen­dun­gen sind unter anderem ihre Platt­form­un­ab­hän­gig­keit und In­te­gra­ti­ons­fä­hig­keit zu Un­ter­neh­mens-Software und -Prozessen, sowie ihre klare Struktur.

Spring wird ty­pi­scher­wei­se auch als Light­weight-Framework (dt. leicht­ge­wich­tig) für Java-An­wen­dun­gen be­zeich­net, da nahezu keinerlei An­pas­sun­gen am Quellcode notwendig sind, um von seinen viel­zäh­li­gen Vorteilen zu pro­fi­tie­ren. Unter anderem handelt es sich dabei um Ver­ein­fa­chun­gen bei der Umsetzung von Trans­ak­ti­ons-Ma­nage­ment, Schnitt­stel­len und dem Da­ten­bank­zu­griff. Auch die Mög­lich­keit, un­kom­pli­ziert Unit- und In­te­gra­ti­ons-Tests durch­zu­füh­ren, ist ein ent­schei­den­der Grund für die Be­liebt­heit des Spring-Frame­works. Der zentrale Punkt ist jedoch ohne Zweifel der Verzicht auf platt­form­spe­zi­fi­sche und nicht-stan­dar­di­sier­te Kom­po­nen­ten, der Spring in hohem Maße portabel und un­ab­hän­gig von Ap­pli­ka­ti­ons­ser­vern macht. Aus diesem Grund kann man es pro­blem­los als Meta-Framework einsetzen, in das sich weitere externe Kom­po­nen­ten oder gar Frame­works in­te­grie­ren lassen. Ein typisches An­wen­dungs­bei­spiel ist die Ent­wick­lung eines Backends auf Spring-Basis, das man an­schlie­ßend mit einem Frontend verknüpft, das zuvor mithilfe eines UI-Frame­works wie Twitter Bootstrap erstellt wurde.

Ins­be­son­de­re bei der Rea­li­sie­rung komplexer Business-An­wen­dun­gen spielt Spring seine Stärken aus. Für Un­ter­neh­men ist das Framework sowie Java im All­ge­mei­nen deshalb seit Jahren eine aus­ge­zeich­ne­te Wahl, um die be­nö­tig­ten Tech­no­lo­gien um­zu­set­zen. Anders als reine Web­frame­works – wie bei­spiels­wei­se das Kon­kur­renz­pro­jekt Struts von Apache – ist Spring dabei nicht auf Web­ap­pli­ka­tio­nen be­schränkt, sondern er­mög­licht auch die Ent­wick­lung nativer Desktop-Lösungen. Für einfache An­wen­dun­gen – ob online oder offline – sind Spring (und Java) jedoch eher weniger geeignet, auch wenn die Rea­li­sie­rung solcher Projekte grund­sätz­lich möglich ist.

Wenn Sie vor der Ent­wick­lung Ihres nächsten großen Projekts stehen und auf der Suche nach dem passenden Framework sind, sollten Sie den Einsatz des Spring-Frame­works in Betracht ziehen. Ins­be­son­de­re, wenn Java in Ihren Plänen sowieso eine Rolle spielt, können Sie sich die Arbeit erheblich ver­ein­fa­chen, indem Sie die flexible Mo­dul­samm­lung nutzen. So erhalten Sie eine leis­tungs­star­ke Grund­struk­tur, die Sie kaum verändern müssen, und können sich ganz auf die Ent­wick­lung der ei­gent­li­chen Business-Logik kon­zen­trie­ren. Im of­fi­zi­el­len GitHub-Re­po­si­to­ry können Sie das Framework jederzeit her­un­ter­la­den und aus­pro­bie­ren. Hier für Sie Vorzüge der Java-Ent­wick­lungs­um­ge­bung noch einmal für Sie über­sicht­lich auf­ge­lis­tet:

• Logik kann in Form von POJOs angelegt werden

• Fertiges Ba­sis­code­ge­rüst, das kaum Ver­än­de­run­gen bedarf

• Kein Ap­pli­ka­ti­ons­ser­ver notwendig

• Er­mög­licht Unit- und In­te­gra­ti­ons-Tests

• MVC-Ar­chi­tek­tur

• Aspekt­ori­en­tier­te Pro­gram­mie­rung mit AspectJ möglich

• De­pen­den­cy Injection (externe Ab­hän­gig­keits­re­gu­lie­rung)

• Pro­gram­ma­ti­sches Trans­ak­ti­ons-Ma­nage­ment