Condividi variabili tra le funzioni di PHP senza utilizzare globali

Question

Ho una classe per interagire con un server memcache. Ho diverse funzioni di inserimento, cancellazione e recuperare dati. Originariamente ogni funzione ha fatto una chiamata a memcache_connect(), tuttavia, che non era necessario, per esempio:.

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

renderebbe tre connessioni memcache. Ho lavorato intorno a questo con la creazione di un costrutto per la classe:

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

e quindi utilizzando $this->mem ovunque era necessaria la risorsa, in modo da ciascuna delle tre funzioni utilizzare la stessa risorsa memcache_connect.

Questo è bene, se io chiamo la classe all'interno di altre classi, per esempio:.

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

, allora è ancora facendo due chiamate memcache_connect, quando solo deve uno.

posso fare questo con variabili globali, ma io preferirei non usarli se non devo.

implementazione globali esempio:

$resource = memcache_connect( ... );

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

}

Quindi, non importa quante volte la classe si chiama non ci sarà una sola chiamata a memcache_connect.

C'è un modo per fare questo o devo semplicemente usare variabili globali?

Answer 1

Vorrei codificare un'altra classe utilizzando pattern Singleton per ottenere l'unica istanza di memcache. Ti piace questa -

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

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

    return self::$instance; 
  } 
}

e l'uso -

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

Answer 2

Passate nell'istanza MC:

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

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

ecc.

Answer 3

Credo che siete alla ricerca di proprietà statiche qui.

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

Questa implementa un modello di base Singleton. Invece di costruire l'oggetto mc::getInstance() chiamata. Dai un'occhiata alla singletons .

Answer 4

Si dovrebbe usare l'iniezione di dipendenza. Il pattern Singleton e costrutti statici sono considerati cattiva pratica perché in sostanza sono globali. (E per una buona ragione - che si cementano ad utilizzare qualsiasi classe si crea un'istanza al contrario di qualche altro)

Qui è qualcosa di simile a ciò che si dovrebbe fare in modo da avere una facile manutenzione.

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.