In this article, we’ll go through a low-level design (LLD) implementation of a parking lot system in Go. We'll explore different aspects of the system and see how each component interacts with the rest. This implementation focuses on clarity and real-world usefulness, so you can extend it easily if you want to add features like more vehicle types, multiple payment options, or spot reservations.

The system handles tasks like managing parking floors and spots, parking and unparking vehicles, and processing payments. We’ll also ensure it’s thread-safe for concurrent access, so if we need to expand it into a larger system, it won’t break down under pressure.

Core Components

Our design includes six main components:

1. Parking Lot - The main entry point managing floors and parking operations.
2. Parking Floor - Each floor contains multiple parking spots for different types of vehicles.
3. Parking Spot - Represents a parking spot that can hold a specific type of vehicle.
4. Parking Ticket - Tracks entry/exit times, parking charges, and the associated vehicle.
5. Payment System - Handles parking fee calculations and payment processing.
6. Vehicle Types - Supports different types of vehicles (cars, vans, trucks, and motorcycles). Each type has a different hourly charge.

Singleton Parking Lot

Our ParkingLot uses the Singleton pattern. This means there’s only one instance of the parking lot, which is created once and reused across the application. Here’s the code to get that working:

var (
    parkingLotInstance *ParkingLot
    once               sync.Once
)

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

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

Using sync.Once, we ensure that only one instance is created, even when accessed by multiple goroutines.

Managing Floors in the Parking Lot

The parking lot has multiple floors, each with designated parking spots for different vehicle types (e.g., cars, vans, trucks, and motorcycles). To add a floor to the parking lot, we use the AddFloor method:

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

Each floor is created using the NewParkingFloor function, which organizes spots by vehicle type.

Parking Spots

Each ParkingSpot is associated with a specific vehicle type (like a car or motorcycle). This allows the system to manage and restrict which vehicles can park in each spot. Here’s the ParkingSpot structure and the ParkVehicle method:

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
}

We use a Mutex lock to make sure only one vehicle can park in a spot at a time.

Parking Ticket

Every vehicle gets a ticket with the entry time, exit time, parking spot, and total charge. This ticket will be updated when the vehicle exits, and charges will be calculated based on the time spent parked.

var (
    parkingLotInstance *ParkingLot
    once               sync.Once
)

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

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

The CalculateTotalCharge method calculates parking fees based on the vehicle type and duration.

Payment System

The PaymentSystem class processes the payment, updating the payment status based on whether the required amount is paid:

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

The ProcessPayment function checks the amount and updates the payment status to Completed or Failed.

Adding Vehicle Types

Our system supports different types of vehicles (cars, vans, trucks, and motorcycles). Each type has a different hourly charge. This is achieved by setting up a VehicleType and VehicleInterface in a separate vehicles package:

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
}

We can create new vehicles by calling NewCar, NewVan, NewTruck, etc., each of which implements VehicleInterface.

Bringing It All Together

Let’s see how the pieces fit together in a flow:

• Create a Parking Lot: Call GetParkingLotInstance() and add floors with AddFloor.
• Find Parking Spot and Park Vehicle: ParkVehicle method finds an available spot, validates it against the vehicle type, and generates a ticket.
• Unpark Vehicle and Process Payment: UnparkVehicle generates the total charge, initiates the payment system, and completes the transaction.

This parking lot system is a simplified starting point for building more complex systems. We covered the basics of floor and spot management, vehicle parking and unparking, and a basic payment process.

For full code implementation, check the following repository:

The above is the detailed content of System Design: Building a Parking Lot System in Go. For more information, please follow other related articles on the PHP Chinese website!