Spring MVC – Validator

Objectifs

  • Comprendre le mécanisme utilisé par Spring MVC pour la validation d’un formulaire.

Validation

La validation ne fait pas partie du module Spring MVC mais elle est déléguée à l’infrastructure de validation fournie par Spring et ceci en implémentant l’interface org.springframework.validation.Validator.

Deux types de validaton sont possibles :

  • Programmatique validation : les règles de validation sont implémentées dans une classe java.
  • Déclaratif validation : les règles de validation sont déclarées dans un fichier de configuration.

Le schéma ci-dessous décrit le cycle de traitement d’une requête par Spring MVC. Ce qui nous intéresse, à ce niveau, est l’étape de validation du formulaire, mais ceci n’empêche pas de décrire tout le cycle à titre de rappel.

validationschema.jpg

Lire la suite de ‘Spring MVC – Validator’

Spring MVC – SimpleFormController

Objectifs

  • Comprendre le processus de traitement d’une requête par le contrôleur SimpleFormController.
  • Comprendre les méthodes utilisées par le contrôleur SimpleFormController.

Processus de traitement d’une requête

Nous décrivons ci-dessous le cycle de traitement d’une requête  par le  contrôleur SimpleFormContoller. Après le submit du formulaire le form bean envoyé vers le contrôleur passe par plusieurs méthodes pour être traité.

simpleformcontrollerprocess.jpg

  1. En recevant une requête le SimpleFormController teste, isFormSubmission(), si la requête est de type POST. Si c’est le cas, une commande sera créée formBackingObject().  
  2. Ensuite un binder sera crée et initialisé initBinder().
  3. Le SimpleFormController teste par la suite, isBindOnNewForm(), si un post traitement spécifique doit être exécuté.
  4. Tester, isSessionForm(), si le formulaire doit être récupéré de la session.
  5. Initialiser par la suite le formulaire par les reference data.

Lire la suite de ‘Spring MVC – SimpleFormController’

Spring MVC Controllers

Objectifs:

  • Déterminer les cas d’utilisation des contrôleurs implémentés par Spring MVC
  • Déterminer le fonctionnement des contrôleurs : AbstractController et AbstractCommandController

Spring MVC controllers

Un grand plus que marque Spring MVC par rapport aux autres framework telleque Struts ou WebWork, c’est qu’il offre une panoplies de contrôleurs dont chaque un est spécifique à un traitement bien particulier. Mais pour profiter de cet avantage il faut bien comprendre le fonctionnement de chaque contrôleur à fin de faire le bon choix.

Les contrôleurs de Spring MVC peuvent être classés en six catégories, nous décrivons dans le tableau ci-dessous en quel cas on peut choisir chaque type.

tabusecase.jpg

Lire la suite de ‘Spring MVC Controllers’

Les design pattern GoF – 2 éme partie

Dans cet article nous allons voir en détail l’objectif des designs pattern de GoF.

Les patterns de création

Les patterns de création ont pour vocation d’abstraire les mécanismes de création d’objets. Un système utilisant ces patterns devient indépendant de la façon dont les objets sont créés et, en particulier, des mécanismes d’instanciation des classes concrètes. Ces patterns encapsulent l’utilisation des classes concrètes et favorisent ainsi l’utilisation des interfaces dans les relations entre objets augmentant les capacités d’abstraction dans la conception globale du système.

Les 5 patterns de création sont

  • Factory Method
  • Abstract Factory
  • Builder
  •  Prototype
  • Singleton

Factory Method : a pour but d’introduire une méthode abstraite de création d’un objet en reportant aux sous-classes concrètes la création effective.

Utiliser ce pattern lorsque :

  • Une classe ne peut pas anticiper la classe des objets qu’elle doit créer.

Lire la suite de ‘Les design pattern GoF – 2 éme partie’

Spring MVC – Hello World

Dans cet article nous allons créer notre première application, Hello World,  avec spring MVC.

Structure de l’application

La structure de notre première application est la suivante :

structure1.jpg

Dans WEB-INF créer le dossier lib et ajouter les libs suivantes :

  • \spring-framework-2.5.5\dist\ spring.jar
  • \spring-framework-2.5.5\dist\modules\ spring-webmvc.jar
  • \spring-framework-2.5.5\lib\jakarta-commons\ commons-logging.jar
  • \spring-framework-2.5.5\lib\j2ee\servlet-api.jar
  • \spring-framework-2.5.5\lib\j2ee\jstl.jar

Vous pouvez télécharger les lib de l’adresse : http://www.springframework.org/download

Fichiers de configuration

Lire la suite de ‘Spring MVC – Hello World’

Spring MVC – Présentation

L’objectif de cet article est de présenter le principe de fonctionnement de spring MVC ainsi que les bases de ce framework.

Principe de fonctionnement

Spring MVC est un framwork qui permet d’implémenter des applications selon le design pattern MVC. Donc, comme tous autre MVC framework, Spring MVC se base sur le principe décrit par le schéma ci-dessous :

mvc schema

Passant maintenant aux détails : ci-dessous la cinématique de la gestion d’une requête par Spring MVC.

spring mvc

Lire la suite de ‘Spring MVC – Présentation’

Les design pattern GoF – 1 ère partie

Définition

Un design pattern ou pattern de conception est une architecture de classes qui forme une solution à un problème fréquemment rencontré lors des phases d’analyse et de conception d’applications.

 Un pattern est donc une façon de faire, permettant d’utiliser des solutions connues et éprouvées dont la conception provient de l’expérience de programmeurs.

 Les design Patterns permettent de :        

  • Simplifier les phases d’analyse et de conception en réutilisant des solutions existantes.

  • Structurer l’application et rendre le code plus lisible et simple à maintenir.

  • Réduire la complexité de l’architecture des applications.

  • Etablir une terminologie commune en fournissant un point de référence commun au cours de la phase d’analyse et de conception d’un projet.

Mais attention, avant d’appliquer un design pattern il faut bien identifier le problème pour choisir le design pattern adéquat. Le plus important est  donc comprendre et savoir quel problème chacun des designs pattern permet de résoudre

Lire la suite de ‘Les design pattern GoF – 1 ère partie’

Eclipse : les raccourcis clavier pour coder plus vite

A fin d’optimiser le temps de développement en utilisant l’IDE eclipse, je vous propose dans cet article une suite de raccourcis que je trouve les plus pratiques :

Complétion

Ctrl+espace : L’indispensable auto-complétion.

En tapant les premières lettres d’un nom de classe ou de méthode et par la suite « Ctrl + espace », Eclipse propose une liste des éléments commençant par le préfixe donné.

Il est possible d’utiliser la complétion dans les cas suivants :

  • Pour une classe, il est possible d’utiliser la complétion en tapant les « CamelCase » exemple tapez  « HM » pour HashMap. En utilisant la complétion pour une classe, Eclipse ajoute automatiquement la déclaration de l’import si ce dernier est absent.

  •   Pou les noms de variables. Exemple : après HashMap, Eclipse propose hashMap et map comme nom de variable.
  • Pour une méthode.

  • Pour utiliser un modèle (exemple le squelette d’une boucle while, il suffit de taper le prefixe et Ctrl+space. Il est possible d’ajouter ces propres modèles dans Preferences->Java->Editor-> Templates.

Correction rapide

Le raccourci Ctrl+1 affiche le ‘QuickFix’. Eclipse affiche alors une liste d’actions possibles pour corriger l’erreur.

Recherche et Navigation

Eclipse propose plusieurs raccourcis  pour chercher une classe, naviguer entre les classes et pour visualiser des informations sur un nom de classe ou de méthode sélectionné.

Le raccourci F3 affiche le code de l’élément actuellement sélectionné dans l’éditeur. Ou en cliquant dessus avec la touche Ctrl enfoncée.

ALT+LEFT,  ALT+RIGHT : aller à la position précédente ou suivante et Ctrl+Q pour revenir à la position de la dernière modification.

Ctrl+T : affiche l’arborescence d’héritage de la classe courante. Très utile pour trouver rapidement quelle classe concrète implémente une interface donnée, ou dans quelle classe une méthode est définie.

Ctrll-Shift-T : permet la recherche d’une classe. Il est possible d’utiliser les « CamelCase » dans la recherche.

Ctrl+F : recherche dans l’éditeur.

Ctrl+E : afficher la liste des fichiers ouverts dans l’éditeur.

Formatage du code

Ctrl+Shift+F : pour le formatage soit de tout le fichier soit les lignes sélectionnées.

Ctrl+Shift+O : pour organiser  la liste des imports : les imports manquants sont ajoutés, les inutiles supprimés et la liste est classée.

Vous pouvez demander à Eclipse de nettoyer automatiquement votre code, suivant les règles que vous aurez établies, à chaque fois que vous sauvegardez. Pour cela, passez par la page de préférence Java -> Editor -> Save Actions. Par exemple, vous pouvez demander à Eclipse de supprimer les variables non utilisés, d’ajouter les annotations « @Override » manquantes, de supprimer les espaces superflus à la fin des lignes, etc.

Enfin, vous pouvez utiliser Ctrl+shift+L pour afficher la liste des raccourcis qui propose Eclipse.

L’essentiel

resumé

NB : Ces raccourcis ont été testés avec Eclipse 3.4.

Struts 2 : première application

L’objectif de cet article est d’expliquer comment mettre en place le framework Struts 2 : (configuration des fichiers,  implémentation des actions, implémentation des jsp). Pour ceci, nous allons créer une application de gestion d’utilisateur se basant sur le framework Struts 2. Dans une première étape, nous nous limitons à l’implémentation de l’action d’authentification afin  de se concentrer sur les bases nécessaires pour la configuration et l’utilisation de Struts 2. Ensuite, nous ajouterons d’autres fonctionnalités d’ajout, suppression et modifications des utilisateurs et des droits.

Nous intégrerons par la suite, dans les prochains articles, les framework Freemark, Hibernate et Spring.

Présentation du Struts 2

Contrairement à ce que peut indiquer le nom, Struts 2 n’est pas une continuation de Struts 1 mais une fusion entre les frameworks Struts 1 et WebWork.

Struts 2 est créé pour répondre aux  faiblesses de Struts 1 et particulièrement le fort couplage des actions avec le framework et l’obligation de re-décrire un javabean pour récupérer un formulaire.

Le cycle de vie standard de Struts 2 est définit par le schéma ci-dessous :

cycle de vie de struts

  • Une fois le « dispatcher filter » passé, la requête est soumise aux intercepteurs. Ces derniers ont pour rôle d’effectuer des pre/post traitements sur la requête (gestion des exceptions, upload de fichier, validation…).
  • L’action est instanciée, peuplée puis le formulaire est validé.

  • Invocation de la méthode contenant la logique de l’action.

  • Délégation de l’affichage à la vue.

 
Application Gestion des utilisateurs

Pour commencer, créez sous eclipse un nouveau projet web « UserAdmin ».
Ajoutez au projet les librairies suivantes :

  1. struts2-core.jar
  2. xwork.jar
  3. ognl.jar
  4. freemarker.jar
  5. commons-logging.jar

Ces librairies sont obligatoires pour créer un projet Struts 2.

La structure du projet est décrite par le schéma ci-dessous :

structure application

Dans ce qui suit, nous allons décrire en détail les fichiers de configuration (web.xml et struts.xml) du projet.

Fichier de configuration web.xml

La configuration minimale du fichier web.xml pour  un projet Struts 2  est la suivante :

web.xml

Les éléments les plus importants dans le fichier web.xml sont filter et filter-mapping utilisés pour la configuration du FilterDispatcher.

Le FilterDispatcher est la servlet de base du framework Struts 2, il permet  de traiter toutes les requêtes en entrée, il permet l’accès aux éléments de base (ConfigurationManager, ActionMapper, ObjectFactory …)  du framework pour traiter les requêtes.

Fichier de configuration struts.xml

struts.xml

Le fichier struts.xml permet de configurer le mapping entre l’URL et l’implémentation de l’action. Ce fichier doit être  dans le dossier  src.

Le fichier struts.xml peut contenir les balises suivantes: constant, package, include, et  bean.

La balise constant :

Struts 2 permet de définir des constantes dans le ficher de configuration struts.xml, ces constantes peuvent être aussi définies dans le fichier de configuration struts.properties.

Il faut juste faire attention à l’ordre de chargement des fichiers de configuration de Struts car une constante définie dans un fichier peut être ‘overiden’ dans un autre fichier chargé après.

L’ordre de chargement des fichiers de configuration est le suivant:

  1. web.xml
  2. default.properties dans  Struts JAR
  3. struts.properties  dans  WEB-INF/classes
  4. struts-plugin.xml dans chaque plug-in JAR
  5. struts.xml dans WEB-INF/classes

La balise package :

La configuration de l’application peut être fragmentée en package. On peut par exemple créer un package pour chaque module de l’application ou par chaque fonctionnalité.

La synthaxe est la suivante:

  • name: nom du package, il doit être unique.
  • extends: un package peut extends un autre package, ce qui permet d’accéder à toutes les propriétés du package parent.
  • abstract: si le package est abstract il ne peut pas être accédé à partir d’une URL, il est juste utilisé pour l’organisation de la configuration.
  • namespace: indique le chemin depuis laquelle les actions vont être accessible.

Il est recommandé d’étendre le package par défaut struts-default pour ne pas être obliger à redéfinir des intercepteurs nécessaire pour le fonctionnement de Struts 2.

Les Actions

Créer les actions LoginAction et LogoutAction

actions

La seule contrainte pour les actions, avec Struts 2, est le fait qu’elles doivent implémenter au moins une méthode du type  ‘no-argument’ qui doit retourner un String ou un objet Result, si non on peut utiliser la méthode execute ().

Avec Struts 2, il n’est pas obligatoire d’hériter d’une action générique, mais les actions peuvent hériter de la classe générique ActionSupport  qui implémente la méthode execute().

La classe ActionSupport  implémente plusieurs interface telles que Action, Validateable et  ValidationAware interfaces.

Les jsp

Créer les pages login.jsp et success.jsp

jsp

Pour télécharger l’application cliquez ici application

Conclusion

Dans cet article, nous avons vu la configuration minimale pour un projet se basant sur le framework Struts 2. Dans les prochains articles, nous allons voir en détail des aspects plus avancés de Struts 2.

 Référence

Struts 2 in Action par DONALD BROWN, CHAD MICHAEL DAVIS et SCOTT STANLIC

 

Intégration d’Hibernate avec Spring

L’objectif de cet article est d’exposer les différentes méthodes permettant d’intégrer les frameworks Hibernate et Spring dans une même application.

Intégartion Hibarnate et Spring

Il existe deux méthodes pour intégrer les deux frameworks spring et Hibernate dans une même application :

  • La première méthode consiste à utiliser le module spring ORM.
  • La deuxième c’est d’utiliser le module spring DAO.    

Spring offre, à travers ses deux modules, spring ORM et spring DAO,  une solution pour l’intégration de plusieurs frameworks de mapping (Hibernate, iBatis, JDO, TopLink …).

Le principe des deux modules consiste à faire une abstraction par rapport au framework de mapping utilisé pour accéder à la base de données en offrant un système de management des transactions et d’accès aux données et une hiérarchie d’exceptions génériques.

Dans cet article, nous allons voir comment configurer spring et Hibernate en utilisant les deux méthodes.

Pour les deux méthodes,  il est obligatoire de déclarer un dataSource qui définit la connexion à la base. L’exemple ci-dessous permet de configurer la connexion à une base MySQL.

On peut utiliser un fichier « propreties » pour configurer et définir les paramètres de la dataSource.config

Une fois le dataSource est configurée, il est nécessaire de définir une sessionFactory. L’exemple ci-dessous montre comment définir une sessionFactory pour Hibernate2.

config

Pour utiliser spring et Hibernate, il est obligatoire que le sessionFactory soit une instance de la classe LocalSessionFactoryBean de Spring. Le sessionFactory doit faire référence à la dataSource définit précédemment. Ensuite, il faut préciser les fichiers de mapping d’Hibenate. Enfin, il faut définir les propriétés spécifiques à Hibernate telle que hibernate.dialect qui est spécifique à chaque base et qui permet d’optimiser l’utilisation des spécificités de chaque base, par exemple pour la génération du SQL.

Utiliser Spring DAO

Pour utiliser cette méthode, il faut que les classes DAO héritent de la classe HibernateDaoSupport de Spring. Les beans des DAOs doivent avoir la propriété « sessionFactory » comme le montre l’exemple ci-dessous.

daoconf

 
Utiliser Spring ORM

Cette méthode n’impose aucune contrainte, il suffit juste de définir un HibernateTemplate comme le montre l’exemple ci-dessous :

orm context

HibernatTemplate offre plusieurs méthodes pour accéder aux méthodes offertes par le framework Hibernate. Si vous voulez utiliser des méthodes non supportés par HibernateTemplate vous devez utiliser callback, comme le montre l’exemple ci dessous, et ceci pour accéder aux méthodes de la session Hibernate.

orm dao

Application

Dans cet article, nous allons partir de  l’application  de l’article précédent « intégration spring  struts » pour ajouter le framework Hibernate.

La base de données utilisée est MySQL. La base springdb contient une table user qui contient les champs id, login et password.

L’objectif de l’application est de montrer comment  mettre en place Hibernate et spring sans entrer dans les détails des méthodes des modules spring DAO et spring ORM.

Pour utiliser Spring ORM il faut:

Modifier le fichier de configuration applicationContext.xml  en suivant ce qui est décrit précédement.

Ajouter le fichier de mapping User.hbm.xml.

user hbm

Ajouter les interfaces DAO et UserDAO.

Ajouter la classe UserDAOImpl, l’implémentation de la classe UserDAO.

user dao

Modifier la classe UserManagerImpl pour utiliser la classe UserDAO.

manager
Pour télécharger le code de cette application cliquer ici application

Pour utiliser spring ORM, il suffit  de modifier les fichiers applicationContext.xml et UserDAOImpl comme c’est indiqué dans les exemples du paragraphe « Utiliser Spring ORM ».

Conclusion

Dans cet article, nous avons vu comment intégrer spring et Hibernate dans une même application en utilisant spring DAO et spring ORM. Il reste maintenant à configurer l’application pour gérer les transactions, ceci sera l’objectif du prochain article.

Références

http://static.springframework.org/spring/docs/2.0.x/reference/orm.html

Spring in action Craig Walls & Ryan Breidenbach


12



OCS :: Oracle Collaborative... |
UN PEU SUR JACKS, C'EST COM... |
Mes ordinateurs |
Unblog.fr | Créer un blog | Annuaire | Signaler un abus | MM SITE
| Dahevos L!f3
| bkaurelien