Spring

Benoît CHARROUX
Spring
Spring IDE
Ce tutorial est le premier d'une série consacrée à Spring. Cette série n'a pas pour objectif de
couvrir toutes les possibilités offertes par ce framework. Il y a pour cela des livres [1] ainsi que
des manuels de référence [2]. A l'opposé de l'approche exhaustive de ces ouvrages, qui requièrent
d'emblée des connaissances avancées telles que Struts, Hibernate..., les tutoriaux présentés ici
nécessitent uniquement, à la base, une bonne connaissance du langage Java Standard Edition.
Puis, au fil des tutoriaux, les concepts de persistance dans une base de données, de transaction, de
sécurité... sont abordés. De plus, l'ordre des tutoriaux suit le cycle de vie typique du
développement d'un logiciel, qui commence bien souvent par l'implantation de la partie métier
d'une application, se poursuit par le développement de la partie applicative, puis des services
associés (la persistance...), de l'interface utilisateur, etc. En plus de la maîtrise du langage Java, la
lecture de ces tutoriaux nécessite un minimum de connaissances dans la modélisation avec UML.
Le lecteur qui souhaite acquérir des connaissances sur UML pourra se référer à l'ouvrage [3].
Le but de ce premier tutorial est de :
–préparer l'environnement de développement basé sur Eclipse et utilisant Spring qui servira pour
tous les tutoriaux à suivre ;
–réaliser une première application utilisant Spring.
______________________________________________________________________________________________
1 / 16
Benoît CHARROUX
Spring
Introduction à Spring
Avant de débuter ce tutorial, quelques mots pour mieux cerner Spring...
Spring est un framework pour développer des applications professionnelles en Java. Ce
framework permet d'utiliser un ensemble de technologies, conçues par les promoteurs du langage
Java, et regroupées sous l'appellation Java Entreprise Edition (JEE) [4]. JEE est censé couvrir
tous les besoins, en terme de développement, d'une application professionnelle : depuis la
sauvegarde des données dans des bases de données, jusqu'au développement d'interface
utilisateur pour le Web, etc. Or, les technologies de JEE ont connu plus ou moins de succès.
Certaines ont connu un succès immédiat et durable (Servlet, JSP...), d'autres un succès relatif
(JDBC...), d'autres enfin sont assez peu utilisés (EJB...). C'est à partir de ce constat que Spring a
été créé, notamment par Rob Johnson, et développé par des experts JEE. Ces derniers ont cherché
à pallier les lacunes de JEE. Ils y sont parvenues s'y on en juge par la popularité de Spring au sein
de la communauté des développeurs JEE. Spring va même au-delà de JEE, puisqu'il permet de
programmer une partie d'une application en utilisant la POA (Programmation Orientée Aspect)
[5].
Un dernier mot avant de partir à la découverte de Spring : c'est un framework Open Source
suppporté par une communauté très active qui est prête, grâce à de nombreux forums, à vous
aider. Alors, prêt pour Spring ?
______________________________________________________________________________________________
2 / 16
Benoît CHARROUX
Spring
Matériel requis
Il n'est plus envisageable aujourd'hui d'utiliser des technologies de développement sans
avoir recours à un environnement de développement intégré (IDE). Spring n'échappe pas à la
règle car il propose un IDE pour Eclipse appelé : Spring IDE.
Eclipse [6] est donc requis pour réaliser ce tutorial : ici, c'est la version 3.4.X, appelée aussi
Ganymede, qui est utilisée [7]. Cela dit, une version antérieure, Europa par exemple, fera très
bien l'affaire. Eclipse se présente sous plusieurs forme : avec ou sans Java. Dans ce dernier cas,
vous devez disposer de Java sur votre machine avant d'y installer Eclipse. Pour ce tutorial, c'est la
version 1.5.X de Java qui est utilisée [8]. L'installation d'Eclipse ne pose pas de problème et
prend quelques minutes.
Les premiers tutoriaux de la présente série n'utilisent pas de technologies Web, et donc, les
plugs-in idoines d'Eclipse ne sont pas indispensables. Néanmoins, vous pouvez dès à présent les
installer. Ils vous permettrons d'utiliser plus tard des technologies comme Struts, JSP, Servlet...
Pour être prisent en charge par Eclipse, ces technologies requiert un plug-in appelé Web Tool
Plateform (WTP) [9]. Ici, c'est la version 3.0.X qui est utilisée, mais une version antérieure doit
suffire. L'installation d'un plug-in dans Eclipse peut se faire automatiquement via le menu Help
-> Software Updates. Cependant, une autre façon plus barbare existe pour installer des plug-ins :
chaque plug-in se présente sous la forme d'un fichier compressé qui contient un répertoire appelé
plugins. Il suffit de copier le contenu de ce répertoire dans le répertoire plugin d'Eclipse (il est
conseillé d'arrêter Eclipse pendant l'installation). Au redémarrage d'Eclipse, le répertoire plugin
sera vérifié, et le nouveau plugin pris en compte. WTP est en réalité composé d'un ensemble de
plug-ins que vous pouvez télécharger et installer d'un bloc ou par partie.
Après avoir installé WTP, on peut passer à l'installation du plugin Spring IDE dans Eclipse.
C'est la version 2.2 qui est utilisée pour le présent tutorial [10]. Pour installer Spring IDE,
procédez de la même façon qu'indiquée dans le paragraphe précédent.
Il ne reste plus maintenant qu'à installer le framework Spring. Il ne s'agit pas d'un plug-in
Eclipse mais de l'ensemble des classes Java qui implémentent Spring. Ce framework est
disponible en plusieurs versions. Le plus simple est de télécharger le framework avec ses
dépendances (framework with dependencies). C'est la version 2.5.X qui est utilisée pour ce
tutorial [11]. Elle se présente essentiellement comme un ensemble de fichiers jar compressés.
L'installation du framework consiste simplement à décompresser l'archive dans le répertoire de
votre choix, en sachant que tous les projets utilisant Spring auront besoins d'accéder aux fichiers
jar.
Pour résumer, les logiciels suivants sont requis :
______________________________________________________________________________________________
3 / 16
Benoît CHARROUX
Spring
–Eclipse
–Spring IDE
–Spring framework
et pour pouvoir mener à terme cette série de tutoriaux :
–WTP
La partie la plus rébarbative de ce tutorial doit à présent être achevée, et nous pouvons
passer à la réalisation de notre première application utilisant Spring, ce qui devrait ne prendre de
quelques minutes.
______________________________________________________________________________________________
4 / 16
Benoît CHARROUX
Spring
Création d'un projet Eclipse
Pour débuter notre application, il faut commencer par créer un projet Eclipse : utilisez le
menu File->New->Project... pour cela, en choisissant un projet Spring.
______________________________________________________________________________________________
5 / 16
Benoît CHARROUX
Spring
Cliquez sur Next pour donner un nom à votre projet et pour choisir sa localisation sur votre
machine (vous pouvez choisir un emplacement différent du workspace d'Eclipse).
______________________________________________________________________________________________
6 / 16
Benoît CHARROUX
Spring
Afin d'avoir accès aux classes implantant Spring, il faut ajouter les librairies spring.jar et
commons-logging.jar, issue du framework Spring, à votre projet :
Le projet est à présent prêt à accueillir notre premier composant spring.
______________________________________________________________________________________________
7 / 16
Benoît CHARROUX
Spring
Réalisation d'un composant Spring
Un composant spring (spring bean) est une simple classe Java qui respecte le style Plain
Old Java Object (POJO), ce qui pourrait se traduire par : le bon vieux Java des familles !
Mais avant tout, commençons par créer un paquetage pour recevoir notre classe. Pour cela,
cliquez droit sur le répertoire src qui doit contenir les fichiers sources du projet, et activez le
menu New -> Package. Saisissez un nom de paquetage (rss.application par exemple).
Tout composant Spring doit être issu d'une interface qui déclare les méthodes du
composant. Pour créer l'interface, cliquez droit à nouveau sur le répertoire src mais cette fois
créer une nouvelle interface (New -> Interface).
______________________________________________________________________________________________
8 / 16
Benoît CHARROUX
Spring
Donnez le nom que vous voulez à cette interface (ChannelManager par exemple). Editez
ensuite l'interface et ajoutez-y vos méthodes :
package rss.application;
public interface ChannelManager {
public void addChannel( String title );
}
Pour finir l'implantation de notre composant, il ne nous reste plus qu'à créer une classe qui
implémente l'interface. Utilisez pour cela le menu New->Class (accessible par un clic droit sur le
répertoire src). N'oubliez pas de complétez le champ Interfaces avec le nom de votre interface et
de donner un nom à votre classe (ChannelManagerImpl par exemple) :
______________________________________________________________________________________________
9 / 16
Benoît CHARROUX
Spring
Implantez enfin les méthodes dans la classe :
package rss.application;
public class ChannelManagerImpl implements ChannelManager {
public void addChannel(String title) {
System.out.println("Mon premier composant Spring qui affiche " +
title );
}
}
Jusqu'à présent, il n'y a rien d'original. C'est à partir d'ici que Spring intervient.
Contrairement à une utilisation classique d'une classe dans un programme où un objet est créé
avec new comme dans
public class Test {
public static void main(String[] args) {
ChannelManager channelManager = new ChannelManagerImpl();
}
}
______________________________________________________________________________________________
10 / 16
Benoît CHARROUX
Spring
nous allons déclarer le composant dans un fichier XML. Pour cela, utilisez le menu New ->
Other -> Spring -> Spring bean definition :
______________________________________________________________________________________________
11 / 16
Benoît CHARROUX
Spring
Sélectionnez ensuite le répertoire src et donnez comme nom de fichier :
applicationContext.xml
______________________________________________________________________________________________
12 / 16
Benoît CHARROUX
Spring
Passer à l'écran suivant et cocher les cases beans et context :
Editez le fichier XML et ajoutez y la ligne (vous pouvez passer du mode design au mode
source en utilisant les onglets en bas de la page) :
<bean id="channelManager" class="rss.application.ChannelManagerImpl"></bean>
Au final, le fichier doit être comme ci-dessous :
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
<bean id="channelManager"
class="rss.application.ChannelManagerImpl"></bean>
</beans>
______________________________________________________________________________________________
13 / 16
Benoît CHARROUX
Spring
Test du composant Spring
Il ne reste plus à présent qu'à créer et lancer un programme de test. Voici un exemple :
package test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import rss.application.ChannelManager;
public class Test {
public static void main(String[] args) {
ApplicationContext context = new
ClassPathXmlApplicationContext("applicationContext.xml");
ChannelManager channelManager =
(ChannelManager)context.getBean("channelManager");
channelManager.addChannel("coucou");
}
}
où l'argument de la méthode getBean, channelManager, est le nom contenu dans la ligne
suivante du fichier XML.
<bean id="channelManager" class="rss.application.ChannelManagerImpl"></bean>
______________________________________________________________________________________________
14 / 16
Benoît CHARROUX
Spring
Conclusions
Ce tutorial a permis d'installer Spring IDE dans Eclipse et accessoirement d'écrire un
premier composant Spring.
Le lecteur qui connaît uniquement Java version Standard Edition doit se dire : « quoi ! tout
ça pour ça ? ». C'est vrai que c'est plus compliqué qu'un simple main qui crée un objet via un
new. Eh bien, la seule réponse à apporter à ce stage des tutoriaux est de reconnaître que Spring
n'est d'aucun intérêt pour un projet aussi simple ! Rendez-vous donc dans les autres tutoriaux de
la série pour voir l'intérêt de Spring.
Le lecteur qui connaît les design patterns reconnaîtra l'utilisation d'une fabrique d'objet et il
aura raison.
Le lecteur qui connaît les EJB reconnaîtra l'utilisation d'un contexte pour accéder à un
composant, sauf qu'avec les EJB, on utilise un lookup plutôt qu'un getBean. Au-delà de cette
différence mineure, il n'est pas besoin ici d'un conteneur massif tel que JBoss par exemple.
Spring au contraire utilise un conteneur dit léger, c'est à dire qu'il prend en charge le cycle de vie
des objets (de la création jusqu'à leur destruction) comme tout conteneur JEE, mais sans
nécessairement avoir recourt à un serveur d'applications.
______________________________________________________________________________________________
15 / 16
Benoît CHARROUX
Spring
Bibliographie
[1] Spring par la pratique. Julien Dubois, Jean-Philippe Retaillé, Thierry Templier. Heyrolles 2008.
[2] http://www.springframework.org/documentation
[3] UML 2, pratique de la modélisation. 2 ième édition. Benoît Charroux, Aomar Osmani, Yann Thierry-Mieg.
Pearson Education.
[4] http://java.sun.com/javaee/5/docs/tutorial/doc/
[5] http://en.wikipedia.org/wiki/Aspect-oriented_programming
[6] http://www.eclipse.org/
[7] http://www.eclipse.org/downloads/download.php?file=/eclipse/downloads/drops/R-3.4.1-200809111700/eclipseSDK-3.4.1-win32.zip
[8] http://java.sun.com/javase/downloads/index_jdk5.jsp
[9] http://www.eclipse.org/projects/project_summary.php?projectid=webtools
[10] http://springide.org/blog/
[11] http://www.springframework.org/download
______________________________________________________________________________________________
16 / 16