OO PHP where to reference singleton class?

I am going to use singleton classes to manage both DB connections and references to application settings.

It seems a little messy to have to use the following code in every method in order to access the开发者_如何学Go db class.

$db = DB::getInstance();

Is there a more efficient way of going about it?

Any advice appreciated.

Thanks

---

I often use the Registry pattern, where this behavior occurs as well. I always set a instance variable in the constructor of my models to point to the Registry entry;

class Registry {
    private static $_instance;
    private $_registry;

    private function __construct() {
        $_registry = array();
    }

    public static function getInstance() {
        if (!Registry::$_instance) {
            Registry::$_instance = new Registry();
        }

        return Registry::$_instance;
    }

    public function add($key, &$entry) {
        $this->_registry[$key] = &$entry;
    }

    public function &get($key) {
        return $this->_registry[$key];
    }

    public function has($key) {
        return ($this->get($key) !== null);
    }
}

Model example;

class MyModel {
    private $_db;
    public function __construct() {
        $this->_db = Registry::getInstance()->get('dbKey');
    }

    /* Every function has now access to the DAL */
}

Instantiation example;

$dal = new Db(...);
Registry::getInstance()->add('dbKey', $dal);
...
$model = new MyModel();
$model->doDbStuff();

Another approach is to always pass the reference as a parameter to each constructor.

Of course I only use this behavior when most of the methods in my model use the reference, if only a few (one or two) methods have use of the reference, I call the Registry/Singleton like you showed.

---

It is not messy. This is an intended behavior of Singletons. And, actually, this is just one line of code. Do you wish to make it even more compact? :)

---

My preferred method is to create a Base class which all the classes that need db access descend from. Base calls the singleton(s) in its constructor. All its children call their parent constructor. e.g.:

class Base {
  protected $db;

  public function __construct(){
    $this->db = DB::getInstance();
  }
}

class Achild extends Base {
  protected $var1;

  public function __construct($arg){
     parent::__construct();
     $this->var1=$arg;
  }
}

---

I know what you mean... hate that ::getInstance() stuff! So go and use static methods:

class DB {
    private static $db;

    public static function getInstance() {
        if(!self::$db) {
            self::$db = new DBconnector();
        }
    }

    public static function query($query) {
        return self::$db->query($query);
    }
}

Usage is much nicer:

$result = DB::query('SELECT whatever;');

And if you use PHP 5.3 you can write a __callStatic similar to this, to forward all the method calls to the object:

public static function __callStatic($method, $args) {
    call_user_func_array(array(self::$db, $method), $args);
}

And to make me happy, add an __autoloader so that you can access DB without any worries any time!