Cos'è un Factory Design Pattern in PHP?
https://stackoverflow.com/questions/2083424
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianDomanda
Questo mi confonde, in termini più semplici cosa fa?Fai finta di spiegarlo a tua madre o a qualcuno, quasi per favore.
Soluzione
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;
}
}
Non si vuole 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);
E 'qui che la fabbrica sarebbe venuto in Definiamo 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();
L'vero vantaggio è quando si desidera cambiare la classe. Diciamo che abbiamo voluto passare in un ClassC diversa:
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 utilizzare l'ereditarietà per modificare facilmente come viene creata la classe, di mettere in un diverso insieme 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, consente di dire che usiamo una sessione per memorizzare 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();
}
}
Le fabbriche sono un modello di progettazione che usiamo per controllare il modo abbiamo messo insieme gli oggetti, e l'utilizzo di modelli di fabbrica corretto ci permette di creare oggetti personalizzati di cui abbiamo bisogno.
Altri suggerimenti
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.
design pattern Factory è molto buono quando si ha a che fare con più risorse e desidera implementare alto livello di astrazione.
Rompiamo questo in sezione diversa.
Supponiamo di avere per implementare l'astrazione e l'utente della classe non ha bisogno di prendersi cura di ciò che hai implementato nella definizione di classe.
Lui / Lei solo bisogno di preoccuparsi per l'uso dei vostri metodi di classe.
es. Si hanno due basi di dati per il progetto
class MySQLConn {
public function __construct() {
echo "MySQL Database Connection" . PHP_EOL;
}
public function select() {
echo "Your mysql select query execute here" . PHP_EOL;
}
}
class OracleConn {
public function __construct() {
echo "Oracle Database Connection" . PHP_EOL;
}
public function select() {
echo "Your oracle select query execute here" . PHP_EOL;
}
}
La classe di fabbrica si sarebbe preso cura della creazione di oggetti per la connessione al database.
class DBFactory {
public static function getConn($dbtype) {
switch($dbtype) {
case "MySQL":
$dbobj = new MySQLConn();
break;
case "Oracle":
$dbobj = new OracleConn();
break;
default:
$dbobj = new MySQLConn();
break;
}
return $dbobj;
}
}
utente solo bisogno di passare il nome del tipo di database
$dbconn1 = DBFactory::getConn("MySQL");
$dbconn1->select();
Output:
MySQL Database Connection
Your mysql select query execute here
In futuro, si può avere database diverso, allora non c'è bisogno di cambiare l'intero codice solo bisogno di passare al nuovo tipo di database e altro codice verrà eseguito senza apportare alcuna modifica.
$dbconn2 = DBFactory::getConn("Oracle");
$dbconn2->select();
Output:
Oracle Database Connection
Your oracle select query execute here
Spero che questo vi aiuterà.
In generale una "fabbrica" produce qualcosa:nel caso della programmazione orientata agli oggetti, un "modello di progettazione di fabbrica" produce oggetti.
Non importa se è in PHP, C# o qualsiasi altro linguaggio orientato agli oggetti.
Design Factory Pattern (fabbrica Pattern) è per accoppiamento lasco. Come il significato di fabbrica, i dati di una fabbrica (produrre dati) per l'utente finale. In questo modo, la fabbrica di rompere l'accoppiamento stretto tra la fonte dei dati e il processo di dati.
Una fabbrica solo genera uno o più oggetti.
Si può avere una fabbrica che costruisce una connessione MySQL.
Questa risposta è in relazione ad altri post in cui Daniel Bianca ha detto di utilizzare in fabbrica per la creazione di connessione MySQL utilizzando modello di fabbrica.
Per la connessione MySQL Avrei preferito utilizzare pattern Singleton come si desidera utilizzare stessa connessione per accedere al database non crea un altro.
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 variabile $ classname contiene il nome della classe vuole istanziare.
Quindi 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. In caso contrario, se si chiama getInstance ( 'clienti') funzione di questa fabbrica sarà creare e restituire tipo di clienti oggetto (creato da clienti () della classe).
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()
Per la cronaca, in parole semplici, una fabbrica come @Pindatjuh detto, restituisce un oggetto.
Quindi, qual è la differenza con un costruttore? (Che fa lo stesso)
- un costruttore utilizza il suo esempio.
- qualcosa che voglio quindi qualcosa di più avanzato e non voglio che a gonfiare l'oggetto (o aggiungere le dipendenze).
-
costruttore viene chiamato quando viene creata ogni istanza. A volte non si vuole questo.
Per esempio, diciamo che ogni volta che crea un oggetto della classe di conto, ho letto dal database di un file e utilizzarlo come modello.
Utilizzando costruttore:
class Account {
var $user;
var $pwd;
var ...
public __construct() {
// here i read from the file
// and many other stuff
}
}
Uso di 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;
}
