blocks|key|1356177|text|工厂只生成一个或多个对象。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1356178|您可能有一个构建MySQL连接的工厂。|1356179|http://en.wikipedia.org/wiki/Factory_method_pattern|offset|length|1356180|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|1F|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Q|8|@]|9|@$F|R|G|S|1|T]]|A|$]]|$1|H|3|-4|5|6|7|U|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|E]]]]

A factory just generates an object or objects.

You may have a factory that builds a MySQL connection.

<a href="http://en.wikipedia.org/wiki/Factory_method_pattern" rel="nofollow noreferrer">http://en.wikipedia.org/wiki/Factory_method_pattern</a>

blocks|key|1141155|text|就像现实生活中的工厂一样，它创建一些东西并返回它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1141156|想象一下这样的事情：|1141157|$joe+=+new+Joe();
$joe->say('hello');|code-block|syntax|javascript|1141158|或工厂方法|1141159|Joe::Factory()->say('hello');|1141160|工厂方法的实现将创建一个新实例并返回它。|1141161|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Like a real life factory, it creates something and returns it.

Imagine something like this

<pre><code>$joe = new Joe();
$joe-&gt;say('hello');
</code></pre>

or a factory method

<pre><code>Joe::Factory()-&gt;say('hello');
</code></pre>

The implementation of the factory method will create a new instance and return it.

blocks|key|1141220|text|一般来说，“工厂”会产生一些东西:在面向对象编程的情况下，“工厂设计模式”会产生对象。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1141221|不管它是用PHP、C#还是其他面向对象语言编写的。|1141222|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

In general a "factory" produces something: in the case of Object-Orientated-Programming, a "factory design pattern" produces objects.

It doesn't matter if it's in PHP, C# or any other Object-Orientated language.

blocks|key|1141267|text|工厂创建一个对象。所以，如果你想构建|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1141268|+class+A{
++++public+$classb;
++++public+$classc;
++++public+function+__construct($classb,+$classc)
++++{
+++++++++$this->classb+=+$classb;
+++++++++$this->classc+=+$classc;
++++}
++}|code-block|syntax|javascript|1141269|您不会希望每次创建对象时都必须执行以下代码|1141270|$obj+=+new+ClassA(new+ClassB,+new+Class+C);|1141271|这就是工厂的用武之地。我们定义了一个工厂来为我们解决这个问题：|1141272|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;
++++}
}|1141273|现在我们要做的就是|1141274|$factory+=+new+Factory;
$obj+++++=+$factory->build();|1141275|真正的好处是当你想要改变类的时候。假设我们想传入一个不同的ClassC：|1141276|class+Factory_New+extends+Factory{
++++public+function+buildC(){
++++++++return+new+ClassD;
++++}
}|1141277|或新的ClassB：|1141278|class+Factory_New2+extends+Factory{
++++public+function+buildB(){
++++++++return+new+ClassE;
++++}
}|1141279|现在我们可以使用继承来轻松地修改类的创建方式，以放入一组不同的类中。|1141280|下面的user类就是一个很好的例子：|1141281|class+User{
++++public+$data;
++++public+function+__construct($data)
++++{
++++++++$this->data+=+$data;
++++}
}|1141282|在这个类中，$data是我们用来存储数据的类。现在对于这个类，假设我们使用一个会话来存储我们的数据。工厂应该是这样的：|offset|length|style|CODE|1141283|class+Factory{
++++public+function+build()
++++{
++++++++$data+=+$this->buildData();
++++++++return+$this->buildUser($data);
++++}

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

++++public+function+buildUser($data)
++++{
++++++++return+User($data);
++++}
}|1141284|现在，假设我们想要将所有数据存储在数据库中，更改它真的很简单：|1141285|class+Factory_New+extends+Factory{
++++public+function+buildData()
++++{
++++++++return+DatabaseObject();
++++}
}|1141286|工厂是我们用来控制如何将对象放在一起的设计模式，使用正确的工厂模式允许我们创建所需的自定义对象。|1141287|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|6|5|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|1P|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|1R|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|1S|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|1T|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|1U|8|@]|9|@]|A|$]]|$1|U|3|V|5|D|7|1V|8|@]|9|@]|A|$E|F]]|$1|W|3|X|5|6|7|1W|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|D|7|1X|8|@]|9|@]|A|$E|F]]|$1|10|3|11|5|6|7|1Y|8|@]|9|@]|A|$]]|$1|12|3|13|5|6|7|1Z|8|@]|9|@]|A|$]]|$1|14|3|15|5|D|7|20|8|@]|9|@]|A|$E|F]]|$1|16|3|17|5|6|7|21|8|@$18|22|19|23|1A|1B]]|9|@]|A|$]]|$1|1C|3|1D|5|D|7|24|8|@]|9|@]|A|$E|F]]|$1|1E|3|1F|5|6|7|25|8|@]|9|@]|A|$]]|$1|1G|3|1H|5|D|7|26|8|@]|9|@]|A|$E|F]]|$1|1I|3|1J|5|6|7|27|8|@]|9|@]|A|$]]|$1|1K|3|-4|5|6|7|28|8|@]|9|@]|A|$]]]|1L|$]]

A factory creates an object. So, if you wanted to build

<pre><code> class A{
 public $classb;
 public $classc;
 public function __construct($classb, $classc)
 {
 $this-&gt;classb = $classb;
 $this-&gt;classc = $classc;
 }
 }
</code></pre>

You wouldn't want to rely on having to do the following code everytime you create the object

<pre><code>$obj = new ClassA(new ClassB, new Class C);
</code></pre>

That is where the factory would come in. We define a factory to take care of that for us:

<pre><code>class Factory{
 public function build()
 {
 $classc = $this-&gt;buildC();
 $classb = $this-&gt;buildB();
 return $this-&gt;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;
 }
}
</code></pre>

Now all we have to do is

<pre><code>$factory = new Factory;
$obj = $factory-&gt;build();
</code></pre>

The real advantage is when you want to change the class. Lets say we wanted to pass in a different ClassC:

<pre><code>class Factory_New extends Factory{
 public function buildC(){
 return new ClassD;
 }
}
</code></pre>

or a new ClassB:

<pre><code>class Factory_New2 extends Factory{
 public function buildB(){
 return new ClassE;
 }
}
</code></pre>

Now we can use inheritance to easily modify how the class is created, to put in a different set of classes. 

A good example might be this user class:

<pre><code>class User{
 public $data;
 public function __construct($data)
 {
 $this-&gt;data = $data;
 }
}
</code></pre>

In this class <code>$data</code> is the class we use to store our data. Now for this class, lets say we use a Session to store our data. The factory would look like this:

<pre><code>class Factory{
 public function build()
 {
 $data = $this-&gt;buildData();
 return $this-&gt;buildUser($data);
 }

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

 public function buildUser($data)
 {
 return User($data);
 }
}
</code></pre>

Now, lets say instead we want to store all of our data in the database, it is really simple to change it:

<pre><code>class Factory_New extends Factory{
 public function buildData()
 {
 return DatabaseObject();
 }
}
</code></pre>

Factories are a design pattern we use to control how we put objects together, and using correct factory patterns allows us to create the customized objects we need.

blocks|key|1141324|text|工厂设计模式(Factory+Pattern)是用于松散耦合的。就像工厂的含义一样，数据到工厂(生产数据)到最终用户。通过这种方式，工厂打破了数据源和数据处理之间的紧密耦合。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1141325|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Factory Design Pattern (Factory Pattern) is for loose coupling. Like the meaning of factory, data to a factory (produce data) to final user. By this way, the factory break the tight coupling between source of data and process of data.

blocks|key|1356466|text|这个答案与丹尼尔·怀特的另一篇文章有关，在那篇文章中，丹尼尔·怀特说使用工厂模式创建MySQL连接。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1356467|对于MySQL连接，我宁愿使用单例模式，因为您希望使用相同的连接来访问数据库，而不是创建另一个连接。|1356468|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

This answer is in relation to other post in which Daniel White said to use factory for creating MySQL connection using factory pattern.

For MySQL connection I would rather use singleton pattern as you want to use same connection 
for accessing the database not create another one.

blocks|key|1356532|text|实例化对象的经典方法是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1356533|$Object=new+ClassName();|code-block|syntax|javascript|1356534|PHP能够使用以下语法从变量名动态创建对象：|1356535|$Object=new+$classname;|1356536|其中变量$classname包含要实例化的类的名称。|1356537|所以经典的对象分解看起来像这样：|1356538|function+getInstance($classname)
{
++if($classname==='Customer')
++{
++++$Object=new+Customer();
++}
++elseif($classname==='Product')
++{
++++$Object=new+Product();
++}
++return+$Object;
}|1356539|如果你调用getInstance('+Product+')函数，这个工厂将创建并返回Product对象。否则，如果您调用getInstance('+Customer+')函数，此工厂将创建并返回Customer类型对象(从Customer()类创建)。|1356540|不再需要这样做了，可以将'Product‘或'Customer’(现有类的确切名称)作为variable的值发送给动态实例化：|1356541|$classname='Product';
$Object1=new+$classname;+//this+will+instantiate+new+Product()

$classname='Customer';
$Object2=new+$classname;+//this+will+instantiate+new+Customer()|1356542|entityMap^0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|10|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|12|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|13|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|14|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|15|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|16|8|@]|9|@]|A|$]]|$1|U|3|V|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|W|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|X|$]]

The classic approach to instantiate an object is:

<pre><code>$Object=new ClassName();
</code></pre>

PHP has the ability to dynamically create an object from variable name using the following syntax:

<pre><code>$Object=new $classname;
</code></pre>

where variable $classname contains the name of class one wants to instantiate.

So classic object factoring would look like:

<pre><code>function getInstance($classname)
{
 if($classname==='Customer')
 {
 $Object=new Customer();
 }
 elseif($classname==='Product')
 {
 $Object=new Product();
 }
 return $Object;
}
</code></pre>

and if you call getInstance('Product') function this factory will create and return Product object. Otherwise if you call getInstance('Customer') function this factory will create and return Customer type object (created from Customer() class).

There's no need for that any more, one can send 'Product' or 'Customer' (exact names of existing classes) as a value of variable for dynamic instantiation:

<pre><code>$classname='Product';
$Object1=new $classname; //this will instantiate new Product()

$classname='Customer';
$Object2=new $classname; //this will instantiate new Customer()
</code></pre>

blocks|key|1141574|text|当您处理多个资源并希望实现高级抽象时，工厂设计模式非常好。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1141575|让我们把它分成不同的部分。|1141576|假设您必须实现抽象，并且您的类的用户不需要关心您在类定义中实现了什么。|1141577|他/她只需要担心你的类方法的使用。|1141578|例如，您的项目有两个数据库|1141579|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;
++++++++}

}|code-block|syntax|javascript|1141580|您的Factory类将负责为数据库连接创建对象。|1141581|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;
++++++++}

}|1141582|用户只需要传递数据库类型的名称|1141583|$dbconn1+=+DBFactory::getConn("MySQL");
$dbconn1->select();|1141584|输出：|1141585|MySQL+Database+Connection
Your+mysql+select+query+execute+here|1141586|将来你可能会有不同的数据库，然后你不需要改变整个代码，只需要传递新的数据库类型，其他代码就会运行，而不会做任何改变。|1141587|$dbconn2+=+DBFactory::getConn("Oracle");
$dbconn2->select();|1141588|1141589|Oracle+Database+Connection
Your+oracle+select+query+execute+here|1141590|希望这能有所帮助。|1141591|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1B|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1C|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1D|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|1E|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|1F|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|1G|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|1H|8|@]|9|@]|A|$]]|$1|Q|3|R|5|L|7|1I|8|@]|9|@]|A|$M|N]]|$1|S|3|T|5|6|7|1J|8|@]|9|@]|A|$]]|$1|U|3|V|5|L|7|1K|8|@]|9|@]|A|$M|N]]|$1|W|3|X|5|6|7|1L|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|L|7|1M|8|@]|9|@]|A|$M|N]]|$1|10|3|11|5|6|7|1N|8|@]|9|@]|A|$]]|$1|12|3|13|5|L|7|1O|8|@]|9|@]|A|$M|N]]|$1|14|3|X|5|6|7|1P|8|@]|9|@]|A|$]]|$1|15|3|16|5|L|7|1Q|8|@]|9|@]|A|$M|N]]|$1|17|3|18|5|6|7|1R|8|@]|9|@]|A|$]]|$1|19|3|-4|5|6|7|1S|8|@]|9|@]|A|$]]]|1A|$]]

Factory design pattern is very good when you are dealing with multiple resources and want to implement high level abstraction.

Let's break this into different section.

Suppose you have to implement abstraction and the user of your class doesn't need to care about what you've implemented in class definition. 

He/She just need to worry about the use of your class methods.

e.g. You have two databases for your project 

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

}
</code></pre>

Your Factory class would take care of the creation of object for database connection.

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

}
</code></pre>

User just need to pass the name of the database type

<pre><code>$dbconn1 = DBFactory::getConn("MySQL");
$dbconn1-&gt;select();
</code></pre>

Output:

<pre><code>MySQL Database Connection
Your mysql select query execute here
</code></pre>

In future you may have different database then you don't need to change the entire code only need to pass the new database type and other code will run without making any changes.

<pre><code>$dbconn2 = DBFactory::getConn("Oracle");
$dbconn2-&gt;select();
</code></pre>

Output:

<pre><code>Oracle Database Connection
Your oracle select query execute here
</code></pre>

Hope this will help.

This confuses me, in the most simplest terms what does it do? Pretend you are explaining to your mother or someone almost please.

What is a Factory Design Pattern in PHP?

数据存储

数据库

MySQL

这让我很困惑，用最简单的术语来说，它是做什么的？假装你正在向你的母亲或其他人解释。

问PHP中的工厂设计模式是什么？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问PHP中的工厂设计模式是什么？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问PHP中的工厂设计模式是什么？
EN