米粒人生 2019-01-02 09:45:54 1062次浏览 3条评论 7 7 0

应用举例

百家乐彩 www.br8y.com.cn yii\db\Schema抽象类中:

//获取数据表元数据
public function getTableSchema($name, $refresh = false)
{
    if (array_key_exists($name, $this->_tables) && !$refresh) {
        return $this->_tables[$name];
    }

    $db = $this->db;
    $realName = $this->getRawTableName($name);

    if ($db->enableSchemaCache && !in_array($name, $db->schemaCacheExclude, true)) {
        /* @var $cache Cache */
        $cache = is_string($db->schemaCache) ? Yii::$app->get($db->schemaCache, false) : $db->schemaCache;
        if ($cache instanceof Cache) {
            $key = $this->getCacheKey($name);
            if ($refresh || ($table = $cache->get($key)) === false) {
                //通过工厂方法loadTableSchema()去获取TableSchema实例
                $this->_tables[$name] = $table = $this->loadTableSchema($realName);
                if ($table !== null) {
                    $cache->set($key, $table, $db->schemaCacheDuration, new TagDependency([
                        'tags' => $this->getCacheTag(),
                    ]));
                }
            } else {
                $this->_tables[$name] = $table;
            }

            return $this->_tables[$name];
        }
    }
    //通过工厂方法loadTableSchema()去获取TableSchema实例
    return $this->_tables[$name] = $this->loadTableSchema($realName);
}

//获取TableSchema实例,让子类去实现
abstract protected function loadTableSchema($name);

这里使用了工厂方法模式。loadTableSchema()就是工厂方法,它负责提供一个具体的TableSchema类以供getTableSchema()使用。而要提供具体的TableSchema类,显然要到各个Schema的子类中去实现。

工厂方法模式

模式定义

工厂方法模式(Factory Method Pattern)定义了一个创建对象的接口,但由子类决定要实例化的类是哪一个。工厂方法让类吧实例化推迟到子类。

什么意思?说起来有这么几个要点:

  • 对象不是直接new产生,而是交给一个类方法去完成。比如loadTableSchema()方法
  • 这个方法是抽象的,且必须被子类所实现
  • 这个提供实例的抽象方法需要参与到其他逻辑中,去完成另一项功能。比如loadTableSchema()方法出现在getTableSchema()方法中,参与实现获取数据表元数据的功能
代码实现

现在,我们打算用利用面向对象的手段——工厂方法模式为你开一家披萨连锁店。

假如你现在打算开一家披萨连锁店,分店以加盟的方式加入。加盟店提供加盟费以及利润提成,而总店提供配方,烹饪方法,以及选址和其他方面的建议。这种场景够常见了吧?什么奶茶加盟店、花甲加盟店、火锅加盟店等等都是这个套路。那么,现在你打算怎么做?

首先,我希望为各个加盟店制定一定的规范以保证基本口味和品牌形象,比如配方、原料、加工方式都我来提供

其次,我也允许加盟店可以适当的扩展以增加其灵活性和丰富性,比如切块和包装可以采用自己的

如果你想明白这两点,那恭喜你!你已经基本搞清楚了抽象和具体的关系了。在这里总店就是是抽象,加盟店就是具体。

第一步,我们的披萨是什么样子的,配方原料加工方式是什么。因此我们要有个抽象的Pizza类,规定要做披萨的原料有面团、酱汁、各种配菜;加工程序有准备、烘烤、切块、包装。

abstract class Pizza
{
    /**
     * @var
     */
    protected $name;
    /**
     * @var
     */
    protected $dough;
    /**
     * @var
     */
    protected $sauce;
    /**
     * @var array
     */
    protected $toppings = [];

    public function prepare()
    {
        print_r('Preparing '.$this->name.'<br>');
        print_r('Tossing dough...'.'<br>');
        print_r('Adding sauce...'.'<br>');
        print_r('Adding toppings...'.'<br>');
        foreach ($this->toppings as $topping) {
            print_r("$topping".'<br>');
        }
    }

    public function bake()
    {
        print_r('Bake: Bake for 25 minutes at 350'.'<br>');
    }

    public function cut()
    {
        print_r('Cut: Cutting the pizza into diagonal slices'.'<br>');
    }

    public function box()
    {
        print_r('Box: Place pizza in official PizzaStore box'.'<br>');
    }

    /**
     * @return mixed
     */
    public function getName()
    {
        return $this->name;
    }
}

你是总店,你可以规定哪些工序可以用我总店的,而哪些必须你自己去实现。比如,加盟店选择开在哪里必须加盟店自己去完成,而原料和做法则总店来决定。

体现在上面的代码,就是abstract Pizza类所有方法都可以根据需要改成abstract的。当你要求必须子类去完成的就是abstract的;当你提供了默认的行为,可让子类继承直接使用的就是具体的。

规定了披萨如何构成的,总店第二步还需要指导下分店怎么把披萨做出来,因此还需要有个抽象的披萨店类PizzaStore:

abstract class PizzaStore
{
    /**
     * @var Pizza
     */
    protected $pizza;

    /**
     * @param $type
     *
     * @return Pizza
     */
    public function orderPizza($type)
    {
        // create a pizza
        $this->pizza = $this->createPizza($type);

        // handle the pizza
        $this->pizza->prepare();
        $this->pizza->bake();
        $this->pizza->cut();
        $this->pizza->box();

        // return the prepared pizza
        return $this->pizza;
    }

    /**
     * Create a Pizza.
     *
     * @param $type
     *
     * @return Pizza
     */
    abstract protected function createPizza($type);
}

总店在抽象的PizzaStore规定了披萨加工的基本流程,所有的加盟店加工披萨都必须按照准备->烘烤->切块->装盒这几个固定的工序进行。至于谁提供披萨,这些披萨原料是啥,烘烤多久,切成啥形状,包装成啥样子,这些都是具体的Pizza本身所的细节,由各个加盟店自己决定的。

因此,各个加盟店必须要继承抽象的createPizza()方法,去具体实现自己的细节,做出不同口味的披萨来。

最后一步,我们可以让别人来加盟了。

有人打算在纽约开一家披萨加盟店:

class NYPizzaStore extends PizzaStore
{
    /**
     * Create a Pizza.
     *
     * @param $type
     *
     * @return Pizza
     */
    public function createPizza($type)
    {
        if ($type == 'cheese') {
            return new NYStyleCheesePizza();
        } elseif ( $type == 'clam') {
            return new NYStyleClamPizza();
        }
    }
}

纽约店暂时提供两种口味的披萨:奶酪味和蛤蜊味。

//奶酪味
class NYStyleCheesePizza extends Pizza
{
    /**
     * NYStyleCheesePizza constructor.
     */
    public function __construct()
    {
        $this->name = 'NY Style Sauce and Cheese Pizza';
        $this->dough = 'Thin Crust Dough';
        $this->sauce = 'Marinara Sauce';

        $this->toppings[] = 'Grated Reggiano Cheese';
    }

    /**
     * {@inheritdoc}
     */
    public function box()
    {
        print_r('Box: Place pizza in NY PizzaStore box'.'<br>');
    }
}

//蛤蜊味
class NYStyleClamPizza extends Pizza
{
    /**
     * NYStyleClamPizza constructor.
     */
    public function __construct()
    {
        $this->name = 'NY Style Sauce and Clam Pizza';
        $this->dough = 'Thin Crust Dough';
        $this->sauce = 'Marinara Sauce';

        $this->toppings[] = 'Grated Reggiano Clam';
    }

    /**
     * {@inheritdoc}
     */
    public function box()
    {
        print_r('Box: Place pizza in NY PizzaStore box'.'<br>');
    }
}

纽约店两种口味披萨的特点是:

  • 奶酪味:薄面团、Marinara酱料,配菜是Grated Reggiano Cheese(一种奶酪),采用自己的包装,烘烤和切块采用总店的
  • 蛤蜊味:薄面团、Marinara酱料,配菜是Grated Reggiano Clam(一种蛤蜊),采用自己的包装,烘烤和切块采用总店的

看来纽约喜欢的披萨面团要薄一点....

不久,芝加哥又想加盟一家披萨店,和纽约人不同的是,芝加哥人希望披萨的面团厚一些,所谓一方一俗吧。于是我们把店先开起来,然后再做披萨:

class ChicagoPizzaStore extends PizzaStore
{
    /**
     * @param $type
     *
     * @return Pizza
     */
    public function createPizza($type)
    {
        if ($type == 'cheese') {
            return new ChicagoStyleCheesePizza();
        } elseif ($type' == 'clam) {
            return new ChicagoStyleClamPizza();
        }
    }
}

芝加哥的分店暂时也只提供两种口味:奶酪味和蛤蜊味。

//奶酪味
class ChicagoStyleCheesePizza extends Pizza
{
    /**
     * ChicagoStyleCheesePizza constructor.
     */
    public function __construct()
    {
        $this->name = 'Chicago Style Deep Dish Cheese Pizza';
        $this->dough = 'Extra Thick Crust Dough';
        $this->sauce = 'Plum Tomato Sauce';

        $this->toppings[] = 'Shredded Mozzarella Cheese';
    }

    public function cut()
    {
        print_r('Cut: Cutting the pizza into square slices').'<br>';
    }
}

//蛤蜊味
class ChicagoStyleClamPizza extends Pizza
{
    /**
     * ChicagoStyleClamPizza constructor.
     */
    public function __construct()
    {
        $this->name = 'Chicago Style Deep Dish Clam Pizza';
        $this->dough = 'Extra Thick Crust Dough';
        $this->sauce = 'Plum Tomato Sauce';

        $this->toppings[] = 'Shredded Mozzarella Clam';
    }

    public function cut()
    {
        print_r('Cut: Cutting the pizza into square slices'.'<br>');
    }
}

芝加哥店两种口味披萨的特点是:

  • 奶酪味:加厚面团、Plum Tomato酱料,配菜是Shredded Mozzarella Cheese(一种奶酪),切成方块,烘烤和包装采用总店的
  • 蛤蜊味:加厚面团、Marinara酱料,配菜是Shredded Mozzarella Clam(一种蛤蜊),切成方块,烘烤和包装采用总店的

现在我们就有了两家分店,四种不同口味披萨了。你已经等了很久了,来吃些披萨吧:

class Test 
{
    public function run()
    {
        $nyStore = new NYPizzaStore();   
        print_r("Terry ordered a NY Style Cheese Pizza" . '<br>');
        $pizza1 = $nyStore->orderPizza('cheese');

        echo '<br><br>';

		$chicagoStore = new ChicagoPizzaStore();
        print_r("Json ordered a Chicago Style Clam Pizza" . '<br>');
        $pizza2 = $chicagoStore->orderPizza('clam');
    }
}

我想尝尝纽约奶酪风味的,那我首先要有个纽约店,再由纽约店给我提供奶酪味的;我想尝尝芝加哥蛤蜊味的,那我首先要有个芝加哥店,再有芝加哥店给我提供蛤蜊味的。

认识工厂方法模式

所有的工厂模式都是用来封装对象的创建。工厂方法模式通过让子类来决定创建的对象是什么,从而达到将对象创建的过程封装的目的。

披萨店通过orderPizza()提供最终的披萨,在orderPizza()看来,我需要一个工厂方法createPizza()给我提供一个未加工的,然后我来做准备、烘烤、切块、包装,最终返回。orderPizza()无需了解披萨具体细节,因为反正所有的披萨都这么个过程。而在抽象的PizzaStore中也createPizza()也不确定细节,它只能保证自己要提供这么一个。具体的细节是其子类去规定。

因此,表现在代码中,就是在abstract class PizzaStore中,我还没有一个Pizza的实例呢,但prepare()->bake()->cut()->box()->return 也照样这么做了下来。

public function orderPizza($type)
{
    // create a pizza
    $this->pizza = $this->createPizza($type);

    // handle the pizza
    $this->pizza->prepare();
    $this->pizza->bake();
    $this->pizza->cut();
    $this->pizza->box();

    // return the prepared pizza
    return $this->pizza;
}

此时的$this->pizza是实现abstract class Pizza的规定的一种抽象,而还不是一个具体的实例。

这就是依赖抽象而不依赖具体!

工厂方法模式的另一种认识,就是将orderPizza()和一个工厂方法createPizza()联合起来,加上其他的prepare()/bake()等逻辑,就组成了一个框架,一种规范。子类继承这个抽象类也就获得了这个规范。如果说createPizza()是子类自由发挥的部分,那么orderPizza()就给你规定了自由发挥的一些前提,从而是有限度的自由。这是总店希望看到的,希望你在这个框框里面去开你的分店,而不要自由发挥得太离谱。

工厂方法和简单工厂

工厂方法和简单工厂的区别在于,简单工厂把全部的事情,在一个地方都处理完了,然而工厂方法却是在创建一个框架,让子类决定要如何实现。比如说,在工厂方法中,orderPizza()方法提供了一般的框架,以便创建披萨,orderPizza()方法依赖工厂方法创建具体类,再经过一系列其他操作,最终制造出实际的披萨??赏ü坛蠵izzaStore类,决定实际造出的披萨是什么。简单工厂的做法,可以将对象的创建封装起来,但是一下子给你一个完整的,没有那种子类的“推迟”,因此不具备工厂方法的弹性。

工厂方法和抽象工厂

细心的读者可能会发现一个问题,就是各家披萨店的原料都是自己提供(参看各个披萨店的__construct()),这样口味还是有较大的随意性。为了保证各分店口味大致相同,我们需要对原料做统一管理,让总店来统一供给做披萨的原料。

为了吃一个披萨,我们首先要有个披萨工厂(店),为了供给披萨原料,我们需要什么呢?——原料工厂呗!如果想到这一层,那恭喜你,已经进阶到抽象工厂的层次了。

抽象工厂将上面的dough,sauce,cheese,clams等等——凡是出现过的原料都让一个抽象方法去实现,将所有这些抽象方法集合起来放到一个类里,就是抽象工厂。例如,原料工厂应该实现下面的接口:

interface PizzaIngredientFactory
{
    /**
     * @return Dough
     */
    public function createDough();

    /**
     * @return Sauce
     */
    public function createSauce();

    /**
     * @return Cheese
     */
    public function createCheese();

    /**
     * @return Veggie[]
     */
    public function createVeggies();

    /**
     * @return Clams
     */
    public function createClams();
}

实现了这个接口的就是具体原料工厂。在让PizzaStore创建披萨时,先往PizzaStore注入一个PizzaIngredientFactory实例,然后委托这个实例去提供各种原料。

因此,抽象工厂其实是基于工厂方法的。工厂方法定义创建一种产品,而抽象工厂负责定义常见一组产品的接口,这个接口的每个方法都像工厂方法一样创建一个具体产品,同时我们用抽象工厂的子类去提供这些具体的做法,从而最终提供一组一组的形形色色的产品来。

Yii2中的工厂方法模式

我们已经走得够远了,让我们回到Yii2框架中来。

本文开头的那个例子中,yii\db\Schema是为各个DBMS提供了一个统一的、抽象的数据库信息的基类。getTableSchema()方法是获取表的元数据,而loadTableSchema()将一个数据表填充为一个TableSchema类。

也就说说loadTableSchema()需要返回一个TableSchema的具体类。这个类包含了schema名、表名、主键foreignKeys以及代表数据表字段信息的ColumnSchema的数组colums[]。

显然,各个数据库的表和字段类型是有差异的,因此loadTableSchema()必须为抽象方法,由子类去做具体实现。mysql/mssql/cubrid/sqlite等DBMS的Schema也确实继承了yii\db\Schema类,实现了各自的loadTableSchema()具体方法。

以mysql的为例:

class Schema extends \yii\db\Schema
{
    //...

    /**
     * Loads the metadata for the specified table.
     * @param string $name table name
     * @return TableSchema driver dependent table metadata. Null if the table does not exist.
     */
    protected function loadTableSchema($name)
    {
        $table = new TableSchema;
        $this->resolveTableNames($table, $name);

        if ($this->findColumns($table)) {
            $this->findConstraints($table);

            return $table;
        } else {
            return null;
        }
    }

    //...
}

它就在loadTableSchema()方法中返回了一个具体的TableSchema实例。

原文链接:https://blog.csdn.net/qq_24127857/article/details/85597852

觉得很赞
亿速云
  • 评论于 2019-01-11 10:59 举报

    这篇文章写的不错,举得例子还好,虽然和真正的业务时有点差距,可看得出来作者很用心在写了,这种举例,作者肯定想了很久,想举个看起来很能贴近现实的例子来说明

    但希望楼主下次能用真正实例时能用得上的,来介绍这些设计模式,哪怕是举得例子是写cms时,在何种情况下能用上这些设计模式都行。因为你面向的受众人群不是什么不懂的吃瓜群主,必须得用这些生活例子才能知道啥用处,是些好歹是些能用到工作中的人,所以举这些例子还不如举些最常用的工作里用的东西效果好,这样,对于我们这种菜鸟,才能够有恍然大悟的感觉,原来这种模式在实践中,可以这么使用??!

    谢谢作者大佬的分享与教导

    1 条回复
    评论于 2019-01-15 10:27 回复

    因为文中主要是讲设计模式,设计模式属于面向对象技术范畴了。我所理解的面向对象,就一定要用代码语言反映现实生活,解决现实生活中的问题。虽说Pizza加盟店的例子你开发中不容易碰到,但是稍作变通,距离你真实的业务场景比如用户、订单、cms这些也就是一步之遥。
    此外,《设计模式》《Head First》等讲解设计模式的经典书籍,里面也多用这种和现实结合紧密的例子。在后面的模式中,当然也会有和开发中直接对应的例子。

    觉得很赞
  • 评论于 2019-01-11 14:12 举报

    走马看花来了一遍 点个赞不为过

    觉得很赞
  • 评论于 2019-03-14 10:36 举报

    很用心的讲解

您需要登录后才可以评论。登录 | 立即注册