【搬运于GitHub开源项目DesignPatternsPHP】
项目地址：戳我
1、创建型设计模式
在软件工程中，创建型设计模式承担着对象创建的职责，尝试创建适合程序上下文的对象，对象创建设计模式的产生是由于软件工程设计的问题，具体说是向设计中增加复杂度，创建型设计模式解决了程序设计中对象创建的问题。
1.1 抽象工厂
1.1.1 目的
创建一系列相关或依赖的对象，而不指定它们的具体类。通常创建的类都实现相同的接口。抽象工厂的客户端并不关心这些对象是如何创建的，它只知道它们是如何组合在一起的。
1.1.2 UML图
1.2.4 代码
你可以在 GitHub 上找到这些代码
Director.php
namespace DesignPatternsCreationalBuilder;
use DesignPatternsCreationalBuilderPartsVehicle;
/**
* Director is part of the builder pattern. It knows the interface of the builder
* and builds a complex object with the help of the builder
*
* You can also inject many builders instead of one to build more complex objects
*/
class Director
{
public function build(BuilderInterface $builder): Vehicle
{
$builder->createVehicle();
$builder->addDoors();
$builder->addEngine();
$builder->addWheel();
return $builder->getVehicle();
}
}
BuilderInterface.php
namespace DesignPatternsCreationalBuilder;
use DesignPatternsCreationalBuilderPartsVehicle;
interface BuilderInterface
{
public function createVehicle();
public function addWheel();
public function addEngine();
public function addDoors();
public function getVehicle(): Vehicle;
}
TruckBuilder.php
namespace DesignPatternsCreationalBuilder;
use DesignPatternsCreationalBuilderPartsVehicle;
class TruckBuilder implements BuilderInterface
{
/**
* @var PartsTruck
*/
private $truck;
public function addDoors()
{
$this->truck->setPart(‘rightDoor’, new PartsDoor());
$this->truck->setPart(‘leftDoor’, new PartsDoor());
}
public function addEngine()
{
$this->truck->setPart(‘truckEngine’, new PartsEngine());
}
public function addWheel()
{
$this->truck->setPart(‘wheel1’, new PartsWheel());
$this->truck->setPart(‘wheel2’, new PartsWheel());
$this->truck->setPart(‘wheel3’, new PartsWheel());
$this->truck->setPart(‘wheel4’, new PartsWheel());
$this->truck->setPart(‘wheel5’, new PartsWheel());
$this->truck->setPart(‘wheel6’, new PartsWheel());
}
public function createVehicle()
{
$this->truck = new PartsTruck();
}
public function getVehicle(): Vehicle
{
return $this->truck;
}
}
CarBuilder.php
namespace DesignPatternsCreationalBuilder;
use DesignPatternsCreationalBuilderPartsVehicle;
class CarBuilder implements BuilderInterface
{
/**
* @var PartsCar
*/
private $car;
public function addDoors()
{
$this->car->setPart(‘rightDoor’, new PartsDoor());
$this->car->setPart(‘leftDoor’, new PartsDoor());
$this->car->setPart(‘trunkLid’, new PartsDoor());
}
public function addEngine()
{
$this->car->setPart(‘engine’, new PartsEngine());
}
public function addWheel()
{
$this->car->setPart(‘wheelLF’, new PartsWheel());
$this->car->setPart(‘wheelRF’, new PartsWheel());
$this->car->setPart(‘wheelLR’, new PartsWheel());
$this->car->setPart(‘wheelRR’, new PartsWheel());
}
public function createVehicle()
{
$this->car = new PartsCar();
}
public function getVehicle(): Vehicle
{
return $this->car;
}
}
Parts/Vehicle.php
namespace DesignPatternsCreationalBuilderParts;
abstract class Vehicle
{
/**
* @var object[]
*/
private $data = [];
/**
* @param string $key
* @param object $value
*/
public function setPart($key, $value)
{
$this->data[$key] = $value;
}
}
Parts/Truck.php
namespace DesignPatternsCreationalBuilderParts;
class Truck extends Vehicle
{
}
Parts/Car.php
namespace DesignPatternsCreationalBuilderParts;
class Engine
{
}
Parts/Engine.php
namespace DesignPatternsCreationalBuilderParts;
class Engine
{
}
Parts/Wheel.php
namespace DesignPatternsCreationalBuilderParts;
class Wheel
{
}
Parts/Door.php
namespace DesignPatternsCreationalBuilderParts;
class Door
{
}
1.3 工厂方法
1.3.1 目的
SimpleFactory的优点是您可以子类化它来实现创建对象的不同方法。
对于简单的情况，这个抽象类可能只是一个接口。
这个模式是一个 “真正” 的设计模式，因为它遵循了依赖反转原则 Dependency Inversion Principle 众所周知这个 “D” 代表了真正的面向对象程序设计。
它意味着工厂方法类依赖于类的抽象，而不是具体将被创建的类，这是工厂方法模式与简单工厂模式和静态工厂模式最重要的区别。
1.3.2 UML图
1.4.4 代码
你可以在 GitHub 上找到这些代码
Multiton.php
namespace DesignPatternsCreationalMultiton;
final class Multiton
{
const INSTANCE_1 = ‘1’;
const INSTANCE_2 = ‘2’;
/**
* @var Multiton[]
*/
private static $instances = [];
/**
* this is private to prevent from creating arbitrary instances
*/
private function __construct()
{
}
public static function getInstance(string $instanceName): Multiton
{
if (!isset(self::$instances[$instanceName])) {
self::$instances[$instanceName] = new self();
}
return self::$instances[$instanceName];
}
/**
* prevent instance from being cloned
*/
private function __clone()
{
}
/**
* prevent instance from being unserialized
*/
private function __wakeup()
{
}
}
1.5 对象池
1.5.1 目的
对象池设计模式 是创建型设计模式，它会对新创建的对象应用一系列的初始化操作，让对象保持立即可使用的状态 – 一个存放对象的 “池子” – 而不是对对象进行一次性的的使用(创建并使用，完成之后立即销毁)。对象池的使用者会对对象池发起请求，以期望获取一个对象，并使用获取到的对象进行一系列操作，当使用者对对象的使用完成之后，使用者会将由对象池的对象创建工厂创建的对象返回给对象池，而不是用完之后销毁获取到的对象。
对象池在某些情况下会带来重要的性能提升，比如耗费资源的对象初始化操作，实例化类的代价很高，但每次实例化的数量较少的情况下。对象池中将被创建的对象会在真正被使用时被提前创建，避免在使用时让使用者浪费对象创建所需的大量时间(比如在对象某些操作需要访问 络资源的情况下)从池子中取得对象的时间是可预测的，但新建一个实例所需的时间是不确定。
总之，对象池会为你节省宝贵的程序执行时间，比如像数据库连接，socket连接，大量耗费资源的代表数字资源的对象，像字体或者位图。不过，在特定情况下，简单的对象创建池(没有请求外部的资源，仅仅将自身保存在内存中)或许并不会提升效率和性能，这时候，就需要使用者酌情考虑了。
1.5.2 UML图
1.6.4 代码
你可以在 GitHub 上找到这些代码
BookPrototype.php
namespace DesignPatternsCreationalPrototype;
abstract class BookPrototype
{
/**
* @var string
*/
protected $title;
/**
* @var string
*/
protected $category;
abstract public function __clone();
public function getTitle(): string
{
return $this->title;
}
public function setTitle($title)
{
$this->title = $title;
}
}
BarBookPrototype.php
namespace DesignPatternsCreationalPrototype;
class BarBookPrototype extends BookPrototype
{
/**
* @var string
*/
protected $category = ‘Bar’;
public function __clone()
{
}
}
FooBookPrototype.php
namespace DesignPatternsCreationalPrototype;
class FooBookPrototype extends BookPrototype
{
/**
* @var string
*/
protected $category = ‘Foo’;
public function __clone()
{
}
}
1.7 简单工厂
1.7.1 目的
它与静态工厂不同，因为它不是静态的。因此，可以有多个参数化的工厂，可以子类化它，也可以模拟它。它总是比静态工厂更受欢迎!
1.7.2 UML图
1.8.4 代码
你可以在 GitHub 上找到这些代码
Singleton.php
namespace DesignPatternsCreationalSingleton;
final class Singleton
{
/**
* @var Singleton
*/
private static $instance;
/**
* gets the instance via lazy initialization (created on first usage)
*/
public static function getInstance(): Singleton
{
if (null === static::$instance) {
static::$instance = new static();
}
return static::$instance;
}
/**
* is not allowed to call from outside to prevent from creating multiple instances,
* to use the singleton, you have to obtain the instance from Singleton::getInstance() instead
*/
private function __construct()
{
}
/**
* prevent the instance from being cloned (which would create a second instance of it)
*/
private function __clone()
{
}
/**
* prevent from being unserialized (which would create a second instance of it)
*/
private function __wakeup()
{
}
}
1.9 静态工厂
1.9.1 目的
和抽象工厂类似，静态工厂模式用来创建一系列互相关联或依赖的对象，和抽象工厂模式不同的是静态工厂模式只用一个静态方法就解决了所有类型的对象创建，通常被命名为 Factory 或者 Generators
1.9.2 例子
Zend Framework: zend_cache_ 后端或 _Frontend 使用工厂方法创建缓存后端和前端
1.9.3 UML图
1.9.4 代码
你可以在 GitHub 上找到这些代码
StaticFactory.php
namespace DesignPatternsCreationalStaticFactory;
/**
* Note1: Remember, static means global state which is evil because it can’t be mocked for tests
* Note2: Cannot be subclassed or mock-upped or have multiple different instances.
*/
final class StaticFactory
{
/**
* @param string $type
*
* @return Formatter
*/
public static function factory(string $type): Formatter
{
if ($type == ‘number’) {
return new FormatNumber();
} elseif ($type == ‘string’) {
return new FormatString();
}
throw new InvalidArgumentException(‘Unknown format given’);
}
}
Formatter.php
namespace DesignPatternsCreationalStaticFactory;
interface Formatter
{
public function format(string $input): string;
}
FormatString.php
namespace DesignPatternsCreationalStaticFactory;
class FormatString implements Formatter
{
public function format(string $input): string
{
return $input;
}
}
FormatNumber.php
namespace DesignPatternsCreationalStaticFactory;
class FormatNumber implements Formatter
{
public function format(string $input): string
{
return number_format($input);
}
}
声明：本站部分文章及图片源自用户投稿，如本站任何资料有侵权请您尽早请联系jinwei@zod.com.cn进行处理,非常感谢！