Spring Framework Tutorial for beginners #12
Summary
TLDRCe tutoriel explique comment établir une relation entre les beans dans le contexte Spring à l'aide d'un appel de méthode direct. Il met en lumière la différence entre la programmation orientée objet et la gestion des relations par Spring, qui gère les objets et leur cycle de vie. Le guide crée une classe 'Library' et montre comment, via l'annotation @Autowired et des appels de méthodes, relie un bean 'Book' à un bean 'Library', en utilisant l'injection de dépendances pour tester la relation.
Takeaways
- 📚 L'objectif de ce tutoriel est d'apprendre à utiliser la méthode directe d'appel pour lier des beans dans le contexte Spring.
- 🔗 La relation entre les beans est établie en déléguant des responsabilités d'un objet à un autre dans la programmation orientée objet, mais Spring gère cela différemment.
- 🌱 Les objets qui ne font pas partie du contexte Spring ne peuvent pas être gérés par celui-ci.
- 📘 Le script crée une classe 'Library' pour établir une relation avec la classe 'Book'.
- 📖 La classe 'Library' a un champ privé 'Book' pour représenter la relation simple entre une bibliothèque et un livre.
- 🛠️ Les méthodes d'accès (getters et setters) sont générées pour la classe 'Library'.
- ➕ Les annotations `@Autowired` sont utilisées pour ajouter 'Book' et 'Library' au contexte Spring.
- 🔧 La relation entre 'Book' et 'Library' est implémentée par un appel de méthode direct lors de l'initialisation de 'Library'.
- 📥 Le contexte Spring est initialisé avec les beans 'Book' et 'Library' à l'aide de la configuration dans 'AppConfig'.
- 🔄 Pour vérifier la relation, le script utilise des appels de méthode pour obtenir des références aux beans et vérifier leur contenu.
- 📝 L'exemple final vérifie que le 'Book' est bien présent dans la 'Library' et affiche les informations pour confirmation.
Q & A
Quel est le sujet principal de ce tutoriel vidéo ?
-Le sujet principal de ce tutoriel est l'apprentissage de la mise en œuvre de relations entre les beans dans le contexte Spring à l'aide d'appels de méthodes directes.
Comment le Spring gère-t-il les relations entre les objets par rapport à la programmation orientée objet ?
-Dans la programmation orientée objet, on établit une relation en déléguant des responsabilités d'un objet à un autre. Le Spring gère les relations différemment en gérant directement les objets et leur cycle de vie.
Pourquoi les objets en dehors du contexte Spring ne peuvent-ils pas être gérés par ce contexte ?
-Les objets qui ne font pas partie du contexte Spring ne peuvent pas être gérés par lui car ils ne sont pas reconnus ou configurés dans l'environnement Spring.
Quel est le premier exemple de bean créé dans ce tutoriel ?
-Le premier exemple de bean créé dans ce tutoriel est un objet 'Book'.
Quel est le deuxième bean créé et comment est-il lié au bean 'Book' ?
-Le deuxième bean créé est un objet 'Library'. Il est lié au bean 'Book' en implémentant une relation où la bibliothèque contient un livre.
Comment ajouter les beans 'Book' et 'Library' au contexte Spring ?
-Les beans 'Book' et 'Library' sont ajoutés au contexte Spring en utilisant l'annotation @Autowired et en définissant des méthodes pour chaque bean qui sont appelées lors de l'initialisation du contexte Spring.
Quelle est la différence entre l'injection de dépendances et l'appel de méthode directe mentionnée dans le script ?
-L'injection de dépendances est une technique où le Spring injecte automatiquement les dépendances nécessaires dans les beans, tandis que l'appel de méthode directe est une technique où les relations entre les beans sont établies par des appels de méthode explicites dans le code.
Comment tester la relation entre 'Book' et 'Library' après l'avoir mise en place ?
-On peut tester la relation entre 'Book' et 'Library' en récupérant les références de ces beans à partir du contexte Spring et en vérifiant si le livre est bien associé à la bibliothèque.
Quel est le but de surcharger la méthode 'toString' dans le bean 'Book' ?
-Le but de surcharger la méthode 'toString' dans le bean 'Book' est de fournir une représentation textuelle du livre, notamment pour vérifier si le nom du livre est correctement associé à la bibliothèque lors des tests.
Quel est le prochain sujet abordé dans la série de tutoriels après celui-ci ?
-Le prochain sujet abordé dans la série de tutoriels sera d'examiner d'autres façons d'établir des relations entre les beans, en se concentrant sur l'injection de dépendances.
Outlines
📚 Établir des relations entre les beans avec l'appel de méthode directe
Dans ce tutoriel, l'objectif est d'apprendre à établir des relations entre les beans dans le contexte Spring à l'aide d'appels de méthodes directes. On abordera la manière dont Spring gère les relations entre les objets, en soulignant que les objets en dehors du contexte Spring ne peuvent pas être gérés par celui-ci. Un exemple pratique est donné avec la création de deux beans, 'Book' et 'Library', où une relation est établie entre eux. Pour cela, on crée une classe 'Library' avec des méthodes 'get' et 'set' pour la propriété 'book'. On utilise l'annotation '@Bean' pour ajouter ces beans au contexte Spring, et on illustre comment l'injection de dépendances se fait via des appels de méthodes directes plutôt que par l'injection automatique.
🔗 Test de la relation entre 'Book' et 'Library' dans le contexte Spring
Le paragraphe explique comment tester et confirmer la relation établie entre les beans 'Book' et 'Library' dans le contexte Spring. On montre comment obtenir des références à ces beans à partir du contexte Spring à l'aide de la classe de configuration 'AppConfig'. On vérifie la relation en utilisant la méthode 'getTitle' sur le bean 'Book' et en comparant avec le titre attendu. L'objectif est de s'assurer que le 'Book' est bien associé à la 'Library' et que cette relation est correctement gérée par Spring, ce qui est confirmé par l'impression du nom de la 'Library' et du titre du 'Book' dans la console.
🚀 Conclusion sur l'implémentation des relations avec l'appel de méthode directe
Dans ce dernier paragraphe, on conclut sur la manière d'implémenter des relations entre les beans en utilisant l'appel de méthode directe dans Spring. On souligne que cette méthode est l'une des différentes approches pour établir des relations, et on mentionne brièvement que les prochains tutoriels exploreront d'autres méthodes telles que l'injection de dépendances. On insiste sur l'importance de sauvegarder tous les changements avant de lancer l'application et on confirme que l'application fonctionne comme prévu, avec l'exemple donné où le 'Book' est correctement associé à la 'Library'.
Mindmap
Keywords
💡méthode directe d'appel
💡Spring context
💡bean
💡relation objet-objet
💡dépendance
💡injection de dépendances
💡configuration de Spring
💡annotation
💡méthode de configuration
💡test de l'application
Highlights
Tutoriel sur l'utilisation de l'appel de méthode directe pour intégrer des beans dans Spring.
Introduction à la mise en relation de beans au sein du contexte Spring à l'aide de l'appel de méthode directe.
Explication de la différence entre la programmation orientée objet et la gestion des relations par Spring.
La nécessité pour les objets de faire partie du contexte Spring pour être gérés par celui-ci.
Création d'une classe Library pour établir une relation avec la classe Book.
Définition des attributs privés 'name' et 'book' dans la classe Library.
Ajout de méthodes d'accès (getters et setters) pour les attributs de la classe Library.
Inclusion de la classe Book et Library dans le contexte Spring à l'aide de l'annotation @Bean.
Utilisation de la méthode config pour définir et ajouter des beans à Spring context.
Mise en œuvre de la relation entre Book et Library via un appel de méthode direct.
Explication du processus d'injection de dépendances en utilisant l'annotation @Autowired.
Création d'une méthode pour tester et vérifier l'existence de la relation entre les beans.
Utilisation de la classe ApplicationContext pour obtenir des références aux beans.
Vérification de la relation entre Book et Library en utilisant les méthodes getBook et getName.
Modification de la méthode toString de la classe Book pour inclure le titre du livre.
Confirmation de la relation entre Book et Library à travers l'impression du nom de la bibliothèque et du livre.
Exemple de test de l'application pour valider la mise en œuvre de la relation.
Présentation des résultats de l'application montrant la relation entre la bibliothèque et le livre.
Aperçu des différentes méthodes pour établir des relations entre beans dans Spring au-delà de l'appel de méthode directe.
Transcripts
hi in this tutorial you will learn
wearing beans using direct method call
in the previous tutorial we learn
different ways of adding beans to Spring
context this video focus on how we
Implement relationship between being
that are in the spring context using
direct method call in object oriented
programming we establish a relationship
between object where an object delegate
a responsibilities to other object
but spring has its own way of
establishing relationship since that it
manages the object and the life cycle
the object that are not part of the
spring context cannot be managed by the
spring context so now here we have a
book so we need to create another beans
that we will implement the relationship
between the book and the other bin so
let's create a
bin
here inside the package pins
new
class and call this
Library
so so the book and the library we will
implement the relationship between the
book and the library so let provide a
file for this
private
string
name and normally the library will have
books so we need to Define
private
book
book so here we did not
have a list of books since that we know
that the library contains a lot of book
but for this example we will just
provide a book for each Library so that
they we will have the example for the
implementing the relationship between
these two okay so let's save let add the
gets and sets
generate Gators and set for
this select all
generate okay so here as you can see we
have the library and the book so now
what is remaining is to implement the
relationship so as you can see here in
this book the book and the library it
has to be inside the spring context
before implementing this relationship so
now let add the book and the library to
the spring context we will use Adin
annotation okay so the first thing we
will do let go to the app
config that is configuration
file so
and have ad pin
we Define the method
public so now let Define a
book and add the name and the title new
book okay so at have
book
do set
title let's see
so we will return this
book
return
book okay so now we finish with the book
Now by adding the Adin annotation when
the spring initialize it will call this
method uh return these values to the
spring context now it add it as a pin so
let also have ad pin for the Library ad
pin
Public
Library so now let's
have
library
library and set the name and the
book equal to
new reary
how we implement this relationship as we
said that by direct method call so now
when we
call this
Library
do
set book so now we will call this method
so by calling this
method we implement this relationship
ship between the book and the library in
the spring context and we will try this
and test it you can see so let's call
this method
book I return the
library let return the
library okay so now that is is how we
said
that we implement the okay let go to the
library and save the GS and the sets
that we just added okay you see the
arrow is gone this is why we said that
we implement this relationship using
direct method call this is one way of
implementing the relationship in the
spring using the direct method call okay
now let go to the app the Java and
get the reference to the book the
reference to the
library with the instance of the context
you see we have the instance of the
spring context that is using the app
config class here okay so first what we
will
do let's have a
library library
equal to
context do
get bin so we get the reference using
the type in the previous tutorial we
learn how to get those
references so we use type here um it is
a
library do
class okay this is fine okay now let get
also the reference to the book as well
and we will test to see if we have this
relationship okay
book equal
to
context we will get the reference using
the get
pin book do
class so so now we are getting these
references using the type and the get
pin method okay now to check to see if
we have this relationship we will check
this let have
the system that out the print we
duplicate
this okay so for the live Library will
say
that
Library so let call the name of the
library
plus
Library do get
name so to get the book of this Library
let go back to the book here and
overwrite the two string
method add over
right and we want it to return the name
of the
book
so
return and let's set the
book
name okay so this save this and
go back to the app do Java and when we
say
it here we will just use the
library do
get
book okay so here we will check if this
book that we have here
is inside the
Library okay so to confirm this book
name let check to see if it is
added we will duplicate
this okay we will check to see if this
book is in the context and we will
confirm the name using this line the
library name
and the book name okay so let's
have let's set the
book
name okay so let's use the book
do get
title this is to confirm and to we will
see the relationship here okay let's
save the changes and for the app config
will also save the changes make sure you
save all the changes before running your
application okay
so let's run
this
application and
see if our implementation works as
expected okay you see the book that we
have added to
the spring context and here we have the
name of the library and inside this
Library we have a brief history of that
I just printed this for the
confirmation but here is what we
have the library and the book so so this
is how we implement the relationship
okay let me just remove this
on print this in the
console okay you see we have the library
and in the library we have a book name A
Brief History of Time okay so this is
how to implement relationship
using direct method call that is wearing
beIN using direct method call so in the
next tutorial we will look at other ways
that is dependency injection
5.0 / 5 (0 votes)