PHP中的设计模式-建站笔记

CreationalPatterns

Singleton(单例模式)

单例模式是最常见的模式之一,在Web应用的开发中,常常用于允许在运行时为某个特定的类创建一个可访问的实例。



php

/**

*Singletonclass

*/

finalclassProduct

/**

*@varself

*/

privatestatic$instance;

/**

*@varmixed

*/

public$mix;

/**

*Returnselfinstance

*@returnself

*/

publicstaticfunctiongetInstance(){

if(!

(self:$instanceinstanceofself)){

self:$instance=newself();

returnself:$instance;

privatefunction__construct(){

privatefunction__clone(){

$firstProduct=Product:getInstance();

$secondProduct=Product:getInstance();

$firstProduct-mix=test

$secondProduct-mix=example

print_r($firstProduct-mix);

//example

print_r($secondProduct-mix);

//example

在很多情况下,需要为系统中的多个类创建单例的构造方式,这样,可以建立一个通用的抽象父工厂方法:



php

abstractclassFactoryAbstract{

protectedstatic$instances=array();

publicstaticfunctiongetInstance(){

$className=static:getClassName();

if(!

(self:$instances[$className]instanceof$className)){

self:$instances[$className]=new$className();

returnself:$instances[$className];

publicstaticfunctionremoveInstance(){

$className=static:getClassName();

if(array_key_exists($className,self:$instances)){

unset(self:$instances[$className]);

finalprotectedstaticfunctiongetClassName(){

returnget_called_class();

protectedfunction__construct(){}

finalprotectedfunction__clone(){}

abstractclassFactoryextendsFactoryAbstract{

finalpublicstaticfunctiongetInstance(){

returnparent:getInstance();

finalpublicstaticfunctionremoveInstance(){

parent:removeInstance();

//using:

classFirstProductextendsFactory{

public$a=[];

classSecondProductextendsFirstProduct{

FirstProduct:getInstance()-a[]=1;

SecondProduct:getInstance()-a[]=2;

FirstProduct:getInstance()-a[]=3;

SecondProduct:getInstance()-a[]=4;

print_r(FirstProduct:getInstance()-

//array(1,3)

print_r(SecondProduct:getInstance()-

//array(2,4)

Registry

注册台模式并不是很常见,它也不是一个典型的创建模式,只是为了利用静态方法更方便的存取数据。



php

/**

*Registryclass

*/

classPackage{

protectedstatic$data=array();

publicstaticfunctionset($key,$value){

self:$data[$key]=$value;

publicstaticfunctionget($key){

returnisset(self:$data[$key])?

self:$data[$key]:null;

finalpublicstaticfunctionremoveObject($key){

if(array_key_exists($key,self:$data)){

unset(self:$data[$key]);

Package:set(name,Packagename);

print_r(Package:get(name));

//Packagename

Factory(工厂模式)

工厂模式是另一种非常常用的模式,正如其名字所示:确实是对象实例的生产工厂。

某些意义上,工厂模式提供了通用的方法有助于我们去获取对象,而不需要关心其具体的内在的实现。



php

interfaceFactory{

publicfunctiongetProduct();

interfaceProduct{

publicfunctiongetName();

classFirstFactoryimplementsFactory{

publicfunctiongetProduct(){

returnnewFirstProduct();

classSecondFactoryimplementsFactory{

publicfunctiongetProduct(){

returnnewSecondProduct();

classFirstProductimplementsProduct{

publicfunctiongetName(){

returnThefirstproduct

classSecondProductimplementsProduct{

publicfunctiongetName(){

returnSecondproduct

$factory=newFirstFactory();

$firstProduct=$factory-getProduct();

$factory=newSecondFactory();

$secondProduct=$factory-getProduct();

print_r($firstProduct-getName());

//Thefirstproduct

print_r($secondProduct-getName());

//Secondproduct

AbstractFactory(抽象工厂模式)

有些情况下我们需要根据不同的选择逻辑提供不同的构造工厂,而对于多个工厂而言需要一个统一的抽象工厂:



php

classConfig{

publicstatic$factory=1;

interfaceProduct{

publicfunctiongetName();

abstractclassAbstractFactory{

publicstaticfunctiongetFactory(){

switch(Config:$factory){

case1:

returnnewFirstFactory();

case2:

returnnewSecondFactory();

thrownewException(Badconfig);

abstractpublicfunctiongetProduct();

classFirstFactoryextendsAbstractFactory{

publicfunctiongetProduct(){

returnnewFirstProduct();

classFirstProductimplementsProduct{

publicfunctiongetName(){

returnTheproductfromthefirstfactory

classSecondFactoryextendsAbstractFactory{

publicfunctiongetProduct(){

returnnewSecondProduct();

classSecondProductimplementsProduct{

publicfunctiongetName(){

returnTheproductfromsecondfactory

$firstProduct=AbstractFactory:getFactory()-getProduct();

Config:$factory=2;

$secondProduct=AbstractFactory:getFactory()-getProduct();

print_r($firstProduct-getName());

//Thefirstproductfromthefirstfactory

print_r($secondProduct-getName());

//Secondproductfromsecondfactory

Objectpool(对象池)

对象池可以用于构造并且存放一系列的对象并在需要时获取调用:



php

classProduct{

protected$id;

publicfunction__construct($id){

$this-id=$id;

publicfunctiongetId(){

return$this-

classFactory{

protectedstatic$products=array();

publicstaticfunctionpushProduct(Product$product){

self:$products[$product-getId()]=$product;

publicstaticfunctiongetProduct($id){

returnisset(self:$products[$id])?

self:$products[$id]:null;

publicstaticfunctionremoveProduct($id){

if(array_key_exists($id,self:$products)){

unset(self:$products[$id]);

Factory:pushProduct(newProduct(first));

Factory:pushProduct(newProduct(second));

print_r(Factory:getProduct(first)-getId());

//first

print_r(Factory:getProduct(second)-getId());

//second

LazyInitialization(延迟初始化)

对于某个变量的延迟初始化也是常常被用到的,对于一个类而言往往并不知道它的哪个功能会被用到,而部分功能往往是仅仅被需要使用一次。



php

interfaceProduct{

publicfunctiongetName();

classFactory{

protected$firstProduct;

protected$secondProduct;

publicfunctiongetFirstProduct(){

if(!

$this-firstProduct){

$this-firstProduct=newFirstProduct();

return$this-firstProduct;

publicfunctiongetSecondProduct(){

if(!

$this-secondProduct){

$this-secondProduct=newSecondProduct();

return$this-secondProduct;

classFirstProductimplementsProduct{

publicfunctiongetName(){

returnThefirstproduct

classSecondProductimplementsProduct{

publicfunctiongetName(){

returnSecondproduct

$factory=newFactory();

print_r($factory-getFirstProduct()-getName());

//Thefirstproduct

print_r($factory-getSecondProduct()-getName());

//Secondproduct

print_r($factory-getFirstProduct()-getName());

//Thefirstproduct

Prototype(原型模式)

有些时候,部分对象需要被初始化多次。

而特别是在如果初始化需要耗费大量时间与资源的时候进行预初始化并且存储下这些对象。



php

interfaceProduct{

classFactory{

private$product;

publicfunction__construct(Product$product){

$this-product=$product;

publicfunctiongetProduct(){

returnclone$this-product;

classSomeProductimplementsProduct{

public$name;

$prototypeFactory=newFactory(newSomeProduct());

$firstProduct=$prototypeFactory-getProduct();

$firstProduct-name=Thefirstproduct

$secondProduct=$prototypeFactory-getProduct();

$secondProduct-name=Secondproduct

print_r($firstProduct-name);

//Thefirstproduct

print_r($secondProduct-name);

//Secondproduct

Builder(构造者)

构造者模式主要在于创建一些复杂的对象:



php

classProduct{

private$name;

publicfunctionsetName($name){

$this-name=$name;

publicfunctiongetName(){

return$this-name;

abstractclassBuilder{

protected$product;

finalpublicfunctiongetProduct(){

return$this-product;

publicfunctionbuildProduct(){

$this-product=newProduct();

classFirstBuilderextendsBuilder{

publicfunctionbuildProduct(){

parent:buildProduct();

$this-product-setName(Theproductofthefirstbuilder);

classSecondBuilderextendsBuilder{

publicfunctionbuildProduct(){

parent:buildProduct();

$this-product-setName(Theproductofsecondbuilder);

classFactory{

private$builder;

publicfunction__construct(Builder$builder){

$this-builder=$builder;

$this-builder-buildProduct();

publicfunctiongetProduct(){

return$this-builder-getProduct();

$firstDirector=newFactory(newFirstBuilder());

$secondDirector=newFactory(newSecondBuilder());

print_r($firstDirector-getProduct()-getName());

//Theproductofthefirstbuilder

print_r($secondDirector-getProduct()-getName());

//Theproductofsecondbuilder

StructuralPatterns

Decorator(装饰器模式)

装饰器模式允许我们根据运行时不同的情景动态地为某个对象调用前后添加不同的行为动作。



php

classHtmlTemplate{

//anyparentclassmethods

classTemplate1extendsHtmlTemplate{

protected$_html;

publicfunction__construct(){

$this-_html=p__text__/p

publicfunctionset($html){

$this-_html=$html;

publicfunctionrender(){

echo$this-_html;

classTemplate2extendsHtmlTemplate{

protected$_element;

publicfunction__construct($s){

$this-_element=$s;

$this-set(h2。

$this-_html。

/h2);

publicfunction__call($name,$args){

$this-_element-$name($args[0]);

classTemplate3extendsHtmlTemplate{

protected$_element;

publicfunction__construct($s){

$this-_element=$s;

$this-set(u。

$this-_html。

/u);

publicfunction__call($name,$args){

$this-_element-$name($args[0]);

Adapter(适配器模式)

这种模式允许使用不同的接口重构某个类,可以允许使用不同的调用方式进行调用:



php

classSimpleBook{

private$author;

private$title;

function__construct($author_in,$title_in){

$this-author=$author_in;

$this-title=$title_in;

functiongetAuthor(){

return$this-author;

functiongetTitle(){

return$this-title;

classBookAdapter{

private$book;

function__construct(SimpleBook$book_in){

$this-book=$book_in;

functiongetAuthorAndTitle(){

return$this-book-getTitle()。

by。

$this-book-getAuthor();

//Usage

$book=newSimpleBook(Gamma,Helm,Johnson,andVlissides,DesignPatterns);

$bookAdapter=newBookAdapter($book);

echoAuthorandTitle。

$bookAdapter-getAuthorAndTitle();

functionecho$line_in){

echo$line_in。

br/

BehavioralPatterns

Strategy(策略模式)

测试模式主要为了让客户类能够更好地使用某些算法而不需要知道其具体的实现。



php

interfaceOutputInterface{

publicfunctionload();

classSerializedArrayOutputimplementsOutputInterface{

publicfunctionload(){

returnserialize($arrayOfData);

classJsonStringOutputimplementsOutputInterface{

publicfunctionload(){

returnjson_encode($arrayOfData);

classArrayOutputimplementsOutputInterface{

publicfunctionload(){

return$arrayOfData;

Observer(观察者模式)

某个对象可以被设置为是可观察的,只要通过某种方式允许其他对象注册为观察者。

每当被观察的对象改变时,会发送信息给观察者。



php

interfaceObserver{

functiononChanged($sender,$args);

interfaceObservable{

functionaddObserver($observer);

classCustomerListimplementsObservable{

private$_observers=array();

publicfunctionaddCustomer($name){

foreach($this-_observersas$obs)

$obs-onChanged($this,$name);

publicfunctionaddObserver($observer){

$this-_observers[]=$observer;

classCustomerListLoggerimplementsObserver{

publicfunctiononChanged($sender,$args){

echo($argsCustomerhasbeenaddedtothelist

);

$ul=newUserList();

$ul-addObserver(newCustomerListLogger());

$ul-addCustomer(Jack);

Chainofresponsibility(责任链模式)

这种模式有另一种称呼:控制链模式。

它主要由一系列对于某些命令的处理器构成,每个查询会在处理器构成的责任链中传递,在每个交汇点由处理器判断是否需要对它们进行响应与处理。

每次的处理程序会在有处理器处理这些请求时暂停。



php

interfaceCommand{

functiononCommand($name,$args);

classCommandChain{

private$_commands=array();

publicfunctionaddCommand($cmd){

$this-_commands[]=$cmd;

publicfunctionrunCommand($name,$args){

foreach($this-_commandsas$cmd){

if($cmd-onCommand($name,$args))

return;

classCustCommandimplementsCommand{

publicfunctiononCommand($name,$args){

if($name!

=addCustomer)

returnfalse;

echo(ThisisCustomerCommandhandlingaddCustomer

);

returntrue;

classMailCommandimplementsCommand{

publicfunctiononCommand($name,$args){

if($name!

=mail)

returnfalse;

echo(ThisisMailCommandhandlingmail

);

returntrue;

$cc=newCommandChain();

$cc-addCommand(newCustCommand());

$cc-addCommand(newMailCommand());

$cc-runCommand(addCustomer,null);

$cc-runCommand(mail,null);

原文地址:DesignPatternsinPHP

未经允许不得转载:建站笔记PHP中的设计模式

分享到:更多()

标签:设计模式

上一篇:程序员必知的前端演进史