php创建放式,PHP设计模式（创建型）

前言

随着编程项目经验的增加，从服务于业务逻辑到针对项目的全局设计。认识到设计模式在开发过程中 \的重要性，遵循 S.O.L.I.D 五大基准原则。它拓展了我的视野，让代码更加灵活，看起来更加富有美感.\美是构建万物的哲学思想.

我们学习的设计模式分为三类：创建者模式、结构型模式、行为型模式；创建型模式与对象的创建有关；结构型模式处理类或对象的组合；而行为型模式是对类或对象怎样交互和怎样分配职责进行描述；

内容：本文介绍的是 PHP 设计模式的创建型一篇。包括：单例模式(Singleton), 多例模式(Multiton), 工厂方法模式(Factory Method), 抽象工厂模式(Abstract Factory), 简单工厂模式(Simple Factory), 原型模式(Prototype), 对象池模式(Pool), 建造者模式(Builder)

推荐：《PHP教程》

(一)单例模式(Singleton)

● 定义

保证一个类只有一个实例，并且提供一个访问它的全局访问点。系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能。

● 代码示例class Singleton { /** * @var Singleton */ private static $instance; /** * 不允许从外部调用以防止创建多个实例 * 要使用单例，必须通过 Singleton::getInstance() 方法获取实例 */ private function __construct() { } /** * 通过懒加载获得实例(在第一次使用的时候创建) */ public static function getInstance(): Singleton { if (null === static::$instance) { static::$instance = new static(); } return static::$instance; } /** * 防止实例被克隆(这会创建实例的副本) */ private function __clone() { } /** * 防止反序列化(这将创建它的副本) */ private function __wakeup() { } }

(二)多例模式(Multiton)

● 定义

在多例模式中，多例类可以有多个实例，而且多例类必须自己创建、管理自己的实例，并向外界提供自己的实例。1. 通过实例容器保存容器。2. 利用私有构造阻止外部构造。3. 提供getInstantce()方法获取实例.

● 代码示例 两个对象通过一个类进行多次实例化abstract class Multiton { private static $instances = array(); public static function getInstance() { $key = get_called_class() . serialize(func_get_args()); if (!isset(self::$instances[$key])) { $rc = new ReflectionClass(get_called_class()); self::$instances[$key] = $rc->newInstanceArgs(func_get_args()); } return self::$instances[$key]; } /** * 该私有对象阻止实例被克隆 */ private function __clone() { } /** * 该私有方法阻止实例被序列化 */ private function __wakeup() { } } class Hello extends Multiton { public function __construct($string = 'World') { echo "Hello $string\n"; } } class GoodBye extends Multiton { public function __construct($string = 'my', $string2 = 'darling') { echo "Goodbye $string $string2\n"; } } $a = Hello::getInstance('World'); $b = Hello::getInstance('bob'); // $a !== $b $c = Hello::getInstance('World'); // $a === $c $d = GoodBye::getInstance(); $e = GoodBye::getInstance(); // $d === $e $f = GoodBye::getInstance('your'); // $d !== $f

(三)工厂方法模式(Factory Method)

● 定义

将类的实例化(具体产品的创建)延迟到工厂类的子类(具体工厂)中完成，即由子类来决定应该实例化(创建)哪一个类

● 代码示例 ： 小成有一间塑料加工厂(仅生产 A 类产品)；随着客户需求的变化，客户需要生产 B 类产品。改变原有塑料加工厂的配置和变化非常困难，假设下一次客户需要再发生变化，再次改变将增大非常大的成本；小成决定置办塑料分厂 B 来生产 B 类产品。abstract class Product{ public abstract function Show(); } //具体产品A类 class ProductA extends Product{ public function Show() { echo "生产出了产品A"; } } //具体产品B类 class ProductB extends Product{ public function Show() { echo "生产出了产品B"; } } abstract class Factory{ public abstract function Manufacture(); } //工厂A类 - 生产A类产品 class FactoryA extends Factory{ public function Manufacture() { return new ProductA(); } } //工厂B类 - 生产B类产品 class FactoryB extends Factory{ public function Manufacture() { return new ProductB(); } }

(四)抽象工厂模式(Abstract Factory)

● 定义

在不指定具体类的情况下创建一系列相关或依赖对象。 通常创建的类都实现相同的接口。 抽象工厂的客户并不关心这些对象是如何创建的，它只是知道它们是如何一起运行的。

● 代码示例 ： 有两个工厂，A 工厂负责运输，B 工厂生产数码产品.interface Product { public function calculatePrice(): int; } class ShippableProduct implements Product { /** * @var float */ private $productPrice; /** * @var float */ private $shippingCosts; public function __construct(int $productPrice, int $shippingCosts) { $this->productPrice = $productPrice; $this->shippingCosts = $shippingCosts; } public function calculatePrice(): int { return $this->productPrice $this->shippingCosts; } } class DigitalProduct implements Product { /** * @var int */ private $price; public function __construct(int $price) { $this->price = $price; } public function calculatePrice(): int { return $this->price; } } class ProductFactory { const SHIPPING_COSTS = 50; public function createShippableProduct(int $price): Product { return new ShippableProduct($price, self::SHIPPING_COSTS); } public function createDigitalProduct(int $price): Product { return new DigitalProduct($price); } }

(五)简单工厂模式(Simple Factory)

● 定义

简单工厂模式是一个精简版的工厂模式。工厂角色-具体产品-抽象产品

● 代码示例 ：

一个农场，要向市场销售水果。农场里有三种水果 苹果、葡萄，我们设想：1、水果有多种属性，每个属性都有不同，但是，他们有共同的地方 | 生长、种植、收货、吃。将来有可能会增加新的水果、我们需要定义一个接口来规范他们必须实现的方法.interface fruit{ /** * 生长 */ public function grow(); /** * 种植 */ public function plant(); /** * 收获 */ public function harvest(); /** * 吃 */ public function eat(); } class apple implements fruit{ //苹果树有年龄 private $treeAge; //苹果有颜色 private $color; public function grow(){ echo "grape grow"; } public function plant(){ echo "grape plant"; } public function harvest(){ echo "grape harvest"; } public function eat(){ echo "grape eat"; } //取苹果树的年龄 public function getTreeAge(){ return $this->treeAge; } //设置苹果树的年龄 public function setTreeAge($age){ $this->treeAge = $age; return true; } } class grape implements fruit{ //葡萄是否有籽 private $seedLess; public function grow(){ echo "apple grow"; } public function plant(){ echo "apple plant"; } public function harvest(){ echo "apple harvest"; } public function eat(){ echo "apple eat"; } //有无籽取值 public function getSeedLess(){ return $this->seedLess; } //设置有籽无籽 public function setSeedLess($seed){ $this->seedLess = $seed; return true; } } class farmer { //定义个静态工厂方法 public static function factory($fruitName){ switch ($fruitName) { case 'apple': return new apple(); break; case 'grape': return new grape(); break; default: throw new badFruitException("Error no the fruit", 1); break; } } } class badFruitException extends Exception { public $msg; public $errType; public function __construct($msg = '' , $errType = 1){ $this->msg = $msg; $this->errType = $errType; } } /** * 获取水果实例化的方法 */ try{ $appleInstance = farmer::factory('apple'); var_dump($appleInstance); }catch(badFruitException $err){ echo $err->msg . "_______" . $err->errType; }

(六)原型模式(Prototype)

● 定义

相比正常创建一个对象 (new Foo () )，首先创建一个原型，然后克隆它会更节省开销。

● 代码示例 ： 为每一本书设置标题abstract class BookPrototype { /** * @var string */ protected $title = 0; /** * @var string */ protected $category; abstract public function __clone(); public function getTitle(): string { return $this->title; } public function setTitle($title) { $this->title = $title; } } class BarBookPrototype extends BookPrototype { /** * @var string */ protected $category = 'Bar'; public function __clone() { } } class FooBookPrototype extends BookPrototype { /** * @var string */ protected $category = 'Foo'; public function __clone() { } } $fooPrototype = new FooBookPrototype(); $barPrototype = new BarBookPrototype(); for ($i = 5; $i < 10; $i ) { $book = clone $fooPrototype; $book->setTitle('Foo Book No ' . $i); var_dump(new FooBookPrototype == $book); } for ($i = 0; $i < 5; $i ) { $book = clone $barPrototype; $book->setTitle('Bar Book No ' . $i); var_dump(new BarBookPrototype == $book); }

(七)对象池模式(Pool)

● 定义

对象池可以用于构造并且存放一系列的对象并在需要时获取调用。在初始化实例成本高，实例化率高，可用实例不足的情况下，对象池可以极大地提升性能。在创建对象(尤其是通过网络)时间花销不确定的情况下，通过对象池在短期时间内就可以获得所需的对象。

● 代码示例class Factory { protected static $products = array(); public static function pushProduct(Product $product) { self::$products[$product->getId()] = $product; } public static function getProduct($id) { return isset(self::$products[$id]) ? self::$products[$id] : null; } public static function removeProduct($id) { if (array_key_exists($id, self::$products)) { unset(self::$products[$id]); } } } Factory::pushProduct(new Product('first')); Factory::pushProduct(new Product('second')); print_r(Factory::getProduct('first')->getId()); // first print_r(Factory::getProduct('second')->getId()); // second

(八)建造者模式(Builder)

● 定义

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

● 2)代码示例 建造相同标准的卡车和汽车。类似于变形金刚，相同的零件进行不同的组合.

● 分为 Director 导演者，负责构建、BuilderInterface 构建接口，规范建造标准、TruckBuilder 构建卡车类 CarBuilder 构建汽车类

Vehicle 零部件公共类、Truck Car Engine Wheel Door 零部件类、DirectorTest 测试类class Director { public function build(BuilderInterface $builder): Vehicle { $builder->createVehicle(); $builder->addDoors(); $builder->addEngine(); $builder->addWheel(); return $builder->getVehicle(); } } interface BuilderInterface { public function createVehicle(); public function addWheel(); public function addEngine(); public function addDoors(); public function getVehicle(): Vehicle; } class TruckBuilder implements BuilderInterface { /** * @var Truck */ private $truck; public function addDoors() { $this->truck->setPart('rightDoor', new Door()); $this->truck->setPart('leftDoor', new Door()); } public function addEngine() { $this->truck->setPart('truckEngine', new Engine()); } public function addWheel() { $this->truck->setPart('wheel1', new Wheel()); $this->truck->setPart('wheel2', new Wheel()); $this->truck->setPart('wheel3', new Wheel()); $this->truck->setPart('wheel4', new Wheel()); $this->truck->setPart('wheel5', new Wheel()); $this->truck->setPart('wheel6', new Wheel()); } public function createVehicle() { $this->truck = new Truck(); } public function getVehicle(): Vehicle { return $this->truck; } } class CarBuilder implements BuilderInterface { /** * @var Car */ private $car; public function addDoors() { $this->car->setPart('rightDoor', new Door()); $this->car->setPart('leftDoor', new Door()); $this->car->setPart('trunkLid', new Door()); } public function addEngine() { $this->car->setPart('engine', new Engine()); } public function addWheel() { $this->car->setPart('wheelLF', new Wheel()); $this->car->setPart('wheelRF', new Wheel()); $this->car->setPart('wheelLR', new Wheel()); $this->car->setPart('wheelRR', new Wheel()); } public function createVehicle() { $this->car = new Car(); } public function getVehicle(): Vehicle { return $this->car; } } abstract class Vehicle { /** * @var object[] */ private $data = []; /** * @param string $key * @param object $value */ public function setPart($key, $value) { $this->data[$key] = $value; } } class Truck extends Vehicle { } class Car extends Vehicle { } class Engine extends Vehicle { } class Wheel extends Vehicle { } class Door extends Vehicle { } class DirectorTest { public function testCanBuildTruck() { $truckBuilder = new TruckBuilder(); return (new Director())->build($truckBuilder); } public function testCanBuildCar() { $carBuilder = new CarBuilder(); return (new Director())->build($carBuilder); } } $directorTest = new DirectorTest(); var_dump($directorTest->testCanBuildTruck()); var_dump($directorTest->testCanBuildCar());