Einfache Fabriken, Fabrikmethoden und abstrakte Fabriken in einem Artikel verstehen

Einfacher Factory-Modus

Grundsätzlich hat jeder einen Musikplayer auf seinem Handy. Die derzeit beliebtesten Player sind: QQ Music, Kugou Music, Sogou Music. NetEase Cloud Music, Tiantian Dongting usw. Das Folgende ist ein Codestück zum Abspielen von Musik:

if ($type == 'QQ') {
    $player = new QQPlayer();
} else if ($type == 'Wy') {
    $player = new WyPlayer();
} else if ($type == 'KG') {
    $player = new KGPlayer();
} else {
    $palyer = null;
}
 
$player->on();  // 打开播放器
$player->choiceMusic('我不配');  // 选择歌曲
$player->play();  // 开始播放

Um die Codelogik klarer und lesbarer zu machen, müssen wir gut darin sein, funktional unabhängige Codeblöcke in Funktionen zu kapseln. Gemäß dieser Designidee können wir die bedingten Zweige extrahieren und sie in einer separaten Methode in einer Klasse platzieren. Diese Klasse kann als einfaches Factory-Muster bezeichnet werden.

Definition eines einfachen Factory-Musters: Eine Klasse kann verschiedene Instanzen basierend auf unterschiedlichen Parametern erhalten. Im Allgemeinen haben diese erstellten Instanzen dieselbe übergeordnete Klasse.

Statisches Fabrikmuster: Im Allgemeinen legen wir die Methoden, die zum Erstellen verschiedener Instanzen im einfachen Fabrikmuster verwendet werden, als statische Methoden fest, um die Erstellung mehrerer identischer Instanzen zu vermeiden.

Lassen Sie uns den obigen Code mit dem einfachen Factory-Muster neu schreiben

class MusicPlayerFactory
{
    public static function create ($type)
    {
        if ($type == 'QQ') {
            $player = new QQPlayer();
        } else if ($type == 'Wy') {
            $player = new WyPlayer();
        } else if ($type == 'KG') {
            $player = new KGPlayer();
        } else {
            $player = null;
        }
        return $player;
    }
}

// 业务代码修改如下
$player = MusicPlayerFactory:create('QQ');
$player->on();  // 打开播放器
$player->choiceMusic('我不配');  // 选择歌曲
$player->play();  // 开始播放

Wenn wir für das obige einfache Factory-Muster einen neuen Musikplayer hinzufügen müssen, werden wir es auf jeden Fall ändern it Die Erstellungsmethode von MusicPlayerFactory steht in gewisser Weise im Widerspruch zum „Öffnungs- und Schließprinzip“. Es gibt nicht viele solcher bedingten Verzweigungen, und die Erstellung anderer Klassen ist ebenfalls sehr einfach. Es ist durchaus möglich, das einfache Factory-Muster zu verwenden. Wenn Sie die If-Verzweigungslogik entfernen und dafür sorgen müssen, dass sie dem „Öffnungs- und Schließprinzip“ entspricht, können Sie dies mit der Factory-Methode erreichen. Für Factory-Methoden ist es nicht unbedingt besser als das einfache Factory-Muster. Obwohl die Skalierbarkeit besser ist, beeinträchtigt es die Lesbarkeit.

Factory-Methodenmuster

Definition: Im Factory-Methodenmuster ist die Factory-Elternklasse für die Definition der öffentlichen Schnittstelle zum Erstellen von Produktobjekten verantwortlich , und die untergeordnete Fabrik Die Klasse ist für die Generierung bestimmter Produktobjekte verantwortlich. Der Zweck besteht darin, den Instanziierungsvorgang der Produktklasse für die Fabrikunterklasse zu verzögern, dh zu bestimmen, welche spezifische Produktklasse über die Fabrikunterklasse instanziiert werden soll .

Jetzt verwenden wir „Polymorphismus“, um die if-Zweigstruktur des obigen einfachen Factory-Musters zu eliminieren. Der implementierte Code lautet wie folgt:

interface IMusicPlayerFactory
{
    static function create ();
}

class QQPlayerFactory implements IMusicPlayerFactory
{
    public static function create ()
    {
        return new QQPlayer();
    }
}

class WyPlayerFactory implements IMusicPlayerFactory
{
    public static function create ()
    {
        return new WyPlayer();
    }
}

class KGPlayerFactory implements IMusicPlayerFactory
{
    public static function create ()
    {
        return new KGPlayer();
    }
}

// 业务代码修改如下
if ($type == 'QQ') {
    $player = QQPlayerFactory::create();
} else if ($type == 'Wy') {
    $player = WyPlayerFactory::create();
} else if ($type == 'KG') {
    $player = KGPlayerFactory::create();
} else {
    throw new \Exception('...');
}
$player->on();  // 打开播放器
$player->choiceMusic('我不配');  // 选择歌曲
$player->play();  // 开始播放

Wie Sie sehen können, liegt das Problem wieder am ursprünglichen Punkt und die if-bedingte Verzweigungsstruktur erscheint erneut im Geschäftscode. Wie kann man dieses Problem lösen?

Wir können eine einfache Factory für die Factory-Klasse erstellen, um Factory-Klassenobjekte zu erstellen. Der neue einfache Factory-Code lautet wie folgt:

class MusicPlayerFactoryMap
{
    const Players = [
        'QQ' => 'QQPlayerFactory',
        'Wy' => 'WyPlayerFactory',
        'KG' => 'KGPlayerFactory'
    ];
    public static function getPlayerFactory (string $type)
    {
        if (empty($type)) {
            return null;
        }
        return (self::Players[$type])::create();
    }
}

// 业务代码修改如下
$palyer = MusicPlayerFactoryMap::getPlayerFactory('QQ')
$player->on();  // 打开播放器
$player->choiceMusic('我不配');  // 选择歌曲
$player->play();  // 开始播放

Wie Sie sehen können, wird die Struktur bei Verwendung des Factory-Musters viel komplexer als zuvor. Wir empfehlen die Verwendung des Factory-Methodenmusters nur, wenn der Prozess der Instanzerstellung kopiert wird.

Abstract Factory Pattern

Die Einsatzszenarien des Abstract Factory Pattern sind recht speziell und werden selten verwendet. Beim Muster der Fabrikmethode sind bestimmte Fabriken für die Herstellung bestimmter Produkte verantwortlich, und jede Fabrik entspricht einem bestimmten Produkt. Aber manchmal brauchen wir eine Fabrik, die mehrere Produktobjekte anstelle eines einzelnen Produkts erstellen kann.

Nehmen wir ein Beispiel: Die Zielcomputerfabrik ist für die Produktion von Computern für den Verkauf verantwortlich. Wir wissen, dass ein Computer aus einem Host, einer Tastatur, einem Monitor und einer Maus besteht. Derzeit werden von Target Computer City nur drei Arten von Computern hergestellt: Low-Profile-, Mid-Range- und High-Profile-Computer verschiedene Hostmarken, Monitormarken usw. von.

Die aktuellen Konsolen sind: Kirin-Konsole, Thunder-Konsole, Winter-Konsole

Die Tastaturen sind derzeit: Rapoo, Logitech, Razer

Die Monitore sind derzeit: aoc, hkc, BenQ

Zu den Mäusen gehören derzeit: Logitech, Snake und Founder

Die Top-Version des Computers besteht aus Kirin Host, Rapoo-Tastatur, AOC-Monitor und Logitech-Maus, die Mittelklasse Version besteht aus...

Der Code für den Host lautet wie folgt:

interface Host
{
    static function createHost ();
}
class DrHost implements Host
{
    public static function createHost()
    {
        echo '创建冬日主机' . PHP_EOL;
    }
}
class QlHost implements Host
{
    public static function createHost()
    {
        echo '创建麒麟主机' . PHP_EOL;
    }
}
class LtHost implements Host
{
    public static function createHost()
    {
        echo '创建雷霆主机' . PHP_EOL;
    }
}

Ebenso wird der Code zum Erstellen einer Tastatur, eines Monitors und einer Maus hier nicht veröffentlicht.

Jetzt definieren wir eine Schnittstelle zum Erstellen von Computern.

interface ComputerFactory
{
    static function createHost ();
    static function createKeyboard ();
    static function createMonitor ();
    static function createMouse ();
}

Schließen Sie dann drei spezifische Fabriken ab, um Low-End-, Mid-End- und High-End-Computer herzustellen.

class GreatComputerFactory implements ComputerFactory
{
    public static function createHost()
    {
        QlHost::createHost();
    }
    public static function createKeyboard()
    {
        LbKeyboard::createKeyboard();
    }
    public static function createMonitor()
    {
        AocMonitor::createMonitor();
    }
    public static function createMouse()
    {
        LjMouse::createMouse();
    }
}
class GoodComputerFactory implements ComputerFactory
{
    public static function createHost()
    {
        LtHost::createHost();
    }
    public static function createKeyboard()
    {
        LjKeyboard::createKeyboard();
    }
    public static function createMonitor()
    {
        HkcMonitor::createMonitor();
    }
    public static function createMouse()
    {
        LsMouse::createMouse();
    }
}
class NormalComputerFactory implements ComputerFactory
{
    public static function createHost()
    {
        DrHost::createHost();
    }
    public static function createKeyboard()
    {
        LsKeyboard::createKeyboard();
    }
    public static function createMonitor()
    {
        BenqMonitor::createMonitor();
    }
    public static function createMouse()
    {
        FzMouse::createMouse();
    }
}

Jetzt können Sie einen bestimmten Computer erstellen

class GreatComputer
{
    public function __construct()
    {
        echo '高配电脑' . PHP_EOL;
        GreatComputerFactory::createHost();
        GreatComputerFactory::createKeyboard();
        GreatComputerFactory::createMonitor();
        GreatComputerFactory::createMouse();
    }
}
class GoodComputer
{
    public function __construct()
    {
        echo '中配电脑' . PHP_EOL;
        GoodComputerFactory::createHost();
        GoodComputerFactory::createKeyboard();
        GoodComputerFactory::createMonitor();
        GoodComputerFactory::createMouse();
    }
}
class NormalComputer
{
    public function __construct()
    {
        echo '低配电脑' . PHP_EOL;
        NormalComputerFactory::createHost();
        NormalComputerFactory::createKeyboard();
        NormalComputerFactory::createMonitor();
        NormalComputerFactory::createMouse();
    }
}

Das obige ist der detaillierte Inhalt vonEinfache Fabriken, Fabrikmethoden und abstrakte Fabriken in einem Artikel verstehen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!