Conception d’un client Eclipse RCP et serveur OSGI avec Spring DM [step14]

Dans le billet précédant [step13] nous avons mis en place l’application RCP qui fait appel au service UserService pour afficher la liste des Users dans une View via Spring DM. Cette liste provient du bundle Implémentation service org.dynaresume.services.impl qui retourne une liste de User statique créées en dur en Java.

A partir de ce billet, nous allons utiliser une base de donnée constituée d’une table T_USER qui contiendra la liste des User qui sera récupérée par le service UserService. Notre implémentation Service UserServiceImpl fera appel à un bundle DAO (Data Access Object) encore appelé Repository qui s’occupera de récupérer la liste des Users d’une base de donnée.

Voici un schéma grossier de ce que nous allons mettre en place dans les billets futurs :

Ce schéma montre que :

• la couche DAO utilisera JPA (Java Persistence API) l’API standard d’ORM (Object Relationnel Mapping).
• JPA étant une API, nous devons utiliser une implémentation de JPA dans notre DAO. Nous allons nous appuyer sur 2 implémentations JPA :
  • JPA/Hibernate implémentation de JPA avec Hibernate.
  • JPA/EclipseLink implémentation JPA avec EclipseLink. Cette implémentation qui est basé sur les sources de TopLink est une version adaptée au contexte OSGi, ce qui le rend facilement utilisable dans un contexte Eclipse RCP. EclipseLink a pour objectif d’implémenter JPA 2.0 (JSR 317).
• nous allons utiliser 2 base de données :
  • H2 Database
  • Derby

  J’ai choisi ces 2 bases de données car elles ne nécessitent aucune installation (comme MySQL par exemple) et peuvent être utilisé en mode embarqué, autrement dit il suffit de placer dans le classpath le JAR de la base de donnée pour l’utiliser.

Avant de démarrer les billets futurs nous devons télécharger les JARs (H2, Derby, JPA, EclipseLink, JPA/Hibernate). Pour cela, jJ’ai décidé d’utiliser Maven. Dans ce billet je vais expliquer comment utiliser Maven pour télécharger nos JARs requis. Dans les prochains billets, j’expliquerais ce qu’est JPA puis ce que peut apporter Spring dans un contexte JPA. Je montrerais ensuite comment utiliser JPA dans un contexte OSGi à l’aide de Spring DM et ce que peut apporter OSGi (changer de base, changer d’implémentation JPA… sans devoir redémarrer l’application RCP).

Ce que nous allons faire dans ce billet.

Vous pouvez télécharger le zip spring-target-platform-dao.zip qui contient tout ce qui va être expliqué dans ce billet. Ce zip contient un projet Simple Eclipse spring-target-platform-dao qui contient :

• le répertoire launch-mvn qui contient les Build Maven du plugin Eclipse plugin Eclipse M2Eclipse expliqué dans ce billet.
• le répertoire lib qui contient tous les JARs récupérés via Maven. Ils on été classés (à la main) pour ensuite pouvoir s’y retrouver dans les billets futurs. (Je n’ai pas réussi à faire ca avec Maven).
• le fichier Maven pom.xml décrit dans ce billet.

Maven, mais pourquoi?

Difficultés rencontrées avec JPA & OSGi

La mise en place de la couche DAO avec JPA (Hibernate et EclipseLink) dans un contexte OSGi a été pour moi la partie la plus difficile. Les 2 grandes difficultés que j’ai rencontré ont été que :

1. la distribution Spring DM ne contient pas les JARs JPA, EclipseLink, Hibernate…
2. une fois les JARs téléchargés avec les bonnes versions (et vous verrez il y en a une panacée), j’ai eu beaucoup de mal à mettre en place JPA/Hibernate du au concept d’1 ClassLoader par Bundle. La difficulté est d‘importer les bon packages dans les bons bundles pour éviter des erreurs de type ClassNotFoundException (du par exemple au Proxy Hibernate)..

Dans ce billet nous allons nous occuper de télécharger tous les JARs que nous allons avoir besoin pour mettre en place notre bundle DAO avec JPA, autrement dit nous devons télécharger :

• les JARs de l’API JPA.
• les JARs des implémentation JPA EclipseLink et JPA/Hibernate.
• les JARs des base de données embarquée Java Derby et H2

Maven pour télécharger des JARs

Lorsque j’ai commencé à mettre en place la couche DAO, j’ai téléchargé un à un ces JARs en utilisant le moteur de recherche SpringSource Enterprise Bundle Repository. J’ai vite abandonné ce procédé car (notamment avec JPA/Hibernate) il y a beaucoup de JARs à télécharger et chacun d’eux dépendent d’une version d’autres JARs en particulier.

Maven permet de régler ce problème car il suffit de déclarer un JAR (une dependency) dans un fichier XML (pom.xml) et celui-ci est capable de retrouver et télécharger les JARs dépendants. C’est ce qui est expliqué dans la section Téléchargement JAR (JPA) via Maven.

Maven

Si vous connaissez Maven et que vous l’avez déjà installé, vous pouvez vous passer de lire cette section.

Maven c’est quoi?

Voici une définition de Maven sur wikipedia :

Maven est un outil logiciel libre pour la gestion et l’automatisation de production des projets logiciels Java en général et Java EE en particulier. L’objectif recherché est comparable au système Make sous Unix : produire un logiciel à partir de ses sources, en optimisant les tâches réalisées à cette fin et en garantissant le bon ordre de fabrication.

Mavenl est semblable à l’outil Ant mais est orienté projet, autrement dit on décrit le projet que l’on souhaite construire en indiquant ces dépendances (dépendance JAR) dans un fichier XML pom.xml (Project Object Model). A partir de ces informations des tâches pré-définies (goal) peuvent être lancés en utilisant ce pom.xml pour par exemple télécharger les JARs dont dépendent le projet décrit, compiler les sources, générer la documentation HTML qui affiche la liste des dépendances…

Comment utiliser Maven?

Après avoir décrit son projet dans un fichier XML pom.xml, il faut lancer des goal sur celui-ci à l’aide de Maven :

• en ligne de commande
• OU avec le plugin Eclipse M2Eclipse.

Dans notre cas nous lancerons le goal dependency:copy-dependencies pour télécharger les JAR dans un répertoire personnalisé. Personnellement je préfère utiliser le plugin Eclipse M2Eclipse car son utilisation évite de devoir ouvrir des commandes DOS pour lancer maven.

Comment installer Maven?

Maven en ligne de commande (mvn)

Pour utiliser Maven en ligne de commande il faut :

1. télécharger son zip.Dans mon cas j’ai téléchargé la dernière version en date apache-maven-2.2.1-bin.zip.
2. Dézipper le zip dans un répertoire de votre disque. Dans mon cas je l’ai dézippé dans C:\Program Files\Apache Software Foundation\apache-maven-2.2.1 :
   
3. Mettre à jour la variable d’environnement M2_HOME (Sous Window Démarrer/Panneau de Configuration/Système puis Onglet Avancé puis bouton Variables d’environnement). Dans mon cas je l’ai défini en tant que variable Système. Cliquez sur Nouveau et renseignez la variable d’environnement qui pointe sur le répertoire racine de Maven. Dans mon cas je l’ai renseigné comme suit :
   • Nom de la variable avec M2_HOME
   • Valeurde la variable avec C:\Program Files\Apache Software Foundation\apache-maven-2.2.1

4. Il faut enfin définir le répertoire bin de Maven dans la variable Path pour que celui puisse être appelé via la commande mvn dans une fenêtre DOS. Ajoutez à la variable Path la chaîne %M2_HOME%\bin :

5. Cliquez sur OK, Maven (en ligne de commande) est maintenant installé.

Pour tester que Maven soit bien installé, ouvrez une Commande DOS (Menu Démarrer/Executer puis Ouvrir cmd).

Saisissez la commande Maven :

mvn

Maven doit se lancer et la fenêtre DOS doit afficher ceci :

La commande mvn s’est bien lancé et renvoit une erreur, ce qui est normal car nous n’avons pas renseigné de goal sur un pom.xml .

maven plugin Eclipse (m2Eclipse)

Le plugin Eclipse M2Eclipse permet de gérer les fichiers XML pom.xml via un éditeur et lancer des goal via des Run Configuration. L’installation de ce plugin s’effectue à l’aide de l’update site http://m2eclipse.sonatype.org/update/. Le plugin embarque une version de Maven 3 (mode EMBEDDED) ce qui évite (théoriquement) d’installer Maven.Je dis théoriquement car je n’ai pas testé ca. J’avais déja installé un Maven (en ligne de commande) avant d’installer le plugin. Il est apparemment aussi possible d’utiliser un Maven spécifique installé sur son disque.

spring-target-platform-dao & POM

Dans cette section nous allons créer le Projet Simple spring-target-platform-dao qui contiendra le pom.xml qui nous permettra de télécharger les JARs dans ce projet.

Créez un Projet Simple Eclipse spring-target-platform-dao.

Création POM

Créez à l’intérieur du projet spring-target-platform-dao le fichier Maven POM pom.xml comme suit :

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>org.dynaresume</groupId>
	<artifactId>org.dynaresume.targetplatform.dao</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>pom</packaging>
	
</project>

Ce POM est le plus basique que l’on puisse effectuer. Il est identifié par ID artifact org.dynaresume.targetplatform.dao appartenent au groupe org.dynaresume. Si vous avez installé le plugin M2Eclipse et que vous ouvrez ce fichier, l’éditeur de POM doit s’ouvrir :

La page d’Overview affiche les informations identifiant le POM.

Test POM (install)

Ici nous allons lancer notre premier goal Maven qui va être d’installer notre projet dans le repository locale Maven via la commande Maven:

mvn install

Si vous connaissez Maven vous n’avez pas besoin d’effectuer cette tâche. C’est juste pour expliquer comment fonctionne Maven.

Repository locale .m2

Mais que signifie repository locale Maven? Que signifie installation de notre projet?

Maven gère un repository locale qui est par défaut dans le répertoire utilisateur <username>/.m2. Dans le cas de Window généralement il se trouve dans C:\Documents and Settings\. Par exemple dans mon cas il se trouve sur C:\Documents and Settings\ANZER69N\.m2. Ce repository locale contient tous les projets (généralement les JARs) qui sont téléchargés par Maven (autant les plugins Maven que les JARs que l’on définit dans les dependencies des POM).

Lorsque l’on lance un goal Maven, celui-ci teste si les projets (généralement les JARs) requis sont contenus dans ce repository locale .m2. Dans le cas contraire il les télécharge.

L’installation de notre projet va consister à recopier notre POM dans le repository locale .m2 que nous pourrons ensuite y faire référence dans un autre POM (Cela ne servira à rien dans notre cas).

maven en ligne de commande (mvn)

Ici nous allons installer notre projet POM en ligne de commande Maven. Pour cela ouvrez une commande DOS puis placez vous dans le répertoire ou se trouve votre fichier pom.xml :

cd YOUR_WORKSPACE_HOME/spring-target-platform-dao

mvn install

Saisissez la commande Maven

mvn install

Ce log montre que le fichier pom a été installé dans le repository locale .m2 :

Le fichier org.dynaresume.targetplatform.dao-0.0.1-SNAPSHOT.pom est est notre fichier pom.xml déployé sur le repository local de Maven.

maven plugin Eclipse (m2Eclipse)

Ici nous allons installer notre projet POM à l’aide du plugin Eclipse M2Eclipse en créant un launch Maven. Pour cela accéder à la fenêtre Run Configuration. Le launch Maven va se créé en créant un Maven Build :

Cliquez sur l’item Maven Build + bouton droit + New puis renommez New_configuration en Install Dynaresume Target Platform DAO :

Cliquez sur le bouton Browse Workspace pour sélectionner notre pom.xml de notre projet, la fenêtre de dialogue de sélection des projets de notre workspace s’affiche :

Sélectionnez le projet spring-target-platform-dao qui contient notre pom.xml puis saisissez install dans le champs goal :

Cliquez sur le bouton Run pour lancer le goal install sur notre pom.xml. La première fois que vous executerez ce goal, maven télécharge tous les JARs dont il a besoin pour le goal install puis déploie notre pom dans le repository local .m2 comme ce que nous avons effectué en ligne de commande.

L’interêt d’utiliser le plugin Eclipse est que l’on peut relancer facilement le goal, exporter le launch pour le partager avec d’autres personnes.

Téléchargement JAR (JPA) via Maven

A ce stade nous avons un POM qui ne fait rien. Dans cette section nous allons voir comment télécharger le JAR de l’API JPA avec Maven. Pour cela nous devons enrichir le POM en déclarant les JARs auquel dépendent notre projet. Ceci s’effectue à l’aide de l’élement dependency qui fait référence à ID groupe et à un ID artifact (comme ce que nous avons renseigné dans notre POM vierge). Les étapes pour effectuer cela sont :

1. Retrouver la dépendance du JAR en cherchant sur Internet. Heursement, il existe plusieurs moteurs de recherche qui permettent de retrouver les dependency. En ce qui me concerne j’ai utilisé celui de SpringSource Enterprise Bundle Repository.
2. Indiquer l’URL du repository qui héberge la dependency dans le fichier pom.xml.
3. Ajoutez la dependency dans le fichier pom.xml.
4. lancez le goal adéquate (dependency:copy-dependencies) pour télécharger le JAR correspondant à la dependency et le copier dans un répertoire personnalisé.

SpringSource Enterprise Bundle Repository

SpringSource Enterprise Bundle Repository permet de télécharger les JARs à la main mais donne aussi les « dependencies » Maven. Ici nous allons retrouver la dependency de l’API JPA via ce repository.

Saississez dans le champs de recherche le mot clé Java Persistence API :

REMARQUE : si vous tappez jpa dans la recherche seul JPA/Hibernate est retrouvé.

Le résultat de recherche suivant s’affiche :

Cliquez sur le lien Java Persistence API 2.0.0. La page permet de télécharger les sources, le binaire du JAR à la main mais propose aussi la dependency Maven que nous allons utiliser :

Pom.xml

Les dependency dans un POM doivent être incluses dans l’élement XML racine dependencies. Pour cela ajoutez le contenu suivant à notre pom.xml :

dependency

<dependencies>

  <dependency>  
    <groupId>javax.persistence</groupId>  
    <artifactId>com.springsource.javax.persistence</artifactId>  
    <version>2.0.0</version> 
  </dependency>

</dependencies>

repository

Il faut aussi indiquer le l’URL du repository qui héberge ce JAR. Cette URL est indiqué dans cette FAQ. Pour JPA voici son URL :

<repository>  
  <id>com.springsource.repository.bundles.external</id>  
  <name>SpringSource Enterprise Bundle Repository - External Bundle Releases</name>  
  <url>http://repository.springsource.com/maven/bundles/external</url> 
</repository>

L’élement repository doit être contenu dans l’élement XML racine repositories. Nous allons devoir télécharger les JARs de Spring. Pour cela ajouter le contenu XML suivant au pom.xml :

<repositories> 
  <repository>  
    <id>com.springsource.repository.bundles.release</id>  
    <name>SpringSource Enterprise Bundle Repository - SpringSource Bundle Releases</name>  
    <url>http://repository.springsource.com/maven/bundles/release</url> 
  </repository> 
  <repository>  
    <id>com.springsource.repository.bundles.external</id>  
    <name>SpringSource Enterprise Bundle Repository - External Bundle Releases</name>  
    <url>http://repository.springsource.com/maven/bundles/external</url> 
  </repository>
</repositories>

goal dependency:copy-dependencies

Pour télécharger les JAR définis dans les dependency d’un pom.xml, il faut utiliser le plugin Maven Dependency Plugin. Ce plugin fournit plusieurs goal dont dependency:copy-dependencies qui permet de copier les dependencies définit dans le pom.xml dans le répertoire YOUR_pom.xml_BASEDIR/target/dependency. Ce goal peut être lancé de 2 manières différentes :

• en appelant directement le goal dependency:copy-dependencies via la commande Maven :

  mvn dependency:copy-dependencies

• en surchargeant une phase standard de Maven pour y inclure l’appel du goal dependency:copy-dependencies. Je ne vais pas détailler ce point, mais grossièrement Maven définit différents cycle de construction (build lifecycle) qui sont des phases comme par exemple :
  • compile : qui compile les sources du projet.
  • install: qui installe dans le repository local le projet construit.

Dans notre cas nous allons surcharger la phase process-resources pour faire appel au goal dependency:copy-dependencies pour copier les JARs téléchargés dans notre projet. Pour cela ajoutez le contenu XML suivant :

<build>
	<plugins>
		<plugin>
			<groupId>org.apache.maven.plugins</groupId>
			<artifactId>maven-dependency-plugin</artifactId>
			<version>2.1</version>
			<executions>
				<execution>
					<id>copy-dependencies</id>
					<phase>process-resources</phase>
					<goals>
						<goal>copy-dependencies</goal>
					</goals>
				</execution>
			</executions>
		</plugin>
	</plugins>
</build>

Lancement goal

A ce stade nous pouvons lancer notre goal qui permet de télécharger les JARs. Si vous souhaitez lancer Maven en ligne de commande vous pouvez lancez :

• mvn dependency:copy-depencies

• OU

  mvn process-resources

Si vous avez le plugin M2Eclipse vous pouvez créer des launch Maven Build pour effectuer cela :

Après avoir lancez le goal process-resources, effectuez un refresh (F5) sur le projet eclipse :

Le JAR JPA com.springsource.javax.persistence-2.0.0.jar se retrouve dans le repertoire target/dependency. Il se retrouve aussi dans le repository local .m2.

Configuration

Il est possible de configurer le répertoire de sortie ou doivent être copié les JAR définit dans les dependency. Dans notre cas nous allons copier les JAR dans le répertoire target/targetPlatform/plugins au lieu de target/dependency. Pour cela modifier l’élement XML execution comme ceci:

...
...
	<execution>
		<id>copy-dependencies</id>
		<phase>process-resources</phase>
		<goals>
			<goal>copy-dependencies</goal>
		</goals>
		<configuration>
			<outputDirectory>${project.build.directory}/targetPlatform/plugins</outputDirectory>
			<overWriteReleases>true</overWriteReleases>
			<overWriteSnapshots>true</overWriteSnapshots>
			<overWriteIfNewer>true</overWriteIfNewer>
			<excludeTypes>libd</excludeTypes>
			</configuration>
		</execution>
	</executions>
...

Relancez le goal process-resources, effectuez un F5 et vous verrez que le JAR est copié dans le répertoire targetPlatform/plugins.

POM final

Dans les prochains billets nous avons besoin de plusieurs JARs (OSGifier). Je les détaillerais au fur et à mesure des billets. Grossièrement nous avons besoins de :

• DBCP qui est un pooling de connection SQL.
• Derby et H2 les bases de données.
• API JPA.;
• JPA/Hibernate implémentation JPA avec Hibernate + Implémentation de SFL4J avec log4j.
• JPA/EclispeLink implémentation JPA avec EclispeLink.

Concernant EclispeLink je n’ai pas utilisé le repository de Spring car celui-ci ne propose que la version 1.1.0 de EclipseLink. Le repository indiqué dans http://wiki.eclipse.org/EclipseLink/Maven propose de télécharger la version EclipseLink 2.0.0 qui intègre la classe H2Platform qui permet de gérer le dialecte SQL pour H2. Cette classe nous sera utile dans la suite des billets (pour notamment gérer les IDENTITY des tables de la base H2). Le repository de EclipseLink :

<repository>
	<id>EclipseLink Repo</id>
	<url>http://www.eclipse.org/downloads/download.php?r=1&amp;nf=1&amp;file=/rt/eclipselink/maven.repo</url>
</repository>

doit être ajouté à la liste des repository du POM. Voici le POM final avec toutes ces repository et ces dépendances :

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>org.dynaresume</groupId>
	<artifactId>org.dynaresume.targetplatform.dao</artifactId>
	<packaging>pom</packaging>
	<version>0.0.1-SNAPSHOT</version>

	<build>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-dependency-plugin</artifactId>
				<version>2.1</version>
				<executions>
					<execution>
						<id>copy-dependencies</id>
						<phase>process-resources</phase>
						<goals>
							<goal>copy-dependencies</goal>
						</goals>
						<configuration>
							<outputDirectory>${project.build.directory}/targetPlatform/plugins</outputDirectory>
							<overWriteReleases>true</overWriteReleases>
							<overWriteSnapshots>true</overWriteSnapshots>
							<overWriteIfNewer>true</overWriteIfNewer>
							<excludeTypes>libd</excludeTypes>
						</configuration>
					</execution>
				</executions>
			</plugin>
		</plugins>
	</build>

	<repositories>

		<repository>
			<id>com.springsource.repository.bundles.release</id>
			<name>SpringSource Enterprise Bundle Repository - SpringSource Bundle Releases</name>
			<url>http://repository.springsource.com/maven/bundles/release</url>
		</repository>

		<repository>
			<id>com.springsource.repository.bundles.external</id>
			<name>SpringSource Enterprise Bundle Repository - External Bundle Releases</name>
			<url>http://repository.springsource.com/maven/bundles/external</url>
		</repository>

		<repository>
			<id>EclipseLink Repo</id>
			<url>http://www.eclipse.org/downloads/download.php?r=1&amp;nf=1&amp;file=/rt/eclipselink/maven.repo</url>
  		</repository>

	</repositories>


	<dependencies>

		<!-- DBCP Pooling Connection -->
		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>com.springsource.org.apache.commons.dbcp</artifactId>
			<version>1.2.2.osgi</version>
		</dependency>

		<!-- Derby Database -->
		<dependency>
			<groupId>org.apache.derby</groupId>
			<artifactId>com.springsource.org.apache.derby</artifactId>
			<version>10.5.1000001.764942</version>
		</dependency>

		<dependency>
			<groupId>org.apache.derby</groupId>
			<artifactId>com.springsource.org.apache.derby.client</artifactId>
			<version>10.5.1000001.764942</version>
		</dependency>

		<!-- H2 Database -->
		<dependency>
			<groupId>com.h2database</groupId>
			<artifactId>com.springsource.org.h2</artifactId>
			<version>1.0.71</version>
		</dependency>

		<!-- Javax JPA API + Transaction -->
		<dependency>
			<groupId>javax.persistence</groupId>
			<artifactId>com.springsource.javax.persistence</artifactId>
			<version>2.0.0</version>
		</dependency>

		<dependency>
			<groupId>javax.transaction</groupId>
			<artifactId>com.springsource.javax.transaction</artifactId>
			<version>1.1.0</version>
		</dependency>

		<!-- Use by Hibernate JPA -->
		<dependency>
			<groupId>javax.xml.stream</groupId>
			<artifactId>com.springsource.javax.xml.stream</artifactId>
			<version>1.0.1</version>
		</dependency>

		<!-- ORM Spring to use JPA with Spring -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>org.springframework.orm</artifactId>
			<version>2.5.6.A</version>
		</dependency>

		<!-- JPA/Hibernate -->
		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>org.hibernate.ejb-library</artifactId>
			<type>libd</type>
			<version>3.4.0.GA</version>
		</dependency>

		<!-- SL4J Implementation with Log4J -->
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>com.springsource.slf4j.log4j</artifactId>
			<version>1.5.0</version>
		</dependency>

		<!-- JPA/Eclipselink -->
		<dependency>
			<groupId>org.eclipse.persistence</groupId>
			<artifactId>org.eclipse.persistence.jpa</artifactId>
			<version>2.0.0</version>
		</dependency>

		<!-- Old version of JPA/Eclipselink
			<dependency>
				<groupId>org.eclipse.persistence</groupId>
				<artifactId>org.eclipse.persistence-library</artifactId>
				<type>libd</type>
				<version>1.1.0</version>
			</dependency>
		-->

	</dependencies>

</project>

Lancer + Refresh :

Conclusion

Dans ce billet nous avons téléchargé tous les JARs dont nous allons avoir besoin dans les prochains billets pour mettre en place la couche DAO avec JPA. Utilisé Maven pour télécharger les JArs facilite grandement la tâche. De plus il est très facile avec Maven de changer de version de JAR juste en modifiant les dependency du POM. Dans le prochain billet nous allons créer les 2 bases de données H2 et Derby.

Vous pouvez lire le billet suivant [step15].