Factory, Simple Factory y Abstract Factory

[OsSk4R]

Buenas,

Estoy tratando de aprender correctamente el uso del patrón factory puesto que antes lo estaba usando como una fábrica general de cualquier tipo de objetos
La cuestión es que después de leer por varios sitios y realizar un primer ejemplo continuo "sin comprenderlo".

Por ejemplo tengo lo siguiente:

Código PHP:

interface IFactory
{
    static public function create($name);
}
 
class DBFactory implements IFactory
{
    private static $database = array('mysql'=>'MySQL', 'postgresql'=>'PostgreSQL'); //DB permitidas
    static public function create($name)
    {
        switch (self::$database[$name]) {  
            case 'MySQL': return new MySQL($name);  
            case 'PostgreSQL': return new PostgreSQL($name);   
            default:  
                echo 'Tipo de base de datos desconocida';  
        }  
    }
}
 
abstract class DB
{
    protected $_name = NULL;  
      
    public function __construct($name)  
    {  
        $this->_name = $name;  
    }  
  
    public function getName()  
    {  
        return $this->_name;  
    }  
}
 
class MySQL extends DB
{
 
}
 
class PostgreSQL extends DB
{
 
}
 
//Supongamos que el usuario elije la base de datos a la que conectarse desde un select option:
$select_db = 'mysql'; //Nos trae la elección
$objeto = DBFactory::create($select_db);
echo $objeto->getName();
 

Entiendo que este ejemplo es el llamado "Simple Factory". ¿Estoy en lo correcto?
Ahora bien. mi duda... Factory Method y el Abstract Factory ¿qué diferencia tendrían con éste?.
Por ejemplo, la siguiente imagen explica el patrón Abstract Factory y sinceramente "no veo la diferencia" en cuanto al ejemplo que acabo de poner, sin embargo, mi ejemplo no es el patrón Abstract Factory.


Saludos y gracias,

[GatorV]

http://www.forosdelweb.com/f68/difer...actory-925846/

[OsSk4R]

:O ¡que rapidez!

Veamos, me he leído el post que mencionas y me ha quedado claro el tema del Simple Factory y el Factroy Method. De hecho, ahora veo claramente que el ejemplo que puse, es un Simple Factory porque estoy creando diferentes objetos que sé que tienen una relación en concreto con esa fabrica, en este caso la fabrica DBFactory.

Factory Method, se usa para separar diferentes Fabricas de Objetos que estan dentro de un mismo componente común, por ejemplo, un objeto que crea formularios, puede tener un fabrica que cree formularios desde un XML, o desde un array, o desde una BDD...

Entiendo por esto que puedo crear un objeto que sea una fabrica de usuarios y que a su vez esta fabrica, cree usuarios desde un XML, BD... ¿no?
He realizado un ejemplo para ver si he entendido el Factory Method, aunque tengo el presagio que esta mal

Código PHP:

<?php
 
interface IFactory
{
    static public function createUserXML($name);
    static public function createUserBD($name);
}
 
class UserFactory implements IFactory
{
    static public function createUserXML($name)
    {
        return new UserXML($name);
    }
    
    static public function createUserBD($name)
    {
        return new UserBD($name);
    }   
}
 
abstract class User
{
    protected $_name = NULL;  
      
    public function __construct($name)  
    {  
        $this->_name = $name;  
    }  
  
    public function getName()  
    {  
        return $this->_name;  
    }  
}
 
class UserXML extends User
{
 
}
 
class UserBD extends User
{
 
}
 
$objeto = UserFactory::createUserXML('UserXML');
echo $objeto->getName();
 

Por otro lado, el patrón Abstract Factory sigo sin cogerlo del todo. El diagrama lo entiendo pero ya esta, no veo claro cuando usarlo y cuando no ya que creo que con un simple factory es suficiente... En fin, sinceramente tengo un lio ahora mismo que no me aclaro ni yo

Saludos y gracias

[GatorV]

Pues de hecho más la idea (con FactoryMethod) es que te devuelva el mismo objeto pero de diferentes fuentes, o sea en tu ejemplo de usuarios:

Código PHP:

<?php
class UserFactory {
    public static function fromXML($sXML)
    {
        // Cargas desde el xml
        return $User;
    }
    
    public static function fromBDD($sId)
    {
        // Cargas desde la bdd
        return $User;
    }
    
    public static function fromText($sTextFile)
    {
        return $User;
    }
}
 

El AbstractFactory, se usa mucho con inyección de dependencias, ya que la idea es que todo este "atado" usando interfaces, pero nada concreto, la idea es que al configurar el objeto (ya en ejecución) la fabrica sea lo más abstracta posible para soportar esos cambios.

Saludos.

[OsSk4R]

Entonces con ese código que has puesto, ¿ya se esta implementando el patrón Factory Method? ¿no hace falta implementar ninguna interfaz ni nada? ¿sólo basta con crear una clase UserFactory y que cada método devuelva el mismo objeto pero de diferentes fuentes? ¿eso es todo?

Saludos y gracias una vez más

[GatorV]

Así es, las interfaces son más usadas para AbstractFactory, ya que como te digo, la idea es que solo a nivel código se devuelvan interfaces, ya es cuando configuras tu fabrica cuando usas el método concreto que va a devolver y la fabrica concreta que va a usar.

[OsSk4R]

Perfecto una vez más GatorV, me ha quedado claro

Saludos y muchas gracias