Design Patterns to be used in Ride Sharing Sevrice

Designing a ride-sharing service involves addressing several core features, including matching riders and drivers, managing ride requests, handling payments, and ensuring scalability and reliability.

1. Factory Pattern:

The factory pattern can be used to create instances of different types of objects like rides (e.g., Standard Ride, Luxury Ride, Pool Ride) based on user preferences.

In the RideFactory example, Ride is likely an interface or an abstract class that defines the common structure or behavior that all types of rides (e.g., StandardRide, LuxuryRide, PoolRide) should implement. This allows the RideFactory to return different types of rides, each with its own specific implementation, while maintaining a consistent interface for clients that use these rides.

public interface Ride {
    void bookRide();
    double calculateFare();
    // Other common methods for a ride
}

public class StandardRide implements Ride {
    @Override
    public void bookRide() {
        System.out.println("Standard Ride booked.");
    }

    @Override
    public double calculateFare() {
        return 10.0; // Example fare calculation
    }
}

public class LuxuryRide implements Ride {
    @Override
    public void bookRide() {
        System.out.println("Luxury Ride booked.");
    }

    @Override
    public double calculateFare() {
        return 30.0; // Example fare calculation
    }
}

public class PoolRide implements Ride {
    @Override
    public void bookRide() {
        System.out.println("Pool Ride booked.");
    }

    @Override
    public double calculateFare() {
        return 5.0; // Example fare calculation
    }
}

// RideFactory to create different types of rides
public class RideFactory {
    public static Ride getRide(String type) {
        switch (type) {
            case "Standard":
                return new StandardRide();
            case "Luxury":
                return new LuxuryRide();
            case "Pool":
                return new PoolRide();
            default:
                throw new IllegalArgumentException("Unknown ride type: " + type);
        }
    }
}

2. Observer Pattern:

The Observer pattern can be used for event-driven updates, such as notifying drivers about new ride requests or informing riders when their ride status is updated (e.g., ride accepted, on the way, or completed).

import java.util.ArrayList;
import java.util.List;

// RideRequestObservable interface
public interface RideRequestObservable {
    void registerObserver(RideRequestObserver observer);
    void removeObserver(RideRequestObserver observer);
    void notifyObservers(RideRequest rideRequest);
}

// Concrete class that implements RideRequestObservable
public class RideRequestService implements RideRequestObservable {
    private List<RideRequestObserver> observers;

    public RideRequestService() {
        this.observers = new ArrayList<>();
    }

    @Override
    public void registerObserver(RideRequestObserver observer) {
        observers.add(observer);
    }

    @Override
    public void removeObserver(RideRequestObserver observer) {
        observers.remove(observer);
    }

    @Override
    public void notifyObservers(RideRequest rideRequest) {
        for (RideRequestObserver observer : observers) {
            observer.update(rideRequest); // Notify each observer of the new ride request
        }
    }

    // Method to create a new ride request and notify observers
    public void createRideRequest(RideRequest rideRequest) {
        System.out.println("New ride request created: " + rideRequest);
        notifyObservers(rideRequest); // Notify all registered observers (drivers)
    }
}

public interface RideRequestObserver {
    void update(RideRequest rideRequest);
}

// RideRequestObserver to notify drivers
public interface RideRequestObserver {
    void update(RideRequest rideRequest);
}

public class Driver implements RideRequestObserver {
    private String name;

    public Driver(String name) {
        this.name = name;
    }

    @Override
    public void update(RideRequest rideRequest) {
        System.out.println("Driver " + name + " notified of new ride request: " + rideRequest);
    }
}

3. Strategy Pattern:

The strategy pattern can be used for different pricing algorithms (e.g., Surge Pricing, Flat Pricing, Distance-based Pricing). Based on traffic, demand, or time, the system can dynamically switch between strategies.

// Pricing Strategy interface
public interface PricingStrategy {
    double calculateFare(Ride ride);
}

// Surge Pricing implementation
public class SurgePricing implements PricingStrategy {
    @Override
    public double calculateFare(Ride ride) {
        return ride.getBaseFare() * 2; // Example surge multiplier
    }
}

// Flat Pricing implementation
public class FlatPricing implements PricingStrategy {
    @Override
    public double calculateFare(Ride ride) {
        return ride.getBaseFare();
    }
}

4. Singleton Pattern:

1. The Singleton pattern can be used to ensure that certain services, such as a RideMatchingService or PaymentService, are instantiated only once and can be shared across the system.

2. To ensure thread safety in a multi-threaded environment, we can use the synchronized keyword in the getInstance() method of the RideMatchingService class. This prevents multiple threads from creating multiple instances of the singleton class at the same time.

3. synchronized Keyword: The getInstance() method is now marked as synchronized, which ensures that only one thread can execute this method at a time. This prevents multiple threads from creating multiple instances of the singleton at the same time.

4. Lazy Initialization: The instance is created only when it's first needed (the first time getInstance() is called). This is known as "lazy initialization."

   public class RideMatchingService {
       // Static volatile instance for thread visibility
       private static volatile RideMatchingService instance;
   
       private RideMatchingService() {
           // private constructor to prevent instantiation
       }
   
       public static RideMatchingService getInstance() {
           if (instance == null) { // First check (without locking)
               synchronized (RideMatchingService.class) {
                   if (instance == null) { // Second check (with locking)
                       instance = new RideMatchingService();
                   }
               }
           }
           return instance;
       }
   
       public void matchRiderToDriver(RideRequest request) {
           // logic to match rider and driver
           System.out.println("Matching rider with driver for request: " + request);
       }
   }
   

   
   5. Builder Pattern:

   The Builder pattern is useful for constructing complex objects like RideRequest, which may have multiple optional parameters (pickup location, destination, preferences for car type, etc.).
   

// RideRequest using Builder Pattern
public class RideRequest {
    private String pickupLocation;
    private String destination;
    private String rideType;
    private boolean pool;

    private RideRequest(Builder builder) {
        this.pickupLocation = builder.pickupLocation;
        this.destination = builder.destination;
        this.rideType = builder.rideType;
        this.pool = builder.pool;
    }

    public static class Builder {
        private String pickupLocation;
        private String destination;
        private String rideType;
        private boolean pool;

        public Builder withPickupLocation(String pickupLocation) {
            this.pickupLocation = pickupLocation;
            return this;
        }

        public Builder withDestination(String destination) {
            this.destination = destination;
            return this;
        }

        public Builder withRideType(String rideType) {
            this.rideType = rideType;
            return this;
        }

        public Builder poolRide(boolean pool) {
            this.pool = pool;
            return this;
        }

        public RideRequest build() {
            return new RideRequest(this);
        }
    }
}

7. Decorator Pattern:

The decorator pattern can be used to add extra features to the ride, such as adding premium services like Wi-Fi, extra luggage, or priority pickup.

// Decorator for additional ride services
public class RideDecorator implements Ride {
    protected Ride decoratedRide;

    public RideDecorator(Ride decoratedRide) {
        this.decoratedRide = decoratedRide;
    }

    @Override
    public void createRide() {
        decoratedRide.createRide();
    }
}

public class WiFiRideDecorator extends RideDecorator {
    public WiFiRideDecorator(Ride decoratedRide) {
        super(decoratedRide);
    }

    @Override
    public void createRide() {
        super.createRide();
        System.out.println("Wi-Fi added to the ride.");
    }
}

8. Command Pattern:

This can be used to handle actions like cancel ride, accept ride, start ride, etc., allowing the system to queue, log, and execute these commands independently

// Command Interface
public interface RideCommand {
    void execute();
}

// Concrete Cancel Ride Command
public class CancelRideCommand implements RideCommand {
    private Ride ride;

    public CancelRideCommand(Ride ride) {
        this.ride = ride;
    }

    @Override
    public void execute() {
        ride.cancel();
    }
}