在状态模式中实现继承层次结构

Question

I have a design which is very similar to this:

Here NewOrder , Registered & Granted all have the common methods AddOrderline() and Cancel() , so refactoring both methods to a parent class is easy.

The problem occurs when I want to Cancel a Shipped line (currently not shown in the figure).

Since a Shipped line doesn't support AddOrderline() then I'll need to break the parent class for NewOrder , Registered & Granted into 2 class one for the Cancel() and another for AddOrderline() .

Now NewOrder must extend 2 parent class to get the 2 functions.

Notes

1. This example is very simplified. My real application has about 12 states.
2. The code is in PHP, but solutions in C# or Java are welcomed because I presume that the solution will be similar as they all don't support multiple inheritance.

Answer 1

I would consider the separation of the interface from the implementation. eg in Java

interface Cancellable {
   void cancel();
}
interface Shippable{
   void ship();
}

etc.

public class NewState implements Cancellable, Shippable {
  public void cancel() { ... }
  public void ship() { ... }
}

If you have an underlying private State, it can implement all the required interfaces, and your public States need only delegate those supported states. eg

 public class UnderlyingState implements Cancellable, Shippable ... {
    public void cancel() { ... }
    public void ship() { ... }
 }

  public class ShippableState implements Shippable {
     private UnderlyingState ustate = new UnderlyingState();
     public void cancel() {
        // you can *only* cancel this
        ustate.cancel();    
     }
   }

In the above you'd probably need to return a new state object (rather than void ) and have your Order adopt that new state. The UnderlyingState object would enforce some state machine.

The headache with this is that as your number of states increase, your interfaces and implementation increases too.

Answer 2

First, you'll need a state manager to handle states:

<?php
class StateManager
{
    protected $states = array();

    public function registerState(StateInterface $state)
    {
        $this->states[$state->getName()] = $state;
    }

    public function getState($state)
    {
        if (!array_key_exists($state, $this->states)) {
            throw new InvalidArgumentException();
        }

        return $this->states[$state];
    }
}

Then you have an order manager that can perform actions against orders:

<?php
class OrderManager
{
    protected $stateManager;

    public function ship(OrderInterface $order)
    {
        try {
            $this->stateManager->getState($order->getState())->ship($order);
        } catch (OperationNotAllowedException $exception) {
            // However you want to handle the fact that the state can't be shipped
        }
    }
}

An exception that gets thrown if an order can't take an action in a certain state:

<?php
class OperationNotAllowedException extends Exception
{
}

The interface for a state:

<?php
interface StateInterface
{
    public function getName();

    // Then your normal functions
    public function ship(OrderInterface $order);
    public function cancel(OrderInterface $cancel);
    public function addOrderLine(OrderInterface $order);
    public function refund(OrderInterface $order);
}

Now, when you setup your application:

$newOrderState = new NewState($database, $otherdependencies);
$stateManager->registerState($newOrderState);

Your order object simply returns a string name for the state it's in, that matches what one of the state's getName methods returns.

This method also allows for easy mocking and testing (which is important for any application, but especially e-commerce where you are handling people's money and products).