SpringSource en vidéos

SpringSource est une bibliothèque Java qui aide à créer des applications Java complexes. Pour aider dans l'apprentissage, voici quelques vidéos sur différents aspects de cet outil.

Article lu   fois.

L'auteur

Site personnel

Liens sociaux

Viadeo Twitter Facebook Share on Google+   

I. Préambule

Le but de cet article est d'assurer la pérennité de ces tutoriels vidéo. Étant donné que mes essais avec des lecteurs Flash ne se sont pas avérés concluants pour faire du streaming efficacement, il y a une version YouTube pour écouter en direct et il y a un lien en dessous pour télécharger la vidéo. Ce lien est sur les serveurs de développez, alors il va toujours fonctionner.

II. Remerciements

Merci à ClaudeLELOUPClaudeLELOUP pour l'aide à la correction.

1. Installer SpringSource Tool Suite dans Eclipse

Cette vidéo explique comment configurer Eclipse Updater sur Eclipse 3.6. Pour la version 3.7, l'explication est la même sauf pour l'URL du fichier de configuration.

Pour configurer Eclipse, vous avez besoin d'un :

2. Configurer une application pour utiliser SpringSource

Pour utiliser SpringSource, vous avez besoin de :
Contenu de la vidéo :
  • Explication du projet exemple utilisé (00:05) ;
  • Créer un fichier de configuration Spring (01:54) ;
  • Le code pour lire le fichier de configuration avec un ApplicationContext (03:05) ;
  • Ajouter les bibliothèques nécessaires pour le contexte (03:37) ;
  • Le code pour lire le fichier de configuration avec un ClassPathXmlApplicationContext (04:19) ;
  • Ajouter les bibliothèques nécessaires pour permettre la compilation (04:47) ;
  • Créer un bean "myStory" dans le fichier de configuration Spring (05:20) ;
  • Le code pour obtenir un bean "myStory" par Spring (06:04) ;
  • Ajouter les bibliothèques nécessaires pour permettre l'exécution (06:56) ;
  • Exécution du projet fonctionnel (08:09) ;
  • Modifier la configuration Spring pour une autre classe (08:45) .

3. Le scope d'un bean

Lorsque vous utilisez le beans factory, des objets sont créés avec la classe et l'id que vous leur spécifiez. Lorsque l'application demande un bean, elle peut recevoir toujours le même ou en recevoir un nouveau.

Contenu de la vidéo :
  • Explication du projet exemple utilisé (00:05) ;
  • La portée par défaut (singleton) (01:11) ;
  • La configuration de la portée dans la configuration Spring (01:37) ;
  • Obtenir un nouvel objet avec la portée "prototype" (01:56) ;
  • Exemples dans les applications (02:28) .

4. Utilisation de beans

Souvent, un bean a besoin d'autres beans pour être créé et utile. Vous verrez comment passer des arguments à leur constructeur et configurer leurs propriétés manuellement ou automatiquement.

Contenu de la vidéo :
  • Explication du projet exemple utilisé (00:08) ;
  • Création d'un bean "myStoryTeller" (01:29) ;
  • Choisir une valeur au paramètre du constructeur de "myStoryTeller" (02:18) ;
  • Créer un bean "myStory" (03:21) ;
  • Passer le bean "myStory" au champ "story" de "myStoryTeller" (03:40) ;
  • Utilisation de "autowire" pour ne pas avoir à passer le bean "myStory" (04:15) ;
  • Utilisation de "autowire" dans le code Java plutôt que dans le fichier de configuration (05:07) ;
  • Ajouter le balayage des classes dans le fichier de configuration pour vérifier s'il y a des annotations "@Autowired" (05:47) ;
  • Essais avec d'autres classes (06:42) .

5. Spring AOP (Aspect Oriented Programming)

SpringSource supporte la programmation orientée aspect en créant des beans proxy.

Pour utiliser l'AOP, vous aurez besoin de :
Contenu de la vidéo :
  • Explication du projet exemple utilisé (00:23) ;
  • Exécution de l'exemple sans utiliser d'aspect (01:30) ;
  • Créer un aspect qui va calculer le temps d'exécution des fonctions (02:09) ;
  • Configurer Spring pour utiliser cet aspect (04:53) ;
  • Exécution de l'exemple en utilisant l'aspect (05:54) ;
  • Démonstration que le proxy de Spring appelle le bean directement (06:42) ;
  • Explication de cette limitation en images (07:04) ;
  • Démonstration qu'il faut absolument passer par un bean de Spring pour utiliser les aspects de Spring AOP (07:56) .

6. AspectJ Weaver

Dans cette vidéo, vous verrez quoi modifier dans votre projet "Spring AOP" pour utiliser le LoadTimeWeaver d'AspectJ. Ceci vous permettra de ne plus avoir d'objets proxy et de pouvoir utiliser les aspects sans avoir à passer par le bean factory de Spring.

Pour utiliser le Weaver, vous aurez besoin de :
Contenu de la vidéo :
  • Configurer Spring pour utiliser le weaver (00:33) ;
  • Configurer AspectJ (01:12) ;
  • Configurer le lancement de Java en spécifiant qu'il faut utiliser l'agent de Spring (02:22) ;
  • Exécution de l'exemple (02:54) .

7. Créer un PropertyEditor

Lorsque vous créez un bean dans le contexte applicatif, vous désirez parfois mettre du texte comme valeur à une propriété. Par défaut, Spring peut transformer le texte en booléen, en nombre et autres primitives, mais il ne sait que faire avec vos types personnalisés. Vous pouvez lui dire comment transformer du texte en vos objets en créant un PropertyEditor.

Contenu de la vidéo :
  • Explication du projet exemple utilisé et description du problème à résoudre (00:10) ;
  • Exécution de l'exemple avec le problème (01:14) ;
  • Créer un éditeur de type PropertyEditorSupport dans le même paquet que la classe à convertir (02:00) ;
  • Exécution de l'exemple (05:15) ;
  • Déplacer l'éditeur dans un autre paquet (05:27) ;
  • Configurer Spring pour qu'il utilise l'éditeur à un endroit personnalisé (06:05) ;
  • Exécution de l'exemple (07:04) .

8. Utiliser ConverterService et créer des Converters

Il arrive souvent de devoir prendre un String et le convertir en nombre. Vous pouvez aussi vouloir convertir une de vos classes en n'importe quelle autre qui a du sens. Spring offre certains convertisseurs et vous pouvez lui en assigner d'autres.

Contenu de la vidéo :
  • Utilisation du ConversionService pour convertir quelques types de base (00:23) ;
  • Configurer Spring en créant un bean (01:10) ;
  • Exécution de l'exemple de base (01:40) ;
  • Explication du type personnalisé "Age" pour l'exemple (01:54) ;
  • Exécution de l'exemple et erreur (02:29) ;
  • Créer deux convertisseurs pour notre type (02:42) ;
  • Configurer Spring pour qu'il utilise nos convertisseurs (03:53) ;
  • Exécution de l'exemple (04:22) .

9. Intégrer Spring MVC, Hibernate et Tomcat

Créer une application complète nécessite l'utilisation de plusieurs technologies. La configuration de celles-ci peut parfois être complexe. Voici un petit projet de chatpetit projet de chat comme exemple.

Voici les technologies utilisées :
  • Maven pour gérer les dépendances ;
  • Tomcat comme container d'application web ;
  • Spring MVC pour gérer les requêtes AJAX ;
  • Hibernate pour enregistrer les messages sur la base de données MySQL ;
  • Html/JavaScript/jQuery pour l'interface web .
Contenu de la vidéo :
  • Dépendances de bibliothèques (pom.xml) (01:08) ;
  • Spring et spring MVC dans Tomcat (web.xml) (01:37) ;
  • Vues et contrôleurs web (dispatcher-servlet.xml) (02:49) ;
  • Classe contrôleur et fichiers JSP de vues (03:40)(04:39)(05:05) ;
  • Persistance avec hibernate (applicationContext.xml) (05:27) ;
  • Entities et DAO (06:52)(09:15) ;
  • Code HTML et Javascript (10:38) .

10. Spring Roo

Lorsque nous créons une application d'entreprise, il n'est pas rare d'utiliser plusieurs bibliothèques ensemble comme Spring, Hibernate, MySQL, AspectJ... La configuration entre elles peut être ardue avec la quantité de fichiers de configuration à créer. Spring RooSpring Roo permet de faire tout cela rapidement et bien plus.

Contenu de la vidéo :
  • Créer le projet (00:31) ;
  • Description des fichiers dans un projet de base (01:17) ;
  • Ouvrir la ligne de commandes Spring Roo (02:09) ;
  • hint (pour voir quoi faire selon l'étape rendue) (02:24) ;
  • persistence setup --provider HIBERNATE --database HYPERSONIC_IN_MEMORY (02:54) ;
  • Changer pour MySQL par la suite (04:54) ;
  • entity --class ~.domain.Message --testAutomatically (05:51) ;
  • Explication du contexte de Spring Roo (09:44) ;
  • field date --fieldName created_date --notNull [--class si pas dans le context] (10:04) ;
  • field string --fieldName nick --notNull (11:31) ;
  • field string --fieldName message --notNull (11:53) ;
  • perform eclipse (12:40) ;
  • perform tests (13:03) ;
  • controller all --package ~.web (13:42) ;
  • Tous les fichiers web (15:41) ;
  • Utiliser Tomcat (17:47) ;
  • security setup (19:12) ;
  • perform package (22:16) .

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants : Viadeo Twitter Facebook Share on Google+