variables Partager entre les fonctions en PHP sans utiliser globals

Question

J'ai une classe pour interagir avec un serveur memcache. J'ai différentes fonctions pour l'insertion, la suppression et la récupération de données. A l'origine chaque fonction fait appel à memcache_connect(), mais qui était inutile, par exemple:.

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

ferait trois connexions memcache. Je CONTOURNÉS en créant une construction pour la classe:

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

et puis en utilisant $this->mem chaque fois que la ressource était nécessaire, pour chacune des trois fonctions utilisent la même ressource memcache_connect.

Ceci est bien, si j'appelle la classe à l'intérieur d'autres classes, par exemple:.

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

alors il continue à faire deux appels memcache_connect, quand il ne a besoin un.

Je peux le faire avec mais je GLOBALS préférerais ne pas les utiliser si je n'ai pas.

Exemple GLOBALS mise en œuvre:

$resource = memcache_connect( ... );

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

}

Alors, peu importe combien de fois la classe est appelée il n'y aura qu'un seul appel à memcache_connect.

Est-il possible de le faire ou devrais-je utiliser globals?

Answer 1

Je coderez une autre classe en utilisant un singleton pour obtenir la seule instance de memcache. Comme cela -

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

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

    return self::$instance; 
  } 
}

et l'utilisation -

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

Answer 2

Passez dans l'instance 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

Je pense que vous êtes à la recherche de propriétés statiques ici.

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

met en œuvre un modèle de base singleton. Au lieu de construire l'appel d'objet mc::getInstance(). Jetez un oeil à singletons .

Answer 4

Vous devez utiliser l'injection de dépendance. Le motif de singleton et les constructions statiques sont considérés comme une mauvaise pratique, car ils sont essentiellement GLOBALS. (Et pour cause - ils vous ciment en utilisant quelque classe instancier par opposition à un autre)

Voici quelque chose comme ce que vous devez faire pour avoir un entretien facile.

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.