Ben genellikle bu davranış da oluşur Defteri tonunu kullanın. Ben her zaman Registry girişe işaret benim modellerin yapıcısı bir örnek değişken ayarlamak;

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);
    }
}

Modeli örnek;

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

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

Örnekleme örnek;

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

Başka bir yaklaşım her zaman her kurucusuna bir parametre olarak başvuru geçmektir.

Benim modelinde yöntemlerin çoğu başvuru kullanın yalnızca birkaç (bir veya iki) yöntemleri referans kullanımı varsa tabii ki ben sadece, bu davranışı kullanmak size gösterdiğim gibi, ben Defteri / Singleton diyoruz.

Bu dağınık değil. Bu Singletons amaçlanan bir davranıştır. Ve aslında, bu kod sadece bir çizgidir. Bunu bile daha kompakt hale getirmek ister misiniz? :)

Benim tercih edilen yöntem db erişim ihtiyacınız olan tüm sınıfları soyundan bir Base sınıfı yaratmaktır. Taban onun kurucu singleton (ler) çağırır. Tüm çocukların ana kurucusunu çağırmak. örneğin:

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;
  }
}

Ben ne demek istediğini biliyorum ... nefret :: getInstance () şeyler! Yani gidip statik yöntemleri kullanın:

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);
    }
}

Kullanımı çok güzel:

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

PHP 5.3 kullanıyorsanız ve tüm yöntem nesneye çağrıları iletmek için, buna benzer bir __ callStatic yazabilirsiniz:

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

Ve, beni mutlu herhangi bir endişeleri olmaksızın her zaman DB erişmek böylece bir __ autoloader eklemek için!