Poo - factory class

Télécharger le projet
Commenter

Description

Une classe générique qui implémente le factory design pattern en utilisant la Reflection API de PHP 5, les espaces de noms et le chargement automatique.

(Il y'avait déjà une source similaire par Naixn, celle-çi est plus évoluée et mise à jour PHP 5.3)

Source / Exemple : 


<?php
/**


     
  •  Class Factory is a generic implementation of the factory design pattern.

 *


     
  •  This class is responsible for `manufacturing` an object.

 *


abstract class Factory
{
    /**


         
  •  Instanciates a class given by the first argument.

     *


         
  •  @param  string $className   The name of the class to instanciate.

    •      
  •  @param  mixed  $argument    Optional, zero or more constructor arguments.

    •      
  •  @param  mixed  $...

    •      
  •  @return object              Returns a new instance of a class.

    •      
  •  @throws LogicException      If the class could not be loaded.

    •      
  •  @throws ReflectionException If the class could not be instancied.

    •      
  • /

    static public function newInstance($className, $argument = null)
    {
        $reflectionClass = self::getReflectionClass($className);

        if ($argument === null) {
            return $reflectionClass->newInstance();
        }

        if (func_num_args() === 2) {
            return $reflectionClass->newInstance($argument);
        }

       return static::newInstanceArgs($className, array_slice(func_get_args(), 1));
    }

    /**


         
  •  Instantiates a class with an array of constructor arguments.

     *


         
  •  @param  string $className   The name of the class to instanciate.

    •      
  •  @param  array  $arguments   The constructor arguments as an indexed

    •      
  •                              array.

    •      
  •  @return object              Returns a new instance of a class.

    •      
  •  @throws LogicException      If the class could not be loaded.

    •      
  •  @throws ReflectionException If the class could not be instancied.

    •      
  • /

    static public function newInstanceArgs($className, array $arguments)
    {
        $reflectionClass = self::getReflectionClass($className);

        return $reflectionClass->newInstanceArgs($arguments);
    }

    /**


         
  •  Returns an instance of ReflectionClass.

     *


         
  •  The ReflectionClass class is a part of the PHP Reflection API that adds

    •      
  •  the ability to reverse-engineer classes, interfaces, functions, methods

    •      
  •  and extensions.

     *


     *


         
  •  @param  string          $className The name of the class being reflected.

    •      
  •  @return ReflectionClass Returns an instance of ReflectionClass.

    •      
  • /

    final static public function getReflectionClass($className)
    {
        static $reflections = array();

        if (!isset($reflections[$className])) {
            $reflections[$className] = new \ReflectionClass($className);
        }

        return $reflections[$className];
    }
}

// Example

class Foo
{
    private $_bar = null;
    private $_baz = null;

    public function __construct($bar, $baz)
    {
        $this->_bar = $bar;
        $this->_baz = $baz;
    }

    public function __toString()
    {
        return (string) $this->_bar . ' ' . $this->_baz . PHP_EOL;
    }
}

try {
    // prints: Hello World!
    // echo Factory::newInstance('Foo', 'Hello', 'World!');

    // prints: Hello World!
    // echo Factory::newInstanceArgs('Foo', array('Hello', 'World!'));
}
catch (ReflectionException $relfectionException) {
    echo $relfectionException->getMessage() . PHP_EOL;
}
catch (LogicException $logicException) {
    echo $logicException->getMessage() . PHP_EOL;
}
?>

Conclusion :


Avec l'arrivée des espaces de noms, on peut désormais utiliser les fonctions de chargements automatiques natives de PHP qui sont un peu plus rapide qu'une fonction définie par __autoload(). Enfin, ajoutons l'utilisation de la Reflection API de PHP 5, on dispose alors de tout les éléments pour avoir une classe assez générique responsable de la "fabrication" d'un objet.

Si vous souhaitez ajouter des conditions, comme par exemple vérifier l'héritage d'une classe ou l'implémentation d'une interface, il vous suffit de les définir dans vos propres méthodes.

<?php
abstract class Database
{
protected $_dsn = null;
protected $_username = null;
protected $_password = null;

public function __construct($dsn, $username = null, $password = null)
{
$this->_dsn = (string) $dsn;
$this->_username = (string) $username;
$this->_password = (string) $password;
}

static public function factory($classname, $argument)
{
if (func_num_args() === 2) {
$object = Factory::newInstance($classname, $argument);
}
else {
$object = Factory::newInstanceArgs($classname, array_slice(func_get_args(), 1));
}

if (!is_a($object, __CLASS__)) {
throw new InvalidArgumentException(sprintf('The class `%s` is not of `%s`', get_class($object), __CLASS__));
}

return $object;
}
}

class MySQL extends Database
{
public function __toString()
{
return __CLASS__ . PHP_EOL
. $this->_dsn . PHP_EOL
. $this->_username . PHP_EOL
. $this->_password . PHP_EOL;
}
}

class SQLite
{
protected $_dsn = null;

public function __construct($dsn)
{
$this->_dsn = (string) $dsn;
}

public function __toString()
{
return __CLASS__ . PHP_EOL
. $this->_dsn . PHP_EOL;
}
}

// prints: MySQL mysql:dbname=test;host=localhost root root
// echo Database::factory('MySqL', 'mysql:dbname=test;host=localhost', 'root', 'root');

// prints (InvalidArgumentException): The class `SQLite` is not of Database
// echo Database::factory('SQLite', 'sqlite:test.sqlite3');
?>

Alternativement, avec l'utilisation de la fonction "get_called_class" de PHP 5.3, on peut par exemple avoir une classe Database étendant "Factory", l'appel alors des méthodes "newInstance" et "newInstanceArgs" (avec modifications) chercheront alors si la classe que l'on souhaite instancier hérite de la classe dans laquelle on appel ces méthodes uniquement si ce n'est pas dans la classe "Factory" elle-même.

<?php
abstract class Database extends Factory
{
protected $_dsn = null;
protected $_username = null;
protected $_password = null;

public function __construct($dsn, $username = null, $password = null)
{
$this->_dsn = (string) $dsn;
$this->_username = (string) $username;
$this->_password = (string) $password;
}
}

class MySQL extends Database
{
public function __toString()
{
return __CLASS__ . PHP_EOL
. $this->_dsn . PHP_EOL
. $this->_username . PHP_EOL
. $this->_password . PHP_EOL;
}
}

class SQLite
{
protected $_dsn = null;

public function __construct($dsn)
{
$this->_dsn = (string) $dsn;
}

public function __toString()
{
return __CLASS__ . PHP_EOL
. $this->_dsn . PHP_EOL;
}
}

// prints: MySQL mysql:dbname=test;host=localhost root root
// echo Database::newInstanceArgs('MySqL', array('mysql:dbname=test;host=localhost', 'root', 'root'));

// prints (InvalidArgumentException): The class `SQLite` is not of Database
// echo Database::newInstance('SQLite', 'sqlite:test.sqlite3');

// prints: SQLite sqlite:test.sqlite3
// echo Factory::newInstance('SQLite', 'sqlite:test.sqlite3');
?>

et les méthodes "Factory::newInstance" et "Factory::newInstanceArgs" aurait une condition, avant l'instanciation, similaire à :

<?php
$calledClass = get_called_class();

if ($calledClass !== __CLASS__ && !$reflectionClass->isSubclassOf($calledClass)) {
throw new InvalidArgumentException(sprintf('Class `%s` is not of `%s`', $reflectionClass->getName(), $calledClass));
}
?>

Mais pour des fabrications nécessitant des conditions plus complexes, le premier exemple reste le plus approprié.
Télécharger le projet

Codes Sources

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (Waredan)