Was ist ein Factory Design Pattern in PHP?

Question

Das verwirrt mich, in den einfachen Worten ausgedrückt, was tut sie? Pretend Sie erklären Ihrer Mutter oder jemand fast bitte.

Answer 1

erstellt eine Fabrik, ein Objekt. Also, wenn Sie wollen bauen

 class A{
    public $classb;
    public $classc;
    public function __construct($classb, $classc)
    {
         $this->classb = $classb;
         $this->classc = $classc;
    }
  }

Sie würde nicht wollen, verlassen sich auf mit den folgenden Code jedes Mal tun Sie das Objekt

erstellen

$obj = new ClassA(new ClassB, new Class C);

.

Das ist, wo die Fabrik kommen würde, in Wir definieren eine Fabrik darum zu kümmern uns:

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;
    }
}

Nun müssen wir tun, ist

$factory = new Factory;
$obj     = $factory->build();

Der wirkliche Vorteil ist, wenn man die Klasse ändern möchten. Lassen Sie uns sagen wir in einem anderen ClassC passieren wollte:

class Factory_New extends Factory{
    public function buildC(){
        return new ClassD;
    }
}

oder eine neue ClassB:

class Factory_New2 extends Factory{
    public function buildB(){
        return new ClassE;
    }
}

Jetzt können wir Vererbung verwenden, um leicht zu ändern, wie die Klasse erstellt wird, in einem anderen Satz von Klassen zu setzen.

Ein gutes Beispiel könnte diese Benutzerklasse sein:

class User{
    public $data;
    public function __construct($data)
    {
        $this->data = $data;
    }
}

In dieser Klasse $data ist die Klasse, die wir verwenden unsere Daten zu speichern. Jetzt für diese Klasse, kann sagen, dass wir eine Session verwenden unsere Daten zu speichern. Die Fabrik würde wie folgt aussehen:

class Factory{
    public function build()
    {
        $data = $this->buildData();
        return $this->buildUser($data);
    }

    public function buildData()
    {
        return SessionObject();
    }

    public function buildUser($data)
    {
        return User($data);
    }
}

wir nun an, sondern wir alle unsere Daten in der Datenbank gespeichert werden sollen, ist es wirklich einfach ist, es zu ändern:

class Factory_New extends Factory{
    public function buildData()
    {
        return DatabaseObject();
    }
}

Fabriken sind ein Design-Muster, das wir steuern können, wie wir Objekte zusammen, und ermöglicht die korrekte Fabrik Muster mit uns die benutzerdefinierten Objekte erstellen wir brauchen.

Answer 2

Wie eine echte Leben Fabrik, es schafft etwas und gibt es zurück.

Stellen Sie sich vor so etwas wie dieses

$joe = new Joe();
$joe->say('hello');

oder eine Factory-Methode

Joe::Factory()->say('hello');

Die Umsetzung der Factory-Methode wird eine neue Instanz erstellen und senden Sie es.

Answer 3

Fabrik-Entwurfsmuster ist sehr gut, wenn Sie mit mehreren Ressourcen zu tun und wollen hohe Abstraktion implementieren.

Lassen Sie uns brechen diese in verschiedene Kapitel.

Angenommen, Sie Abstraktion und die Benutzer Ihrer Klasse implementieren muss nicht brauchen Pflege über das, was Sie in Klassendefinition implementiert haben.

Er / Sie müssen nur Sorgen über die Verwendung von Klassenmethoden.

z. Sie haben zwei Datenbanken für Ihr Projekt

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;
        }

}

Ihre Factory-Klasse würde Pflege der Erstellung des Objekts nimmt für Datenbankverbindung.

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;
        }

}

User brauchen nur den Namen des Datenbanktypen passieren

$dbconn1 = DBFactory::getConn("MySQL");
$dbconn1->select();

Ausgabe:

MySQL Database Connection
Your mysql select query execute here

In Zukunft können Sie verschiedene Datenbank haben, dann müssen Sie nicht nur den gesamten Code zu ändern, müssen Sie den neuen Datenbanktyp und anderen Code übergeben werden, ohne dass Änderungen ausgeführt werden.

$dbconn2 = DBFactory::getConn("Oracle");
$dbconn2->select();

Ausgabe:

Oracle Database Connection
Your oracle select query execute here

Hope dies dazu beitragen wird.

Answer 4

In der Regel eines „Fabrik“ produziert etwas. Im Fall der objektorientierten Programmierung, ein „Fabrik-Entwurfsmuster“ erzeugt Objekte

Es spielt keine Rolle, ob es in PHP, C # oder einer anderen objektorientierten Sprache.

Answer 5

Factory Design Pattern (Factory-Pattern) ist für lose Kopplung. Wie die Bedeutung von Fabrik, Daten in eine Fabrik (Produkte Daten) bis zum Endverbraucher. Auf diese Weise, bricht die Fabrik die enge Kopplung zwischen Datenquelle und dem Prozess der Daten.

Answer 6

Eine Fabrik erzeugt nur ein oder mehrere Objekte.

Sie können eine Fabrik haben, die eine MySQL-Verbindung aufbaut.

http://en.wikipedia.org/wiki/Factory_method_pattern

Answer 7

Diese Antwort ist in Bezug auf andere Posten, in dem Daniel White sagte Fabrik zu verwenden für die Erstellung von MySQL-Verbindungsfactory Mustern.

Für MySQL-Verbindung würde ich eher Singletonmuster verwenden, wie Sie dieselbe Verbindung verwenden möchten für den Zugriff auf die Datenbank nicht eine andere erstellen.

Answer 8

Der klassische Ansatz ein Objekt zu instanziiert ist:

$Object=new ClassName();

hat PHP die Fähigkeit, dynamisch ein Objekt aus Variablennamen mit folgenden Syntax zu erstellen:

$Object=new $classname;

, wo Variable $ classname enthält den Namen der Klasse man will instantiate.

So klassisches Objekt Factoring würde wie folgt aussehen:

function getInstance($classname)
{
  if($classname==='Customer')
  {
    $Object=new Customer();
  }
  elseif($classname==='Product')
  {
    $Object=new Product();
  }
  return $Object;
}

und wenn Sie rufen getInstance ( ‚Produkt‘) Funktion dieses Werk erstellen und Rückkehr Product-Objekt. Andernfalls, wenn Sie getInstance ( ‚Kunde‘) funktionieren diese Fabrik rufen erstellen und Rückkehr Kundentyp Objekt (vom Kunden erstellt () Klasse).

Es gibt keine Notwendigkeit, dass mehr kann man ‚Produkt‘ oder ‚Kunden‘ (genaue Namen vorhandener Klassen) als Wert der Variablen für dynamische Instanziierung senden:

$classname='Product';
$Object1=new $classname; //this will instantiate new Product()

$classname='Customer';
$Object2=new $classname; //this will instantiate new Customer()

Answer 9

Für das Protokoll, in einfachen Worten, eine Fabrik wie @Pindatjuh sagte, gibt ein Objekt.

Also, was ist der Unterschied mit einem Konstruktor? (Das macht das gleiche)

1. ein Konstruktor verwendet seine eigene Instanz.
2. Etwas, was ich will so etwas weiter fortgeschritten und ich will nicht, um das Objekt blähen (oder fügen Sie Abhängigkeiten).

3. Constructor aufgerufen wird, wenn jede Instanz erstellt wird. Manchmal wollen Sie nicht.

   Zum Beispiel, sagen wir mal, dass jedes Mal, wenn ich erstellt ein Objekt der Klasse Konto, i aus der Datenbank gelesen eine Datei und verwenden Sie es als Vorlage.

Mit Konstruktor:

class Account {
      var $user;
      var $pwd;
      var ...
      public __construct() {
         // here i read from the file
         // and many other stuff
      }
}

Mit Fabrik:

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;
      }