Le déclin des serveurs d’applications Java

tomcat-dockerLes serveurs d’applications Java sont-ils en train de mourir à cause de Docker? c’est la question que s’est posé James Strachan dans son article écrit en anglais: the decline of Java application servers when using docker containers
Trouvant l’article particulièrement intéressant, j’ai demandé l’autorisation à son auteur pour le traduire afin de vous le proposer en français. L’article est traduit le plus fidèlement possible, seul la conclusion a été raccourcie et adaptée mais elle reste conforme à la vision de l’auteur initial.

Depuis des années, l’éco-système Java utilise les serveurs d’application. Le principe d’un serveur d’application Java (Servlet, JEE ou OSGi) repose sur un processus Java dans lequel on déploie & retire du code grâce à une archive de déploiement (jar, war, ear, bundle, etc). Le processus Java reste donc actif dans le temps et s’adapte au code. Les serveurs d’application ont donc le plus souvent un répertoire ou l’on dépose  une archive qui va modifier le code en cours d’exécution.

Lire la suite

Différence entre Hibernate et JPA

Hibernate/JPA permet de sauvegarder rapidement un objet java dans une base de données. Il permet de s’affranchir des requêtes SQL écrite à la main et le plus souvent difficile à maintenir dans le temps

Modèle de donnée avec JPA/Hibernate

Avec JDBC Classique, nous aurions probablement écrit des requêtes SQL dans une classe UserDao proposant un ensemble de méthode pour gérer les objets User et les relier à une base de données. C’est typiquement ce que proposait cet ancien article sur la réalisation d’un projet Spring.

JPA et Hibernate vont nous permettre de nous affranchir de l’écriture de ces longues requêtes SQL. Il s’agit de ce qu’on appelle des ORM  (object-relational mapping) ou en français Mapping objet-relationnel. Il s’agit d’un Framework qui va se charger de faire la correspondance entre notre objet User et la table correspondante dans la base de données.

Quel est la différence entre Hibernate et JPA?

Lire la suite

Modules et gestion de dépendances avec Maven

Modules Maven

Vous connaissez déjà Maven grâce à cette article et vous vous demander parfois à quoi peux servir un projet Maven multi-module.

Lorsque vous réaliser un grand projet, il n’est pas rare de réaliser plusieurs petites applications inter-connectés qui réalise chacune des tâches distinctes:

  • L’application Métier
  • Une Interface Web
  • Un application batch de traitement de données
  • Une interface Client Lourd

Maven propose donc une architecture multi-module permettant de regrouper ces différentes applications au sein d’un projet parent. Cette modularité permet une meilleur maintenabilité dans le temps, mais aussi d’identifier clairement les inter-connexions entre modules.

Par exemple, pour stopper le développement de mon client lourd à base de Swing qui ne sert plus à grand chose, je n’ai pas à aller modifier tout le code de mon gros projet volumineux, je ferme simplement le module correspondant, et je n’y touche plus.

Le projet parent a aussi l’avantage de pouvoir regrouper la configuration commune à l’ensemble de nos modules:

  • Gestion des dépendances et des versions. Un seul endroit pour faire une monté de version de Spring par exemple
  • Gérer des variables à réutiliser dans les POM des modules
  • Configurer les paramètres de connexion aux outils externes : git, jenkins, jira, etc.

Création du projet parent

Pour créer un projet multi-module, il faut d’abord créer un répertoire parent du nom de votre projet, et créer un fichier pom.xml, et ensuite créer des sous-répertoire pour chaque module. Chaque module doit avoir son propre pom.xml.

Voici le code du pom parent.

<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/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>fr.w3blog.demo</groupId>
  <artifactId>springrest</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>pom</packaging>
  <modules>
          <module>springrest-model</module>
  </modules>
</project>

Et celui d’un module.

<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/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <groupId>fr.w3blog.demo</groupId>
    <artifactId>springrest</artifactId>
    <version>0.0.1-SNAPSHOT</version>
  </parent>
  <artifactId>springrest-model</artifactId>
</project>

La plupart des IDE doivent vous permettre de créer cette arborescence automatiquement. Sous Eclipse, les modules sont considérés comme des projets à part entière, il vous suffit donc sur un projet maven de créer un nouveau projet et de sélectionner Module Maven dans le type de projet à créer.

Ajout des dépendances avec Maven

Comment ajouter une librairie à notre projet? Nous allons prendre comme exemple la librairie hibernate et l’inclure à notre projet.

Avec un projet Java classique, nous aurions téléchargé l’archive jar depuis un site internet que nous aurions inclus dans le répertoire WEB-INF/lib de notre projet web. Mais il aurait fallut très certainement recommencer pour télécharger la librairie javax.validation pour permettre à notre programme de reconnaître les annotations Beans Validation dont Hibernate a besoin pour contrôler ces données.

C’est là que la gestion des dépendances de Maven intervient, car elle connait les dépendances entre les librairies et est capable de résoudre automatiquement ces problèmes. Il nous suffit donc de déclarer la dépendance à Hibernate dans le fichier pom.xml de notre projet.

A la première compilation, Maven se charge automatiquement d’aller chercher la bonne librairie sur le repository central de Maven. Maven détecte également les dépendances nécessaire au bon fonctionnement d’hibernate, comme  la librairie validation-api, et va donc la télécharger. C’est d’ailleurs pour cette raison, que le tout premier lancement d’une commande Maven sur un nouveau poste est très longue car Maven va télécharger tout ce dont il besoin pour fonctionner, aussi bien les dépendances du projet, que ces propres dépendances pour lui permettre de compiler.

<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/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <groupId>fr.w3blog.demo</groupId>
    <artifactId>springrest</artifactId>
    <version>0.0.1-SNAPSHOT</version>
  </parent>
  <artifactId>springrest-model</artifactId>

        <dependencies>
           <dependency>
               <groupId>org.hibernate</groupId>
               <artifactId>hibernate-core</artifactId>
               <version>3.6.10.Final</version>
           </dependency>
           <dependency>
               <groupId>org.hibernate</groupId>
               <artifactId>hibernate-annotations</artifactId>
               <version>3.5.6-Final</version>
           </dependency>
           <dependency>
               <groupId>org.hibernate</groupId>
               <artifactId>hibernate-validator</artifactId>
               <version>4.3.1.Final</version>
           </dependency>
        </dependencies>

</project>

Si vous avez regardé l’article sur la création d’un projet Maven, vous aller surement reconnaitre les notions de groupId et artefactId.

Si votre IDE est configuré correctement, il doit mettre à jour automatiquement son Classpath et inclure les librairies, ce qui va vous permettre de faire de l’autocompletion sur les classes et les annotations.

Dans le cas contraire ou si vous utiliser la ligne de commande, il faudra executer la commande suivante dans le répertoire parent du projet

mvn install

Votre projet devrait ressembler à ceci.

maven-dependance

Dépendance Maven dans Eclipse

Gérer les dépendances dans le module parent

La syntaxe maven de déclaration des dépendances est assez lourde, il faut préciser la version de la librairie pour chaque dépendance. Monter de version une librairie ou un framework comme Spring pourrait vite devenir problématique. Heureusement, il existe le gestionnaire de dépendance dans maven, associé au multi-module, il présente de nombreux avantages.

Plutôt que de préciser le numéro de version dans chacun de nos sous-module, il est possible de définir une seul fois la version dans le module parent.

Voici à quoi ressemble le module enfant.

	   <dependency>
	       <groupId>org.springframework</groupId>
	       <artifactId>spring-core</artifactId>
	   </dependency>
	   <dependency>
	       <groupId>org.springframework</groupId>
	       <artifactId>spring-jdbc</artifactId>
	   </dependency>
	   <dependency>
	       <groupId>org.springframework</groupId>
	       <artifactId>spring-orm</artifactId>
	   </dependency>
	   <dependency>
	       <groupId>org.springframework</groupId>
	       <artifactId>spring-tx</artifactId>
	   </dependency>
	   <dependency>
	       <groupId>org.springframework</groupId>
	       <artifactId>spring-test</artifactId>
	   </dependency>

La déclaration des version ne se fait qu’une seule fois dans le POM du module parent, ce qui facilite la maintenance.

Voici la gestion des dépendances dans le POM parent :

  <properties>
  	<spring.version>3.2.0.RELEASE</spring.version>
  </properties>
  
  
  <dependencyManagement>
  	<dependencies>
	   <dependency>
	       <groupId>org.springframework</groupId>
	       <artifactId>spring-core</artifactId>
	       <version>${spring.version}</version>
	   </dependency>
	   <dependency>
	       <groupId>org.springframework</groupId>
	       <artifactId>spring-jdbc</artifactId>
	       <version>${spring.version}</version>
	   </dependency>
	   <dependency>
	       <groupId>org.springframework</groupId>
	       <artifactId>spring-orm</artifactId>
	       <version>${spring.version}</version>
	   </dependency>
	   <dependency>
	       <groupId>org.springframework</groupId>
	       <artifactId>spring-tx</artifactId>
	       <version>${spring.version}</version>
	   </dependency>
	   <dependency>
	       <groupId>org.springframework</groupId>
	       <artifactId>spring-test</artifactId>
	       <version>${spring.version}</version>
	   </dependency>
  	</dependencies>
  
  </dependencyManagement>

Grâce au propriété maven, la version peux être écrite qu’une seule fois. spring.version défini dans la balise properties permet de définit une variable qui peux être réutilisée dans le fichier de configuration Maven.

Gérer dans les dépendances aux version dans le POM parent permet d’effectuer une monté de version de Spring très rapidement. Il suffit de mettre à jour la variable à un seul endroit