Birden fazla örneğini kaldırmak ve çok fonksiyonlu php çağırır ise sadece bir örneği var nasıl?

4 Cevap 
public function getHelperInstance()
{
    $user = new Helper();
    $user->set($result['data']);
    return $user;
}

I () sınıfı birden çok kez getHelper çağırıyor ve ben $ kullanıcı getHelperInstance (), şimdi benim durumumda getHelperInstance () her zaman yeni bir Yardımcısı'nın örneğini () sınıfı oluşturur ve aradığım daha boş değilse yani () işlevi getHelperInstance diyoruz her zaman Yardımcısı yeni bir örneğini () bu yüzden sadece Yardımcısı (bir örneğini) oluşturmak ve bunun yerine her bir yeni bir örneğini oluşturmak bunu birden çok kez kullanabilirsiniz herhangi bir yolu yoktur oluşturma. Herhangi bir öneri!

public function getHelper()
{
    $user = array();
    if (!empty($user))
    {
        $user = $this->getHelperInstance();
    }
    return $user;
}

4 Cevap

İşte Erich Gamma, Singleton desenin mucitlerden biri, bu konuda söylenecek budur:

"I'm in favor of dropping Singleton. Its use is almost always a design smell"

Yani, yerine bir Singleton, ben Dependency Injection kullanmanızı öneririm.

Eğer $ bu ne oluşturmadan önce Yardımcısı örneği oluşturun. Sonra bir ayarlayıcı yöntemi aracılığıyla veya kurucusuna yoluyla, dışarıdan $ bu örnek için yardımcı örneği ayarlayın.

Bir alternatif olarak, adıyla yardımcıları örneğini ve $ bu örnek o geçmek bilen bir Yardımcısı broker oluşturun:

class HelperBroker
{
    protected $helpers = array();

    public function getHelper($name)
    {
        // check if we have a helper of this name already
        if(!array_key_exists($name, $this->helpers)) {
            // create helper ve store for later subsequent calls
            $this->helpers[$name] = new $name;
        }
        return $this->helpers[$name];
    }
}

Gerekli ve Singleton kullanmak zorunda kalmadan, ikinci bir örneğini almak asla gibi tembel yük yardımcıları yapabilirsiniz Bu şekilde. Yardımcıları kullanmak için gereken her sınıfa komisyoncu bir örneğini iletir.

Tek bir yardımcı ile Örnek

$helper     = new Helper;
$someClass  = new Something($helper);

ve

class Something
{ 
    protected $helper;
    public function __construct($helper)
    { 
        $this->helper = $helper;
    }
    public function useHelper() 
    { 
        $return = $this->helper->doSomethingHelpful();
    }
}

Inside $something you can now store ve access the helper instance directly. You don't need to instantiate anything. In fact, $something doesn't even have to bother about how a helper is instantiated, because we give $something everything it might need upfront.

Eğer $ birSınıf birden yardımcısı kullanmak istiyorsanız Şimdi, aynı prensip kullanmak istiyorum:

$helper1    = new Helper;
$helper2    = new OtherHelper;
$something  = new Something($helper1, $helper2);

This list will get rather long the more dependencies you insert upfront. We might not want to instantiate all helpers all the time as well. That's where the HelperBroker comes into play. Instead of passing every helper as a ready instance to the $something, we inject an object that knows how to create helpers ve also keeps track of them.

$broker    = new HelperBroker;
$something = new Something($broker);

ve

class Something
{ 
    protected $helperBroker;
    public function __construct($broker)
    { 
        $this->helperBroker = $broker; 
    }
    public function doSomethingHelpful()
    { 
        $return = $this->getHelper('foo')->doSomethingHelpful();
    }
    public function doSomethingElse()
    { 
        $return = $this->getHelper('bar')->doSomethingElse();
    }
}

Şimdi komisyoncu onları gerektiğinde şey, ihtiyacı yardımcıları alabilirsiniz $. Bu mantık broker içerisine kapatılmıştır çünkü ek olarak, yardımcıları erişmek için gereken herhangi bir sınıf artık şimdi, bir yardımcı nasıl oluşturulacağı hakkında rahatsız gerekmez.

$broker    = new HelperBroker;
$something = new Something($broker);
$other     = new Other($broker);

The broker also makes sure that you only have one helper instance, because when a helper was instantiated, it is stored inside the broker ve returned on subsequent calls. This solves your initial problem, that you don't want to reinstance any helpers. It also doesn't force your helpers to know anything about how to manage themselves in the global state, like the Singleton does. Instead you helpers can concentrate on their responsibility: helping. That's clean, simple ve reusable.

Eğer singleton pattern ilgilenen gibi geliyor. Eğer PHP5 + kullanıyorsanız, PHP'nin cepten şeyler yararlanmak gerekir.

Here's an article PHP4'te singleton'ununu nasıl uygulanacağı. (Tüm bir seçenek olup olmadığını Ama şiddetle php5 için güncelleme öneririm)

class Singleton {
    function Singleton() {
        // Perform object initialization here.
    }

    function &getInstance() {
        static $instance = null;
        if (null === $instance) {
            $instance = new Singleton();
        }
        return $instance;
    }
}

PHP 4 Singleton Pattern

Eğer gerçekten seni kullanmak hangi PHP sürümü üzerinde herhangi bir kontrol varsa Bilginize, PHP 5 geçmelisiniz.

etiketler