1. Qu'est-ce que le modèle médiateur
Le modèle médiateur est un modèle de conception comportementale qui réduit les dépendances directes entre les objets en transférant leur communication à un objet médiateur. Dans le modèle médiateur, les objets ne communiquent plus directement entre eux, mais plutôt par l'intermédiaire de l'objet médiateur.
2. Caractéristiques et avantages du modèle médiateur
Les caractéristiques et avantages du modèle médiateur sont les suivants :
- Réduit le couplage direct entre les objets, ce qui diminue la complexité du système.
- Simplifie la communication entre les objets en ayant un objet médiateur gérer leur communication.
- Centralise le contrôle des interactions entre les objets, facilitant l'extension et la maintenance.
3. Exemples concrets du modèle médiateur
Le modèle médiateur trouve de nombreuses applications dans des scénarios réels. Par exemple, dans un système de planification d'aéroport, le répartiteur agit comme médiateur, tandis que les différents modules tels que les avions et le trafic au sol servent de classes collègues communiquant et se coordonnant via le répartiteur.
4. Implémentation du modèle médiateur en Golang
4.1 Introduction au Diagramme de classe UML
Ci-dessous se trouve le diagramme de classe UML pour le modèle médiateur en Golang :
4.2 Introduction de l'exemple
Dans cet exemple, nous allons implémenter une application de salon de discussion simple en utilisant le modèle médiateur pour gérer la communication entre différents utilisateurs.
4.3 Étape d'implémentation 1 : Définir l'interface médiateur et le médiateur concret
Tout d'abord, nous définissons une interface de médiateur et une classe de médiateur concrète :
type Mediator interface {
registerColleague(colleague Colleague)
sendMessage(message string, colleague Colleague)
}
type ConcreteMediator struct {
colleagues map[string]Colleague
}
func (m *ConcreteMediator) registerColleague(colleague Colleague) {
m.colleagues[colleague.getName()] = colleague
}
func (m *ConcreteMediator) sendMessage(message string, colleague Colleague) {
for _, c := range m.colleagues {
if c != colleague {
c.receiveMessage(message)
}
}
}
4.4 Étape d'implémentation 2 : Définir l'interface collègue et le collègue concret
Ensuite, nous définissons une interface collègue et les classes collègues concrets :
type Colleague interface {
receiveMessage(message string)
sendMessage(message string)
getName() string
}
type ConcreteColleagueA struct {
mediator Mediator
name string
}
func (c *ConcreteColleagueA) receiveMessage(message string) {
fmt.Printf("%s a reçu le message : %s\n", c.name, message)
}
func (c *ConcreteColleagueA) sendMessage(message string) {
c.mediator.sendMessage(message, c)
}
func (c *ConcreteColleagueA) getName() string {
return c.name
}
type ConcreteColleagueB struct {
mediator Mediator
name string
}
func (c *ConcreteColleagueB) receiveMessage(message string) {
fmt.Printf("%s a reçu le message : %s\n", c.name, message)
}
func (c *ConcreteColleagueB) sendMessage(message string) {
c.mediator.sendMessage(message, c)
}
func (c *ConcreteColleagueB) getName() string {
return c.name
}
4.5 Étape d'implémentation 3 : Gérer les collègues dans le médiateur
Dans la classe médiateur spécifique, nous devons implémenter la méthode registerColleague et la méthode sendMessage pour gérer la communication entre les classes collègues :
func main() {
mediator := &ConcreteMediator{
colleagues: make(map[string]Colleague),
}
colleagueA := &ConcreteColleagueA{
mediator: mediator,
name: "Collègue A",
}
colleagueB := &ConcreteColleagueB{
mediator: mediator,
name: "Collègue B",
}
mediator.registerColleague(colleagueA)
mediator.registerColleague(colleagueB)
colleagueA.sendMessage("Bonjour tout le monde !")
colleagueB.sendMessage("Salut tout le monde !")
}
Dans la fonction main, nous créons un objet médiateur spécifique et deux objets collègues spécifiques, puis enregistrons les objets collègues via l'objet médiateur et effectuons des tests de communication.