SpringSource en vidéos

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.

Merci à ClaudeLELOUPClaudeLELOUP pour l'aide à la correction.

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.

• fichier de configuration d'Eclipse 3.6Fichier de configuration d'Eclipse 3.6 ;
• fichier de configuration d'Eclipse 3.7Fichier de configuration d'Eclipse 3.7 .

• SpringSource Tool (voir section précédente) ;
• la bibliothèque SpringFrameworkSpringFramework ;
• la bibliothèque Apache Commons LoggingApache Commons Logging .

• 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) .

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.

• 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) .

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.

• 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) .

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

• la bibliothèque AspectJAspectJ ;
• la bibliothèque AOP AllianceAOP Alliance (prenez le fichier .zip le plus récent: 2004) .

• 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) .

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.

• la bibliothèque AspectJAspectJ .

• 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) .

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.

• 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) .

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.

• 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) .

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.

• 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 .

• 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) .

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.

• 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) .