variáveis ??compartilhar entre funções em PHP sem usar globals

Question

Eu tenho uma classe para interagir com um servidor de cache de memória. Eu tenho diferentes funções para inserir, excluir e recuperar dados. Originalmente cada função fez uma chamada para memcache_connect(), no entanto, que era desnecessário, por exemplo:.

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

faria três conexões memcache. Eu trabalhei em torno deste através da criação de uma construção para a classe:

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

e, em seguida, usando $this->mem sempre que foi necessário o recurso, por isso, cada uma das três funções usam o mesmo recurso memcache_connect.

Esta é certo, no entanto, se eu chamar a classe dentro de outras classes, por exemplo:.

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

então ele ainda está fazendo duas chamadas memcache_connect, quando só necessidades um.

Eu posso fazer isso com globals, mas eu preferiria não usá-los se eu não preciso.

Exemplo Globals implementação:

$resource = memcache_connect( ... );

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

}

Então, não importa quantas vezes a classe é chamada só haverá uma chamada para memcache_connect.

Existe uma maneira de fazer isso ou devo apenas usar globals?

Answer 1

Eu codificar outra classe usando o padrão singleton para obter a única instância de memcache. Como este -

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 uso -

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

Answer 2

Passe na instância 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);

etc.

Answer 3

Eu acho que você está procurando propriedades estáticas aqui.

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

isso implementa um padrão Singleton básico. Em vez de construir o mc::getInstance() chamada de objeto. Ter um olhar para singletons .

Answer 4

Você deve usar injeção de dependência. O padrão Singleton e construções estáticas são considerado uma má prática porque eles são essencialmente globals. (E por uma boa razão - eles cimentar-lo a usar qualquer classe instanciar em oposição a algum outro)

Aqui está algo parecido com o que você deve fazer para ter fácil manutenção.

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.