What is builder pattern?

Builder Pattern Introduction

Builder Pattern is an object creation mode. It can separate the internal representation of a product from the product generation process, so that a construction process can generate product objects with different internal representations.

Due to the complexity of the process of building parts, the construction process of these parts is often "externalized" to another object that rides on the builder. The builder object returns to the client a model where all parts are built. The completed product object. It hides the structure and construction process of the product from the client.

The four roles of the construction mode:

1 builder: Specify abstract interfaces for each component that creates a product object.

2 ConcreteBuilder: Implement the Builder interface to construct and assemble the various components of the product, define and clarify the representation it creates, and provide an interface for retrieving the product.

3 Director: Construct an object using the Builder interface.

4 Product: Represents the constructed complex object. ConcreteBuilder creates an internal representation of the product and defines its assembly process, including the classes that define the component parts, including the interfaces for assembling those parts into the final product.

php代码实例
<?php
/**
 * 产品,包含产品类型、价钱、颜色属性
 */
class Product
{
public $_type  = null;
public $_price = null;
public $_color = null;
 
public function setType($type){
echo &#39;设置产品类型&#39;;
$this->_type = $type;
}
 
public function setPrice($price){
echo &#39;设置产品价格,&#39;;
$this->_price = $price;
}
 
 public function setColor($color){
echo &#39;设置产品颜色&#39;;
$this->_color = $color;
}
} 
//不使用builder模式
$product = new Product();
$product->setType("衣服");
$product->setPrice("100");
$product->setColor("红色");
 
//使用builder模式
class ProductBuilder{
public $_config = null;
public $_object = null;
//$config 被设计为一个数组，格式
//$config = array(&#39;type&#39; => &#39;xx&#39;, &#39;price&#39; => &#39;xx&#39;, &#39;color&#39; => &#39;xx&#39;);
public function ProductBuilder($config){
$this->_object = new Product();
$this->_config = $config;
}
 
public function build(){
echo &#39;<br />使用建造者模式:<br />&#39;;
$this->_object->setType($this->_config[&#39;type&#39;]);
$this->_object->setPrice($this->_config[&#39;price&#39;]);
$this->_object->setColor($this->_config[&#39;color&#39;]);
}
 
public function getProduct(){
return $this->_object;
}
}
$config = array(&#39;type&#39; => &#39;汽车&#39;, &#39;price&#39; => &#39;2000000&#39;, &#39;color&#39; => &#39;白色&#39;);
$objBuilder = new ProductBuilder($config);
$objBuilder->build();
$objProduct = $objBuilder->getProduct();
echo &#39;<br />&#39;;
var_dump($objProduct);

Advantages of the builder pattern

First of all, the builder pattern has good encapsulation. Using the builder pattern can effectively encapsulate changes. In scenarios where the builder pattern is used, the general product class and builder class are relatively stable. Therefore, encapsulating the main business logic in the director class can achieve better results overall. Good stability.

Secondly, the builder pattern is easy to extend. If there are new requirements, it can be completed by implementing a new builder class. Basically, there is no need to modify the code that has been tested before, so there will be no risk to the original functions.

The difference between builder pattern and factory pattern

We can see that builder pattern and factory pattern are very similar. Generally speaking, builder pattern is only Compared with factory mode, there is one more "director" role. In the class diagram of the builder pattern, if the director class is regarded as the client that is ultimately called, then the rest of the diagram can be regarded as a simple factory pattern.

Compared with the factory pattern, the builder pattern is generally used to create more complex objects. Because the object creation process is more complicated, the object creation process is separated to form a new class - Director kind. In other words, the factory pattern encapsulates the entire object creation process in the factory class, and the factory class provides the final product to the client; in the builder pattern, the builder class generally only provides the construction of each component in the product class. The specific construction process is handed over to the director class. The director class is responsible for configuring each component into a product according to specific rules, and then delivering the assembled product to the client.

Summary

The builder pattern is similar to the factory pattern. They are both builder patterns and their applicable scenarios are also very similar. Generally speaking, if the product is complex to build, use the factory pattern; if the product is more complex to build, use the builder pattern.

The above is the detailed content of What is builder pattern?. For more information, please follow other related articles on the PHP Chinese website!