comparten variables entre las funciones en PHP sin utilizar variables globales

Question

Tengo una clase para interactuar con un servidor memcache. Tengo diferentes funciones para insertar, eliminar y recuperar datos. Originalmente cada función realiza una llamada a memcache_connect(), sin embargo, que no era necesario, por ejemplo:.

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

haría tres conexiones memcache. He trabajado en torno a este mediante la creación de una construcción para la clase:

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

y luego usando $this->mem donde se necesitaba el recurso, por lo que cada una de las tres funciones utilizan el mismo recurso memcache_connect.

Esto está bien, sin embargo si llamo a la clase dentro de otras clases, por ejemplo:.

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

A continuación, se sigue haciendo dos llamadas memcache_connect, cuando sólo debe uno.

Puedo hacer esto con variables globales pero preferiría no utilizarlos si no es necesario.

implementación de ejemplo globales:

$resource = memcache_connect( ... );

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

}

A continuación, no importa cuántas veces se llama la clase que sólo habrá una llamada a memcache_connect.

¿Hay una manera de hacer esto o debo utilizar variables globales?

Answer 1

Me codificar otra clase con el patrón Singleton para conseguir la única instancia de Memcache. Como esto -

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

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

    return self::$instance; 
  } 
}

y su uso -

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

Answer 2

Pase en la instancia 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

Creo que estás en busca de propiedades estáticas aquí.

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

Esto implementa un patrón básico Singleton. En lugar de construir la mc::getInstance() llamada a un objeto. Echar un vistazo a únicos .

Answer 4

Debe utilizar la inyección de dependencia. El patrón Singleton y construcciones estáticas se consideran malas prácticas, ya que en esencia son globales. (Y por una buena razón - que se cementan a la utilización de cualquier clase se instancia a diferencia de algunos otros)

Aquí es algo así como lo que debe hacer con el fin de tener un fácil mantenimiento.

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.