ePims

Description ANT permet de gérer la construction d’une application, c’est un système de gestion de build, comparable à Make, qui utilise Java et le format XML pour la description des tâches à effectuer.

On utilise ANT dans l’environnement d’Eclipse. Il est toutefois possible d’utiliser ANT en dehors d’Eclipse. Il n’y a pas eu de tests faits avec différentes versions mais aucune ‘tâche’ spéciale n’est utilisée sauf ivy (il faut pointer ivy.jar dans le classpath de ANT)

Afin, que les targets ANT utilisant “javadoc” fonctionnent correctement, il est nécessaire d'ajouter tools.jar de Java dans les préférences ANT: Window → Preferences → Ant → Runtime : Global Entries

IVY est un gestionnaire de dépendance de librairies Java qui s’intègre avec Maeven et Ant. Il permet à des projets J2EE de faciliter l'import et la maintenance des dépendances de librairies entre modules.

Sa mise en place est simple, il suffit de définir un “Repository” central (exemple: partage samba), ensuite de définir dans un fichier XML, les dépendances de chaque JAR. Ensuite, à partir de tâches ANT, il est possible d'importer dynamiquement l'ensemble des JAR requis pour la compilation.

IVY sait gérer les graphes de dépendances entre librairies : par exemple si un JAR “A” nécessite un JAR “B” pour fonctionner, et que le projet à besoin du JAR “A”, alors le JAR “B” sera automatiquement téléchargé dans le classpath de compilation du projet. Il sait de plus gérer les conflits de versions.

L'installation est très simple et rapide, il suffit de suivre les étapes suivantes:

1. copier le fichier Ivy.jar dans le répértoire lib de Ant “ ANT_HOME/lib ”
2. sous eclipse: ajouter au classPath de Ant le Ivy.jar : Window → Preferences → Ant → Runtime : Ant Home Entries

Pour la récupération des librairies, Ivy offre la possibilité de le faire depuis des librairies telles que “ibiblio” ou alors depuis un repository local. Dans le cas où un repository local est défini, créer un fichier “ivyconf.properties” à la racine de son home-dir :

          ivy.local.repository.path= "path"
          ivy.distrib.dir= "path"

exemple :

 <!--  configuration du fichier ivyconf.properties  -->
 <properties file="${user.home}/ivyconf.properties" />
  
  <conf defaultResolver="cp-resolver" />
   
   <resolvers>
    <chain name="cp-resolver" returnFirst="false">
      <!-- Repository local -->
      <filesystem name="cp-local-repository">
         <ivy pattern="${ivy.local.repository.path}/[organisation]/[module]/ivys/ivy-[revision].xml"/>
        <artifact pattern="${ivy.local.repository.path}/[organisation]/[module]/[type]s/[artifact]-[revision].[type]"/>
      </filesystem>
        
      <!-- Autres sources -->
      <ivyrep name="ivyrep-sandbox" ivyroot="http://opensvn.csie.org/ivyrepsandbox/"/>
      <ivyrep name="ivyrep"/>
           <dual name="ivyrep_ibiblio">
              <ivyrep name="ivyrep" ivyroot="http://opensvn.csie.org/ivyrepsandbox/"/>
              <ibiblio name="ibiblio" />
          </dual>   
    </chain>
   </resolvers>  

Remarques : Il est important de noter que l'utilisation du caractère '-' est fortement déconseillée dans les fichiers de dépendances ( ivy.xml) pour la définition des configurations, car le nom de la configuration ne sera pas pris en entier, et il risque d'y avoir des conflits!

JUnit est un framework pour les tests unitaires. La version 3.8.1 est embarquée dans Eclipse.

Pour créer un squelette de test (TestCase) depuis Eclipse :

créer un nouveau ‘JUnit TestCase’ sélectionner la classe à tester possibilité d’intégrer les méthodes setUp, tearDown … choisir les méthodes à tester Pour créer une classe pour exécuter un ensemble de tests, depuis Eclipse :

créer un nouveau ‘JUnit TestSuite’ sélectionner le package que l’on désire tester choisir les classes TestCase définies dans ce package et à exécuter choisir d’implémenter la classe main avec un TestRunner de type texte Il existe des outils de tests, non plus unitaires mais fonctionnels, pour les applications Swing ou Web. Quelques uns de ces outils sont décrits ici, pour information.

Log4j est un utilitaire (Apache/Jakarta) de gestion des logs qui s'intègre aux programmes. Il permet de tracer le flux d’une application et de trouver, par exemple, des bugs qui n'apparaissent qu'après plusieurs heures ou plusieurs opérations. Ce logger remplace les System.err ou System.out. De plus, log4J permet de spécifier où les messages seront logger (dans une console, dans un fichier…), le format d'affichage utilisé (quels renseignements affichés : date, thread, classe, numéro de ligne, etc…).

Il existe plusieurs niveaux de message qui sont gérés par ordre de priorité : FATAL, ERROR, WARN, INFO, DEBUG

Les fonctionnalités de Spring sont multiples : complément d’hibernate pour l’accès aux données de la BD, mécanisme d’inversion de dépendances, et bien d’autres qui ne sont pas utilisées dans eP-Core. Spring permet donc de spécifier, par le mécanisme d’inversion de dépendance, les objets d’implémentation qui sont utilisés par d’autres Objets.

Ainsi, soit un Objet A :

 Class A {
  IB myIB ;
 
   public void setMyIB(IB b) {…}
   public void myMethod{ //use interface myIB … }
 }
 
 Interface IB {
 // ….
 }
 
 Class B implements IB {   
   …
 }
  
 Class BWithNewTechnolgie implements IB {
    …
 }

Dans le fichier de configuration de Spring, on spécifie que la propriété myIB de A, qui est typée par une interface, est implémentée par un objet de type B ou BWithNewTechnologie :

<bean id="ib" class="B" ></bean>
<bean id="aObj" class="A" >
   <property name="myIB"><ref bean="ib"/></property>
</bean>

Après création des objets (utilisation des constructeurs vide), la méthode setMyIB sera appelée. Par la suite les appels aux différentes méthodes de l’objet aObj, qui utilise myIB pourront être utilisés.