PHP OOP :: passing session key between classes

Question

I am trying to work out the most appropriate design to pass a session key between classes in PHP 5.3.

The session key is retrieved from a 3rd-party API and my application makes various API calls that all require this session key to be passed in.

I have created classes to hold related API calls egClass cart holds methods that, when called, will fire off request to the API to return data from calls such as API_GetCart(), API_AddItem() etc.

I am storing the session key in a single cookie (the only cookie that is ever required) and need to make the value of that cookie available to pretty much all of my classes. I cannot use a database or $_SESSION to hold session data. The 3rd-party API looks after session management for things like basket contents etc.

When a user reaches my app for the very first time there will be no cookie value so I need to be able to both assign a new session key to a new cookie and also pass that value (not yet available as a cookie since we're still processing the same HTTP request) to the other classes.

One idea I had was to create a Session class like this, and put the session grabbing/checking code in the constructor.

class Session {
    public $sk;
    function __construct() {
        //code to check if user has sessionkey (sk) in cookie
        //if not, grab new sessionkey from 3rd party API and assign to new cookie
        // $sk = 'abcde12345'; //example $sk value
    }
}

Then on all view pages I would instantiate a new instance of Session and then pass that object into each class that requires it (nearly all do), either as argument to class constructor or as method argument.

orderSummary.php

$s = new Session;

//$s currently would only hold one variable, $sk = "abcde12345"
//but in the future may hold more info or perform more work

// what is best approach to making the sessionkey 
// available to all classes? arg to constructor or method... or neither :)

$basket = new Basket;
$baskSumm = $basket->getBasketSummary();

$billing = new Billing;
$billSumm = $billing->getBillingSummary();

$delivery = new Delivery;
$delSumm = $delivery->getDeliverySummary();

//code to render as HTML the customer's basket details
//as well as their billing and delivery details 

Is creating a Session class (that really only holds a single value) the best idea? Given that it may need to hold more values and perform more checking, it felt 'right' making it a class. In terms of passing that value to the various classes, would it be best to pass in the Session object to their constructor, eg

$se = new Session;
$basket = new Basket($se);
$baskSumm = $basket->getBasketSummary();

I'm new to OOP so some guidance would be very much appreciated.

Answer 1

You may use Factory Pattern. Basket, Billing and Delivery objects should be created by the 3rd-party service API wrapper class:

$svc = new The3rdPartyServiceApiWrapper();
$svc->init();  // connect, get session etc.
if ($svc->fail()) die("halp! error here!");

$basket = $svc->createBasket();
$baskSumm = $basket->getBasketSummary();

$billing = $svc->createBilling();
$billSumm = $billing->getBillingSummary();

$delivery = $svc->createDelivery();
$delSumm = $delivery->getDeliverySummary();

The best way to connect Basket, Billing and Delivery class with the API is storing a reference to the API class, then they can call any method of it, not just getSession().

Another advantage is, that if you have an identified entity, eg a User, then the wrapper class can grant you, that there will be no double objects in the scene.

If the main program creates the users, there should be different objects with the same user, which is wrong:

$user1 = new User("fred12");
$user2 = new User("fred12");

VS if the API wrapper creates them, the wrapper class should keep a "cache" of users, and return with the same User object for the same request:

$user1 = $svc->createUser("fred12");
$user2 = $svc->createUser("fred12");  // $user2 will be the same object

(Maybe it's not a best example, if a program creates twice the same User, it means that the program has major design faulty.)

UPDATE: explanation of svc class

The The3rdPartyServiceApiWrapper should look like this:

 function getSessionId() {
   return $this->sessionId;  // initialized by constructor
 } // getSessionId()

 function createBasket() {
   $basket = new Basket($this);
   return $basket;
 } // createBasket()

The Basket:

 function Basket($s) {  // constructor of Basket class

   $this->svc = $s;

   //... the rest part of constructor

 } // Basket() constructor

function doSomethingUseful() {

  // if you wanna use the session:
  $sess = $this->svc->getSessionId();
  echo("doing useful with session $session");

  // you may access other api functions, I don't know what functions they provide
  $this->svc->closeSession();

} // doSomethingUseful()