Rapport technique : Développement d'un simulateur de stationnement simultané en Go

Présentation

Ce projet consiste en un simulateur de stationnement simultané développé dans Go, utilisant la bibliothèque graphique Fyne pour l'interface utilisateur. Son objectif est de modéliser le comportement d'un parking en temps réel, en gérant simultanément l'entrée et la sortie des véhicules et en montrant visuellement l'état mis à jour des places de stationnement.
Le projet combine les concepts de concurrence, de design pattern Observer et de rendu dynamique dans une interface graphique. Ce rapport détaille l'utilisation de ces outils, les défis rencontrés (notamment avec le pattern Observer et Fyne), et comment ils ont été résolus, dans le but de fournir une référence technique aux autres développeurs.

1. Initialisation Fyne

Fyne est une bibliothèque moderne permettant de développer des interfaces graphiques avec Go. L'initialisation de base suit ces étapes :

1. Créez une nouvelle application avec app.New().
2. Configurez la fenêtre principale avec app.NewWindow().
3. Concevez du contenu à l'aide de conteneurs et de widgets Fyne.
4. Appelez ShowAndRun() pour exécuter l'application.

Dans le simulateur, une fenêtre principale a été créée qui intègre la vue du parking et se connecte au modèle logique concurrent :

func main() {
    myApp := app.New()
    mainWindow := myApp.NewWindow("Simulador de Parking")

    estacionamiento := models.NewEstacionamiento(20)
    parkingView := views.NewParkingView()

    mainScene := scenes.NewMainScene(estacionamiento, parkingView)
    mainWindow.SetContent(parkingView.Container)

    mainWindow.ShowAndRun()
}

Ce flux de base facilite la séparation entre la logique métier et l'interface graphique.

2. Utiliser le modèle d'observateur

Pourquoi utiliser le modèle Observer

Le modèle Observer a été utilisé pour synchroniser les calques de modèle et de vue. Lorsqu'un véhicule entre ou sort du parking, le modèle en informe la vue, qui met à jour les éléments graphiques correspondants. Ce modèle est idéal pour les systèmes où plusieurs composants doivent réagir au même événement.

Problèmes rencontrés lors de l'utilisation du modèle Observer dans Go

Implémenter le modèle Observer dans Go peut être un défi, en particulier pour ceux qui sont habitués à son implémentation dans des langages orientés objet comme Java ou C#. Un problème courant lors de l'utilisation de ce modèle dans Go est la gestion de la concurrence et des blocages lors de la notification aux observateurs.

Initialement, l'itération sur les observateurs enregistrés dans le modèle (Parking) pour signaler les événements entraînait des conditions de course et des crashs. Cela se produisait parce que la méthode d'enregistrement des nouveaux observateurs n'était pas correctement protégée, provoquant des accès simultanés à la liste des observateurs.

Comment cela a été résolu
Pour résoudre ce problème, un mutex (sync.Mutex) a été utilisé pour protéger l'accès simultané à la liste d'observateurs. De plus, des méthodes sécurisées pour enregistrer les observateurs et signaler les événements ont été mises en œuvre :

func main() {
    myApp := app.New()
    mainWindow := myApp.NewWindow("Simulador de Parking")

    estacionamiento := models.NewEstacionamiento(20)
    parkingView := views.NewParkingView()

    mainScene := scenes.NewMainScene(estacionamiento, parkingView)
    mainWindow.SetContent(parkingView.Container)

    mainWindow.ShowAndRun()
}

Mise en œuvre complète dans le projet
Le modèle Parking agit comme sujet observable, tandis que la MainScene et d'autres composants, tels que la vue graphique, sont des observateurs :
1. Définition de l'interface observateur :

func (e *Estacionamiento) RegistrarObservador(o Observer) {
    e.mu.Lock()
    defer e.mu.Unlock()
    e.observadores = append(e.observadores, o)
}

func (e *Estacionamiento) NotificarVehiculoEntra(id, cajon, espaciosDisponibles, capacidad int) {
    e.mu.Lock()
    defer e.mu.Unlock()
    for _, o := range e.observadores {
        o.OnVehiculoEntra(id, cajon, espaciosDisponibles, capacidad)
    }
}

func (e *Estacionamiento) NotificarVehiculoSale(id, cajon, espaciosDisponibles, capacidad int) {
    e.mu.Lock()
    defer e.mu.Unlock()
    for _, o := range e.observadores {
        o.OnVehiculoSale(id, cajon, espaciosDisponibles, capacidad)
    }
}

1. Notification d'événement du modèle :

package models

type Observer interface {
    OnVehiculoEntra(id, cajon, espaciosDisponibles, capacidad int)
    OnVehiculoSale(id, cajon, espaciosDisponibles, capacidad int)
}

1. Réponse de l'observateur :

func (e *Estacionamiento) VehiculoEntra(id int) {
    // Lógica para manejar la entrada del vehículo
    espaciosDisponibles := e.capacidad - e.ocupados
    e.NotificarVehiculoEntra(id, cajon, espaciosDisponibles, e.capacidad)
}

func (e *Estacionamiento) VehiculoSale(id int) {
    // Lógica para manejar la salida del vehículo
    espaciosDisponibles := e.capacidad - e.ocupados
    e.NotificarVehiculoSale(id, cajon, espaciosDisponibles, e.capacidad)
}

Cette solution garantit que les mises à jour sont cohérentes et que les conditions de concurrence n'affectent pas les performances du système.

3. Problème technique : rendu et calcul de position

Contexte

Le principal défi technique consistait à calculer les positions des tiroirs dans l'interface graphique et à mettre à jour leur couleur en temps réel. Les tiroirs doivent :

1. Être disposé en deux rangées avec un espacement uniforme.
2. Changer de couleur dynamiquement (rouge pour occupé, noir pour disponible).

Problèmes identifiés

1. Calcul de position dynamique : Les places de stationnement devaient être positionnées sur deux rangées, avec un espacement uniforme entre elles. Cependant, le calcul et la mise à jour de ces positions étaient complexes car ils dépendaient de coordonnées précises au sein d'un conteneur sans mise en page (container.NewWithoutLayout()).
2. Synchronisation visuelle : Lors de la gestion de plusieurs threads simultanés, des incohérences visuelles survenaient lors de la tentative de mise à jour des couleurs des tiroirs en temps réel. Parfois, les modifications n'étaient pas reflétées ou provoquaient des erreurs graphiques.

Calcul de position
Des coordonnées absolues ont été utilisées pour définir la position initiale et l'espacement :

func (s *MainScene) OnVehiculoEntra(id, cajon, espaciosDisponibles, capacidad int) {
    s.View.UpdateState(espaciosDisponibles, capacidad, id, cajon, "entra")
}

func (s *MainScene) OnVehiculoSale(id, cajon, espaciosDisponibles, capacidad int) {
    s.View.UpdateState(espaciosDisponibles, capacidad, id, cajon, "sale")
}

Rendu dynamique
Des fonctions ont été mises en place pour peindre les tiroirs selon leur statut :

xStart, yTop, yBottom := float32(185), float32(120), float32(200)
spotSpacing := float32(55)

// Fila superior
for i := 0; i < 10; i++ {
    parkingSpots = append(parkingSpots, fyne.Position{X: xStart + float32(i)*spotSpacing, Y: yTop})
}

// Fila inferior
for i := 0; i < 10; i++ {
    parkingSpots = append(parkingSpots, fyne.Position{X: xStart + float32(i)*spotSpacing, Y: yBottom})
}

Synchronisation visuelle
Pour garantir que les modifications visuelles étaient cohérentes avec l'état du système, le texte principal de l'étiquette et l'état du tiroir ont été mis à jour au sein d'une fonction centrale :

func main() {
    myApp := app.New()
    mainWindow := myApp.NewWindow("Simulador de Parking")

    estacionamiento := models.NewEstacionamiento(20)
    parkingView := views.NewParkingView()

    mainScene := scenes.NewMainScene(estacionamiento, parkingView)
    mainWindow.SetContent(parkingView.Container)

    mainWindow.ShowAndRun()
}

Cela garantit une représentation graphique précise et à jour à tout moment.

Conclusion

Ce projet a non seulement atteint son objectif de simuler le stationnement simultané, mais est également confronté à des problèmes de développement pratiques, tels que l'utilisation du modèle Observer et la création d'interfaces graphiques avec Fyne. Les problèmes rencontrés et les solutions mises en œuvre ont vocation à servir de guide aux autres développeurs débutant avec Go ou confrontés à des problématiques similaires.
La mise en œuvre du modèle Observer dans Go, en particulier, démontre comment gérer la concurrence de manière sûre et efficace. Ce rapport, en documentant ces problèmes et solutions, vise à contribuer à la communauté des programmeurs intéressés par l'apprentissage et l'application de ces outils, en facilitant leur processus d'apprentissage et de développement.
Si vous avez des questions sur la mise en œuvre et la solution de ceci, vous pouvez consulter mon référentiel github : simulador-parking.git

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!