Accueil → 2006/03/12, 14h59

Java/Spring/Hibernate versus Ruby On Rails -- 1

Ces jours ci, j'ai eu l'occasion de me familiariser à des technologies que je n'avais encore jamais utilisées:

Chez mon client, je suis impliqué dans le développement d'une application Web spécialisée basée en partie sur les standards J2EE, mais aussi sur une architecture maison qui génère une interface Web qui ne suit pas les standards habituels. Quoique très puissante et configurable, cette architecture nécessite un apprentissage assez considérable. Il est par conséquent difficile d'intégrer rapidement de nouveaux développeurs Web et l'ajout de nouvelles interfaces prend donc plus de temps que nécessaire.

Afin remédier à cette situation, il a été décidé d'effectuer une transition vers une architecture MVC standard. Comme une réécriture complète est hors de question, il s'est avéré nécessaire de trouver un moyen de transformer graduellement l'implantation actuelle: Les pages existantes restent, et les nouvelles sont développées de façon standard.

Les technologies choisies sont donc String et Hibernate. Il n'est pas opportun de discuter les raisons de ces choix ici. La partie Spring MVC s'intègre donc à un environnement qui offre déjà les services suivants:

  • L'authentification des utilisateurs
  • Gestion des droits d'accès aux pages en fonctions de rôles
  • Configuration: Fichiers XML avec valeurs systèmes telles que connexion à la base de données, valeurs par défaut, etc.
  • Profil d'utilisateur (Locale, formats de dates, fuseau horaire, formats numérique et décimal etc.)
  • Gestion des connexions à la base de données (Connection pool)
  • Présentation basée sur les FRAMESET html: La nouvelle partie Spring MVC est limités au seul "frame" central dans cette première phase d'intégration.

La première phase de cette intégration consiste à afficher des données provenant de la base de données. Il n'est pas nécessaire de produire des formulaires. Seule la visualisation de données avec pagination doit être implantée. Afin d'effectuer cette intégration, il fallait donc:

  • bien connaître l'architecture existante,
  • apprendre les technologies à intégrer: Spring, Spring MVC, et Hibernate,
  • imaginer un scénario d'intégration,
  • et implanter et intégrer ce scénario.

J'ai consacré exactement 3 semaines à ces tâches. Il en résulte une intégration réussie. Voici ce qui a été livré:

  • 3 JARs:
    • domain.jar: 2 JavaBean associés à 2 tables de la base de données
    • data.jar: Implantation DAO Hibernate
    • business.jar: Gère l'accès au domaine par l'entremise du DAO.
  • 1 WAR: Une nouvelle application Web basée sur Spring MVC, comprenant 3 vues.

Et voici en bref les éléments qui ont bouffé la plus grande parie de mon temps:

  • Apprendre les nouvelles technologies: Spring, Aspect Oriented Programming (AOP), Hibernate.
  • Intégrer le système d'authentification existant
  • Intégrer le pool de connexion existant
  • Intégrer le système de configuration existant
  • Pagination de longues listes de résultats avec utilisation de tags JSP tel que DisplayTag.
  • Intégrer au "build" existant

Par contre, il y a eu aussi des éléments facilitateurs:

  • Forums très actifs sur Hibernate, et Spring. Les réponses sont rapides et les recherches fructueuses.
  • Une fois AOP compris, ses avantages sont certains
  • Les technologies sont éprouvées (Hibernate 3, Spring 2)
  • Bonne utilisation des annotations dans Hibernate
  • Création de tests unitaires (JUnit) bien adaptée
  • Configuration XML dans MVC simple et puissante
  • Spring est peu (ou pas du tout) intrusif: Aucun changement dans le code existant n'a été requis (hum... un seul changement mineur en fait était nécessaire afin de permettre de connecter le gestionnaires de connexions existant à Spring)

3 semaines donc. Je suis un développeur Java senior. Mon expérience de travail avec ce langage et sa multitude de librairies remonte à la première version du JDK. Les habitués de J2EE, Spring et/ou Hibernate vont peut-être crier à l'incompétence. Soit; j'accepte le blâme et vous donne donc raison en acceptant d'être vu comme un junior très moyen dans le cadre de ce projet. Il aura donc fallu 3 semaines à un junior pour intégrer Spring, Hibernate, les tags JSP à une application Web existante.

À temps partiel dans les semaines qui viennent, ce même junior va créer une application Web nouvelle basée sur Ruby On Rails.

Certains diront que je comparerai des pommes et des oranges: Dans le cas de Java (Spring/Hibernate), il s'agissait d'une intégration à un système existant alors que dans le cas à venir, il s'agira d'une application nouvelle. Les tâches sont donc différentes. L'intégration force à se creuser la tête afin de connecter 2 façons de faire. Par contre, l'existence des processus de déploiement, et la connaissance approfondie du domaine ont fait en sorte que j'ai sauvé du temps. Dans le cas d'une application neuve, il me faudra maîtriser une nouvelle technologie, définir le domaine, et les vues de A à Z. En tant que junior, il faudra:

  • apprendre un nouveau langage (Ruby),
  • me familiariser à une librairie et façon de faire (Rails),
  • définir un schéma de données,
  • définir un processus de visualisation et de modifications des données (vues et formulaires),
  • implanter le tout,
  • déployer le tout.

Le compte à rebours n'est pas commencé car je ferai ça durant mes temps libres, aussi rares soient-ils. Mais une fois commencé et complété, je publierai les résultats.