¿Qué es una Fábrica de Patrón de Diseño en PHP?
https://stackoverflow.com/questions/2083424
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPregunta
Esto me confunde, en la mayoría de los términos más simples, ¿qué hacer?Pretender que usted está explicando a su madre o a alguien casi por favor.
Solución
Una fábrica crea un objeto. Por lo tanto, si usted quiere construir
class A{
public $classb;
public $classc;
public function __construct($classb, $classc)
{
$this->classb = $classb;
$this->classc = $classc;
}
}
Usted no quiere depender de tener que hacer el siguiente código cada vez que se crea el objeto
$obj = new ClassA(new ClassB, new Class C);
Esto es donde la fábrica vendría en Definimos una fábrica de cuidar de que para nosotros:.
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;
}
}
Ahora todo lo que tenemos que hacer es
$factory = new Factory;
$obj = $factory->build();
La ventaja real es cuando se quiere cambiar la clase. Digamos que queríamos pasar en un ClassC diferente:
class Factory_New extends Factory{
public function buildC(){
return new ClassD;
}
}
o un nuevo ClassB:
class Factory_New2 extends Factory{
public function buildB(){
return new ClassE;
}
}
Ahora podemos utilizar la herencia para modificar fácilmente cómo se crea la clase, para poner en un conjunto diferente de clases.
Un buen ejemplo podría ser esta clase de usuario:
class User{
public $data;
public function __construct($data)
{
$this->data = $data;
}
}
En este $data clase es la clase que utilizamos para almacenar nuestros datos. Ahora, para esta clase, digamos que utilizamos una sesión para almacenar nuestros datos. La fábrica se vería así:
class Factory{
public function build()
{
$data = $this->buildData();
return $this->buildUser($data);
}
public function buildData()
{
return SessionObject();
}
public function buildUser($data)
{
return User($data);
}
}
Ahora, digamos que en lugar queremos almacenar todos nuestros datos en la base de datos, es muy simple para cambiarlo:
class Factory_New extends Factory{
public function buildData()
{
return DatabaseObject();
}
}
Las fábricas son un patrón de diseño que utilizamos para controlar la forma en que ponemos objetos entre sí, y el uso de patrones de fábrica correctas nos permite crear los objetos personalizados que necesitamos.
Otros consejos
Al igual que una fábrica de la vida real, se crea algo y lo devuelve.
Imagínese que algo como esto
$joe = new Joe();
$joe->say('hello');
o un método de fábrica
Joe::Factory()->say('hello');
La aplicación del método de fábrica creará una nueva instancia y devolverlo.
patrón de diseño de fábrica es muy bueno cuando se trata de múltiples recursos y desea implementar abstracción de alto nivel.
Vamos a romper esto en la sección diferente.
Supongamos que tenemos para implementar la abstracción y el usuario de la clase no tiene que preocuparse por lo que ha implementado en la definición de clase.
El / ella sólo tiene que preocuparse por el uso de métodos de su clase.
por ejemplo. Tiene dos bases de datos para su proyecto
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;
}
}
Su clase de fábrica se haría cargo de la creación de objetos para la conexión de base de datos.
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;
}
}
El usuario sólo tiene que pasar el nombre del tipo de base de datos
$dbconn1 = DBFactory::getConn("MySQL");
$dbconn1->select();
Salida:
MySQL Database Connection
Your mysql select query execute here
En el futuro es posible que tenga base de datos diferente, entonces no es necesario cambiar el código completo sólo se necesita para pasar el nuevo tipo de base de datos y otro tipo de código se ejecutará sin hacer ningún cambio.
$dbconn2 = DBFactory::getConn("Oracle");
$dbconn2->select();
Salida:
Oracle Database Connection
Your oracle select query execute here
Esperamos que esto ayude.
En general, una "fábrica" produce algo:en el caso de la orientación a Objetos-Programación, una "fábrica de patrón de diseño" produce objetos.
No importa si es en PHP, C# o cualquier otro lenguaje Orientado a Objetos.
La fábrica del diseño del patrón (patrón de fábrica) es para el acoplamiento débil. Al igual que el significado de la fábrica, los datos a una fábrica (producir datos) para el usuario final. De esta manera, la fábrica de romper el estrecho acoplamiento entre la fuente de datos y el proceso de datos.
Un habitante genera uno o varios objetos.
Es posible que tenga una fábrica que construye una conexión MySQL.
Esta respuesta está en relación con otros post en el que Daniel White dice que el uso de fábrica para crear la conexión de MySQL utilizando el patrón de fábrica.
Para la conexión MySQL prefiero utilizar como patrón Singleton desea utilizar misma conexión para acceder a la base de datos no crea otro.
El enfoque clásico para instanciar un objeto es:
$Object=new ClassName();
PHP tiene la capacidad de crear dinámicamente un objeto del nombre de la variable utilizando la siguiente sintaxis:
$Object=new $classname;
donde la variable $ nombre de clase contiene el nombre de una clase quiere crear una instancia.
Así clásico factoring objeto se vería así:
function getInstance($classname)
{
if($classname==='Customer')
{
$Object=new Customer();
}
elseif($classname==='Product')
{
$Object=new Product();
}
return $Object;
}
y si se llama a la función getInstance ( 'producto') esta fábrica va a crear y devolver objetos del producto. De lo contrario, si se llama a getInstance ( 'Cliente') la función de esta fábrica va a crear y devolver al cliente el tipo de objeto (creado a partir de los clientes () de clase).
No hay necesidad de eso nunca más, se puede enviar 'producto' o 'Cliente' (los nombres exactos de las clases existentes) como un valor de la variable para la instanciación dinámica:
$classname='Product';
$Object1=new $classname; //this will instantiate new Product()
$classname='Customer';
$Object2=new $classname; //this will instantiate new Customer()
Para el registro, en palabras sencillas, una fábrica como @Pindatjuh dijo, devuelve un objeto.
Así que, ¿cuál es la diferencia con un constructor? (Que hace lo mismo)
- un constructor utiliza su propia instancia.
- algo que quiero así que algo más avanzado y que no quiero a inflar el objeto (o agregar dependencias).
-
Constructor se llama cuando se crea cada instancia. A veces usted no quiere eso.
Por ejemplo, digamos que cada vez que crea un objeto de la clase de cuenta, he leído desde la base de datos de un archivo y lo utilizan como una plantilla.
El uso de constructor:
class Account {
var $user;
var $pwd;
var ...
public __construct() {
// here i read from the file
// and many other stuff
}
}
El uso de fábrica:
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;
}
