Küresellerle kullanmadan PHP fonksiyonları arasındaki payı değişkenleri

4 Cevap php

Ben bir memcache sunucusu ile etkileşim için bir sınıf var. Ben, ekleme, silme ve veri almak için farklı işlevlere sahiptir. Başlangıçta her bir fonksiyon, örneğin gereksiz olduğunu ancak, memcache_connect() için bir çağrı yaptı:

mc->insert()  
mc->get()  
mc->delete()

Üç memcache bağlantıları yapmak istiyorum. Ben sınıf için bir yapı oluşturarak bu çalıştı:

function __construct() {
    $this->mem = memcache_connect( ... );
}

ve daha sonra kaynak gerekli $this->mem yerde kullanarak, bu nedenle üç fonksiyonların her biri aynı memcache_connect kaynak kullanımı.

Bu tamam, ancak ben diğer sınıfları içinde sınıf aramak ise, örneğin:

class abc
{
    function __construct() {
        $this->mc = new cache_class;
    }
}    
class def
{
    function __construct() {
        $this->mc = new cache_class;
    }
}

zaman sadece needs, bir o hala, iki memcache_connect çağrıları yapıyor.

Ben globalleri ile yapabilirsiniz ama ben yoksa bunları kullanmamayı tercih ederim.

Örnek globallerinin uygulama:

$resource = memcache_connect( ... );

class cache_class
{
    function insert() {
        global $resource;
        memcache_set( $resource , ... );
    }
    function get() {
        global $resource;
        return memcache_get( $resource , ... );
    }

}

Sonra ne olursa olsun sınıf denir kaç kez sadece memcache_connect bir çağrı olacaktır.

Bunu yapmak için veya sadece küresellerle kullanmanız gereken bir yolu var mı?

4 Cevap

Ben memcache sadece örneğini almak için singleton deseni kullanarak başka bir sınıf kod olacaktır. Bu gibi -

class MemCache 
{ 
  private static $instance = false;   
  private function __construct() {}

  public static function getInstance()
  { 
    if(self::$instance === false)
    { 
      self::$instance = memcache_connect(); 
    } 

    return self::$instance; 
  } 
}

ve kullanımı -

$mc = MemCache::getInstance();
memcache_get($mc, ...)
...

MC örneği Pass:

class abc
{
    function __construct($mc) {
        $this->mc = $mc;
    }
}    
class def
{
    function __construct($mc) {
        $this->mc = $mc;
    }
}

$mc = new cache_class;
$abc = new abc($mc);

vb

Burada statik özellikleri arıyoruz düşünüyorum.

class mc {
    private static $instance;

    public static function getInstance() {
        if (self::$instance== null) {
            self::$instance= new self;
        }
        return self::$instance;
    }

    private function __construct() {
        $this->mem = memcache_connect(...);
    }
}

Bu temel bir singleton deseni uygular. Bunun yerine nesne çağrıyı inşa mc::getInstance(). singletons bakabilirsiniz.

Sen bağımlılık enjeksiyon kullanmalısınız. Onlar aslında globallerinin çünkü tekiz desen ve statik yapıları kötü uygulama olarak kabul edilir (ve iyi bir sebeple - onlar diğer bazı aksine örneğini ne olursa olsun sınıf kullanarak sizi çimento).

Burada kolay bakım sahip olmak için ne yapmalıyım gibi bir şeydir.

class MemCache {
    protected $memcache;

    public function __construct(){
        $this->memcache = memcache_connect();
    }
}

class Client {
    protected $MemCache;

    public function __construct( MemCache $MemCache ){
        $this->MemCache = $MemCache;
    }

    public function getMemCache(){
        return $this->MemCache;
    }
}

$MemCache = new MemCache();
$Client = new Client($MemCache);
$MemCache1 = $Client->getMemCache();

// $MemCache and $MemCache1 are the same object. 
// memcache_connect() has not been called more than once.

etiketler