Qu'est-ce qu'un modèle Factory Design en PHP?
https://stackoverflow.com/questions/2083424
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
Cela me confond, dans les termes les plus simples que fait-il? Imaginez que vous expliquez à votre mère ou quelqu'un presque s'il vous plaît.
La solution
Une usine crée un objet. , Si vous vouliez construire ainsi
class A{
public $classb;
public $classc;
public function __construct($classb, $classc)
{
$this->classb = $classb;
$this->classc = $classc;
}
}
Vous ne voudriez pas se fier à avoir à faire le code suivant à chaque fois que vous créez l'objet
$obj = new ClassA(new ClassB, new Class C);
C'est là l'usine viendrait Nous définissons une usine de prendre soin de cela pour nous.
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;
}
}
Maintenant, tout ce que nous avons à faire est
$factory = new Factory;
$obj = $factory->build();
L'avantage réel est quand vous voulez changer la classe. Disons que nous voulions passer dans un autre ClassC:
class Factory_New extends Factory{
public function buildC(){
return new ClassD;
}
}
ou une nouvelle classe B:
class Factory_New2 extends Factory{
public function buildB(){
return new ClassE;
}
}
Maintenant, nous pouvons utiliser l'héritage pour modifier facilement la façon dont la classe est créée, de mettre dans un autre ensemble de classes.
Un bon exemple pourrait être cette classe d'utilisateur:
class User{
public $data;
public function __construct($data)
{
$this->data = $data;
}
}
Dans ce $data de classe est la classe que nous utilisons pour stocker nos données. Maintenant, pour cette classe, disons que nous utilisons une session pour stocker nos données. L'usine ressemblerait à ceci:
class Factory{
public function build()
{
$data = $this->buildData();
return $this->buildUser($data);
}
public function buildData()
{
return SessionObject();
}
public function buildUser($data)
{
return User($data);
}
}
Maintenant, laisse dire la place que nous voulons stocker toutes nos données dans la base de données, il est très simple de le changer:
class Factory_New extends Factory{
public function buildData()
{
return DatabaseObject();
}
}
Les usines sont un modèle de conception que nous utilisons pour contrôler la façon dont nous mettons ensemble les objets et l'utilisation de modèles d'usine corrects nous permet de créer des objets personnalisés dont nous avons besoin.
Autres conseils
Comme une véritable usine de la vie, il crée quelque chose et le renvoie.
Imaginez quelque chose comme ceci
$joe = new Joe();
$joe->say('hello');
ou une méthode de fabrication
Joe::Factory()->say('hello');
La mise en œuvre de la méthode de l'usine va créer une nouvelle instance et le retourner.
modèle de conception d'usine est très bien quand vous avez affaire à des ressources multiples et que vous voulez mettre en œuvre abstraction de haut niveau.
Brisons ce dans la section différente.
Supposons que vous ayez à mettre en œuvre l'abstraction et l'utilisateur de votre classe n'a pas besoin de se soucier de ce que vous avez mis en place dans la définition de la classe.
Il / Elle juste besoin de vous soucier de l'utilisation de vos méthodes de classe.
par exemple. Vous disposez de deux bases de données pour votre projet
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;
}
}
Votre classe d'usine prendrait soin de la création d'objet pour la connexion de base de données.
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;
}
}
L'utilisateur a besoin pour passer le nom du type de base de données
$dbconn1 = DBFactory::getConn("MySQL");
$dbconn1->select();
Sortie:
MySQL Database Connection
Your mysql select query execute here
À l'avenir, vous pouvez avoir autre base de données, alors vous n'avez pas besoin de changer tout le code seulement besoin de passer le nouveau type de base de données et tout autre code fonctionnera sans apporter de modifications.
$dbconn2 = DBFactory::getConn("Oracle");
$dbconn2->select();
Sortie:
Oracle Database Connection
Your oracle select query execute here
Espérons que cela vous aidera.
En général, une « usine » produit quelque chose:. Dans le cas de l'objet-Orientée-programmation, un « modèle de conception d'usine » produit des objets
Peu importe si elle est en PHP, C # ou toute autre langue d'objets AXÉE.
Design Pattern usine (modèle d'usine) est pour le couplage lâche. Comme le sens de l'usine, les données à une usine (production de données) à l'utilisateur final. De cette manière, l'usine briser le couplage étroit entre la source de données et le processus de données.
Une usine génère seulement un objet ou des objets.
Vous pouvez avoir une usine qui construit une connexion MySQL.
Cette réponse est par rapport aux autres poste où Daniel White a dit d'utiliser l'usine pour créer une connexion MySQL à l'aide modèle de l'usine.
Pour la connexion MySQL Je préfère utiliser un singleton que vous souhaitez utiliser une même connexion pour accéder à la base de données crée pas un autre.
L'approche classique pour instancier un objet est:
$Object=new ClassName();
PHP a la capacité de créer dynamiquement un objet de nom de variable en utilisant la syntaxe suivante:
$Object=new $classname;
où classname $ variable contient le nom d'une classe veut instancier.
affacturage objet donc classique ressemblerait à ceci:
function getInstance($classname)
{
if($classname==='Customer')
{
$Object=new Customer();
}
elseif($classname==='Product')
{
$Object=new Product();
}
return $Object;
}
et si vous appelez getInstance ( « Produit ») fonction de cette usine va créer et retourner l'objet produit. Sinon, si vous appelez la fonction getInstance ( 'Customer') cette usine va créer et retourner l'objet de type client (créé de la classe Client ()).
Il n'y a pas besoin de cela plus, on peut envoyer des « produits » ou « client » (noms exacts des classes existantes) en tant que valeur de la variable pour instanciation dynamique:
$classname='Product';
$Object1=new $classname; //this will instantiate new Product()
$classname='Customer';
$Object2=new $classname; //this will instantiate new Customer()
Pour l'enregistrement, des mots faciles, comme une usine @Pindatjuh dit, retourne un objet.
Alors, quelle est la différence avec un constructeur? (Qui fait la même)
- un constructeur utilise sa propre instance.
- Quelque chose que je veux donc quelque chose de plus avancé et je ne veux pas enfler l'objet (ou ajouter des dépendances).
-
Constructor est appelée lorsque chaque instance est créée. Parfois, vous ne voulez pas.
Par exemple, disons que chaque fois que je crée un objet du compte de la classe, je l'ai lu à partir de la base de données d'un fichier et l'utiliser comme un modèle.
Utilisation constructeur:
class Account {
var $user;
var $pwd;
var ...
public __construct() {
// here i read from the file
// and many other stuff
}
}
Utilisation de l'usine:
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;
}
