创建型模式 工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式

说起模式来大家都很头疼．大篇的介绍和概念，还有uml图．不弄的复杂点都不好意思拿出来叫做教程．本篇文章列举出了各个模式的示例,额....省略了很多东西.凡人很难理解!理解了的都是超神级别的人物!

 

关键词:Factory,AbstractFactory,getInstance,Builder,Prototype

 

一　简单工厂模式不属于23中涉及模式，简单工厂一般分为：普通简单工厂、多方法简单工厂、静态方法简单工厂。

简单工厂模式：专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。它又称为静态工厂方法模式，属于类的创建型模式。

简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类（这些产品类继承自一个父类或接口）的实例。

普通简单工厂	多方法简单工厂	静态方法简单工厂
class SimpleFactory1 { public static function createService($name) { switch ($name) { case 'value': return new Service1(); break; case 'value': return new Service2(); break; default: break; } } }	class SimpleFactory2 { public function createService1() { return new Service1() } public function createService2() { return new Service2() } }	class SimpleFactory3 { public static function createService1() { return new Service1() } public static function createService2() { return new Service2() } }

在以上的三种模式中，第一种如果传入的字符串有误，不能正确创建对象，第三种相对于第二种，不需要实例化工厂类，所以，大多数情况下，我们会选用第三种——静态工厂方法模式。

二　工厂模式

很多人拿工厂模式和简单工厂模式进行比较．．我到现在还不知道用意为何．．．

我对工厂模式的理解很简单，就是一个实现抽象工厂接口且受到应用程序调用以创建产品对象的类．让我们看一个zf2中的实例

interface  FactoryInterface
{
    public function createService(ServiceLocatorInterface $serviceLocator);
}

class EventManagerFactory implements FactoryInterface
{
    public function createService(ServiceLocatorInterface $serviceLocator)
    {
        $em = new EventManager();
        $em->setSharedManager($serviceLocator->get('SharedEventManager'));
        return $em;
    }
}

三 抽象工厂模式  

在抽象工厂模式中，有一个产品族的概念：所谓的产品族，是指位于不同产品等级结构中功能相关联的产品组成的家族。抽象工厂模式所提供的一系列产品就组成一个产品族；而工厂方法提供的一系列产品称为一个等级结构。我们依然拿生产汽车的例子来说明他们之间的区别。

抽象工厂生产的是产品族.例如表单..一个表单有多个表单元素.下面我们看zf2的一个实例:

interface AbstractFactoryInterface
{

    public function canCreateServiceWithName(ServiceLocatorInterface $serviceLocator, $name, $requestedName);
    public function createServiceWithName(ServiceLocatorInterface $serviceLocator, $name, $requestedName);
}


class FormAbstractServiceFactory implements AbstractFactoryInterface
{
    public function createServiceWithName(ServiceLocatorInterface $serviceLocator, $name, $requestedName)
    {
        $config  = $this->getConfig($serviceLocator);
        $config  = $config[$requestedName];
        $factory = $this->getFormFactory($serviceLocator);

        $this->marshalInputFilter($config, $serviceLocator, $factory);//不同input
        return $factory->createForm($config);//最后创建产品
    }

    protected function getFormFactory(ServiceLocatorInterface $services)
    {
        if ($this->factory instanceof Factory) {
            return $this->factory;
        }

        $elements = null;
        if ($services->has('FormElementManager')) {
            $elements = $services->get('FormElementManager');
        }

        $this->factory = new Factory($elements);
        return $this->factory;
    }

    /**
    * 生产不同input
    */
    protected function marshalInputFilter(array &$config, ServiceLocatorInterface $services, Factory $formFactory)
    {
        if (!isset($config['input_filter'])) {
            return;
        }

        if ($config['input_filter'] instanceof InputFilterInterface) {
            return;
        }

        if (is_string($config['input_filter'])
            && $services->has('InputFilterManager')
        ) {
            $inputFilters = $services->get('InputFilterManager');
            if ($inputFilters->has($config['input_filter'])) {
                $config['input_filter'] = $inputFilters->get($config['input_filter']);
                return;
            }
        }

        $inputFilterFactory = $formFactory->getInputFilterFactory();
        $inputFilterFactory->getDefaultFilterChain()->setPluginManager($services->get('FilterManager'));
        $inputFilterFactory->getDefaultValidatorChain()->setPluginManager($services->get('ValidatorManager'));
    }
}

抽象工厂是工厂模式的复杂情况

總結:

简单工厂:生产同一系列的任意产品 （对于增加新的产品，无能为力）

工厂模式:生产固定产品 （支持增加任意产品）  

抽象工厂: 生产固定产品族,

四 单例模式

单例模式 保证应用只有一个全局惟一的实例，并且提供一个访问它的全局访问点。没啥好解释的

class Single {
 
    //保存类实例的静态成员变量
    private static $_instance;
     
    //private标记的构造方法
    private function __construct(){
        echo 'This is a Constructed method;';
    }
     
    //创建__clone方法防止对象被复制克隆
    public function __clone(){
        trigger_error('Clone is not allow!',E_USER_ERROR);
    }
     
    //单例方法,用于访问实例的公共的静态方法
    public static function getInstance(){
        if(!(static::$_instance instanceof static)){
            static::$_instance = new self;
        }
        return static::$_instance;
    }
     
    public function test(){
        echo '调用方法成功';
    }
 
}

五 建造者模式

建造者模式:将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示

class Product
{
    protected $_type="";
    protected $_size="";

    public function setType($type)
    {
        $this->_type = $type;
    }

    public function setSize($size)
    {
        $this->_size = $size;
    }
}

class ProductBuilder
{
    protected $_product = null;
    protected $_conifg = [];

    public function __construct($config)
    {
        $this->_product = new Product();
        $this->_conifg = $config;
    }

    public function build()
    {
        $this->_product->setType($this->_conifg["type"]);
        $this->_product->setSize($this->_conifg["size"]);
    }

    public function getProduct()
    {
        return $this->_product;
    }
}

六 原型模式

原型设计模式创建对象的方式是复制和克隆初始对象或原型...

注意clone是浅复制.如果复制的对象中有属性也为对象,则克隆后的对象中该属性是引用...可以使用__clone在克隆的时候对其进行处理

class Prototype{  
    private $name;  
  
    public function __construct($name){  
        $this->name = $name;  
    }  
  
    public function setName($name){  
        $this->name = $name;  
    }  
  
    public function getName(){  
        return $this->name;  
    }  
  

    public function __clone(){  
         $this->name = "child";
    }  
} 

$other = clone new Prototype();