• 15 heures
  • Moyenne

Ce cours est visible gratuitement en ligne.

course.header.alt.is_video

course.header.alt.is_certifying

J'ai tout compris !

Mis à jour le 12/12/2019

Récapitulatif général

Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

Youhou, ça y est, vous arrivez au bout du tunnel ! Bravo !

Alors, je ne sais pas si tout est clair pour vous, mais ça fait quand même pas mal d'informations à ingurgiter non ?

Je vous propose de faire un petit récapitulatif général de ce que nous avons vu ensemble tout au long de ce cours.

Partie 1 : Mettre en œuvre une inversion de contrôle

Dans la première partie, je vous ai mis l'eau à la bouche avec ma tartiflette, l'inversion de contrôle, l'injection de dépendances et l'abstraction dont voici un petit rappel :

  • l'inversion de contrôle : le flot d'exécution n'est plus totalement géré par le développeur ou les traitements de l'application, mais il est pris en charge par des éléments annexes.

  • l'injection de dépendances : les objets dépendant d'autres objets ne se soucient plus de comment les obtenir, ils leurs sont directement injectés.

  • les abstractions : très souvent réalisées à l'aide d'interfaces, ces abstractions sont les « contrats » des interactions entre les différentes couches de l'application. Les couches basses implémentent ces abstractions. Les couches hautes dépendent de ces abstractions et non des implémentations faites dans les couches basses.

Nous avons vu que cela était une réponse aux principes SOLID :

  • Single responsibility principle (responsabilité unique)

  • Open/closed principle (ouvert/fermé)

  • Liskov substitution principle (substitution de Liskov)

  • Interface segregation principle (ségrégation des interfaces)

  • Dependency inversion principle (inversion des dépendances)

Après avoir implémenté une injection de dépendance simple à partir de zéro, nous sommes passés à la vitesse supérieure avec Spring !

Ce qu'il faut retenir de l'approche de Spring, c'est qu'il fait de l'injection de dépendances en s'appuyant sur un IoC container.

Les beans sont déclarés (via la configuration XML) ou se déclarent (via les annotations) dans l'IoC container. Ces beans déclarent aussi les dépendances dont ils ont besoin. Tout cela forme le context Spring. À partir de ce context, Spring se charge d'instancier les beans et d'injecter les dépendances.

N'oubliez pas les divers conseils que j'ai pu vous donner dans cette première partie comme :

  • Découpez la configuration du contexte par couche.

  • Si vous mixer la Configuration XML et les annotations, restez consistant dans votre manière de faire sur tout le projet.

  • Etc.

Partie 2 : Faciliter le développement avec Spring

Dans la deuxième partie, je vous ai montré quelques modules complémentaires du framework Spring :

  • Spring JDBC : employé dans la couche consumer pour exécuter des requêtes SQL.

  • Spring TX : employé dans la couche business pour gérer les transactions

Ces deux modules fonctionnent ensemble de manière transparente.

Pour Spring JDBC, les principales classes/interfaces à utiliser sont :

  • JdbcTemplate : pour définir et exécuter une requête SQL

  • NamedParameterJdbcTemplate : comme JdbcTemplate mais pour des requêtes avec paramètres nommés (:param)

  • RowMapper<T> : interface à implémenter pour définir le mapping entre les lignes de résultats d'une requête et les objets java à créer.

Pour Spring TX, les principales classes/interfaces à utiliser sont :

  • PlatformTransactionManager : interface pour faire le lien entre les transactions logique et physique (implémentée par la classe DataSourceTransactionManager dans le cas d'une DataSource JDBC)

  • TransactionTemplateTransactionCallbackTransactionCallbackWithoutResult : pour ouvrir et configurer une transaction et implémenter le traitement transactionnel

  • Ou :

    • directement le PlatformTransactionManager : pour ouvrir/valider/annuler une transaction

    • et la classe DefaultTransactionDefinition pour configurer les paramètres de la transaction

Spring est vraiment un framework riche. Dans ce cours nous n'en avons vu qu'une partie. Même si cela est déjà suffisant pour commencer à développer des applications plus professionnelles, je vous invite à explorer le framework et sa documentation.

Vous pouvez regarder en premier lieu la documentation de Spring Test. Ce module va vous faciliter la vie lors du développement des tests d'intégration en permettant de configurer rapidement un contexte Spring spécifique pour vos tests.

Maintenant, à vous de jouer. Lancez-vous, testez, expérimentez... Et d'ici peu de temps vous ne pourrez plus vous passer de Spring !

Exemple de certificat de réussite
Exemple de certificat de réussite