Spring : le framework pour les ap­pli­ca­tions Java complexes

En 2002, le dé­ve­lop­peur aus­tra­lien Rod Johnson présenta dans son livre Expert One-on-One J2EE Design and De­ve­lop­ment le code du framework Java Interface21, qu’il avait spé­cia­le­ment écrit pour une uti­li­sa­tion au sein de son propre projet. A partir de ce code, il décida ensuite de dé­ve­lop­per avec l’aide d’autres pro­gram­ma­teurs le framework Spring, qui fut publié pour la première fois en juin 2003 sous la licence libre Apache 2.0 sur Sour­ce­Forge, et qui compte aujourd’hui parmi les solutions phares des pro­gram­ma­teurs pour le dé­ve­lop­pe­ment d’ap­pli­ca­tions En­ter­prise Java. Ce framework open-source contourne les fai­blesses et les limites de l’en­vi­ron­ne­ment de dé­ve­lop­pe­ment standard J2EE (aujourd’hui également connu sous le nom « Java Plattform ») et le modèle com­po­sants En­ter­prise JavaBeans (EJB), ce qui réduit con­si­dé­ra­ble­ment sa com­plexité.

Spring simplifie le dé­ve­lop­pe­ment des ap­pli­ca­tions Java, peu importe s’il s’agit d’une uti­li­sa­tion Web ou offline. Les grands avantages du framework résident en son code source très épuré et un temps d’adap­ta­tion minime. Pour pouvoir offrir ce confort au dé­ve­lop­peur, Spring se base sur les principes ci-dessous, que Rod Johnson explique dans son livre :

• L’injection de dé­pen­dance (DI pour De­pen­dency Injection) : par cette ex­pres­sion, on entend en pro­gram­ma­tion orientée objet une instance externe, qui ré­gle­mente à l’avance les dé­pen­dances des objets. Spring utilise à cette fin le composant Javabeans. Celui-ci se base dans Java entre autres comme conteneur pour la trans­mis­sion des données, et sert donc de modèle pour les res­sources gérées (« beans »). De cette manière, Spring peut agir en tant que conteneur, qui met à dis­po­si­tion au projet Java des classes pré­con­fi­gu­rées ainsi que ses dé­pen­dances.

• Pro­gram­ma­tion orientée aspect (AOP) : pour augmenter la mo­du­la­rité des ap­pli­ca­tions orientées objet, Spring propose en option une approche de pro­gram­ma­tion orientée aspect avec la langue AspectJ. Ainsi, les aspects (rapports de com­po­sants iné­vi­tables dans les systèmes complexes) peuvent être struc­tu­rés syn­taxi­que­ment. Ceci possède l’avantage que le code de pro­gram­ma­tion réel soit séparé des opé­ra­tions tech­niques comme le trai­te­ment des erreurs, la va­li­da­tion ou la sécurité.

• Templates: le terme se réfère pour Spring à des classes pour des in­ter­faces de pro­gram­ma­tion diverses, qui fa­ci­li­tent le travail avec les APIs, et permet la gestion de res­sources au­to­ma­tiques, le trai­te­ment d’erreurs et autres aides.

Afin que les principes nommés ci-dessus puissent être respectés, le framework Spring permet pour le dé­ve­lop­pe­ment d’ap­pli­ca­tion Java En­ter­prise de se tourner vers Plain Old Java Objects, raccourci POJO. Ces derniers sont, à la dif­fé­rence du contre-projet En­ter­prise JavaBeans (EJBs), opé­ra­tion­nels dans presque tous les en­vi­ron­ne­ments et ne né­ces­si­tent donc pas de serveur d’ap­pli­ca­tion spé­ci­fique qui sou­tien­drait le conteneur EJB. Des solutions standard comme Tomcat suffisent amplement. Pour pouvoir utiliser Spring, vous aurez de plus besoin du kit de dé­ve­lop­pe­ment Java SE De­ve­lop­ment Kit (SDK).

Pour les ap­pli­ca­tions diverses de Java, Spring se démarque par­ti­cu­liè­re­ment tout d’abord grâce à la cons­truc­tion modulaire du framework. Près de 20 modules sont à votre dis­po­si­tion pour votre dé­ve­lop­pe­ment, modules que vous pouvez sé­lec­tion­ner selon votre con­ve­nance suivant s’ils sont utiles pour votre ap­pli­ca­tion ou non. Dans l’ar­chi­tec­ture standard, les divers modules sont répartis selon les 6 grandes ca­té­go­ries suivantes :

• Core Container : il comprend les modules élé­men­taires spring-core, spring-beans, spring-context, spring-context-support et spring-ex­pres­sion. Core et Beans cons­ti­tuent l’ar­chi­tec­ture de base du framework et com­pren­nent par exemple la fonction d’injection de dé­pen­dance, ainsi qu’un support POJO. Le module Context tient ses fonctions du module Beans et apporte des fonctions telles que par exemple l’in­ter­na­tio­na­li­sa­tion ou le char­ge­ment de res­sources. De plus, il prend en charge les fonctions Java En­ter­prise comme EJB et JMX (Java Ma­na­ge­ment Ex­ten­sions). Avec Context-Support, des bi­blio­thèques de four­nis­seurs tiers peuvent être intégrées à Spring. spring-ex­pres­sion comprend le langage Spring Ex­pres­sion Language (SPeL), une extension du Unified Ex­pres­sion Language des spé­ci­fi­ca­tions JSP-2.1-Spe­zi­fi­ka­tion (Ja­va­Ser­ver Pages).

• AOP et ins­tru­men­ta­tion : pour permettre la pro­gram­ma­tion orientée aspect, le framework Spring comprend le module spring-aop ainsi que le module spring-aspects pour intégrer le langage évoqué à l’instant AspectJ. Les com­po­sants spring-ins­tru­ment per­met­tent d’ins­tru­men­ta­li­ser les classes Java (et donc de modifier les bytecodes en process), et per­met­tent de plus des im­plé­men­ta­tions Class­Loa­der pour les dif­fé­rents serveurs d’ap­pli­ca­tions.

• Messaging : pour pouvoir cons­ti­tuer la base d’ap­pli­ca­tion de mes­sa­ge­rie, Spring dispose de certaines fonctions de chif­fre­ment du projet d‘in­té­gra­tion Spring, comme par exemple « Message », « Mes­sa­ge­Chan­nel » ou « Mes­sa­ge­Hand­ler ». Le module cor­res­pon­dant porte le nom spring-jdbc.

• Data Access/In­te­gra­tion : les modules de cette catégorie servent à octroyer les com­pé­tences utiles aux ap­pli­ca­tions Java pour leurs in­te­rac­tions avec d’autres ap­pli­ca­tions et de réguler les accès aux données. Le module spring-jdbc met par exemple à dis­po­si­tion une couche d’abs­trac­tion, qui définit la manière dont un client a accès à une base de données, en laissant de côté le codage typique JDBC assez compliqué. Spring-orm offre en revanche les couches d’in­té­gra­tion aux in­ter­faces ORM (mapping objet-re­la­tion­nel), avec les­quelles il est possible d’accéder aux bases de données re­la­tion­nelles. On trouve également les com­po­sants spring-tx (prend en charge la gestion pro­gram­mée des tran­sac­tions pour toutes les classes et POJOs), spring-oxm (couche d’abs­trac­tion pour les mapping Object/XML) et spring-jms (module pour générer et traiter les messages).

• Web : dans cette catégorie, on trouve les modules spé­ci­fiques pour les ap­pli­ca­tions Web, à savoir spring-web, spring-webmvc et spring-websocket. Le premier apporte à l’ap­pli­ca­tion Java les ca­rac­té­ris­tiques d’in­té­gra­tion orientées Web typiques comme une fonction upload pour les données en plusieurs parties (multipart) ou un client HTTP. Le module spring-webmvc est également décrit comme une servlet Web et reçoit les im­plé­men­ta­tions Spring pour la réa­li­sa­tion de l’ar­chi­tec­ture standard modèle-vue-con­trô­leur et des services Web REST. spring-websocket permet le transfert de données entre le client et le serveur sur la base de Web­so­ckets.

• Test : le module spring-test permet  de vérifier la fonc­tion­na­lité des com­po­sants de votre ap­pli­ca­tion Java. Ainsi, vous pourrez soumettre des tests JUnit complets (avec focus sur chaque composant) ainsi que des tests d’in­té­gra­tion (se con­cen­trant cette fois sur les in­te­rac­tions entre les com­po­sants) grâce à des sup­plé­ments au framework adéquats, comme JUnit ou Test NG.

Dès le début, Java et les tech­no­lo­gies associées ont été conçues pour le dé­ve­lop­pe­ment Web. Après quelques dif­fi­cul­tés au lancement dues prin­ci­pa­le­ment au faible niveau de prise en charge des na­vi­ga­teurs an­té­rieurs, aux bandes passantes encore faibles des con­nexions Internet privées et aux puis­sances encore in­suf­fi­santes des anciens PC, le langage de pro­gram­ma­tion ne perça qu’à la fin des années 1990. Au tout début du World Wide Web, les applets Java étaient encore po­pu­laires (des ap­pli­ca­tions écrites en Java qui sont exécutées dans le na­vi­ga­teur à l’aide des en­vi­ron­ne­ments d’exécution adéquats et qui peuvent interagir avec l’uti­li­sa­teur sans avoir à envoyer des données aux serveurs. Cependant, du fait de leur besoin important en res­sources, ils n’étaient pas des plus pratiques. Avec l’avènement des appareils mobiles, qui ne prennent pas en charge les applets, les éléments Web in­te­rac­tifs ont com­plé­te­ment disparus de l’écran.

Alors que Java a fait assez ra­pi­de­ment un flop en frontend, le langage de pro­gram­ma­tion est devenu con­si­dé­rable coté serveur, ce qui fait que les scénarios d'ap­pli­ca­tion sont très variables : des servlets et applets exécutés sur le serveur aux solutions en­tre­prises complexes comme Midd­le­ware, les logiciels bancaires ou les grands systèmes de gestion de contenu, les dif­fé­rentes tech­no­lo­gies Java sont aujourd’hui plus demandées que jamais, si tout du moins le budget le permet. Compte tenu de ses avantages en termes de coûts et de temps, près des trois quarts de tous les sites Web utilisent le langage de script PHP. Pour les dé­ve­lop­peurs Web, qui tra­vail­lent néanmoins avec Java, Spring offre à la fois les struc­tures né­ces­saires et une sim­pli­fi­ca­tion con­si­dé­rable du processus de travail. Les avantages des ap­pli­ca­tions Web Java sont, entre autres, leur in­dé­pen­dance vis-à-vis des pla­te­formes, leur capacité d’in­té­gra­tion aux logiciels et process d’en­tre­prise, ainsi que leur structure claire.

Spring est souvent décrit comme un framework light­weight (c’est-à-dire léger) pour les ap­pli­ca­tions Java, puisque presque aucune mo­di­fi­ca­tion du code source n'est né­ces­saire pour profiter de ses nombreux avantages. Il s’agit entre autres de sim­pli­fi­ca­tion dans la mise en œuvre de la gestion des tran­sac­tions, des in­ter­faces et de l’accès aux bases de données. La pos­si­bi­lité d'ef­fec­tuer fa­ci­le­ment des tests unitaires et d'in­té­gra­tion est également une raison pour laquelle le Framework Spring est si apprécié. Le point central est tout de même in­con­tes­ta­ble­ment le fait de renoncer aux com­po­sants spé­ci­fiques à la pla­te­forme et non-stan­dar­di­sés, ce qui rend Spring hautement portable et in­dé­pen­dant des serveurs d’ap­pli­ca­tion. De ce fait, il est très facile de l’installer en tant que méta-framework, dans lequel d’autres com­po­sants externes ou même des fra­me­works pourront être intégrés. Un exemple d’ap­pli­ca­tion typique est le dé­ve­lop­pe­ment d’un backend basé Spring, qui peut être ensuite relié à un frontend créé au préalable à l’aide d’un framework UI comme Twitter Bootstrap. Spring prend tout son sens dans la réa­li­sa­tion d’ap­pli­ca­tions com­mer­ciales complexes. Pour les en­tre­prises, le framework ainsi que Java est en général un très bon choix pour mettre en place les tech­no­lo­gies né­ces­saires. Outre les fra­me­works Web purs, comme par exemple le projet con­cur­rent Struts d’Apache, Spring ne se limite pas aux ap­pli­ca­tions Web, mais permet également le dé­ve­lop­pe­ment de solutions bu­reau­tiques. Pour les ap­pli­ca­tions simples, qu'elles soient en ligne ou hors ligne, Spring (et Java) convient moins, même si la réa­li­sa­tion de tels projets est tout à fait possible.

Si vous êtes sur le point de dé­ve­lop­per un projet Web d’envergure et que vous re­cher­chez un framework, Spring est une solution à con­si­dé­rer. Si vous utilisez en par­ti­cu­lier Java dans votre projet, vous pourrez en effet con­si­dé­ra­ble­ment faciliter votre travail en re­grou­pant de manière flexible des modules. Vous ob­tien­drez alors ainsi une ar­chi­tec­ture de base per­for­mante, que vous ne pourrez presque pas modifier, et vous pourrez vous con­cen­trer sur le dé­ve­lop­pe­ment d’une logique business réelle. Dans les ré­per­toires GitHub officiels, vous pouvez té­lé­char­ger le framework quand vous le souhaitez et l’essayer. Voici une liste des avantages de l’en­vi­ron­ne­ment de dé­ve­lop­pe­ment Java pour y voir plus clair :

• Logique pouvant être instaurée selon le plain old Java object (POJO) ;
• Struc­tures de codes de base prêtes à l’emploi, qui né­ces­si­tent peu de mo­di­fi­ca­tions ;
• Pas de serveur d’ap­pli­ca­tion né­ces­saire ;
• Tests Unit et d’in­té­gra­tion possibles ;
• Ar­chi­tec­ture MVC ;
• Pos­si­bi­lité d’une pro­gram­ma­tion orientée aspect avec AspectJ ;
• Injection de dé­pen­dance (ré­gu­la­tion de dé­pen­dance externe) ;
• Gestion de tran­sac­tion pro­gram­mable.