php - remove - strip_tags wordpress
¿Qué es un patrón de diseño de fábrica en PHP? (9)
Esto me confunde, en los términos más simples, ¿qué hace? Imagina que le estás explicando a tu madre o a alguien casi por favor.
Al igual que una fábrica de la vida real, crea algo y lo devuelve.
Imagina algo como esto
$joe = new Joe();
$joe->say(''hello'');
o un método de fábrica
Joe::Factory()->say(''hello'');
La implementación del método de fábrica creará una nueva instancia y la devolverá.
El enfoque clásico para crear instancias de un objeto es:
$Object=new ClassName();
PHP tiene la capacidad de crear dinámicamente un objeto a partir del nombre de la variable con la siguiente sintaxis:
$Object=new $classname;
donde variable $ classname contiene el nombre de la clase que uno quiere crear una instancia.
Así que el factorizado de objetos clásico se vería así:
function getInstance($classname)
{
if($classname===''Customer'')
{
$Object=new Customer();
}
elseif($classname===''Product'')
{
$Object=new Product();
}
return $Object;
}
y si llama a la función getInstance (''Producto'') esta fábrica creará y devolverá el objeto Producto. De lo contrario, si llama a la función getInstance (''Cliente'') esta fábrica creará y devolverá el tipo de objeto del cliente (creado desde la clase Cliente ()).
Ya no es necesario, puede enviar ''Producto'' o ''Cliente'' (nombres exactos de las clases existentes) como un valor de variable para la creación de instancias dinámicas:
$classname=''Product'';
$Object1=new $classname; //this will instantiate new Product()
$classname=''Customer'';
$Object2=new $classname; //this will instantiate new Customer()
El patrón de diseño de fábrica (patrón de fábrica) es para acoplamiento flexible. Al igual que el significado de fábrica, los datos a una fábrica (producir datos) para el usuario final. De esta manera, la fábrica rompe el estrecho acoplamiento entre la fuente de datos y el proceso de datos.
El patrón de diseño de la fábrica es muy bueno cuando se trata de múltiples recursos y se desea implementar una abstracción de alto nivel.
Vamos a dividir esto en una sección diferente.
Supongamos que tiene que implementar la abstracción y que el usuario de su clase no tiene que preocuparse por lo que ha implementado en la definición de la clase.
Él / ella solo necesita preocuparse por el uso de sus métodos de 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 Factory se encargaría de la creación del objeto para la conexión de la 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 solo necesita 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, puede tener una base de datos diferente, entonces no necesita cambiar todo el código, solo necesita pasar el nuevo tipo de base de datos y se ejecutará otro código sin realizar ningún cambio.
$dbconn2 = DBFactory::getConn("Oracle");
$dbconn2->select();
Salida:
Oracle Database Connection
Your oracle select query execute here
Espero que esto ayude
En general, una "fábrica" produce algo: en el caso de la Programación Orientada a Objetos, un "patrón de diseño de fábrica" produce objetos.
No importa si está en PHP, C # o cualquier otro lenguaje orientado a objetos.
Esta respuesta está en relación con otra publicación en la que Daniel White dijo que usara fábrica para crear una conexión MySQL usando el patrón de fábrica.
Para la conexión MySQL, prefiero usar el patrón singleton, ya que quiere usar la misma conexión para acceder a la base de datos, no crear otra.
Para el registro, en palabras sencillas, una fábrica como @Pindatjuh dijo, devuelve un objeto.
Entonces, ¿cuál es la diferencia con un constructor? (eso hace lo mismo)
- un constructor usa su propia instancia.
- Algo que quiero es algo más avanzado y no quiero hinchar el objeto (o agregar dependencias).
Se llama a Constructor cuando se crea cada instancia. A veces no quieres eso.
Por ejemplo, supongamos que cada vez que creo un objeto de la clase Cuenta, leo de la base de datos un archivo y lo uso como plantilla.
Usando constructor:
class Account {
var $user;
var $pwd;
var ...
public __construct() {
// here i read from the file
// and many other stuff
}
}
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;
}
Una fábrica solo genera un objeto u objetos.
Puede tener una fábrica que construya una conexión MySQL.
Una fábrica crea un objeto. Entonces, si quisieras construir
class A{
public $classb;
public $classc;
public function __construct($classb, $classc)
{
$this->classb = $classb;
$this->classc = $classc;
}
}
No querrá confiar en tener que hacer el siguiente código cada vez que cree el objeto
$obj = new ClassA(new ClassB, new Class C);
Ahí es donde entraría la fábrica. Definimos una fábrica para que se encargue de eso por 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 verdadera ventaja es cuando quieres cambiar la clase. Digamos que queríamos pasar 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 usar 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 esta clase $data es la clase que usamos para almacenar nuestros datos. Ahora para esta clase, digamos que usamos 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 queremos almacenar todos nuestros datos en la base de datos, es realmente simple 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 cómo unimos los objetos, y el uso de patrones de fábrica correctos nos permite crear los objetos personalizados que necesitamos.