Che cos'è un modello di progettazione in fabbrica in PHP?

Question

Questo mi confonde, nel modo più semplice, che cosa fa? Fai finta di spiegare a tua madre oa qualcuno quasi per favore.

Answer 1

Una fabbrica crea un oggetto. Quindi, se si voleva costruire

class A{ 
    public $classb; 
    public $classc; 
    public function __construct($classb, $classc) 
    { 
     $this->classb = $classb; 
     $this->classc = $classc; 
    } 
    } 

Lei non vorrebbe fare affidamento su di dover effettuare le seguenti operazioni ogni volta che il codice si crea l'oggetto

$obj = new ClassA(new ClassB, new Class C); 

Questo è dove la fabbrica sarebbe venuto. Abbiamo definire una fabbrica di prendersi cura di questo per noi:

class Factory{ 
    public function build() 
    { 
     $classc = $this->buildC(); 
     $classb = $this->buildB(); 
     return $this->buildA($classb, $classc); 

    } 

    public function buildA($classb, $classc) 
    { 
     return new ClassA($classb, $classc); 
    } 

    public function buildB() 
    { 
     return new ClassB; 
    } 

    public function buildC() 
    { 
     return new ClassC; 
    } 
} 

Ora tutto quello che dobbiamo fare è

$factory = new Factory; 
$obj  = $factory->build(); 

Il vero vantaggio è quando si desidera cambiare classe. Diciamo che abbiamo voluto passare in un altro ClassC:

class Factory_New extends Factory{ 
    public function buildC(){ 
     return new ClassD; 
    } 
} 

o un nuovo ClassB:

class Factory_New2 extends Factory{ 
    public function buildB(){ 
     return new ClassE; 
    } 
} 

Ora possiamo usare l'ereditarietà per modificare facilmente come viene creata la classe, per mettere in un set diverso di classi.

Un buon esempio potrebbe essere questa classe utente:

class User{ 
    public $data; 
    public function __construct($data) 
    { 
     $this->data = $data; 
    } 
} 

In questa classe $data è la classe che usiamo per memorizzare i nostri dati. Ora per questa classe, diciamo che usiamo una sessione per archiviare i nostri dati.La fabbrica sarebbe simile a questa:

class Factory{ 
    public function build() 
    { 
     $data = $this->buildData(); 
     return $this->buildUser($data); 
    } 

    public function buildData() 
    { 
     return SessionObject(); 
    } 

    public function buildUser($data) 
    { 
     return User($data); 
    } 
} 

Ora, consente di dire invece che vogliamo memorizzare tutti i nostri dati nel database, è davvero semplice da cambiare:

class Factory_New extends Factory{ 
    public function buildData() 
    { 
     return DatabaseObject(); 
    } 
} 

Fabbriche sono un disegno pattern che usiamo per controllare il modo in cui uniamo gli oggetti, e l'utilizzo di modelli di fabbrica corretti ci consente di creare gli oggetti personalizzati di cui abbiamo bisogno.

Answer 2

Una fabbrica genera solo un oggetto o oggetti.

Si può avere una fabbrica che crea una connessione MySQL.

http://en.wikipedia.org/wiki/Factory_method_pattern

Answer 3

Come una vera e propria fabbrica di vita, si crea qualcosa e lo restituisce.

Immaginate qualcosa di simile

$joe = new Joe(); 
$joe->say('hello'); 

o un metodo factory

Joe::Factory()->say('hello'); 

L'implementazione del metodo factory creerà una nuova istanza e restituirlo.

Answer 4

In generale una "fabbrica" ​​produce qualcosa: nel caso di programmazione orientata agli oggetti, un "modello di progettazione di fabbrica" ​​produce oggetti.

Non importa se è in PHP, C# o qualsiasi altra lingua orientata agli oggetti.

Answer 5

Il modello di progetto di fabbrica (modello di fabbrica) è per accoppiamento lento. Come il significato di fabbrica, i dati di una fabbrica (produrre dati) all'utente finale. In questo modo, la fabbrica rompe lo stretto legame tra la fonte dei dati e il processo dei dati.

Answer 6

Questa risposta è in relazione ad altri post in cui Daniel White ha dichiarato di utilizzare factory per la creazione della connessione MySQL utilizzando il modello factory.

Per la connessione MySQL, preferirei utilizzare il modello singleton poiché si desidera utilizzare la stessa connessione per accedere al database e non crearne un altro.

Answer 7

L'approccio classico per creare un'istanza di un oggetto è:

$Object=new ClassName(); 

PHP ha la capacità di creare in modo dinamico un oggetto dal nome della variabile utilizzando la seguente sintassi:

$Object=new $classname; 

dove $ classname variabile contiene il il nome della classe uno vuole creare un'istanza.

così classico factoring oggetto sarà simile:

function getInstance($classname) 
{ 
    if($classname==='Customer') 
    { 
    $Object=new Customer(); 
    } 
    elseif($classname==='Product') 
    { 
    $Object=new Product(); 
    } 
    return $Object; 
} 

e se si chiama la funzione getInstance ('prodotto') questa fabbrica sarà creare e restituire oggetto prodotto. Altrimenti, se chiami la funzione getInstance ('Customer'), questo factory creerà e restituirà l'oggetto Type del cliente (creato dalla classe Customer()).

Non c'è bisogno di questo più, si può inviare 'prodotto' o 'clienti' (i nomi esatti di classi esistenti) come valore della variabile per esemplificazione dinamica:

$classname='Product'; 
$Object1=new $classname; //this will instantiate new Product() 

$classname='Customer'; 
$Object2=new $classname; //this will instantiate new Customer() 

Answer 8

Per la cronaca, in parole facili, una fabbrica come ha detto @Pindatjuh, restituisce un oggetto.

Quindi, qual è la differenza con un costruttore? (che fa lo stesso)

1. un costruttore utilizza la propria istanza.
2. Qualcosa che voglio così qualcosa di più avanzato e non voglio ingrossare l'oggetto (o aggiungere dipendenze).

3. Il costruttore viene chiamato quando viene creata ogni istanza. A volte non lo vuoi.

   Ad esempio, supponiamo che ogni volta che creo un oggetto della classe Account, leggo dal database un file e lo utilizzo come modello.

utilizzando il costruttore:

class Account { 
     var $user; 
     var $pwd; 
     var ... 
     public __construct() { 
     // here i read from the file 
     // and many other stuff 
     } 
} 

Utilizzando fabbrica:

class Account { 
     var $user; 
     var $pwd; 
     var ... 
} 
class AccountFactory { 
     public static Create() { 
     $obj=new Account(); 
     // here we read the file and more stuff. 
     return $obj; 
     }