Scaling PHP E-commerce: Implementing Multi-Product Order Systems with OOP Patterns

Building an Order System with Multiple Products in PHP

Luan Figueiredo’s architectural framework utilizes the Strategy and Factory patterns to decouple business logic from data persistence. The system demonstrates complex state management by calculating a 4515.48 total for a multi-item order including weight-based shipping and percentage discounts.

Why This Matters

Technical reality often involves shifting business requirements, such as changing shipping providers or discount structures, which can cripple procedural codebases. By utilizing interfaces like ShippingCalculatorInterface and DiscountInterface, developers can swap concrete implementations without modifying the core Order entity, reducing regression risks and technical debt in high-volume e-commerce environments.

Key Insights

• Encapsulation of item-level logic within an OrderItem class to manage individual product subtotals and weights (2026).
• Application of Dependency Inversion by passing interfaces to the Order constructor to avoid high coupling between domain logic and external services.
• Orchestration via OrderController which delegates object instantiation to Factories and data retrieval to Repositories.
• Use of InMemoryProductRepository for automated unit testing to validate rounding logic and subtotal accuracy without database overhead.

Working Examples

OrderItem manages specific product quantities and calculates local subtotals and weights.

class OrderItem
{
public function __construct(
private Product $product,
private int $quantity
) {}
public function getSubTotal(): float
{
return $this->product->price * $this->quantity;
}
public function getWeight(): float
{
return $this->product->weight * $this->quantity;
}
}

The Order entity uses Strategy patterns to calculate the final price including shipping and discounts.

class Order
{
public function __construct(
private array $items,
private ShippingCalculatorInterface $shippingCalculator,
private ?DiscountInterface $discount = null
) {}
public function getTotal(): float
{
$total = $this->getProductsTotal();
$total += $this->shippingCalculator->calculate($this->getTotalWeight());
if ($this->discount) {
$total = $this->discount->apply($total);
}
return $total;
}
}

The controller orchestrates data flow by fetching entities and instantiating calculators via factories.

class OrderController
{
public function __construct(
private ProductRepositoryInterface $productRepository,
private ShippingCalculatorFactory $shippingFactory,
private DiscountFactory $discountFactory,
private CouponRepositoryInterface $couponRepository
) {}
public function checkout(array $itemsData, string $shippingType, ?string $couponCode = null): float
{
$items = [];
foreach ($itemsData as $data) {
$product = $this->productRepository->findById($data['productId']);
$items[] = new OrderItem($product, $data['quantity']);
}
$shippingCalculator = $this->shippingFactory->create($shippingType);
$discount = null;
if ($couponCode) {
$coupon = $this->couponRepository->findByCode($couponCode);
$discount = $this->discountFactory->create($coupon->type, $coupon->value);
}
$order = new Order($items, $shippingCalculator, $discount);
return $order->getTotal();
}
}

Practical Applications

• Use Case: Implementing a ShippingCalculatorFactory to switch between ‘Transport’ and ‘Express’ shipping types without altering the Order class. Pitfall: Hardcoding shipping types directly in the controller, which leads to rigid code that is difficult to extend.
• Use Case: Utilizing CouponRepositoryInterface to fetch and apply seasonal discounts like ‘DISCOUNT10’. Pitfall: Failing to use interfaces for repositories, which prevents the use of in-memory mocks for testing.

References:

• https://dev.to/luan_figueiredo_7f279d0b5/building-an-order-system-with-multiple-products-in-php-3183