應用舉例

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()方法依賴工廠方法建立具體類，再經過一系列其他操作，最終制造出實際的披薩。可通過繼承PizzaStore類，決定實際造出的披薩是什麼。簡單工廠的做法，可以將物件的建立封裝起來，但是一下子給你一個完整的，沒有那種子類的“推遲”，因此不具備工廠方法的彈性。

工廠方法和抽象工廠

細心的讀者可能會發現一個問題，就是各家披薩店的原料都是自己提供(參看各個披薩店的__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例項。