Systemdesign: Aufbau eines Parkplatzsystems in Go

In diesem Artikel gehen wir eine Low-Level-Design-Implementierung (LLD) eines Parkplatzsystems in Go durch. Wir werden verschiedene Aspekte des Systems untersuchen und sehen, wie jede Komponente mit den anderen interagiert. Diese Implementierung konzentriert sich auf Klarheit und praktischen Nutzen, sodass Sie sie problemlos erweitern können, wenn Sie Funktionen wie mehr Fahrzeugtypen, mehrere Zahlungsoptionen oder Platzreservierungen hinzufügen möchten.

Das System übernimmt Aufgaben wie die Verwaltung von Parkebenen und -plätzen, das Ein- und Ausparken von Fahrzeugen sowie die Zahlungsabwicklung. Wir stellen außerdem sicher, dass es für den gleichzeitigen Zugriff threadsicher ist, damit es bei einer Erweiterung auf ein größeres System nicht unter Druck zusammenbricht.

---

Kernkomponenten

Unser Design umfasst sechs Hauptkomponenten:

1. Parkplatz – Der Haupteingangspunkt für die Verwaltung von Stockwerken und Parkvorgängen.
2. Parkebene – Jede Etage verfügt über mehrere Parkplätze für verschiedene Fahrzeugtypen.
3. Parkplatz – Stellt einen Parkplatz dar, der einen bestimmten Fahrzeugtyp aufnehmen kann.
4. Parkschein – Verfolgt Ein-/Ausfahrtszeiten, Parkgebühren und das zugehörige Fahrzeug.
5. Zahlungssystem – Verwaltet die Berechnung der Parkgebühren und die Zahlungsabwicklung.
6. Fahrzeugtypen – Unterstützt verschiedene Fahrzeugtypen (Autos, Lieferwagen, Lastwagen und Motorräder). Für jeden Typ gilt ein anderer Stundensatz.

Singleton-Parkplatz

Unser ParkingLot verwendet das Singleton-Muster. Das bedeutet, dass es nur eine Instanz des Parkplatzes gibt, die einmal erstellt und in der gesamten Anwendung wiederverwendet wird. Hier ist der Code, um das zum Laufen zu bringen:

var (
    parkingLotInstance *ParkingLot
    once               sync.Once
)

type ParkingLot struct {
    Name   string
    floors []*ParkingFloor
}

func GetParkingLotInstance() *ParkingLot {
    once.Do(func() {
        parkingLotInstance = &ParkingLot{}
    })
    return parkingLotInstance
}

Mit sync.Once stellen wir sicher, dass nur eine Instanz erstellt wird, auch wenn mehrere Goroutinen darauf zugreifen.

Verwalten von Etagen auf dem Parkplatz

Der Parkplatz verfügt über mehrere Etagen mit jeweils ausgewiesenen Parkplätzen für verschiedene Fahrzeugtypen (z. B. Autos, Transporter, Lastwagen und Motorräder). Um dem Parkplatz eine Etage hinzuzufügen, verwenden wir die AddFloor-Methode:

func (p *ParkingLot) AddFloor(floorID int) {
    p.floors = append(p.floors, NewParkingFloor(floorID))
}

Jede Etage wird mit der NewParkingFloor-Funktion erstellt, die Plätze nach Fahrzeugtyp organisiert.

Parkplätze

Jeder ParkingSpot ist einem bestimmten Fahrzeugtyp zugeordnet (z. B. einem Auto oder einem Motorrad). Dadurch kann das System verwalten und einschränken, welche Fahrzeuge an welchen Stellen parken dürfen. Hier ist die ParkingSpot-Struktur und die ParkVehicle-Methode:

type ParkingSpot struct {
    SpotID         int
    VehicleType    vehicles.VehicleType
    CurrentVehicle *vehicles.VehicleInterface
    lock           sync.Mutex
}

func (p *ParkingSpot) ParkVehicle(vehicle vehicles.VehicleInterface) error {
    p.lock.Lock()
    defer p.lock.Unlock()

    if vehicle.GetVehicleType() != p.VehicleType {
        return fmt.Errorf("vehicle type mismatch: expected %s, got %s", p.VehicleType, vehicle.GetVehicleType())
    }
    if p.CurrentVehicle != nil {
        return fmt.Errorf("parking spot already occupied")
    }

    p.CurrentVehicle = &vehicle
    return nil
}

Wir verwenden eine Mutex-Sperre, um sicherzustellen, dass jeweils nur ein Fahrzeug an einem Parkplatz parken kann.

Parkschein

Jedes Fahrzeug erhält ein Ticket mit Einfahrtszeit, Ausfahrtzeit, Parkplatz und Gesamtgebühr. Dieses Ticket wird aktualisiert, wenn das Fahrzeug ausfährt, und die Gebühren werden auf der Grundlage der Parkzeit berechnet.

var (
    parkingLotInstance *ParkingLot
    once               sync.Once
)

type ParkingLot struct {
    Name   string
    floors []*ParkingFloor
}

func GetParkingLotInstance() *ParkingLot {
    once.Do(func() {
        parkingLotInstance = &ParkingLot{}
    })
    return parkingLotInstance
}

Die CalculateTotalCharge-Methode berechnet Parkgebühren basierend auf Fahrzeugtyp und -dauer.

Zahlungssystem

Die PaymentSystem-Klasse verarbeitet die Zahlung und aktualisiert den Zahlungsstatus basierend darauf, ob der erforderliche Betrag bezahlt wurde:

func (p *ParkingLot) AddFloor(floorID int) {
    p.floors = append(p.floors, NewParkingFloor(floorID))
}

Die ProcessPayment-Funktion prüft den Betrag und aktualisiert den Zahlungsstatus auf „Abgeschlossen“ oder „Fehlgeschlagen“.

Fahrzeugtypen hinzufügen

Unser System unterstützt verschiedene Fahrzeugtypen (Autos, Lieferwagen, Lastwagen und Motorräder). Für jeden Typ gelten unterschiedliche Stundensätze. Dies wird durch die Einrichtung eines VehicleType und VehicleInterface in einem separaten Fahrzeugpaket erreicht:

type ParkingSpot struct {
    SpotID         int
    VehicleType    vehicles.VehicleType
    CurrentVehicle *vehicles.VehicleInterface
    lock           sync.Mutex
}

func (p *ParkingSpot) ParkVehicle(vehicle vehicles.VehicleInterface) error {
    p.lock.Lock()
    defer p.lock.Unlock()

    if vehicle.GetVehicleType() != p.VehicleType {
        return fmt.Errorf("vehicle type mismatch: expected %s, got %s", p.VehicleType, vehicle.GetVehicleType())
    }
    if p.CurrentVehicle != nil {
        return fmt.Errorf("parking spot already occupied")
    }

    p.CurrentVehicle = &vehicle
    return nil
}

Wir können neue Fahrzeuge erstellen, indem wir NewCar, NewVan, NewTruck usw. aufrufen, die jeweils VehicleInterface implementieren.

---

Alles zusammenbringen

Mal sehen, wie die Teile in einem Fluss zusammenpassen:

• Erstellen Sie einen Parkplatz: Rufen Sie GetParkingLotInstance() auf und fügen Sie Stockwerke mit AddFloor hinzu.
• Parkplatz finden und Fahrzeug parken: Die ParkVehicle-Methode findet einen verfügbaren Platz, validiert ihn anhand des Fahrzeugtyps und generiert ein Ticket.
• Fahrzeug entparken und Zahlung verarbeiten: UnparkVehicle generiert die Gesamtgebühr, initiiert das Zahlungssystem und schließt die Transaktion ab.

---

Dieses Parkplatzsystem ist ein vereinfachter Ausgangspunkt für den Aufbau komplexerer Systeme. Wir haben die Grundlagen der Boden- und Stellplatzverwaltung, des Ein- und Ausparkens von Fahrzeugen sowie einen grundlegenden Zahlungsvorgang behandelt.

Informationen zur vollständigen Code-Implementierung finden Sie im folgenden Repository:

thesaltree / Low-Level-Design-Golang

Low-Level-Systemdesignlösungen in Golang

Low-Level-Systemdesign in Go

Willkommen im Repository Low-Level-Systemdesign in Go! Dieses Repository enthält verschiedene Low-Level-Systemdesignprobleme und ihre in Go implementierten Lösungen. Das primäre Ziel besteht darin, den Entwurf und die Architektur von Systemen anhand praktischer Beispiele zu demonstrieren.

Inhaltsverzeichnis

• Übersicht
• Parkplatzsystem
• Aufzugssystem
• Bibliotheksverwaltungssystem
• Verkaufsautomatensystem
• Social-Media-Plattform

Übersicht

Systemdesign auf niedriger Ebene beinhaltet das Verständnis der Kernkonzepte der Systemarchitektur und das Entwerfen skalierbarer, wartbarer und effizienter Systeme. In diesem Repository wird versucht, Lösungen für verschiedene Probleme und Szenarien mit Go abzudecken.

Parkplatzsystem

Das erste Projekt in diesem Repository ist ein Parkplatzsystem. Dieses System simuliert einen Parkplatz, auf dem Fahrzeuge ein- und ausgeparkt werden können. Es zeigt:

• Singleton-Entwurfsmuster zur Verwaltung der Parkplatzinstanz.
• Umgang mit verschiedenen Fahrzeugtypen (z. B. Pkw, Lkw).
• Parkplatzmanagement über mehrere Etagen hinweg.
• Zahlungsabwicklung für…

Auf GitHub ansehen

Das obige ist der detaillierte Inhalt vonSystemdesign: Aufbau eines Parkplatzsystems in Go. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!